libsanitizer/sanitizer_common/sanitizer_mutex.h

   1 //===-- sanitizer_mutex.h ---------------------------------------*- C++ -*-===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
   9 //
  10 //===----------------------------------------------------------------------===//
  11
  12 #ifndef SANITIZER_MUTEX_H
  13 #define SANITIZER_MUTEX_H
  14
  15 #include "sanitizer_atomic.h"
  16 #include "sanitizer_internal_defs.h"
  17 #include "sanitizer_libc.h"
  18
  19 namespace __sanitizer {
  20
  21 class StaticSpinMutex {
  22  public:
  23   void Init() {
  24     atomic_store(&state_, 0, memory_order_relaxed);
  25   }
  26
  27   void Lock() {
  28     if (atomic_exchange(&state_, 1, memory_order_acquire) == 0)
  29       return;
  30     LockSlow();
  31   }
  32
  33   void Unlock() {
  34     atomic_store(&state_, 0, memory_order_release);
  35   }
  36
  37  private:
  38   atomic_uint8_t state_;
  39
  40   void NOINLINE LockSlow() {
  41     for (int i = 0;; i++) {
  42       if (i < 10)
  43         proc_yield(10);
  44       else
  45         internal_sched_yield();
  46       if (atomic_load(&state_, memory_order_relaxed) == 0
  47           && atomic_exchange(&state_, 1, memory_order_acquire) == 0)
  48         return;
  49     }
  50   }
  51 };
  52
  53 class SpinMutex : public StaticSpinMutex {
  54  public:
  55   SpinMutex() {
  56     Init();
  57   }
  58
  59  private:
  60   SpinMutex(const SpinMutex&);
  61   void operator=(const SpinMutex&);
  62 };
  63
  64 template<typename MutexType>
  65 class GenericScopedLock {
  66  public:
  67   explicit GenericScopedLock(MutexType *mu)
  68       : mu_(mu) {
  69     mu_->Lock();
  70   }
  71
  72   ~GenericScopedLock() {
  73     mu_->Unlock();
  74   }
  75
  76  private:
  77   MutexType *mu_;
  78
  79   GenericScopedLock(const GenericScopedLock&);
  80   void operator=(const GenericScopedLock&);
  81 };
  82
  83 template<typename MutexType>
  84 class GenericScopedReadLock {
  85  public:
  86   explicit GenericScopedReadLock(MutexType *mu)
  87       : mu_(mu) {
  88     mu_->ReadLock();
  89   }
  90
  91   ~GenericScopedReadLock() {
  92     mu_->ReadUnlock();
  93   }
  94
  95  private:
  96   MutexType *mu_;
  97
  98   GenericScopedReadLock(const GenericScopedReadLock&);
  99   void operator=(const GenericScopedReadLock&);
 100 };
 101
 102 typedef GenericScopedLock<StaticSpinMutex> SpinMutexLock;
 103
 104 }  // namespace __sanitizer
 105
 106 #endif  // SANITIZER_MUTEX_H