src/sync.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #ifndef BITCOIN_SYNC_H
   7 #define BITCOIN_SYNC_H
   8
   9 #include <threadsafety.h>
  10
  11 #include <boost/thread/condition_variable.hpp>
  12 #include <boost/thread/mutex.hpp>
  13 #include <condition_variable>
  14 #include <thread>
  15 #include <mutex>
  16
  17
  18 ////////////////////////////////////////////////
  19 //                                            //
  20 // THE SIMPLE DEFINITION, EXCLUDING DEBUG CODE //
  21 //                                            //
  22 ////////////////////////////////////////////////
  23
  24 /*
  25 CCriticalSection mutex;
  26     std::recursive_mutex mutex;
  27
  28 LOCK(mutex);
  29     std::unique_lock<std::recursive_mutex> criticalblock(mutex);
  30
  31 LOCK2(mutex1, mutex2);
  32     std::unique_lock<std::recursive_mutex> criticalblock1(mutex1);
  33     std::unique_lock<std::recursive_mutex> criticalblock2(mutex2);
  34
  35 TRY_LOCK(mutex, name);
  36     std::unique_lock<std::recursive_mutex> name(mutex, std::try_to_lock_t);
  37
  38 ENTER_CRITICAL_SECTION(mutex); // no RAII
  39     mutex.lock();
  40
  41 LEAVE_CRITICAL_SECTION(mutex); // no RAII
  42     mutex.unlock();
  43  */
  44
  45 ///////////////////////////////
  46 //                           //
  47 // THE ACTUAL IMPLEMENTATION //
  48 //                           //
  49 ///////////////////////////////
  50
  51 /**
  52  * Template mixin that adds -Wthread-safety locking
  53  * annotations to a subset of the mutex API.
  54  */
  55 template <typename PARENT>
  56 class LOCKABLE AnnotatedMixin : public PARENT
  57 {
  58 public:
  59     void lock() EXCLUSIVE_LOCK_FUNCTION()
  60     {
  61         PARENT::lock();
  62     }
  63
  64     void unlock() UNLOCK_FUNCTION()
  65     {
  66         PARENT::unlock();
  67     }
  68
  69     bool try_lock() EXCLUSIVE_TRYLOCK_FUNCTION(true)
  70     {
  71         return PARENT::try_lock();
  72     }
  73 };
  74
  75 #ifdef DEBUG_LOCKORDER
  76 void EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs, bool fTry = false);
  77 void LeaveCritical();
  78 std::string LocksHeld();
  79 void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs);
  80 void AssertLockNotHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs);
  81 void DeleteLock(void* cs);
  82 #else
  83 void static inline EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs, bool fTry = false) {}
  84 void static inline LeaveCritical() {}
  85 void static inline AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs) {}
  86 void static inline AssertLockNotHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs) {}
  87 void static inline DeleteLock(void* cs) {}
  88 #endif
  89 #define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  90 #define AssertLockNotHeld(cs) AssertLockNotHeldInternal(#cs, __FILE__, __LINE__, &cs)
  91
  92 /**
  93  * Wrapped mutex: supports recursive locking, but no waiting
  94  * TODO: We should move away from using the recursive lock by default.
  95  */
  96 class CCriticalSection : public AnnotatedMixin<std::recursive_mutex>
  97 {
  98 public:
  99     ~CCriticalSection() {
 100         DeleteLock((void*)this);
 101     }
 102 };
 103
 104 /** Wrapped mutex: supports waiting but not recursive locking */
 105 typedef AnnotatedMixin<std::mutex> CWaitableCriticalSection;
 106
 107 /** Just a typedef for std::condition_variable, can be wrapped later if desired */
 108 typedef std::condition_variable CConditionVariable;
 109
 110 /** Just a typedef for std::unique_lock, can be wrapped later if desired */
 111 typedef std::unique_lock<std::mutex> WaitableLock;
 112
 113 #ifdef DEBUG_LOCKCONTENTION
 114 void PrintLockContention(const char* pszName, const char* pszFile, int nLine);
 115 #endif
 116
 117 /** Wrapper around std::unique_lock<CCriticalSection> */
 118 class SCOPED_LOCKABLE CCriticalBlock
 119 {
 120 private:
 121     std::unique_lock<CCriticalSection> lock;
 122
 123     void Enter(const char* pszName, const char* pszFile, int nLine)
 124     {
 125         EnterCritical(pszName, pszFile, nLine, (void*)(lock.mutex()));
 126 #ifdef DEBUG_LOCKCONTENTION
 127         if (!lock.try_lock()) {
 128             PrintLockContention(pszName, pszFile, nLine);
 129 #endif
 130             lock.lock();
 131 #ifdef DEBUG_LOCKCONTENTION
 132         }
 133 #endif
 134     }
 135
 136     bool TryEnter(const char* pszName, const char* pszFile, int nLine)
 137     {
 138         EnterCritical(pszName, pszFile, nLine, (void*)(lock.mutex()), true);
 139         lock.try_lock();
 140         if (!lock.owns_lock())
 141             LeaveCritical();
 142         return lock.owns_lock();
 143     }
 144
 145 public:
 146     CCriticalBlock(CCriticalSection& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : lock(mutexIn, std::defer_lock)
 147     {
 148         if (fTry)
 149             TryEnter(pszName, pszFile, nLine);
 150         else
 151             Enter(pszName, pszFile, nLine);
 152     }
 153
 154     CCriticalBlock(CCriticalSection* pmutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(pmutexIn)
 155     {
 156         if (!pmutexIn) return;
 157
 158         lock = std::unique_lock<CCriticalSection>(*pmutexIn, std::defer_lock);
 159         if (fTry)
 160             TryEnter(pszName, pszFile, nLine);
 161         else
 162             Enter(pszName, pszFile, nLine);
 163     }
 164
 165     ~CCriticalBlock() UNLOCK_FUNCTION()
 166     {
 167         if (lock.owns_lock())
 168             LeaveCritical();
 169     }
 170
 171     operator bool()
 172     {
 173         return lock.owns_lock();
 174     }
 175 };
 176
 177 #define PASTE(x, y) x ## y
 178 #define PASTE2(x, y) PASTE(x, y)
 179
 180 #define LOCK(cs) CCriticalBlock PASTE2(criticalblock, __COUNTER__)(cs, #cs, __FILE__, __LINE__)
 181 #define LOCK2(cs1, cs2) CCriticalBlock criticalblock1(cs1, #cs1, __FILE__, __LINE__), criticalblock2(cs2, #cs2, __FILE__, __LINE__)
 182 #define TRY_LOCK(cs, name) CCriticalBlock name(cs, #cs, __FILE__, __LINE__, true)
 183
 184 #define ENTER_CRITICAL_SECTION(cs)                            \
 185     {                                                         \
 186         EnterCritical(#cs, __FILE__, __LINE__, (void*)(&cs)); \
 187         (cs).lock();                                          \
 188     }
 189
 190 #define LEAVE_CRITICAL_SECTION(cs) \
 191     {                              \
 192         (cs).unlock();             \
 193         LeaveCritical();           \
 194     }
 195
 196 class CSemaphore
 197 {
 198 private:
 199     boost::condition_variable condition;
 200     boost::mutex mutex;
 201     int value;
 202
 203 public:
 204     explicit CSemaphore(int init) : value(init) {}
 205
 206     void wait()
 207     {
 208         boost::unique_lock<boost::mutex> lock(mutex);
 209         while (value < 1) {
 210             condition.wait(lock);
 211         }
 212         value--;
 213     }
 214
 215     bool try_wait()
 216     {
 217         boost::unique_lock<boost::mutex> lock(mutex);
 218         if (value < 1)
 219             return false;
 220         value--;
 221         return true;
 222     }
 223
 224     void post()
 225     {
 226         {
 227             boost::unique_lock<boost::mutex> lock(mutex);
 228             value++;
 229         }
 230         condition.notify_one();
 231     }
 232 };
 233
 234 /** RAII-style semaphore lock */
 235 class CSemaphoreGrant
 236 {
 237 private:
 238     CSemaphore* sem;
 239     bool fHaveGrant;
 240
 241 public:
 242     void Acquire()
 243     {
 244         if (fHaveGrant)
 245             return;
 246         sem->wait();
 247         fHaveGrant = true;
 248     }
 249
 250     void Release()
 251     {
 252         if (!fHaveGrant)
 253             return;
 254         sem->post();
 255         fHaveGrant = false;
 256     }
 257
 258     bool TryAcquire()
 259     {
 260         if (!fHaveGrant && sem->try_wait())
 261             fHaveGrant = true;
 262         return fHaveGrant;
 263     }
 264
 265     void MoveTo(CSemaphoreGrant& grant)
 266     {
 267         grant.Release();
 268         grant.sem = sem;
 269         grant.fHaveGrant = fHaveGrant;
 270         fHaveGrant = false;
 271     }
 272
 273     CSemaphoreGrant() : sem(nullptr), fHaveGrant(false) {}
 274
 275     explicit CSemaphoreGrant(CSemaphore& sema, bool fTry = false) : sem(&sema), fHaveGrant(false)
 276     {
 277         if (fTry)
 278             TryAcquire();
 279         else
 280             Acquire();
 281     }
 282
 283     ~CSemaphoreGrant()
 284     {
 285         Release();
 286     }
 287
 288     operator bool() const
 289     {
 290         return fHaveGrant;
 291     }
 292 };
 293
 294 #endif // BITCOIN_SYNC_H