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