/thirdparty/breakpad/third_party/glog/src/base/mutex.h

http://github.com/tomahawk-player/tomahawk · C++ Header · 325 lines · 147 code · 34 blank · 144 comment · 30 complexity · ce5bb9b20411aecc506601ba66029995 MD5 · raw file

  1. // Copyright (c) 2007, Google Inc.
  2. // All rights reserved.
  3. //
  4. // Redistribution and use in source and binary forms, with or without
  5. // modification, are permitted provided that the following conditions are
  6. // met:
  7. //
  8. // * Redistributions of source code must retain the above copyright
  9. // notice, this list of conditions and the following disclaimer.
  10. // * Redistributions in binary form must reproduce the above
  11. // copyright notice, this list of conditions and the following disclaimer
  12. // in the documentation and/or other materials provided with the
  13. // distribution.
  14. // * Neither the name of Google Inc. nor the names of its
  15. // contributors may be used to endorse or promote products derived from
  16. // this software without specific prior written permission.
  17. //
  18. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29. //
  30. // ---
  31. // Author: Craig Silverstein.
  32. //
  33. // A simple mutex wrapper, supporting locks and read-write locks.
  34. // You should assume the locks are *not* re-entrant.
  35. //
  36. // To use: you should define the following macros in your configure.ac:
  37. // ACX_PTHREAD
  38. // AC_RWLOCK
  39. // The latter is defined in ../autoconf.
  40. //
  41. // This class is meant to be internal-only and should be wrapped by an
  42. // internal namespace. Before you use this module, please give the
  43. // name of your internal namespace for this module. Or, if you want
  44. // to expose it, you'll want to move it to the Google namespace. We
  45. // cannot put this class in global namespace because there can be some
  46. // problems when we have multiple versions of Mutex in each shared object.
  47. //
  48. // NOTE: by default, we have #ifdef'ed out the TryLock() method.
  49. // This is for two reasons:
  50. // 1) TryLock() under Windows is a bit annoying (it requires a
  51. // #define to be defined very early).
  52. // 2) TryLock() is broken for NO_THREADS mode, at least in NDEBUG
  53. // mode.
  54. // If you need TryLock(), and either these two caveats are not a
  55. // problem for you, or you're willing to work around them, then
  56. // feel free to #define GMUTEX_TRYLOCK, or to remove the #ifdefs
  57. // in the code below.
  58. //
  59. // CYGWIN NOTE: Cygwin support for rwlock seems to be buggy:
  60. // http://www.cygwin.com/ml/cygwin/2008-12/msg00017.html
  61. // Because of that, we might as well use windows locks for
  62. // cygwin. They seem to be more reliable than the cygwin pthreads layer.
  63. //
  64. // TRICKY IMPLEMENTATION NOTE:
  65. // This class is designed to be safe to use during
  66. // dynamic-initialization -- that is, by global constructors that are
  67. // run before main() starts. The issue in this case is that
  68. // dynamic-initialization happens in an unpredictable order, and it
  69. // could be that someone else's dynamic initializer could call a
  70. // function that tries to acquire this mutex -- but that all happens
  71. // before this mutex's constructor has run. (This can happen even if
  72. // the mutex and the function that uses the mutex are in the same .cc
  73. // file.) Basically, because Mutex does non-trivial work in its
  74. // constructor, it's not, in the naive implementation, safe to use
  75. // before dynamic initialization has run on it.
  76. //
  77. // The solution used here is to pair the actual mutex primitive with a
  78. // bool that is set to true when the mutex is dynamically initialized.
  79. // (Before that it's false.) Then we modify all mutex routines to
  80. // look at the bool, and not try to lock/unlock until the bool makes
  81. // it to true (which happens after the Mutex constructor has run.)
  82. //
  83. // This works because before main() starts -- particularly, during
  84. // dynamic initialization -- there are no threads, so a) it's ok that
  85. // the mutex operations are a no-op, since we don't need locking then
  86. // anyway; and b) we can be quite confident our bool won't change
  87. // state between a call to Lock() and a call to Unlock() (that would
  88. // require a global constructor in one translation unit to call Lock()
  89. // and another global constructor in another translation unit to call
  90. // Unlock() later, which is pretty perverse).
  91. //
  92. // That said, it's tricky, and can conceivably fail; it's safest to
  93. // avoid trying to acquire a mutex in a global constructor, if you
  94. // can. One way it can fail is that a really smart compiler might
  95. // initialize the bool to true at static-initialization time (too
  96. // early) rather than at dynamic-initialization time. To discourage
  97. // that, we set is_safe_ to true in code (not the constructor
  98. // colon-initializer) and set it to true via a function that always
  99. // evaluates to true, but that the compiler can't know always
  100. // evaluates to true. This should be good enough.
  101. #ifndef GOOGLE_MUTEX_H_
  102. #define GOOGLE_MUTEX_H_
  103. #include "config.h" // to figure out pthreads support
  104. #if defined(NO_THREADS)
  105. typedef int MutexType; // to keep a lock-count
  106. #elif defined(_WIN32) || defined(__CYGWIN32__) || defined(__CYGWIN64__)
  107. # define WIN32_LEAN_AND_MEAN // We only need minimal includes
  108. # ifdef GMUTEX_TRYLOCK
  109. // We need Windows NT or later for TryEnterCriticalSection(). If you
  110. // don't need that functionality, you can remove these _WIN32_WINNT
  111. // lines, and change TryLock() to assert(0) or something.
  112. # ifndef _WIN32_WINNT
  113. # define _WIN32_WINNT 0x0400
  114. # endif
  115. # endif
  116. // To avoid macro definition of ERROR.
  117. # define NOGDI
  118. // To avoid macro definition of min/max.
  119. # define NOMINMAX
  120. # include <windows.h>
  121. typedef CRITICAL_SECTION MutexType;
  122. #elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK)
  123. // Needed for pthread_rwlock_*. If it causes problems, you could take it
  124. // out, but then you'd have to unset HAVE_RWLOCK (at least on linux -- it
  125. // *does* cause problems for FreeBSD, or MacOSX, but isn't needed
  126. // for locking there.)
  127. # ifdef __linux__
  128. # define _XOPEN_SOURCE 500 // may be needed to get the rwlock calls
  129. # endif
  130. # include <pthread.h>
  131. typedef pthread_rwlock_t MutexType;
  132. #elif defined(HAVE_PTHREAD)
  133. # include <pthread.h>
  134. typedef pthread_mutex_t MutexType;
  135. #else
  136. # error Need to implement mutex.h for your architecture, or #define NO_THREADS
  137. #endif
  138. // We need to include these header files after defining _XOPEN_SOURCE
  139. // as they may define the _XOPEN_SOURCE macro.
  140. #include <assert.h>
  141. #include <stdlib.h> // for abort()
  142. #define MUTEX_NAMESPACE glog_internal_namespace_
  143. namespace MUTEX_NAMESPACE {
  144. class Mutex {
  145. public:
  146. // Create a Mutex that is not held by anybody. This constructor is
  147. // typically used for Mutexes allocated on the heap or the stack.
  148. // See below for a recommendation for constructing global Mutex
  149. // objects.
  150. inline Mutex();
  151. // Destructor
  152. inline ~Mutex();
  153. inline void Lock(); // Block if needed until free then acquire exclusively
  154. inline void Unlock(); // Release a lock acquired via Lock()
  155. #ifdef GMUTEX_TRYLOCK
  156. inline bool TryLock(); // If free, Lock() and return true, else return false
  157. #endif
  158. // Note that on systems that don't support read-write locks, these may
  159. // be implemented as synonyms to Lock() and Unlock(). So you can use
  160. // these for efficiency, but don't use them anyplace where being able
  161. // to do shared reads is necessary to avoid deadlock.
  162. inline void ReaderLock(); // Block until free or shared then acquire a share
  163. inline void ReaderUnlock(); // Release a read share of this Mutex
  164. inline void WriterLock() { Lock(); } // Acquire an exclusive lock
  165. inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock()
  166. // TODO(hamaji): Do nothing, implement correctly.
  167. inline void AssertHeld() {}
  168. private:
  169. MutexType mutex_;
  170. // We want to make sure that the compiler sets is_safe_ to true only
  171. // when we tell it to, and never makes assumptions is_safe_ is
  172. // always true. volatile is the most reliable way to do that.
  173. volatile bool is_safe_;
  174. inline void SetIsSafe() { is_safe_ = true; }
  175. // Catch the error of writing Mutex when intending MutexLock.
  176. Mutex(Mutex* /*ignored*/) {}
  177. // Disallow "evil" constructors
  178. Mutex(const Mutex&);
  179. void operator=(const Mutex&);
  180. };
  181. // Now the implementation of Mutex for various systems
  182. #if defined(NO_THREADS)
  183. // When we don't have threads, we can be either reading or writing,
  184. // but not both. We can have lots of readers at once (in no-threads
  185. // mode, that's most likely to happen in recursive function calls),
  186. // but only one writer. We represent this by having mutex_ be -1 when
  187. // writing and a number > 0 when reading (and 0 when no lock is held).
  188. //
  189. // In debug mode, we assert these invariants, while in non-debug mode
  190. // we do nothing, for efficiency. That's why everything is in an
  191. // assert.
  192. Mutex::Mutex() : mutex_(0) { }
  193. Mutex::~Mutex() { assert(mutex_ == 0); }
  194. void Mutex::Lock() { assert(--mutex_ == -1); }
  195. void Mutex::Unlock() { assert(mutex_++ == -1); }
  196. #ifdef GMUTEX_TRYLOCK
  197. bool Mutex::TryLock() { if (mutex_) return false; Lock(); return true; }
  198. #endif
  199. void Mutex::ReaderLock() { assert(++mutex_ > 0); }
  200. void Mutex::ReaderUnlock() { assert(mutex_-- > 0); }
  201. #elif defined(_WIN32) || defined(__CYGWIN32__) || defined(__CYGWIN64__)
  202. Mutex::Mutex() { InitializeCriticalSection(&mutex_); SetIsSafe(); }
  203. Mutex::~Mutex() { DeleteCriticalSection(&mutex_); }
  204. void Mutex::Lock() { if (is_safe_) EnterCriticalSection(&mutex_); }
  205. void Mutex::Unlock() { if (is_safe_) LeaveCriticalSection(&mutex_); }
  206. #ifdef GMUTEX_TRYLOCK
  207. bool Mutex::TryLock() { return is_safe_ ?
  208. TryEnterCriticalSection(&mutex_) != 0 : true; }
  209. #endif
  210. void Mutex::ReaderLock() { Lock(); } // we don't have read-write locks
  211. void Mutex::ReaderUnlock() { Unlock(); }
  212. #elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK)
  213. #define SAFE_PTHREAD(fncall) do { /* run fncall if is_safe_ is true */ \
  214. if (is_safe_ && fncall(&mutex_) != 0) abort(); \
  215. } while (0)
  216. Mutex::Mutex() {
  217. SetIsSafe();
  218. if (is_safe_ && pthread_rwlock_init(&mutex_, NULL) != 0) abort();
  219. }
  220. Mutex::~Mutex() { SAFE_PTHREAD(pthread_rwlock_destroy); }
  221. void Mutex::Lock() { SAFE_PTHREAD(pthread_rwlock_wrlock); }
  222. void Mutex::Unlock() { SAFE_PTHREAD(pthread_rwlock_unlock); }
  223. #ifdef GMUTEX_TRYLOCK
  224. bool Mutex::TryLock() { return is_safe_ ?
  225. pthread_rwlock_trywrlock(&mutex_) == 0 :
  226. true; }
  227. #endif
  228. void Mutex::ReaderLock() { SAFE_PTHREAD(pthread_rwlock_rdlock); }
  229. void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock); }
  230. #undef SAFE_PTHREAD
  231. #elif defined(HAVE_PTHREAD)
  232. #define SAFE_PTHREAD(fncall) do { /* run fncall if is_safe_ is true */ \
  233. if (is_safe_ && fncall(&mutex_) != 0) abort(); \
  234. } while (0)
  235. Mutex::Mutex() {
  236. SetIsSafe();
  237. if (is_safe_ && pthread_mutex_init(&mutex_, NULL) != 0) abort();
  238. }
  239. Mutex::~Mutex() { SAFE_PTHREAD(pthread_mutex_destroy); }
  240. void Mutex::Lock() { SAFE_PTHREAD(pthread_mutex_lock); }
  241. void Mutex::Unlock() { SAFE_PTHREAD(pthread_mutex_unlock); }
  242. #ifdef GMUTEX_TRYLOCK
  243. bool Mutex::TryLock() { return is_safe_ ?
  244. pthread_mutex_trylock(&mutex_) == 0 : true; }
  245. #endif
  246. void Mutex::ReaderLock() { Lock(); }
  247. void Mutex::ReaderUnlock() { Unlock(); }
  248. #undef SAFE_PTHREAD
  249. #endif
  250. // --------------------------------------------------------------------------
  251. // Some helper classes
  252. // MutexLock(mu) acquires mu when constructed and releases it when destroyed.
  253. class MutexLock {
  254. public:
  255. explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); }
  256. ~MutexLock() { mu_->Unlock(); }
  257. private:
  258. Mutex * const mu_;
  259. // Disallow "evil" constructors
  260. MutexLock(const MutexLock&);
  261. void operator=(const MutexLock&);
  262. };
  263. // ReaderMutexLock and WriterMutexLock do the same, for rwlocks
  264. class ReaderMutexLock {
  265. public:
  266. explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); }
  267. ~ReaderMutexLock() { mu_->ReaderUnlock(); }
  268. private:
  269. Mutex * const mu_;
  270. // Disallow "evil" constructors
  271. ReaderMutexLock(const ReaderMutexLock&);
  272. void operator=(const ReaderMutexLock&);
  273. };
  274. class WriterMutexLock {
  275. public:
  276. explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); }
  277. ~WriterMutexLock() { mu_->WriterUnlock(); }
  278. private:
  279. Mutex * const mu_;
  280. // Disallow "evil" constructors
  281. WriterMutexLock(const WriterMutexLock&);
  282. void operator=(const WriterMutexLock&);
  283. };
  284. // Catch bug where variable name is omitted, e.g. MutexLock (&mu);
  285. #define MutexLock(x) COMPILE_ASSERT(0, mutex_lock_decl_missing_var_name)
  286. #define ReaderMutexLock(x) COMPILE_ASSERT(0, rmutex_lock_decl_missing_var_name)
  287. #define WriterMutexLock(x) COMPILE_ASSERT(0, wmutex_lock_decl_missing_var_name)
  288. } // namespace MUTEX_NAMESPACE
  289. using namespace MUTEX_NAMESPACE;
  290. #undef MUTEX_NAMESPACE
  291. #endif /* #define GOOGLE_MUTEX_H__ */