← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/re2/src/util/mutex.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/re2/src/util/mutex.h
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
 
 
13
 
namespace 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
 
 
54
 
class 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
 
 
99
 
Mutex::Mutex() : mutex_(0) { }
100
 
Mutex::~Mutex()            { assert(mutex_ == 0); }
101
 
void Mutex::Lock()         { assert(--mutex_ == -1); }
102
 
void Mutex::Unlock()       { assert(mutex_++ == -1); }
103
 
bool Mutex::TryLock()      { if (mutex_) return false; Lock(); return true; }
104
 
void Mutex::ReaderLock()   { assert(++mutex_ > 0); }
105
 
void 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
 
 
112
 
Mutex::Mutex()             { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); }
113
 
Mutex::~Mutex()            { SAFE_PTHREAD(pthread_rwlock_destroy(&mutex_)); }
114
 
void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); }
115
 
void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
116
 
bool Mutex::TryLock()      { return pthread_rwlock_trywrlock(&mutex_) == 0; }
117
 
void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); }
118
 
void 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
 
 
127
 
Mutex::Mutex()             { SAFE_PTHREAD(pthread_mutex_init(&mutex_, NULL)); }
128
 
Mutex::~Mutex()            { SAFE_PTHREAD(pthread_mutex_destroy(&mutex_)); }
129
 
void Mutex::Lock()         { SAFE_PTHREAD(pthread_mutex_lock(&mutex_)); }
130
 
void Mutex::Unlock()       { SAFE_PTHREAD(pthread_mutex_unlock(&mutex_)); }
131
 
bool Mutex::TryLock()      { return pthread_mutex_trylock(&mutex_) == 0; }
132
 
void Mutex::ReaderLock()   { Lock(); }      // we don't have read-write locks
133
 
void Mutex::ReaderUnlock() { Unlock(); }
134
 
#undef SAFE_PTHREAD
135
 
 
136
 
#elif defined(WIN32)
137
 
 
138
 
Mutex::Mutex()             { InitializeCriticalSection(&mutex_); }
139
 
Mutex::~Mutex()            { DeleteCriticalSection(&mutex_); }
140
 
void Mutex::Lock()         { EnterCriticalSection(&mutex_); }
141
 
void Mutex::Unlock()       { LeaveCriticalSection(&mutex_); }
142
 
bool Mutex::TryLock()      { return TryEnterCriticalSection(&mutex_) != 0; }
143
 
void Mutex::ReaderLock()   { Lock(); }      // we don't have read-write locks
144
 
void 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.
153
 
class 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
165
 
class 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
 
 
176
 
class 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_ */