1 /* 2 ********************************************************************** 3 * Copyright (C) 1997-2015, International Business Machines 4 * Corporation and others. All Rights Reserved. 5 ********************************************************************** 6 * 7 * File UMUTEX.H 8 * 9 * Modification History: 10 * 11 * Date Name Description 12 * 04/02/97 aliu Creation. 13 * 04/07/99 srl rewrite - C interface, multiple mutices 14 * 05/13/99 stephen Changed to umutex (from cmutex) 15 ****************************************************************************** 16 */ 17 18 #ifndef UMUTEX_H 19 #define UMUTEX_H 20 21 #include "unicode/utypes.h" 22 #include "unicode/uclean.h" 23 #include "putilimp.h" 24 25 26 27 // Forward Declarations. UMutex is not in the ICU namespace (yet) because 28 // there are some remaining references from plain C. 29 struct UMutex; 30 struct UConditionVar; 31 32 U_NAMESPACE_BEGIN 33 struct UInitOnce; 34 U_NAMESPACE_END 35 36 // Stringify macros, to allow #include of user supplied atomic & mutex files. 37 #define U_MUTEX_STR(s) #s 38 #define U_MUTEX_XSTR(s) U_MUTEX_STR(s) 39 40 /**************************************************************************** 41 * 42 * Low Level Atomic Operations. 43 * Compiler dependent. Not operating system dependent. 44 * 45 ****************************************************************************/ 46 #if defined (U_USER_ATOMICS_H) 47 #include U_MUTEX_XSTR(U_USER_ATOMICS_H) 48 49 #elif U_HAVE_STD_ATOMICS 50 51 // C++11 atomics are available. 52 53 #include <atomic> 54 55 U_NAMESPACE_BEGIN 56 57 typedef std::atomic<int32_t> u_atomic_int32_t; 58 #define ATOMIC_INT32_T_INITIALIZER(val) ATOMIC_VAR_INIT(val) 59 60 inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) { 61 return var.load(std::memory_order_acquire); 62 } 63 64 inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) { 65 var.store(val, std::memory_order_release); 66 } 67 68 inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) { 69 return var->fetch_add(1) + 1; 70 } 71 72 inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) { 73 return var->fetch_sub(1) - 1; 74 } 75 U_NAMESPACE_END 76 77 #elif U_PLATFORM_HAS_WIN32_API 78 79 // MSVC compiler. Reads and writes of volatile variables have 80 // acquire and release memory semantics, respectively. 81 // This is a Microsoft extension, not standard C++ behavior. 82 // 83 // Update: can't use this because of MinGW, built with gcc. 84 // Original plan was to use gcc atomics for MinGW, but they 85 // aren't supported, so we fold MinGW into this path. 86 87 # define WIN32_LEAN_AND_MEAN 88 # define VC_EXTRALEAN 89 # define NOUSER 90 # define NOSERVICE 91 # define NOIME 92 # define NOMCX 93 # ifndef NOMINMAX 94 # define NOMINMAX 95 # endif 96 # include <windows.h> 97 98 U_NAMESPACE_BEGIN 99 typedef volatile LONG u_atomic_int32_t; 100 #define ATOMIC_INT32_T_INITIALIZER(val) val 101 102 inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) { 103 return InterlockedCompareExchange(&var, 0, 0); 104 } 105 106 inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) { 107 InterlockedExchange(&var, val); 108 } 109 110 111 inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) { 112 return InterlockedIncrement(var); 113 } 114 115 inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) { 116 return InterlockedDecrement(var); 117 } 118 U_NAMESPACE_END 119 120 121 #elif U_HAVE_CLANG_ATOMICS 122 /* 123 * Clang __c11 atomic built-ins 124 */ 125 126 U_NAMESPACE_BEGIN 127 typedef _Atomic(int32_t) u_atomic_int32_t; 128 #define ATOMIC_INT32_T_INITIALIZER(val) val 129 130 inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) { 131 return __c11_atomic_load(&var, __ATOMIC_ACQUIRE); 132 } 133 134 inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) { 135 return __c11_atomic_store(&var, val, __ATOMIC_RELEASE); 136 } 137 138 inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) { 139 return __c11_atomic_fetch_add(var, 1, __ATOMIC_SEQ_CST) + 1; 140 } 141 142 inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) { 143 return __c11_atomic_fetch_sub(var, 1, __ATOMIC_SEQ_CST) - 1; 144 } 145 U_NAMESPACE_END 146 147 148 #elif U_HAVE_GCC_ATOMICS 149 /* 150 * gcc atomic ops. These are available on several other compilers as well. 151 */ 152 153 U_NAMESPACE_BEGIN 154 typedef int32_t u_atomic_int32_t; 155 #define ATOMIC_INT32_T_INITIALIZER(val) val 156 157 inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) { 158 int32_t val = var; 159 __sync_synchronize(); 160 return val; 161 } 162 163 inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) { 164 __sync_synchronize(); 165 var = val; 166 } 167 168 inline int32_t umtx_atomic_inc(u_atomic_int32_t *p) { 169 return __sync_add_and_fetch(p, 1); 170 } 171 172 inline int32_t umtx_atomic_dec(u_atomic_int32_t *p) { 173 return __sync_sub_and_fetch(p, 1); 174 } 175 U_NAMESPACE_END 176 177 #else 178 179 /* 180 * Unknown Platform. Use out-of-line functions, which in turn use mutexes. 181 * Slow but correct. 182 */ 183 184 #define U_NO_PLATFORM_ATOMICS 185 186 U_NAMESPACE_BEGIN 187 typedef int32_t u_atomic_int32_t; 188 #define ATOMIC_INT32_T_INITIALIZER(val) val 189 190 U_COMMON_API int32_t U_EXPORT2 191 umtx_loadAcquire(u_atomic_int32_t &var); 192 193 U_COMMON_API void U_EXPORT2 194 umtx_storeRelease(u_atomic_int32_t &var, int32_t val); 195 196 U_COMMON_API int32_t U_EXPORT2 197 umtx_atomic_inc(u_atomic_int32_t *p); 198 199 U_COMMON_API int32_t U_EXPORT2 200 umtx_atomic_dec(u_atomic_int32_t *p); 201 202 U_NAMESPACE_END 203 204 #endif /* Low Level Atomic Ops Platfrom Chain */ 205 206 207 208 /************************************************************************************************* 209 * 210 * UInitOnce Definitions. 211 * These are platform neutral. 212 * 213 *************************************************************************************************/ 214 215 U_NAMESPACE_BEGIN 216 217 struct UInitOnce { 218 u_atomic_int32_t fState; 219 UErrorCode fErrCode; 220 void reset() {fState = 0;}; 221 UBool isReset() {return umtx_loadAcquire(fState) == 0;}; 222 // Note: isReset() is used by service registration code. 223 // Thread safety of this usage needs review. 224 }; 225 226 #define U_INITONCE_INITIALIZER {ATOMIC_INT32_T_INITIALIZER(0), U_ZERO_ERROR} 227 228 229 U_COMMON_API UBool U_EXPORT2 umtx_initImplPreInit(UInitOnce &); 230 U_COMMON_API void U_EXPORT2 umtx_initImplPostInit(UInitOnce &); 231 232 template<class T> void umtx_initOnce(UInitOnce &uio, T *obj, void (T::*fp)()) { 233 if (umtx_loadAcquire(uio.fState) == 2) { 234 return; 235 } 236 if (umtx_initImplPreInit(uio)) { 237 (obj->*fp)(); 238 umtx_initImplPostInit(uio); 239 } 240 } 241 242 243 // umtx_initOnce variant for plain functions, or static class functions. 244 // No context parameter. 245 inline void umtx_initOnce(UInitOnce &uio, void (*fp)()) { 246 if (umtx_loadAcquire(uio.fState) == 2) { 247 return; 248 } 249 if (umtx_initImplPreInit(uio)) { 250 (*fp)(); 251 umtx_initImplPostInit(uio); 252 } 253 } 254 255 // umtx_initOnce variant for plain functions, or static class functions. 256 // With ErrorCode, No context parameter. 257 inline void umtx_initOnce(UInitOnce &uio, void (*fp)(UErrorCode &), UErrorCode &errCode) { 258 if (U_FAILURE(errCode)) { 259 return; 260 } 261 if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { 262 // We run the initialization. 263 (*fp)(errCode); 264 uio.fErrCode = errCode; 265 umtx_initImplPostInit(uio); 266 } else { 267 // Someone else already ran the initialization. 268 if (U_FAILURE(uio.fErrCode)) { 269 errCode = uio.fErrCode; 270 } 271 } 272 } 273 274 // umtx_initOnce variant for plain functions, or static class functions, 275 // with a context parameter. 276 template<class T> void umtx_initOnce(UInitOnce &uio, void (*fp)(T), T context) { 277 if (umtx_loadAcquire(uio.fState) == 2) { 278 return; 279 } 280 if (umtx_initImplPreInit(uio)) { 281 (*fp)(context); 282 umtx_initImplPostInit(uio); 283 } 284 } 285 286 // umtx_initOnce variant for plain functions, or static class functions, 287 // with a context parameter and an error code. 288 template<class T> void umtx_initOnce(UInitOnce &uio, void (*fp)(T, UErrorCode &), T context, UErrorCode &errCode) { 289 if (U_FAILURE(errCode)) { 290 return; 291 } 292 if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) { 293 // We run the initialization. 294 (*fp)(context, errCode); 295 uio.fErrCode = errCode; 296 umtx_initImplPostInit(uio); 297 } else { 298 // Someone else already ran the initialization. 299 if (U_FAILURE(uio.fErrCode)) { 300 errCode = uio.fErrCode; 301 } 302 } 303 } 304 305 U_NAMESPACE_END 306 307 308 309 /************************************************************************************************* 310 * 311 * Mutex Definitions. Platform Dependent, #if platform chain follows. 312 * TODO: Add a C++11 version. 313 * Need to convert all mutex using files to C++ first. 314 * 315 *************************************************************************************************/ 316 317 #if defined(U_USER_MUTEX_H) 318 // #inlcude "U_USER_MUTEX_H" 319 #include U_MUTEX_XSTR(U_USER_MUTEX_H) 320 321 #elif U_PLATFORM_HAS_WIN32_API 322 323 /* Windows Definitions. 324 * Windows comes first in the platform chain. 325 * Cygwin (and possibly others) have both WIN32 and POSIX APIs. Prefer Win32 in this case. 326 */ 327 328 329 /* For CRITICAL_SECTION */ 330 331 /* 332 * Note: there is an earlier include of windows.h in this file, but it is in 333 * different conditionals. 334 * This one is needed if we are using C++11 for atomic ops, but 335 * win32 APIs for Critical Sections. 336 */ 337 338 # define WIN32_LEAN_AND_MEAN 339 # define VC_EXTRALEAN 340 # define NOUSER 341 # define NOSERVICE 342 # define NOIME 343 # define NOMCX 344 # ifndef NOMINMAX 345 # define NOMINMAX 346 # endif 347 # include <windows.h> 348 349 350 typedef struct UMutex { 351 icu::UInitOnce fInitOnce; 352 CRITICAL_SECTION fCS; 353 } UMutex; 354 355 /* Initializer for a static UMUTEX. Deliberately contains no value for the 356 * CRITICAL_SECTION. 357 */ 358 #define U_MUTEX_INITIALIZER {U_INITONCE_INITIALIZER} 359 360 struct UConditionVar { 361 HANDLE fEntryGate; 362 HANDLE fExitGate; 363 int32_t fWaitCount; 364 }; 365 366 #define U_CONDITION_INITIALIZER {NULL, NULL, 0} 367 368 369 370 #elif U_PLATFORM_IMPLEMENTS_POSIX 371 372 /* 373 * POSIX platform 374 */ 375 376 #include <pthread.h> 377 378 struct UMutex { 379 pthread_mutex_t fMutex; 380 }; 381 typedef struct UMutex UMutex; 382 #define U_MUTEX_INITIALIZER {PTHREAD_MUTEX_INITIALIZER} 383 384 struct UConditionVar { 385 pthread_cond_t fCondition; 386 }; 387 #define U_CONDITION_INITIALIZER {PTHREAD_COND_INITIALIZER} 388 389 #else 390 391 /* 392 * Unknow platform type. 393 * This is an error condition. ICU requires mutexes. 394 */ 395 396 #error Unknown Platform. 397 398 #endif 399 400 401 402 /************************************************************************************** 403 * 404 * Mutex Implementation function declaratations. 405 * Declarations are platform neutral. 406 * Implementations, in umutex.cpp, are platform specific. 407 * 408 ************************************************************************************/ 409 410 /* Lock a mutex. 411 * @param mutex The given mutex to be locked. Pass NULL to specify 412 * the global ICU mutex. Recursive locks are an error 413 * and may cause a deadlock on some platforms. 414 */ 415 U_INTERNAL void U_EXPORT2 umtx_lock(UMutex* mutex); 416 417 /* Unlock a mutex. 418 * @param mutex The given mutex to be unlocked. Pass NULL to specify 419 * the global ICU mutex. 420 */ 421 U_INTERNAL void U_EXPORT2 umtx_unlock (UMutex* mutex); 422 423 /* 424 * Wait on a condition variable. 425 * The calling thread will unlock the mutex and wait on the condition variable. 426 * The mutex must be locked by the calling thread when invoking this function. 427 * 428 * @param cond the condition variable to wait on. 429 * @param mutex the associated mutex. 430 */ 431 432 U_INTERNAL void U_EXPORT2 umtx_condWait(UConditionVar *cond, UMutex *mutex); 433 434 435 /* 436 * Broadcast wakeup of all threads waiting on a Condition. 437 * The associated mutex must be locked by the calling thread when calling 438 * this function; this is a temporary ICU restriction. 439 * 440 * @param cond the condition variable. 441 */ 442 U_INTERNAL void U_EXPORT2 umtx_condBroadcast(UConditionVar *cond); 443 444 /* 445 * Signal a condition variable, waking up one waiting thread. 446 * CAUTION: Do not use. Place holder only. Not implemented for Windows. 447 */ 448 U_INTERNAL void U_EXPORT2 umtx_condSignal(UConditionVar *cond); 449 450 #endif /* UMUTEX_H */ 451 /*eof*/ 452
