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 (TryLock())
  29       return;
  30     LockSlow();
  31   }
  32
  33   bool TryLock() {
  34     return atomic_exchange(&state_, 1, memory_order_acquire) == 0;
  35   }
  36
  37   void Unlock() {
  38     atomic_store(&state_, 0, memory_order_release);
  39   }
  40
  41   void CheckLocked() {
  42     CHECK_EQ(atomic_load(&state_, memory_order_relaxed), 1);
  43   }
  44
  45  private:
  46   atomic_uint8_t state_;
  47
  48   void NOINLINE LockSlow() {
  49     for (int i = 0;; i++) {
  50       if (i < 10)
  51         proc_yield(10);
  52       else
  53         internal_sched_yield();
  54       if (atomic_load(&state_, memory_order_relaxed) == 0
  55           && atomic_exchange(&state_, 1, memory_order_acquire) == 0)
  56         return;
  57     }
  58   }
  59 };
  60
  61 class SpinMutex : public StaticSpinMutex {
  62  public:
  63   SpinMutex() {
  64     Init();
  65   }
  66
  67  private:
  68   SpinMutex(const SpinMutex&);
  69   void operator=(const SpinMutex&);
  70 };
  71
  72 class BlockingMutex {
  73  public:
  74   explicit BlockingMutex(LinkerInitialized);
  75   BlockingMutex();
  76   void Lock();
  77   void Unlock();
  78   void CheckLocked();
  79  private:
  80   uptr opaque_storage_[10];
  81   uptr owner_;  // for debugging
  82 };
  83
  84 template<typename MutexType>
  85 class GenericScopedLock {
  86  public:
  87   explicit GenericScopedLock(MutexType *mu)
  88       : mu_(mu) {
  89     mu_->Lock();
  90   }
  91
  92   ~GenericScopedLock() {
  93     mu_->Unlock();
  94   }
  95
  96  private:
  97   MutexType *mu_;
  98
  99   GenericScopedLock(const GenericScopedLock&);
 100   void operator=(const GenericScopedLock&);
 101 };
 102
 103 template<typename MutexType>
 104 class GenericScopedReadLock {
 105  public:
 106   explicit GenericScopedReadLock(MutexType *mu)
 107       : mu_(mu) {
 108     mu_->ReadLock();
 109   }
 110
 111   ~GenericScopedReadLock() {
 112     mu_->ReadUnlock();
 113   }
 114
 115  private:
 116   MutexType *mu_;
 117
 118   GenericScopedReadLock(const GenericScopedReadLock&);
 119   void operator=(const GenericScopedReadLock&);
 120 };
 121
 122 typedef GenericScopedLock<StaticSpinMutex> SpinMutexLock;
 123 typedef GenericScopedLock<BlockingMutex> BlockingMutexLock;
 124
 125 }  // namespace __sanitizer
 126
 127 #endif  // SANITIZER_MUTEX_H