15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Copyright 2007 The RE2 Authors. All Rights Reserved. 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Use of this source code is governed by a BSD-style 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// license that can be found in the LICENSE file. 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 55821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)/* 65821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) * A simple mutex wrapper, supporting locks and read-write locks. 75821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) * You should assume the locks are *not* re-entrant. 85821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) */ 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#ifndef RE2_UTIL_MUTEX_H_ 115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define RE2_UTIL_MUTEX_H_ 125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)namespace re2 { 145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#ifndef WIN32 165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define HAVE_PTHREAD 1 175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define HAVE_RWLOCK 1 185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#endif 195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#if defined(NO_THREADS) 215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) typedef int MutexType; // to keep a lock-count 225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK) 235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Needed for pthread_rwlock_*. If it causes problems, you could take it 245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // out, but then you'd have to unset HAVE_RWLOCK (at least on linux -- it 255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // *does* cause problems for FreeBSD, or MacOSX, but isn't needed 265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // for locking there.) 275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# ifdef __linux__ 285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# undef _XOPEN_SOURCE 295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# define _XOPEN_SOURCE 500 // may be needed to get the rwlock calls 305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# endif 315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# include <pthread.h> 325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) typedef pthread_rwlock_t MutexType; 335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#elif defined(HAVE_PTHREAD) 345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# include <pthread.h> 355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) typedef pthread_mutex_t MutexType; 365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#elif defined(WIN32) 375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# ifndef WIN32_LEAN_AND_MEAN 385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# define WIN32_LEAN_AND_MEAN // We only need minimal includes 395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# endif 405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# ifdef GMUTEX_TRYLOCK 415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We need Windows NT or later for TryEnterCriticalSection(). If you 425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // don't need that functionality, you can remove these _WIN32_WINNT 435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // lines, and change TryLock() to assert(0) or something. 445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# ifndef _WIN32_WINNT 455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# define _WIN32_WINNT 0x0400 465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# endif 475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# endif 485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# include <windows.h> 495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) typedef CRITICAL_SECTION MutexType; 505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#else 515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)# error Need to implement mutex.h for your architecture, or #define NO_THREADS 525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#endif 535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class Mutex { 555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Create a Mutex that is not held by anybody. 575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline Mutex(); 585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Destructor 605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline ~Mutex(); 615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline void Lock(); // Block if needed until free then acquire exclusively 635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline void Unlock(); // Release a lock acquired via Lock() 645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline bool TryLock(); // If free, Lock() and return true, else return false 655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Note that on systems that don't support read-write locks, these may 665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // be implemented as synonyms to Lock() and Unlock(). So you can use 675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // these for efficiency, but don't use them anyplace where being able 685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // to do shared reads is necessary to avoid deadlock. 695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline void ReaderLock(); // Block until free or shared then acquire a share 705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline void ReaderUnlock(); // Release a read share of this Mutex 715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline void WriterLock() { Lock(); } // Acquire an exclusive lock 725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock() 735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) inline void AssertHeld() { } 745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MutexType mutex_; 775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Catch the error of writing Mutex when intending MutexLock. 795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Mutex(Mutex *ignored); 805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Disallow "evil" constructors 815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Mutex(const Mutex&); 825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void operator=(const Mutex&); 835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Now the implementation of Mutex for various systems 865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#if defined(NO_THREADS) 875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// When we don't have threads, we can be either reading or writing, 895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// but not both. We can have lots of readers at once (in no-threads 905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// mode, that's most likely to happen in recursive function calls), 915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// but only one writer. We represent this by having mutex_ be -1 when 925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// writing and a number > 0 when reading (and 0 when no lock is held). 935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// In debug mode, we assert these invariants, while in non-debug mode 955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// we do nothing, for efficiency. That's why everything is in an 965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// assert. 975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <assert.h> 985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)Mutex::Mutex() : mutex_(0) { } 1005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)Mutex::~Mutex() { assert(mutex_ == 0); } 1015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::Lock() { assert(--mutex_ == -1); } 1025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::Unlock() { assert(mutex_++ == -1); } 1035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)bool Mutex::TryLock() { if (mutex_) return false; Lock(); return true; } 1045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::ReaderLock() { assert(++mutex_ > 0); } 1055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::ReaderUnlock() { assert(mutex_-- > 0); } 1065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK) 1085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <stdlib.h> // for abort() 1105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define SAFE_PTHREAD(fncall) do { if ((fncall) != 0) abort(); } while (0) 1115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)Mutex::Mutex() { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); } 1135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)Mutex::~Mutex() { SAFE_PTHREAD(pthread_rwlock_destroy(&mutex_)); } 1145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::Lock() { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); } 1155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::Unlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); } 1165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)bool Mutex::TryLock() { return pthread_rwlock_trywrlock(&mutex_) == 0; } 1175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::ReaderLock() { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); } 1185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); } 1195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#undef SAFE_PTHREAD 1215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#elif defined(HAVE_PTHREAD) 1235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <stdlib.h> // for abort() 1255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define SAFE_PTHREAD(fncall) do { if ((fncall) != 0) abort(); } while (0) 1265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)Mutex::Mutex() { SAFE_PTHREAD(pthread_mutex_init(&mutex_, NULL)); } 1285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)Mutex::~Mutex() { SAFE_PTHREAD(pthread_mutex_destroy(&mutex_)); } 1295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::Lock() { SAFE_PTHREAD(pthread_mutex_lock(&mutex_)); } 1305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::Unlock() { SAFE_PTHREAD(pthread_mutex_unlock(&mutex_)); } 1315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)bool Mutex::TryLock() { return pthread_mutex_trylock(&mutex_) == 0; } 1325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::ReaderLock() { Lock(); } // we don't have read-write locks 1335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::ReaderUnlock() { Unlock(); } 1345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#undef SAFE_PTHREAD 1355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#elif defined(WIN32) 1375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)Mutex::Mutex() { InitializeCriticalSection(&mutex_); } 1395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)Mutex::~Mutex() { DeleteCriticalSection(&mutex_); } 1405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::Lock() { EnterCriticalSection(&mutex_); } 1415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::Unlock() { LeaveCriticalSection(&mutex_); } 1425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)bool Mutex::TryLock() { return TryEnterCriticalSection(&mutex_) != 0; } 1435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::ReaderLock() { Lock(); } // we don't have read-write locks 1445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void Mutex::ReaderUnlock() { Unlock(); } 1455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#endif 1475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// -------------------------------------------------------------------------- 1505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Some helper classes 1515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// MutexLock(mu) acquires mu when constructed and releases it when destroyed. 1535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class MutexLock { 1545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 1555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); } 1565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ~MutexLock() { mu_->Unlock(); } 1575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 1585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Mutex * const mu_; 1595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Disallow "evil" constructors 1605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MutexLock(const MutexLock&); 1615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void operator=(const MutexLock&); 1625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 1635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// ReaderMutexLock and WriterMutexLock do the same, for rwlocks 1655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class ReaderMutexLock { 1665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 1675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); } 1685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ~ReaderMutexLock() { mu_->ReaderUnlock(); } 1695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 1705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Mutex * const mu_; 1715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Disallow "evil" constructors 1725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ReaderMutexLock(const ReaderMutexLock&); 1735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void operator=(const ReaderMutexLock&); 1745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 1755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class WriterMutexLock { 1775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 1785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); } 1795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ~WriterMutexLock() { mu_->WriterUnlock(); } 1805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 1815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Mutex * const mu_; 1825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Disallow "evil" constructors 1835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) WriterMutexLock(const WriterMutexLock&); 1845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void operator=(const WriterMutexLock&); 1855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 1865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Catch bug where variable name is omitted, e.g. MutexLock (&mu); 1885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define MutexLock(x) COMPILE_ASSERT(0, mutex_lock_decl_missing_var_name) 1895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define ReaderMutexLock(x) COMPILE_ASSERT(0, rmutex_lock_decl_missing_var_name) 1905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define WriterMutexLock(x) COMPILE_ASSERT(0, wmutex_lock_decl_missing_var_name) 1915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Provide safe way to declare and use global, linker-initialized mutex. Sigh. 1935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#ifdef HAVE_PTHREAD 1945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define GLOBAL_MUTEX(name) \ 1965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) static pthread_mutex_t (name) = PTHREAD_MUTEX_INITIALIZER 1975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define GLOBAL_MUTEX_LOCK(name) \ 1985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) pthread_mutex_lock(&(name)) 1995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define GLOBAL_MUTEX_UNLOCK(name) \ 2005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) pthread_mutex_unlock(&(name)) 2015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#else 2035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define GLOBAL_MUTEX(name) \ 2055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) static Mutex name 2065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define GLOBAL_MUTEX_LOCK(name) \ 2075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) name.Lock() 2085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define GLOBAL_MUTEX_UNLOCK(name) \ 2095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) name.Unlock() 2105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#endif 2125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} // namespace re2 2145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#endif /* #define RE2_UTIL_MUTEX_H_ */ 216