1// Copyright 2007 The RE2 Authors. All Rights Reserved. 2// Use of this source code is governed by a BSD-style 3// license that can be found in the LICENSE file. 4 5/* 6 * A simple mutex wrapper, supporting locks and read-write locks. 7 * You should assume the locks are *not* re-entrant. 8 */ 9 10#ifndef RE2_UTIL_MUTEX_H_ 11#define RE2_UTIL_MUTEX_H_ 12 13namespace re2 { 14 15#ifndef WIN32 16#define HAVE_PTHREAD 1 17#define HAVE_RWLOCK 1 18#endif 19 20#if defined(NO_THREADS) 21 typedef int MutexType; // to keep a lock-count 22#elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK) 23 // Needed for pthread_rwlock_*. If it causes problems, you could take it 24 // out, but then you'd have to unset HAVE_RWLOCK (at least on linux -- it 25 // *does* cause problems for FreeBSD, or MacOSX, but isn't needed 26 // for locking there.) 27# ifdef __linux__ 28# undef _XOPEN_SOURCE 29# define _XOPEN_SOURCE 500 // may be needed to get the rwlock calls 30# endif 31# include <pthread.h> 32 typedef pthread_rwlock_t MutexType; 33#elif defined(HAVE_PTHREAD) 34# include <pthread.h> 35 typedef pthread_mutex_t MutexType; 36#elif defined(WIN32) 37# ifndef WIN32_LEAN_AND_MEAN 38# define WIN32_LEAN_AND_MEAN // We only need minimal includes 39# endif 40# ifdef GMUTEX_TRYLOCK 41 // We need Windows NT or later for TryEnterCriticalSection(). If you 42 // don't need that functionality, you can remove these _WIN32_WINNT 43 // lines, and change TryLock() to assert(0) or something. 44# ifndef _WIN32_WINNT 45# define _WIN32_WINNT 0x0400 46# endif 47# endif 48# include <windows.h> 49 typedef CRITICAL_SECTION MutexType; 50#else 51# error Need to implement mutex.h for your architecture, or #define NO_THREADS 52#endif 53 54class Mutex { 55 public: 56 // Create a Mutex that is not held by anybody. 57 inline Mutex(); 58 59 // Destructor 60 inline ~Mutex(); 61 62 inline void Lock(); // Block if needed until free then acquire exclusively 63 inline void Unlock(); // Release a lock acquired via Lock() 64 inline bool TryLock(); // If free, Lock() and return true, else return false 65 // Note that on systems that don't support read-write locks, these may 66 // be implemented as synonyms to Lock() and Unlock(). So you can use 67 // these for efficiency, but don't use them anyplace where being able 68 // to do shared reads is necessary to avoid deadlock. 69 inline void ReaderLock(); // Block until free or shared then acquire a share 70 inline void ReaderUnlock(); // Release a read share of this Mutex 71 inline void WriterLock() { Lock(); } // Acquire an exclusive lock 72 inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock() 73 inline void AssertHeld() { } 74 75 private: 76 MutexType mutex_; 77 78 // Catch the error of writing Mutex when intending MutexLock. 79 Mutex(Mutex *ignored); 80 // Disallow "evil" constructors 81 Mutex(const Mutex&); 82 void operator=(const Mutex&); 83}; 84 85// Now the implementation of Mutex for various systems 86#if defined(NO_THREADS) 87 88// When we don't have threads, we can be either reading or writing, 89// but not both. We can have lots of readers at once (in no-threads 90// mode, that's most likely to happen in recursive function calls), 91// but only one writer. We represent this by having mutex_ be -1 when 92// writing and a number > 0 when reading (and 0 when no lock is held). 93// 94// In debug mode, we assert these invariants, while in non-debug mode 95// we do nothing, for efficiency. That's why everything is in an 96// assert. 97#include <assert.h> 98 99Mutex::Mutex() : mutex_(0) { } 100Mutex::~Mutex() { assert(mutex_ == 0); } 101void Mutex::Lock() { assert(--mutex_ == -1); } 102void Mutex::Unlock() { assert(mutex_++ == -1); } 103bool Mutex::TryLock() { if (mutex_) return false; Lock(); return true; } 104void Mutex::ReaderLock() { assert(++mutex_ > 0); } 105void Mutex::ReaderUnlock() { assert(mutex_-- > 0); } 106 107#elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK) 108 109#include <stdlib.h> // for abort() 110#define SAFE_PTHREAD(fncall) do { if ((fncall) != 0) abort(); } while (0) 111 112Mutex::Mutex() { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); } 113Mutex::~Mutex() { SAFE_PTHREAD(pthread_rwlock_destroy(&mutex_)); } 114void Mutex::Lock() { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); } 115void Mutex::Unlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); } 116bool Mutex::TryLock() { return pthread_rwlock_trywrlock(&mutex_) == 0; } 117void Mutex::ReaderLock() { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); } 118void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); } 119 120#undef SAFE_PTHREAD 121 122#elif defined(HAVE_PTHREAD) 123 124#include <stdlib.h> // for abort() 125#define SAFE_PTHREAD(fncall) do { if ((fncall) != 0) abort(); } while (0) 126 127Mutex::Mutex() { SAFE_PTHREAD(pthread_mutex_init(&mutex_, NULL)); } 128Mutex::~Mutex() { SAFE_PTHREAD(pthread_mutex_destroy(&mutex_)); } 129void Mutex::Lock() { SAFE_PTHREAD(pthread_mutex_lock(&mutex_)); } 130void Mutex::Unlock() { SAFE_PTHREAD(pthread_mutex_unlock(&mutex_)); } 131bool Mutex::TryLock() { return pthread_mutex_trylock(&mutex_) == 0; } 132void Mutex::ReaderLock() { Lock(); } // we don't have read-write locks 133void Mutex::ReaderUnlock() { Unlock(); } 134#undef SAFE_PTHREAD 135 136#elif defined(WIN32) 137 138Mutex::Mutex() { InitializeCriticalSection(&mutex_); } 139Mutex::~Mutex() { DeleteCriticalSection(&mutex_); } 140void Mutex::Lock() { EnterCriticalSection(&mutex_); } 141void Mutex::Unlock() { LeaveCriticalSection(&mutex_); } 142bool Mutex::TryLock() { return TryEnterCriticalSection(&mutex_) != 0; } 143void Mutex::ReaderLock() { Lock(); } // we don't have read-write locks 144void Mutex::ReaderUnlock() { Unlock(); } 145 146#endif 147 148 149// -------------------------------------------------------------------------- 150// Some helper classes 151 152// MutexLock(mu) acquires mu when constructed and releases it when destroyed. 153class MutexLock { 154 public: 155 explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); } 156 ~MutexLock() { mu_->Unlock(); } 157 private: 158 Mutex * const mu_; 159 // Disallow "evil" constructors 160 MutexLock(const MutexLock&); 161 void operator=(const MutexLock&); 162}; 163 164// ReaderMutexLock and WriterMutexLock do the same, for rwlocks 165class ReaderMutexLock { 166 public: 167 explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); } 168 ~ReaderMutexLock() { mu_->ReaderUnlock(); } 169 private: 170 Mutex * const mu_; 171 // Disallow "evil" constructors 172 ReaderMutexLock(const ReaderMutexLock&); 173 void operator=(const ReaderMutexLock&); 174}; 175 176class WriterMutexLock { 177 public: 178 explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); } 179 ~WriterMutexLock() { mu_->WriterUnlock(); } 180 private: 181 Mutex * const mu_; 182 // Disallow "evil" constructors 183 WriterMutexLock(const WriterMutexLock&); 184 void operator=(const WriterMutexLock&); 185}; 186 187// Catch bug where variable name is omitted, e.g. MutexLock (&mu); 188#define MutexLock(x) COMPILE_ASSERT(0, mutex_lock_decl_missing_var_name) 189#define ReaderMutexLock(x) COMPILE_ASSERT(0, rmutex_lock_decl_missing_var_name) 190#define WriterMutexLock(x) COMPILE_ASSERT(0, wmutex_lock_decl_missing_var_name) 191 192// Provide safe way to declare and use global, linker-initialized mutex. Sigh. 193#ifdef HAVE_PTHREAD 194 195#define GLOBAL_MUTEX(name) \ 196 static pthread_mutex_t (name) = PTHREAD_MUTEX_INITIALIZER 197#define GLOBAL_MUTEX_LOCK(name) \ 198 pthread_mutex_lock(&(name)) 199#define GLOBAL_MUTEX_UNLOCK(name) \ 200 pthread_mutex_unlock(&(name)) 201 202#else 203 204#define GLOBAL_MUTEX(name) \ 205 static Mutex name 206#define GLOBAL_MUTEX_LOCK(name) \ 207 name.Lock() 208#define GLOBAL_MUTEX_UNLOCK(name) \ 209 name.Unlock() 210 211#endif 212 213} // namespace re2 214 215#endif /* #define RE2_UTIL_MUTEX_H_ */ 216