The Tor Browser / file comparison

comparison: intl/icu/source/common/umutex.cpp

intl/icu/source/common/umutex.cpp

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:8115880f7743
1 /*
2 ******************************************************************************
3 *
4 * Copyright (C) 1997-2013, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 ******************************************************************************
8 *
9 * File umutex.cpp
10 *
11 * Modification History:
12 *
13 * Date Name Description
14 * 04/02/97 aliu Creation.
15 * 04/07/99 srl updated
16 * 05/13/99 stephen Changed to umutex (from cmutex).
17 * 11/22/99 aliu Make non-global mutex autoinitialize [j151]
18 ******************************************************************************
19 */
20
21 #include "umutex.h"
22
23 #include "unicode/utypes.h"
24 #include "uassert.h"
25 #include "cmemory.h"
26 #include "ucln_cmn.h"
27
28
29 // The ICU global mutex. Used when ICU implementation code passes NULL for the mutex pointer.
30 static UMutex globalMutex = U_MUTEX_INITIALIZER;
31
32 /*
33 * ICU Mutex wrappers. Wrap operating system mutexes, giving the rest of ICU a
34 * platform independent set of mutex operations. For internal ICU use only.
35 */
36
37 #if defined(U_USER_MUTEX_CPP)
38 // Build time user mutex hook: #include "U_USER_MUTEX_CPP"
39 #include U_MUTEX_XSTR(U_USER_MUTEX_CPP)
40
41 #elif U_PLATFORM_HAS_WIN32_API
42
43 //-------------------------------------------------------------------------------------------
44 //
45 // Windows Specific Definitions
46 //
47 // Note: Cygwin (and possibly others) have both WIN32 and POSIX.
48 // Prefer Win32 in these cases. (Win32 comes ahead in the #if chain)
49 //
50 //-------------------------------------------------------------------------------------------
51
52 #if defined U_NO_PLATFORM_ATOMICS
53 #error ICU on Win32 requires support for low level atomic operations.
54 // Visual Studio, gcc, clang are OK. Shouldn't get here.
55 #endif
56
57
58 // This function is called when a test of a UInitOnce::fState reveals that
59 // initialization has not completed, that we either need to call the
60 // function on this thread, or wait for some other thread to complete.
61 //
62 // The actual call to the init function is made inline by template code
63 // that knows the C++ types involved. This function returns TRUE if
64 // the caller needs to call the Init function.
65 //
66
67 U_NAMESPACE_BEGIN
68
69 U_COMMON_API UBool U_EXPORT2 umtx_initImplPreInit(UInitOnce &uio) {
70 for (;;) {
71 int32_t previousState = InterlockedCompareExchange(
72 #if (U_PLATFORM == U_PF_MINGW) || (U_PLATFORM == U_PF_CYGWIN)
73 (LONG volatile *) // this is the type given in the API doc for this function.
74 #endif
75 &uio.fState, // Destination
76 1, // Exchange Value
77 0); // Compare value
78
79 if (previousState == 0) {
80 return true; // Caller will next call the init function.
81 // Current state == 1.
82 } else if (previousState == 2) {
83 // Another thread already completed the initialization.
84 // We can simply return FALSE, indicating no
85 // further action is needed by the caller.
86 return FALSE;
87 } else {
88 // Another thread is currently running the initialization.
89 // Wait until it completes.
90 do {
91 Sleep(1);
92 previousState = umtx_loadAcquire(uio.fState);
93 } while (previousState == 1);
94 }
95 }
96 }
97
98 // This function is called by the thread that ran an initialization function,
99 // just after completing the function.
100 //
101 // success: True: the inialization succeeded. No further calls to the init
102 // function will be made.
103 // False: the initializtion failed. The next call to umtx_initOnce()
104 // will retry the initialization.
105
106 U_COMMON_API void U_EXPORT2 umtx_initImplPostInit(UInitOnce &uio) {
107 umtx_storeRelease(uio.fState, 2);
108 }
109
110 U_NAMESPACE_END
111
112 static void winMutexInit(CRITICAL_SECTION *cs) {
113 InitializeCriticalSection(cs);
114 return;
115 }
116
117 U_CAPI void U_EXPORT2
118 umtx_lock(UMutex *mutex) {
119 if (mutex == NULL) {
120 mutex = &globalMutex;
121 }
122 CRITICAL_SECTION *cs = &mutex->fCS;
123 umtx_initOnce(mutex->fInitOnce, winMutexInit, cs);
124 EnterCriticalSection(cs);
125 }
126
127 U_CAPI void U_EXPORT2
128 umtx_unlock(UMutex* mutex)
129 {
130 if (mutex == NULL) {
131 mutex = &globalMutex;
132 }
133 LeaveCriticalSection(&mutex->fCS);
134 }
135
136 #elif U_PLATFORM_IMPLEMENTS_POSIX
137
138 //-------------------------------------------------------------------------------------------
139 //
140 // POSIX specific definitions
141 //
142 //-------------------------------------------------------------------------------------------
143
144 # include <pthread.h>
145
146 // Each UMutex consists of a pthread_mutex_t.
147 // All are statically initialized and ready for use.
148 // There is no runtime mutex initialization code needed.
149
150 U_CAPI void U_EXPORT2
151 umtx_lock(UMutex *mutex) {
152 if (mutex == NULL) {
153 mutex = &globalMutex;
154 }
155 int sysErr = pthread_mutex_lock(&mutex->fMutex);
156 (void)sysErr; // Suppress unused variable warnings.
157 U_ASSERT(sysErr == 0);
158 }
159
160
161 U_CAPI void U_EXPORT2
162 umtx_unlock(UMutex* mutex)
163 {
164 if (mutex == NULL) {
165 mutex = &globalMutex;
166 }
167 int sysErr = pthread_mutex_unlock(&mutex->fMutex);
168 (void)sysErr; // Suppress unused variable warnings.
169 U_ASSERT(sysErr == 0);
170 }
171
172 U_NAMESPACE_BEGIN
173
174 static pthread_mutex_t initMutex = PTHREAD_MUTEX_INITIALIZER;
175 static pthread_cond_t initCondition = PTHREAD_COND_INITIALIZER;
176
177
178 // This function is called when a test of a UInitOnce::fState reveals that
179 // initialization has not completed, that we either need to call the
180 // function on this thread, or wait for some other thread to complete.
181 //
182 // The actual call to the init function is made inline by template code
183 // that knows the C++ types involved. This function returns TRUE if
184 // the caller needs to call the Init function.
185 //
186 U_COMMON_API UBool U_EXPORT2
187 umtx_initImplPreInit(UInitOnce &uio) {
188 pthread_mutex_lock(&initMutex);
189 int32_t state = uio.fState;
190 if (state == 0) {
191 umtx_storeRelease(uio.fState, 1);
192 pthread_mutex_unlock(&initMutex);
193 return TRUE; // Caller will next call the init function.
194 } else {
195 while (uio.fState == 1) {
196 // Another thread is currently running the initialization.
197 // Wait until it completes.
198 pthread_cond_wait(&initCondition, &initMutex);
199 }
200 pthread_mutex_unlock(&initMutex);
201 U_ASSERT(uio.fState == 2);
202 return FALSE;
203 }
204 }
205
206
207
208 // This function is called by the thread that ran an initialization function,
209 // just after completing the function.
210 // Some threads may be waiting on the condition, requiring the broadcast wakeup.
211 // Some threads may be racing to test the fState variable outside of the mutex,
212 // requiring the use of store/release when changing its value.
213
214 U_COMMON_API void U_EXPORT2
215 umtx_initImplPostInit(UInitOnce &uio) {
216 pthread_mutex_lock(&initMutex);
217 umtx_storeRelease(uio.fState, 2);
218 pthread_cond_broadcast(&initCondition);
219 pthread_mutex_unlock(&initMutex);
220 }
221
222 U_NAMESPACE_END
223
224 // End of POSIX specific umutex implementation.
225
226 #else // Platform #define chain.
227
228 #error Unknown Platform
229
230 #endif // Platform #define chain.
231
232
233 //-------------------------------------------------------------------------------
234 //
235 // Atomic Operations, out-of-line versions.
236 // These are conditional, only defined if better versions
237 // were not available for the platform.
238 //
239 // These versions are platform neutral.
240 //
241 //--------------------------------------------------------------------------------
242
243 #if defined U_NO_PLATFORM_ATOMICS
244 static UMutex gIncDecMutex = U_MUTEX_INITIALIZER;
245
246 U_NAMESPACE_BEGIN
247
248 U_COMMON_API int32_t U_EXPORT2
249 umtx_atomic_inc(u_atomic_int32_t *p) {
250 int32_t retVal;
251 umtx_lock(&gIncDecMutex);
252 retVal = ++(*p);
253 umtx_unlock(&gIncDecMutex);
254 return retVal;
255 }
256
257
258 U_COMMON_API int32_t U_EXPORT2
259 umtx_atomic_dec(u_atomic_int32_t *p) {
260 int32_t retVal;
261 umtx_lock(&gIncDecMutex);
262 retVal = --(*p);
263 umtx_unlock(&gIncDecMutex);
264 return retVal;
265 }
266
267 U_COMMON_API int32_t U_EXPORT2
268 umtx_loadAcquire(u_atomic_int32_t &var) {
269 int32_t val = var;
270 umtx_lock(&gIncDecMutex);
271 umtx_unlock(&gIncDecMutex);
272 return val;
273 }
274
275 U_COMMON_API void U_EXPORT2
276 umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
277 umtx_lock(&gIncDecMutex);
278 umtx_unlock(&gIncDecMutex);
279 var = val;
280 }
281
282 U_NAMESPACE_END
283 #endif
284
285 //--------------------------------------------------------------------------
286 //
287 // Deprecated functions for setting user mutexes.
288 //
289 //--------------------------------------------------------------------------
290
291 U_DEPRECATED void U_EXPORT2
292 u_setMutexFunctions(const void * /*context */, UMtxInitFn *, UMtxFn *,
293 UMtxFn *, UMtxFn *, UErrorCode *status) {
294 if (U_SUCCESS(*status)) {
295 *status = U_UNSUPPORTED_ERROR;
296 }
297 return;
298 }
299
300
301
302 U_DEPRECATED void U_EXPORT2
303 u_setAtomicIncDecFunctions(const void * /*context */, UMtxAtomicFn *, UMtxAtomicFn *,
304 UErrorCode *status) {
305 if (U_SUCCESS(*status)) {
306 *status = U_UNSUPPORTED_ERROR;
307 }
308 return;
309 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial