| /* |
| ****************************************************************************** |
| * |
| * Copyright (C) 1997-2012, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ****************************************************************************** |
| * |
| * File umutex.cpp |
| * |
| * Modification History: |
| * |
| * Date Name Description |
| * 04/02/97 aliu Creation. |
| * 04/07/99 srl updated |
| * 05/13/99 stephen Changed to umutex (from cmutex). |
| * 11/22/99 aliu Make non-global mutex autoinitialize [j151] |
| ****************************************************************************** |
| */ |
| |
| #include "unicode/utypes.h" |
| #include "uassert.h" |
| #include "ucln_cmn.h" |
| |
| /* |
| * ICU Mutex wrappers. Wrap operating system mutexes, giving the rest of ICU a |
| * platform independent set of mutex operations. For internal ICU use only. |
| */ |
| |
| #if U_PLATFORM_HAS_WIN32_API |
| /* Prefer native Windows APIs even if POSIX is implemented (i.e., on Cygwin). */ |
| # undef POSIX |
| #elif U_PLATFORM_IMPLEMENTS_POSIX |
| # define POSIX |
| #else |
| # undef POSIX |
| #endif |
| |
| #if defined(POSIX) |
| # include <pthread.h> /* must be first, so that we get the multithread versions of things. */ |
| #endif /* POSIX */ |
| |
| #if U_PLATFORM_HAS_WIN32_API |
| # define WIN32_LEAN_AND_MEAN |
| # define VC_EXTRALEAN |
| # define NOUSER |
| # define NOSERVICE |
| # define NOIME |
| # define NOMCX |
| # include <windows.h> |
| #endif |
| |
| #include "umutex.h" |
| #include "cmemory.h" |
| |
| #if U_PLATFORM_HAS_WIN32_API |
| #define SYNC_COMPARE_AND_SWAP(dest, oldval, newval) \ |
| InterlockedCompareExchangePointer(dest, newval, oldval) |
| |
| #elif defined(POSIX) |
| #if (U_HAVE_GCC_ATOMICS == 1) |
| #define SYNC_COMPARE_AND_SWAP(dest, oldval, newval) \ |
| __sync_val_compare_and_swap(dest, oldval, newval) |
| #else |
| #define SYNC_COMPARE_AND_SWAP(dest, oldval, newval) \ |
| mutexed_compare_and_swap(dest, newval, oldval) |
| #endif |
| |
| #else |
| // Unknown platform. Note that user can still set mutex functions at run time. |
| #define SYNC_COMPARE_AND_SWAP(dest, oldval, newval) \ |
| mutexed_compare_and_swap(dest, newval, oldval) |
| #endif |
| |
| static void *mutexed_compare_and_swap(void **dest, void *newval, void *oldval); |
| |
| // The ICU global mutex. Used when ICU implementation code passes NULL for the mutex pointer. |
| static UMutex globalMutex = U_MUTEX_INITIALIZER; |
| |
| // Implementation mutex. Used for compare & swap when no intrinsic is available, and |
| // for safe initialization of user defined mutexes. |
| static UMutex implMutex = U_MUTEX_INITIALIZER; |
| |
| // List of all user mutexes that have been initialized. |
| // Used to allow us to destroy them when cleaning up ICU. |
| // Normal platform mutexes are not kept track of in this way - they survive until the process is shut down. |
| // Normal platfrom mutexes don't allocate storage, so not cleaning them up won't trigger memory leak complaints. |
| // |
| // Note: putting this list in allocated memory would be awkward to arrange, because memory allocations |
| // are used as a flag to indicate that ICU has been initialized, and setting other ICU |
| // override functions will no longer work. |
| // |
| static const int MUTEX_LIST_LIMIT = 100; |
| static UMutex *gMutexList[MUTEX_LIST_LIMIT]; |
| static int gMutexListSize = 0; |
| |
| |
| /* |
| * User mutex implementation functions. If non-null, call back to these rather than |
| * directly using the system (Posix or Windows) APIs. See u_setMutexFunctions(). |
| * (declarations are in uclean.h) |
| */ |
| static UMtxInitFn *pMutexInitFn = NULL; |
| static UMtxFn *pMutexDestroyFn = NULL; |
| static UMtxFn *pMutexLockFn = NULL; |
| static UMtxFn *pMutexUnlockFn = NULL; |
| static const void *gMutexContext = NULL; |
| |
| |
| // Clean up (undo) the effects of u_setMutexFunctions(). |
| // |
| static void usrMutexCleanup() { |
| if (pMutexDestroyFn != NULL) { |
| for (int i = 0; i < gMutexListSize; i++) { |
| UMutex *m = gMutexList[i]; |
| U_ASSERT(m->fInitialized); |
| (*pMutexDestroyFn)(gMutexContext, &m->fUserMutex); |
| m->fInitialized = FALSE; |
| } |
| (*pMutexDestroyFn)(gMutexContext, &globalMutex.fUserMutex); |
| (*pMutexDestroyFn)(gMutexContext, &implMutex.fUserMutex); |
| } |
| gMutexListSize = 0; |
| pMutexInitFn = NULL; |
| pMutexDestroyFn = NULL; |
| pMutexLockFn = NULL; |
| pMutexUnlockFn = NULL; |
| gMutexContext = NULL; |
| } |
| |
| |
| /* |
| * User mutex lock. |
| * |
| * User mutexes need to be initialized before they can be used. We use the impl mutex |
| * to synchronize the initialization check. This could be sped up on platforms that |
| * support alternate ways to safely check the initialization flag. |
| * |
| */ |
| static void usrMutexLock(UMutex *mutex) { |
| UErrorCode status = U_ZERO_ERROR; |
| if (!(mutex == &implMutex || mutex == &globalMutex)) { |
| umtx_lock(&implMutex); |
| if (!mutex->fInitialized) { |
| (*pMutexInitFn)(gMutexContext, &mutex->fUserMutex, &status); |
| U_ASSERT(U_SUCCESS(status)); |
| mutex->fInitialized = TRUE; |
| U_ASSERT(gMutexListSize < MUTEX_LIST_LIMIT); |
| if (gMutexListSize < MUTEX_LIST_LIMIT) { |
| gMutexList[gMutexListSize] = mutex; |
| ++gMutexListSize; |
| } |
| } |
| umtx_unlock(&implMutex); |
| } |
| (*pMutexLockFn)(gMutexContext, &mutex->fUserMutex); |
| } |
| |
| |
| |
| #if defined(POSIX) |
| |
| // |
| // POSIX implementation of UMutex. |
| // |
| // Each UMutex has a corresponding pthread_mutex_t. |
| // All are statically initialized and ready for use. |
| // There is no runtime mutex initialization code needed. |
| |
| U_CAPI void U_EXPORT2 |
| umtx_lock(UMutex *mutex) { |
| if (mutex == NULL) { |
| mutex = &globalMutex; |
| } |
| if (pMutexLockFn) { |
| usrMutexLock(mutex); |
| } else { |
| #if U_DEBUG |
| // #if to avoid unused variable warnings in non-debug builds. |
| int sysErr = pthread_mutex_lock(&mutex->fMutex); |
| U_ASSERT(sysErr == 0); |
| #else |
| pthread_mutex_lock(&mutex->fMutex); |
| #endif |
| } |
| } |
| |
| |
| U_CAPI void U_EXPORT2 |
| umtx_unlock(UMutex* mutex) |
| { |
| if (mutex == NULL) { |
| mutex = &globalMutex; |
| } |
| if (pMutexUnlockFn) { |
| (*pMutexUnlockFn)(gMutexContext, &mutex->fUserMutex); |
| } else { |
| #if U_DEBUG |
| // #if to avoid unused variable warnings in non-debug builds. |
| int sysErr = pthread_mutex_unlock(&mutex->fMutex); |
| U_ASSERT(sysErr == 0); |
| #else |
| pthread_mutex_unlock(&mutex->fMutex); |
| #endif |
| } |
| } |
| |
| #elif U_PLATFORM_HAS_WIN32_API |
| // |
| // Windows implementation of UMutex. |
| // |
| // Each UMutex has a corresponding Windows CRITICAL_SECTION. |
| // CRITICAL_SECTIONS must be initialized before use. This is done |
| // with a InitOnceExcuteOnce operation. |
| // |
| // InitOnceExecuteOnce was introduced with Windows Vista. For now ICU |
| // must support Windows XP, so we roll our own. ICU will switch to the |
| // native Windows InitOnceExecuteOnce when possible. |
| |
| typedef UBool (*U_PINIT_ONCE_FN) ( |
| U_INIT_ONCE *initOnce, |
| void *parameter, |
| void **context |
| ); |
| |
| UBool u_InitOnceExecuteOnce( |
| U_INIT_ONCE *initOnce, |
| U_PINIT_ONCE_FN initFn, |
| void *parameter, |
| void **context) { |
| for (;;) { |
| long previousState = InterlockedCompareExchange( |
| &initOnce->fState, // Destination, |
| 1, // Exchange Value |
| 0); // Compare value |
| if (previousState == 2) { |
| // Initialization was already completed. |
| if (context != NULL) { |
| *context = initOnce->fContext; |
| } |
| return TRUE; |
| } |
| if (previousState == 1) { |
| // Initialization is in progress in some other thread. |
| // Loop until it completes. |
| Sleep(1); |
| continue; |
| } |
| |
| // Initialization needed. Execute the callback function to do it. |
| U_ASSERT(previousState == 0); |
| U_ASSERT(initOnce->fState == 1); |
| UBool success = (*initFn)(initOnce, parameter, &initOnce->fContext); |
| U_ASSERT(success); // ICU is not supporting the failure case. |
| |
| // Assign the state indicating that initialization has completed. |
| // Using InterlockedCompareExchange to do it ensures that all |
| // threads will have a consistent view of memory. |
| previousState = InterlockedCompareExchange(&initOnce->fState, 2, 1); |
| U_ASSERT(previousState == 1); |
| // Next loop iteration will see the initialization and return. |
| } |
| }; |
| |
| static UBool winMutexInit(U_INIT_ONCE *initOnce, void *param, void **context) { |
| UMutex *mutex = static_cast<UMutex *>(param); |
| U_ASSERT(sizeof(CRITICAL_SECTION) <= sizeof(mutex->fCS)); |
| InitializeCriticalSection((CRITICAL_SECTION *)mutex->fCS); |
| return TRUE; |
| } |
| |
| /* |
| * umtx_lock |
| */ |
| U_CAPI void U_EXPORT2 |
| umtx_lock(UMutex *mutex) { |
| if (mutex == NULL) { |
| mutex = &globalMutex; |
| } |
| if (pMutexLockFn) { |
| usrMutexLock(mutex); |
| } else { |
| u_InitOnceExecuteOnce(&mutex->fInitOnce, winMutexInit, mutex, NULL); |
| EnterCriticalSection((CRITICAL_SECTION *)mutex->fCS); |
| } |
| } |
| |
| U_CAPI void U_EXPORT2 |
| umtx_unlock(UMutex* mutex) |
| { |
| if (mutex == NULL) { |
| mutex = &globalMutex; |
| } |
| if (pMutexUnlockFn) { |
| (*pMutexUnlockFn)(gMutexContext, &mutex->fUserMutex); |
| } else { |
| LeaveCriticalSection((CRITICAL_SECTION *)mutex->fCS); |
| } |
| } |
| |
| #endif // Windows Implementation |
| |
| |
| U_CAPI void U_EXPORT2 |
| u_setMutexFunctions(const void *context, UMtxInitFn *i, UMtxFn *d, UMtxFn *l, UMtxFn *u, |
| UErrorCode *status) { |
| if (U_FAILURE(*status)) { |
| return; |
| } |
| |
| /* Can not set a mutex function to a NULL value */ |
| if (i==NULL || d==NULL || l==NULL || u==NULL) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| /* If ICU is not in an initial state, disallow this operation. */ |
| if (cmemory_inUse()) { |
| *status = U_INVALID_STATE_ERROR; |
| return; |
| } |
| |
| // Clean up any previously set user mutex functions. |
| // It's possible to call u_setMutexFunctions() more than once without without explicitly cleaning up, |
| // and the last call should take. Kind of a corner case, but it worked once, there is a test for |
| // it, so we keep it working. The global and impl mutexes will have been created by the |
| // previous u_setMutexFunctions(), and now need to be destroyed. |
| |
| usrMutexCleanup(); |
| |
| /* Swap in the mutex function pointers. */ |
| pMutexInitFn = i; |
| pMutexDestroyFn = d; |
| pMutexLockFn = l; |
| pMutexUnlockFn = u; |
| gMutexContext = context; |
| gMutexListSize = 0; |
| |
| /* Initialize the global and impl mutexes. Safe to do at this point because |
| * u_setMutexFunctions must be done in a single-threaded envioronment. Not thread safe. |
| */ |
| (*pMutexInitFn)(gMutexContext, &globalMutex.fUserMutex, status); |
| globalMutex.fInitialized = TRUE; |
| (*pMutexInitFn)(gMutexContext, &implMutex.fUserMutex, status); |
| implMutex.fInitialized = TRUE; |
| } |
| |
| |
| |
| /* synchronized compare and swap function, for use when OS or compiler built-in |
| * equivalents aren't available. |
| */ |
| static void *mutexed_compare_and_swap(void **dest, void *newval, void *oldval) { |
| umtx_lock(&implMutex); |
| void *temp = *dest; |
| if (temp == oldval) { |
| *dest = newval; |
| } |
| umtx_unlock(&implMutex); |
| |
| return temp; |
| } |
| |
| |
| |
| /*----------------------------------------------------------------- |
| * |
| * Atomic Increment and Decrement |
| * umtx_atomic_inc |
| * umtx_atomic_dec |
| * |
| *----------------------------------------------------------------*/ |
| |
| /* Pointers to user-supplied inc/dec functions. Null if no funcs have been set. */ |
| static UMtxAtomicFn *pIncFn = NULL; |
| static UMtxAtomicFn *pDecFn = NULL; |
| static const void *gIncDecContext = NULL; |
| |
| #if defined (POSIX) && (U_HAVE_GCC_ATOMICS == 0) |
| static UMutex gIncDecMutex = U_MUTEX_INITIALIZER; |
| #endif |
| |
| U_CAPI int32_t U_EXPORT2 |
| umtx_atomic_inc(int32_t *p) { |
| int32_t retVal; |
| if (pIncFn) { |
| retVal = (*pIncFn)(gIncDecContext, p); |
| } else { |
| #if U_PLATFORM_HAS_WIN32_API |
| retVal = InterlockedIncrement((LONG*)p); |
| #elif defined(USE_MAC_OS_ATOMIC_INCREMENT) |
| retVal = OSAtomicIncrement32Barrier(p); |
| #elif (U_HAVE_GCC_ATOMICS == 1) |
| retVal = __sync_add_and_fetch(p, 1); |
| #elif defined (POSIX) |
| umtx_lock(&gIncDecMutex); |
| retVal = ++(*p); |
| umtx_unlock(&gIncDecMutex); |
| #else |
| /* Unknown Platform. */ |
| retVal = ++(*p); |
| #endif |
| } |
| return retVal; |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| umtx_atomic_dec(int32_t *p) { |
| int32_t retVal; |
| if (pDecFn) { |
| retVal = (*pDecFn)(gIncDecContext, p); |
| } else { |
| #if U_PLATFORM_HAS_WIN32_API |
| retVal = InterlockedDecrement((LONG*)p); |
| #elif defined(USE_MAC_OS_ATOMIC_INCREMENT) |
| retVal = OSAtomicDecrement32Barrier(p); |
| #elif (U_HAVE_GCC_ATOMICS == 1) |
| retVal = __sync_sub_and_fetch(p, 1); |
| #elif defined (POSIX) |
| umtx_lock(&gIncDecMutex); |
| retVal = --(*p); |
| umtx_unlock(&gIncDecMutex); |
| #else |
| /* Unknown Platform. */ |
| retVal = --(*p); |
| #endif |
| } |
| return retVal; |
| } |
| |
| |
| |
| U_CAPI void U_EXPORT2 |
| u_setAtomicIncDecFunctions(const void *context, UMtxAtomicFn *ip, UMtxAtomicFn *dp, |
| UErrorCode *status) { |
| if (U_FAILURE(*status)) { |
| return; |
| } |
| /* Can not set a mutex function to a NULL value */ |
| if (ip==NULL || dp==NULL) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| /* If ICU is not in an initial state, disallow this operation. */ |
| if (cmemory_inUse()) { |
| *status = U_INVALID_STATE_ERROR; |
| return; |
| } |
| |
| pIncFn = ip; |
| pDecFn = dp; |
| gIncDecContext = context; |
| |
| #if U_DEBUG |
| { |
| int32_t testInt = 0; |
| U_ASSERT(umtx_atomic_inc(&testInt) == 1); /* Sanity Check. Do the functions work at all? */ |
| U_ASSERT(testInt == 1); |
| U_ASSERT(umtx_atomic_dec(&testInt) == 0); |
| U_ASSERT(testInt == 0); |
| } |
| #endif |
| } |
| |
| |
| /* |
| * Mutex Cleanup Function |
| * Reset the mutex function callback pointers. |
| * Called from the global ICU u_cleanup() function. |
| */ |
| U_CFUNC UBool umtx_cleanup(void) { |
| /* Extra, do-nothing function call to suppress compiler warnings on platforms where |
| * mutexed_compare_and_swap is not otherwise used. */ |
| void *pv = &globalMutex; |
| mutexed_compare_and_swap(&pv, NULL, NULL); |
| usrMutexCleanup(); |
| |
| pIncFn = NULL; |
| pDecFn = NULL; |
| gIncDecContext = NULL; |
| |
| return TRUE; |
| } |
