icuSources/common/umutex.h

   1 // © 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 #ifndef WIN32_LEAN_AND_MEAN
  90 # define WIN32_LEAN_AND_MEAN
  91 #endif
  92 # define VC_EXTRALEAN
  93 # define NOUSER
  94 # define NOSERVICE
  95 # define NOIME
  96 # define NOMCX
  97 # ifndef NOMINMAX
  98 # define NOMINMAX
  99 # endif
 100 # include <windows.h>
 101
 102 U_NAMESPACE_BEGIN
 103 typedef volatile LONG u_atomic_int32_t;
 104 #define ATOMIC_INT32_T_INITIALIZER(val) val
 105
 106 inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) {
 107     return InterlockedCompareExchange(&var, 0, 0);
 108 }
 109
 110 inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
 111     InterlockedExchange(&var, val);
 112 }
 113
 114
 115 inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) {
 116     return InterlockedIncrement(var);
 117 }
 118
 119 inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) {
 120     return InterlockedDecrement(var);
 121 }
 122 U_NAMESPACE_END
 123
 124
 125 #elif U_HAVE_CLANG_ATOMICS
 126 /*
 127  *  Clang __c11 atomic built-ins
 128  */
 129
 130 U_NAMESPACE_BEGIN
 131 typedef _Atomic(int32_t) u_atomic_int32_t;
 132 #define ATOMIC_INT32_T_INITIALIZER(val) val
 133
 134 inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) {
 135      return __c11_atomic_load(&var, __ATOMIC_ACQUIRE);
 136 }
 137
 138 inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
 139    return __c11_atomic_store(&var, val, __ATOMIC_RELEASE);
 140 }
 141
 142 inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) {
 143     return __c11_atomic_fetch_add(var, 1, __ATOMIC_SEQ_CST) + 1;
 144 }
 145
 146 inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) {
 147     return __c11_atomic_fetch_sub(var, 1, __ATOMIC_SEQ_CST) - 1;
 148 }
 149 U_NAMESPACE_END
 150
 151
 152 #elif U_HAVE_GCC_ATOMICS
 153 /*
 154  * gcc atomic ops. These are available on several other compilers as well.
 155  */
 156
 157 U_NAMESPACE_BEGIN
 158 typedef int32_t u_atomic_int32_t;
 159 #define ATOMIC_INT32_T_INITIALIZER(val) val
 160
 161 inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) {
 162     int32_t val = var;
 163     __sync_synchronize();
 164     return val;
 165 }
 166
 167 inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
 168     __sync_synchronize();
 169     var = val;
 170 }
 171
 172 inline int32_t umtx_atomic_inc(u_atomic_int32_t *p)  {
 173    return __sync_add_and_fetch(p, 1);
 174 }
 175
 176 inline int32_t umtx_atomic_dec(u_atomic_int32_t *p)  {
 177    return __sync_sub_and_fetch(p, 1);
 178 }
 179 U_NAMESPACE_END
 180
 181 #else
 182
 183 /*
 184  * Unknown Platform. Use out-of-line functions, which in turn use mutexes.
 185  *                   Slow but correct.
 186  */
 187
 188 #define U_NO_PLATFORM_ATOMICS
 189
 190 U_NAMESPACE_BEGIN
 191 typedef int32_t u_atomic_int32_t;
 192 #define ATOMIC_INT32_T_INITIALIZER(val) val
 193
 194 U_COMMON_API int32_t U_EXPORT2
 195 umtx_loadAcquire(u_atomic_int32_t &var);
 196
 197 U_COMMON_API void U_EXPORT2
 198 umtx_storeRelease(u_atomic_int32_t &var, int32_t val);
 199
 200 U_COMMON_API int32_t U_EXPORT2
 201 umtx_atomic_inc(u_atomic_int32_t *p);
 202
 203 U_COMMON_API int32_t U_EXPORT2
 204 umtx_atomic_dec(u_atomic_int32_t *p);
 205
 206 U_NAMESPACE_END
 207
 208 #endif  /* Low Level Atomic Ops Platfrom Chain */
 209
 210
 211
 212 /*************************************************************************************************
 213  *
 214  *  UInitOnce Definitions.
 215  *     These are platform neutral.
 216  *
 217  *************************************************************************************************/
 218
 219 U_NAMESPACE_BEGIN
 220
 221 struct UInitOnce {
 222     u_atomic_int32_t   fState;
 223     UErrorCode       fErrCode;
 224     void reset() {fState = 0;};
 225     UBool isReset() {return umtx_loadAcquire(fState) == 0;};
 226 // Note: isReset() is used by service registration code.
 227 //                 Thread safety of this usage needs review.
 228 };
 229
 230 #define U_INITONCE_INITIALIZER {ATOMIC_INT32_T_INITIALIZER(0), U_ZERO_ERROR}
 231
 232
 233 U_COMMON_API UBool U_EXPORT2 umtx_initImplPreInit(UInitOnce &);
 234 U_COMMON_API void  U_EXPORT2 umtx_initImplPostInit(UInitOnce &);
 235
 236 template<class T> void umtx_initOnce(UInitOnce &uio, T *obj, void (U_CALLCONV T::*fp)()) {
 237     if (umtx_loadAcquire(uio.fState) == 2) {
 238         return;
 239     }
 240     if (umtx_initImplPreInit(uio)) {
 241         (obj->*fp)();
 242         umtx_initImplPostInit(uio);
 243     }
 244 }
 245
 246
 247 // umtx_initOnce variant for plain functions, or static class functions.
 248 //               No context parameter.
 249 inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)()) {
 250     if (umtx_loadAcquire(uio.fState) == 2) {
 251         return;
 252     }
 253     if (umtx_initImplPreInit(uio)) {
 254         (*fp)();
 255         umtx_initImplPostInit(uio);
 256     }
 257 }
 258
 259 // umtx_initOnce variant for plain functions, or static class functions.
 260 //               With ErrorCode, No context parameter.
 261 inline void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(UErrorCode &), UErrorCode &errCode) {
 262     if (U_FAILURE(errCode)) {
 263         return;
 264     }
 265     if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) {
 266         // We run the initialization.
 267         (*fp)(errCode);
 268         uio.fErrCode = errCode;
 269         umtx_initImplPostInit(uio);
 270     } else {
 271         // Someone else already ran the initialization.
 272         if (U_FAILURE(uio.fErrCode)) {
 273             errCode = uio.fErrCode;
 274         }
 275     }
 276 }
 277
 278 // umtx_initOnce variant for plain functions, or static class functions,
 279 //               with a context parameter.
 280 template<class T> void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T), T context) {
 281     if (umtx_loadAcquire(uio.fState) == 2) {
 282         return;
 283     }
 284     if (umtx_initImplPreInit(uio)) {
 285         (*fp)(context);
 286         umtx_initImplPostInit(uio);
 287     }
 288 }
 289
 290 // umtx_initOnce variant for plain functions, or static class functions,
 291 //               with a context parameter and an error code.
 292 template<class T> void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UErrorCode &), T context, UErrorCode &errCode) {
 293     if (U_FAILURE(errCode)) {
 294         return;
 295     }
 296     if (umtx_loadAcquire(uio.fState) != 2 && umtx_initImplPreInit(uio)) {
 297         // We run the initialization.
 298         (*fp)(context, errCode);
 299         uio.fErrCode = errCode;
 300         umtx_initImplPostInit(uio);
 301     } else {
 302         // Someone else already ran the initialization.
 303         if (U_FAILURE(uio.fErrCode)) {
 304             errCode = uio.fErrCode;
 305         }
 306     }
 307 }
 308
 309 U_NAMESPACE_END
 310
 311
 312
 313 /*************************************************************************************************
 314  *
 315  *  Mutex Definitions. Platform Dependent, #if platform chain follows.
 316  *         TODO:  Add a C++11 version.
 317  *                Need to convert all mutex using files to C++ first.
 318  *
 319  *************************************************************************************************/
 320
 321 #if defined(U_USER_MUTEX_H)
 322 // #inlcude "U_USER_MUTEX_H"
 323 #include U_MUTEX_XSTR(U_USER_MUTEX_H)
 324
 325 #elif U_PLATFORM_USES_ONLY_WIN32_API
 326
 327 /* For CRITICAL_SECTION */
 328
 329 /*
 330  *   Note: there is an earlier include of windows.h in this file, but it is in
 331  *         different conditionals.
 332  *         This one is needed if we are using C++11 for atomic ops, but
 333  *         win32 APIs for Critical Sections.
 334  */
 335
 336 #ifndef WIN32_LEAN_AND_MEAN
 337 # define WIN32_LEAN_AND_MEAN
 338 #endif
 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*/