1 /*
2 ******************************************************************************
3 *
4 * Copyright (C) 1997-2015, 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
27
28 // The ICU global mutex. Used when ICU implementation code passes NULL for the mutex pointer.
29 static UMutex globalMutex = U_MUTEX_INITIALIZER;
30
31 /*
32 * ICU Mutex wrappers. Wrap operating system mutexes, giving the rest of ICU a
33 * platform independent set of mutex operations. For internal ICU use only.
34 */
35
36 #if defined(U_USER_MUTEX_CPP)
37 // Build time user mutex hook: #include "U_USER_MUTEX_CPP"
38 #include U_MUTEX_XSTR(U_USER_MUTEX_CPP)
39
40 #elif U_PLATFORM_HAS_WIN32_API
41
42 //-------------------------------------------------------------------------------------------
43 //
44 // Windows Specific Definitions
45 //
46 // Note: Cygwin (and possibly others) have both WIN32 and POSIX.
47 // Prefer Win32 in these cases. (Win32 comes ahead in the #if chain)
48 //
49 //-------------------------------------------------------------------------------------------
50
51 #if defined U_NO_PLATFORM_ATOMICS
52 #error ICU on Win32 requires support for low level atomic operations.
53 // Visual Studio, gcc, clang are OK. Shouldn't get here.
54 #endif
55
56
57 // This function is called when a test of a UInitOnce::fState reveals that
58 // initialization has not completed, that we either need to call the
59 // function on this thread, or wait for some other thread to complete.
60 //
61 // The actual call to the init function is made inline by template code
62 // that knows the C++ types involved. This function returns TRUE if
63 // the caller needs to call the Init function.
64 //
65
66 U_NAMESPACE_BEGIN
67
umtx_initImplPreInit(UInitOnce & uio)68 U_COMMON_API UBool U_EXPORT2 umtx_initImplPreInit(UInitOnce &uio) {
69 for (;;) {
70 int32_t previousState = InterlockedCompareExchange(
71 #if (U_PLATFORM == U_PF_MINGW) || (U_PLATFORM == U_PF_CYGWIN) || defined(__clang__)
72 (LONG volatile *) // this is the type given in the API doc for this function.
73 #endif
74 &uio.fState, // Destination
75 1, // Exchange Value
76 0); // Compare value
77
78 if (previousState == 0) {
79 return true; // Caller will next call the init function.
80 // Current state == 1.
81 } else if (previousState == 2) {
82 // Another thread already completed the initialization.
83 // We can simply return FALSE, indicating no
84 // further action is needed by the caller.
85 return FALSE;
86 } else {
87 // Another thread is currently running the initialization.
88 // Wait until it completes.
89 do {
90 Sleep(1);
91 previousState = umtx_loadAcquire(uio.fState);
92 } while (previousState == 1);
93 }
94 }
95 }
96
97 // This function is called by the thread that ran an initialization function,
98 // just after completing the function.
99
umtx_initImplPostInit(UInitOnce & uio)100 U_COMMON_API void U_EXPORT2 umtx_initImplPostInit(UInitOnce &uio) {
101 umtx_storeRelease(uio.fState, 2);
102 }
103
104 U_NAMESPACE_END
105
winMutexInit(CRITICAL_SECTION * cs)106 static void winMutexInit(CRITICAL_SECTION *cs) {
107 InitializeCriticalSection(cs);
108 return;
109 }
110
111 U_CAPI void U_EXPORT2
umtx_lock(UMutex * mutex)112 umtx_lock(UMutex *mutex) {
113 if (mutex == NULL) {
114 mutex = &globalMutex;
115 }
116 CRITICAL_SECTION *cs = &mutex->fCS;
117 umtx_initOnce(mutex->fInitOnce, winMutexInit, cs);
118 EnterCriticalSection(cs);
119 }
120
121 U_CAPI void U_EXPORT2
umtx_unlock(UMutex * mutex)122 umtx_unlock(UMutex* mutex)
123 {
124 if (mutex == NULL) {
125 mutex = &globalMutex;
126 }
127 LeaveCriticalSection(&mutex->fCS);
128 }
129
130
131 U_CAPI void U_EXPORT2
umtx_condBroadcast(UConditionVar * condition)132 umtx_condBroadcast(UConditionVar *condition) {
133 // We require that the associated mutex be held by the caller,
134 // so access to fWaitCount is protected and safe. No other thread can
135 // call condWait() while we are here.
136 if (condition->fWaitCount == 0) {
137 return;
138 }
139 ResetEvent(condition->fExitGate);
140 SetEvent(condition->fEntryGate);
141 }
142
143 U_CAPI void U_EXPORT2
umtx_condSignal(UConditionVar * condition)144 umtx_condSignal(UConditionVar *condition) {
145 // Function not implemented. There is no immediate requirement from ICU to have it.
146 // Once ICU drops support for Windows XP and Server 2003, ICU Condition Variables will be
147 // changed to be thin wrappers on native Windows CONDITION_VARIABLEs, and this function
148 // becomes trivial to provide.
149 U_ASSERT(FALSE);
150 }
151
152 U_CAPI void U_EXPORT2
umtx_condWait(UConditionVar * condition,UMutex * mutex)153 umtx_condWait(UConditionVar *condition, UMutex *mutex) {
154 if (condition->fEntryGate == NULL) {
155 // Note: because the associated mutex must be locked when calling
156 // wait, we know that there can not be multiple threads
157 // running here with the same condition variable.
158 // Meaning that lazy initialization is safe.
159 U_ASSERT(condition->fExitGate == NULL);
160 condition->fEntryGate = CreateEvent(NULL, // Security Attributes
161 TRUE, // Manual Reset
162 FALSE, // Initially reset
163 NULL); // Name.
164 U_ASSERT(condition->fEntryGate != NULL);
165 condition->fExitGate = CreateEvent(NULL, TRUE, TRUE, NULL);
166 U_ASSERT(condition->fExitGate != NULL);
167 }
168
169 condition->fWaitCount++;
170 umtx_unlock(mutex);
171 WaitForSingleObject(condition->fEntryGate, INFINITE);
172 umtx_lock(mutex);
173 condition->fWaitCount--;
174 if (condition->fWaitCount == 0) {
175 // All threads that were waiting at the entry gate have woken up
176 // and moved through. Shut the entry gate and open the exit gate.
177 ResetEvent(condition->fEntryGate);
178 SetEvent(condition->fExitGate);
179 } else {
180 umtx_unlock(mutex);
181 WaitForSingleObject(condition->fExitGate, INFINITE);
182 umtx_lock(mutex);
183 }
184 }
185
186
187 #elif U_PLATFORM_IMPLEMENTS_POSIX
188
189 //-------------------------------------------------------------------------------------------
190 //
191 // POSIX specific definitions
192 //
193 //-------------------------------------------------------------------------------------------
194
195 # include <pthread.h>
196
197 // Each UMutex consists of a pthread_mutex_t.
198 // All are statically initialized and ready for use.
199 // There is no runtime mutex initialization code needed.
200
201 U_CAPI void U_EXPORT2
umtx_lock(UMutex * mutex)202 umtx_lock(UMutex *mutex) {
203 if (mutex == NULL) {
204 mutex = &globalMutex;
205 }
206 int sysErr = pthread_mutex_lock(&mutex->fMutex);
207 (void)sysErr; // Suppress unused variable warnings.
208 U_ASSERT(sysErr == 0);
209 }
210
211
212 U_CAPI void U_EXPORT2
umtx_unlock(UMutex * mutex)213 umtx_unlock(UMutex* mutex)
214 {
215 if (mutex == NULL) {
216 mutex = &globalMutex;
217 }
218 int sysErr = pthread_mutex_unlock(&mutex->fMutex);
219 (void)sysErr; // Suppress unused variable warnings.
220 U_ASSERT(sysErr == 0);
221 }
222
223
224 U_CAPI void U_EXPORT2
umtx_condWait(UConditionVar * cond,UMutex * mutex)225 umtx_condWait(UConditionVar *cond, UMutex *mutex) {
226 if (mutex == NULL) {
227 mutex = &globalMutex;
228 }
229 int sysErr = pthread_cond_wait(&cond->fCondition, &mutex->fMutex);
230 (void)sysErr;
231 U_ASSERT(sysErr == 0);
232 }
233
234 U_CAPI void U_EXPORT2
umtx_condBroadcast(UConditionVar * cond)235 umtx_condBroadcast(UConditionVar *cond) {
236 int sysErr = pthread_cond_broadcast(&cond->fCondition);
237 (void)sysErr;
238 U_ASSERT(sysErr == 0);
239 }
240
241 U_CAPI void U_EXPORT2
umtx_condSignal(UConditionVar * cond)242 umtx_condSignal(UConditionVar *cond) {
243 int sysErr = pthread_cond_signal(&cond->fCondition);
244 (void)sysErr;
245 U_ASSERT(sysErr == 0);
246 }
247
248
249
250 U_NAMESPACE_BEGIN
251
252 static pthread_mutex_t initMutex = PTHREAD_MUTEX_INITIALIZER;
253 static pthread_cond_t initCondition = PTHREAD_COND_INITIALIZER;
254
255
256 // This function is called when a test of a UInitOnce::fState reveals that
257 // initialization has not completed, that we either need to call the
258 // function on this thread, or wait for some other thread to complete.
259 //
260 // The actual call to the init function is made inline by template code
261 // that knows the C++ types involved. This function returns TRUE if
262 // the caller needs to call the Init function.
263 //
264 U_COMMON_API UBool U_EXPORT2
umtx_initImplPreInit(UInitOnce & uio)265 umtx_initImplPreInit(UInitOnce &uio) {
266 pthread_mutex_lock(&initMutex);
267 int32_t state = uio.fState;
268 if (state == 0) {
269 umtx_storeRelease(uio.fState, 1);
270 pthread_mutex_unlock(&initMutex);
271 return TRUE; // Caller will next call the init function.
272 } else {
273 while (uio.fState == 1) {
274 // Another thread is currently running the initialization.
275 // Wait until it completes.
276 pthread_cond_wait(&initCondition, &initMutex);
277 }
278 pthread_mutex_unlock(&initMutex);
279 U_ASSERT(uio.fState == 2);
280 return FALSE;
281 }
282 }
283
284
285
286 // This function is called by the thread that ran an initialization function,
287 // just after completing the function.
288 // Some threads may be waiting on the condition, requiring the broadcast wakeup.
289 // Some threads may be racing to test the fState variable outside of the mutex,
290 // requiring the use of store/release when changing its value.
291
292 U_COMMON_API void U_EXPORT2
umtx_initImplPostInit(UInitOnce & uio)293 umtx_initImplPostInit(UInitOnce &uio) {
294 pthread_mutex_lock(&initMutex);
295 umtx_storeRelease(uio.fState, 2);
296 pthread_cond_broadcast(&initCondition);
297 pthread_mutex_unlock(&initMutex);
298 }
299
300 U_NAMESPACE_END
301
302 // End of POSIX specific umutex implementation.
303
304 #else // Platform #define chain.
305
306 #error Unknown Platform
307
308 #endif // Platform #define chain.
309
310
311 //-------------------------------------------------------------------------------
312 //
313 // Atomic Operations, out-of-line versions.
314 // These are conditional, only defined if better versions
315 // were not available for the platform.
316 //
317 // These versions are platform neutral.
318 //
319 //--------------------------------------------------------------------------------
320
321 #if defined U_NO_PLATFORM_ATOMICS
322 static UMutex gIncDecMutex = U_MUTEX_INITIALIZER;
323
324 U_NAMESPACE_BEGIN
325
326 U_COMMON_API int32_t U_EXPORT2
umtx_atomic_inc(u_atomic_int32_t * p)327 umtx_atomic_inc(u_atomic_int32_t *p) {
328 int32_t retVal;
329 umtx_lock(&gIncDecMutex);
330 retVal = ++(*p);
331 umtx_unlock(&gIncDecMutex);
332 return retVal;
333 }
334
335
336 U_COMMON_API int32_t U_EXPORT2
umtx_atomic_dec(u_atomic_int32_t * p)337 umtx_atomic_dec(u_atomic_int32_t *p) {
338 int32_t retVal;
339 umtx_lock(&gIncDecMutex);
340 retVal = --(*p);
341 umtx_unlock(&gIncDecMutex);
342 return retVal;
343 }
344
345 U_COMMON_API int32_t U_EXPORT2
umtx_loadAcquire(u_atomic_int32_t & var)346 umtx_loadAcquire(u_atomic_int32_t &var) {
347 umtx_lock(&gIncDecMutex);
348 int32_t val = var;
349 umtx_unlock(&gIncDecMutex);
350 return val;
351 }
352
353 U_COMMON_API void U_EXPORT2
umtx_storeRelease(u_atomic_int32_t & var,int32_t val)354 umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
355 umtx_lock(&gIncDecMutex);
356 var = val;
357 umtx_unlock(&gIncDecMutex);
358 }
359
360 U_NAMESPACE_END
361 #endif
362
363 //--------------------------------------------------------------------------
364 //
365 // Deprecated functions for setting user mutexes.
366 //
367 //--------------------------------------------------------------------------
368
369 U_DEPRECATED void U_EXPORT2
u_setMutexFunctions(const void *,UMtxInitFn *,UMtxFn *,UMtxFn *,UMtxFn *,UErrorCode * status)370 u_setMutexFunctions(const void * /*context */, UMtxInitFn *, UMtxFn *,
371 UMtxFn *, UMtxFn *, UErrorCode *status) {
372 if (U_SUCCESS(*status)) {
373 *status = U_UNSUPPORTED_ERROR;
374 }
375 return;
376 }
377
378
379
380 U_DEPRECATED void U_EXPORT2
u_setAtomicIncDecFunctions(const void *,UMtxAtomicFn *,UMtxAtomicFn *,UErrorCode * status)381 u_setAtomicIncDecFunctions(const void * /*context */, UMtxAtomicFn *, UMtxAtomicFn *,
382 UErrorCode *status) {
383 if (U_SUCCESS(*status)) {
384 *status = U_UNSUPPORTED_ERROR;
385 }
386 return;
387 }
388