• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- sanitizer_mutex.h ---------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef SANITIZER_MUTEX_H
15 #define SANITIZER_MUTEX_H
16 
17 #include "sanitizer_atomic.h"
18 #include "sanitizer_internal_defs.h"
19 #include "sanitizer_libc.h"
20 
21 namespace __sanitizer {
22 
23 class StaticSpinMutex {
24  public:
Init()25   void Init() {
26     atomic_store(&state_, 0, memory_order_relaxed);
27   }
28 
Lock()29   void Lock() {
30     if (TryLock())
31       return;
32     LockSlow();
33   }
34 
TryLock()35   bool TryLock() {
36     return atomic_exchange(&state_, 1, memory_order_acquire) == 0;
37   }
38 
Unlock()39   void Unlock() {
40     atomic_store(&state_, 0, memory_order_release);
41   }
42 
CheckLocked()43   void CheckLocked() {
44     CHECK_EQ(atomic_load(&state_, memory_order_relaxed), 1);
45   }
46 
47  private:
48   atomic_uint8_t state_;
49 
LockSlow()50   void NOINLINE LockSlow() {
51     for (int i = 0;; i++) {
52       if (i < 10)
53         proc_yield(10);
54       else
55         internal_sched_yield();
56       if (atomic_load(&state_, memory_order_relaxed) == 0
57           && atomic_exchange(&state_, 1, memory_order_acquire) == 0)
58         return;
59     }
60   }
61 };
62 
63 class SpinMutex : public StaticSpinMutex {
64  public:
SpinMutex()65   SpinMutex() {
66     Init();
67   }
68 
69  private:
70   SpinMutex(const SpinMutex&);
71   void operator=(const SpinMutex&);
72 };
73 
74 class BlockingMutex {
75  public:
76 #if SANITIZER_WINDOWS
77   // Windows does not currently support LinkerInitialized
78   explicit BlockingMutex(LinkerInitialized);
79 #else
80   explicit constexpr BlockingMutex(LinkerInitialized)
81       : opaque_storage_ {0, }, owner_(0) {}
82 #endif
83   BlockingMutex();
84   void Lock();
85   void Unlock();
86   void CheckLocked();
87  private:
88   uptr opaque_storage_[10];
89   uptr owner_;  // for debugging
90 };
91 
92 // Reader-writer spin mutex.
93 class RWMutex {
94  public:
RWMutex()95   RWMutex() {
96     atomic_store(&state_, kUnlocked, memory_order_relaxed);
97   }
98 
~RWMutex()99   ~RWMutex() {
100     CHECK_EQ(atomic_load(&state_, memory_order_relaxed), kUnlocked);
101   }
102 
Lock()103   void Lock() {
104     u32 cmp = kUnlocked;
105     if (atomic_compare_exchange_strong(&state_, &cmp, kWriteLock,
106                                        memory_order_acquire))
107       return;
108     LockSlow();
109   }
110 
Unlock()111   void Unlock() {
112     u32 prev = atomic_fetch_sub(&state_, kWriteLock, memory_order_release);
113     DCHECK_NE(prev & kWriteLock, 0);
114     (void)prev;
115   }
116 
ReadLock()117   void ReadLock() {
118     u32 prev = atomic_fetch_add(&state_, kReadLock, memory_order_acquire);
119     if ((prev & kWriteLock) == 0)
120       return;
121     ReadLockSlow();
122   }
123 
ReadUnlock()124   void ReadUnlock() {
125     u32 prev = atomic_fetch_sub(&state_, kReadLock, memory_order_release);
126     DCHECK_EQ(prev & kWriteLock, 0);
127     DCHECK_GT(prev & ~kWriteLock, 0);
128     (void)prev;
129   }
130 
CheckLocked()131   void CheckLocked() {
132     CHECK_NE(atomic_load(&state_, memory_order_relaxed), kUnlocked);
133   }
134 
135  private:
136   atomic_uint32_t state_;
137 
138   enum {
139     kUnlocked = 0,
140     kWriteLock = 1,
141     kReadLock = 2
142   };
143 
LockSlow()144   void NOINLINE LockSlow() {
145     for (int i = 0;; i++) {
146       if (i < 10)
147         proc_yield(10);
148       else
149         internal_sched_yield();
150       u32 cmp = atomic_load(&state_, memory_order_relaxed);
151       if (cmp == kUnlocked &&
152           atomic_compare_exchange_weak(&state_, &cmp, kWriteLock,
153                                        memory_order_acquire))
154           return;
155     }
156   }
157 
ReadLockSlow()158   void NOINLINE ReadLockSlow() {
159     for (int i = 0;; i++) {
160       if (i < 10)
161         proc_yield(10);
162       else
163         internal_sched_yield();
164       u32 prev = atomic_load(&state_, memory_order_acquire);
165       if ((prev & kWriteLock) == 0)
166         return;
167     }
168   }
169 
170   RWMutex(const RWMutex&);
171   void operator = (const RWMutex&);
172 };
173 
174 template<typename MutexType>
175 class GenericScopedLock {
176  public:
GenericScopedLock(MutexType * mu)177   explicit GenericScopedLock(MutexType *mu)
178       : mu_(mu) {
179     mu_->Lock();
180   }
181 
~GenericScopedLock()182   ~GenericScopedLock() {
183     mu_->Unlock();
184   }
185 
186  private:
187   MutexType *mu_;
188 
189   GenericScopedLock(const GenericScopedLock&);
190   void operator=(const GenericScopedLock&);
191 };
192 
193 template<typename MutexType>
194 class GenericScopedReadLock {
195  public:
GenericScopedReadLock(MutexType * mu)196   explicit GenericScopedReadLock(MutexType *mu)
197       : mu_(mu) {
198     mu_->ReadLock();
199   }
200 
~GenericScopedReadLock()201   ~GenericScopedReadLock() {
202     mu_->ReadUnlock();
203   }
204 
205  private:
206   MutexType *mu_;
207 
208   GenericScopedReadLock(const GenericScopedReadLock&);
209   void operator=(const GenericScopedReadLock&);
210 };
211 
212 typedef GenericScopedLock<StaticSpinMutex> SpinMutexLock;
213 typedef GenericScopedLock<BlockingMutex> BlockingMutexLock;
214 typedef GenericScopedLock<RWMutex> RWMutexLock;
215 typedef GenericScopedReadLock<RWMutex> RWMutexReadLock;
216 
217 }  // namespace __sanitizer
218 
219 #endif  // SANITIZER_MUTEX_H
220