388 lines
12 KiB
C++
388 lines
12 KiB
C++
/*
|
|
******************************************************************************
|
|
*
|
|
* Copyright (C) 1997-2015, 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 "umutex.h"
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "uassert.h"
|
|
#include "cmemory.h"
|
|
|
|
|
|
// The ICU global mutex. Used when ICU implementation code passes NULL for the mutex pointer.
|
|
static UMutex globalMutex = U_MUTEX_INITIALIZER;
|
|
|
|
/*
|
|
* 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 defined(U_USER_MUTEX_CPP)
|
|
// Build time user mutex hook: #include "U_USER_MUTEX_CPP"
|
|
#include U_MUTEX_XSTR(U_USER_MUTEX_CPP)
|
|
|
|
#elif U_PLATFORM_HAS_WIN32_API
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
//
|
|
// Windows Specific Definitions
|
|
//
|
|
// Note: Cygwin (and possibly others) have both WIN32 and POSIX.
|
|
// Prefer Win32 in these cases. (Win32 comes ahead in the #if chain)
|
|
//
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
#if defined U_NO_PLATFORM_ATOMICS
|
|
#error ICU on Win32 requires support for low level atomic operations.
|
|
// Visual Studio, gcc, clang are OK. Shouldn't get here.
|
|
#endif
|
|
|
|
|
|
// This function is called when a test of a UInitOnce::fState reveals that
|
|
// initialization has not completed, that we either need to call the
|
|
// function on this thread, or wait for some other thread to complete.
|
|
//
|
|
// The actual call to the init function is made inline by template code
|
|
// that knows the C++ types involved. This function returns TRUE if
|
|
// the caller needs to call the Init function.
|
|
//
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
U_COMMON_API UBool U_EXPORT2 umtx_initImplPreInit(UInitOnce &uio) {
|
|
for (;;) {
|
|
int32_t previousState = InterlockedCompareExchange(
|
|
#if (U_PLATFORM == U_PF_MINGW) || (U_PLATFORM == U_PF_CYGWIN) || defined(__clang__)
|
|
(LONG volatile *) // this is the type given in the API doc for this function.
|
|
#endif
|
|
&uio.fState, // Destination
|
|
1, // Exchange Value
|
|
0); // Compare value
|
|
|
|
if (previousState == 0) {
|
|
return true; // Caller will next call the init function.
|
|
// Current state == 1.
|
|
} else if (previousState == 2) {
|
|
// Another thread already completed the initialization.
|
|
// We can simply return FALSE, indicating no
|
|
// further action is needed by the caller.
|
|
return FALSE;
|
|
} else {
|
|
// Another thread is currently running the initialization.
|
|
// Wait until it completes.
|
|
do {
|
|
Sleep(1);
|
|
previousState = umtx_loadAcquire(uio.fState);
|
|
} while (previousState == 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
// This function is called by the thread that ran an initialization function,
|
|
// just after completing the function.
|
|
|
|
U_COMMON_API void U_EXPORT2 umtx_initImplPostInit(UInitOnce &uio) {
|
|
umtx_storeRelease(uio.fState, 2);
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
static void winMutexInit(CRITICAL_SECTION *cs) {
|
|
InitializeCriticalSection(cs);
|
|
return;
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
umtx_lock(UMutex *mutex) {
|
|
if (mutex == NULL) {
|
|
mutex = &globalMutex;
|
|
}
|
|
CRITICAL_SECTION *cs = &mutex->fCS;
|
|
umtx_initOnce(mutex->fInitOnce, winMutexInit, cs);
|
|
EnterCriticalSection(cs);
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
umtx_unlock(UMutex* mutex)
|
|
{
|
|
if (mutex == NULL) {
|
|
mutex = &globalMutex;
|
|
}
|
|
LeaveCriticalSection(&mutex->fCS);
|
|
}
|
|
|
|
|
|
U_CAPI void U_EXPORT2
|
|
umtx_condBroadcast(UConditionVar *condition) {
|
|
// We require that the associated mutex be held by the caller,
|
|
// so access to fWaitCount is protected and safe. No other thread can
|
|
// call condWait() while we are here.
|
|
if (condition->fWaitCount == 0) {
|
|
return;
|
|
}
|
|
ResetEvent(condition->fExitGate);
|
|
SetEvent(condition->fEntryGate);
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
umtx_condSignal(UConditionVar *condition) {
|
|
// Function not implemented. There is no immediate requirement from ICU to have it.
|
|
// Once ICU drops support for Windows XP and Server 2003, ICU Condition Variables will be
|
|
// changed to be thin wrappers on native Windows CONDITION_VARIABLEs, and this function
|
|
// becomes trivial to provide.
|
|
U_ASSERT(FALSE);
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
umtx_condWait(UConditionVar *condition, UMutex *mutex) {
|
|
if (condition->fEntryGate == NULL) {
|
|
// Note: because the associated mutex must be locked when calling
|
|
// wait, we know that there can not be multiple threads
|
|
// running here with the same condition variable.
|
|
// Meaning that lazy initialization is safe.
|
|
U_ASSERT(condition->fExitGate == NULL);
|
|
condition->fEntryGate = CreateEvent(NULL, // Security Attributes
|
|
TRUE, // Manual Reset
|
|
FALSE, // Initially reset
|
|
NULL); // Name.
|
|
U_ASSERT(condition->fEntryGate != NULL);
|
|
condition->fExitGate = CreateEvent(NULL, TRUE, TRUE, NULL);
|
|
U_ASSERT(condition->fExitGate != NULL);
|
|
}
|
|
|
|
condition->fWaitCount++;
|
|
umtx_unlock(mutex);
|
|
WaitForSingleObject(condition->fEntryGate, INFINITE);
|
|
umtx_lock(mutex);
|
|
condition->fWaitCount--;
|
|
if (condition->fWaitCount == 0) {
|
|
// All threads that were waiting at the entry gate have woken up
|
|
// and moved through. Shut the entry gate and open the exit gate.
|
|
ResetEvent(condition->fEntryGate);
|
|
SetEvent(condition->fExitGate);
|
|
} else {
|
|
umtx_unlock(mutex);
|
|
WaitForSingleObject(condition->fExitGate, INFINITE);
|
|
umtx_lock(mutex);
|
|
}
|
|
}
|
|
|
|
|
|
#elif U_PLATFORM_IMPLEMENTS_POSIX
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
//
|
|
// POSIX specific definitions
|
|
//
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
# include <pthread.h>
|
|
|
|
// Each UMutex consists of a 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;
|
|
}
|
|
int sysErr = pthread_mutex_lock(&mutex->fMutex);
|
|
(void)sysErr; // Suppress unused variable warnings.
|
|
U_ASSERT(sysErr == 0);
|
|
}
|
|
|
|
|
|
U_CAPI void U_EXPORT2
|
|
umtx_unlock(UMutex* mutex)
|
|
{
|
|
if (mutex == NULL) {
|
|
mutex = &globalMutex;
|
|
}
|
|
int sysErr = pthread_mutex_unlock(&mutex->fMutex);
|
|
(void)sysErr; // Suppress unused variable warnings.
|
|
U_ASSERT(sysErr == 0);
|
|
}
|
|
|
|
|
|
U_CAPI void U_EXPORT2
|
|
umtx_condWait(UConditionVar *cond, UMutex *mutex) {
|
|
if (mutex == NULL) {
|
|
mutex = &globalMutex;
|
|
}
|
|
int sysErr = pthread_cond_wait(&cond->fCondition, &mutex->fMutex);
|
|
(void)sysErr;
|
|
U_ASSERT(sysErr == 0);
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
umtx_condBroadcast(UConditionVar *cond) {
|
|
int sysErr = pthread_cond_broadcast(&cond->fCondition);
|
|
(void)sysErr;
|
|
U_ASSERT(sysErr == 0);
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
umtx_condSignal(UConditionVar *cond) {
|
|
int sysErr = pthread_cond_signal(&cond->fCondition);
|
|
(void)sysErr;
|
|
U_ASSERT(sysErr == 0);
|
|
}
|
|
|
|
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
static pthread_mutex_t initMutex = PTHREAD_MUTEX_INITIALIZER;
|
|
static pthread_cond_t initCondition = PTHREAD_COND_INITIALIZER;
|
|
|
|
|
|
// This function is called when a test of a UInitOnce::fState reveals that
|
|
// initialization has not completed, that we either need to call the
|
|
// function on this thread, or wait for some other thread to complete.
|
|
//
|
|
// The actual call to the init function is made inline by template code
|
|
// that knows the C++ types involved. This function returns TRUE if
|
|
// the caller needs to call the Init function.
|
|
//
|
|
U_COMMON_API UBool U_EXPORT2
|
|
umtx_initImplPreInit(UInitOnce &uio) {
|
|
pthread_mutex_lock(&initMutex);
|
|
int32_t state = uio.fState;
|
|
if (state == 0) {
|
|
umtx_storeRelease(uio.fState, 1);
|
|
pthread_mutex_unlock(&initMutex);
|
|
return TRUE; // Caller will next call the init function.
|
|
} else {
|
|
while (uio.fState == 1) {
|
|
// Another thread is currently running the initialization.
|
|
// Wait until it completes.
|
|
pthread_cond_wait(&initCondition, &initMutex);
|
|
}
|
|
pthread_mutex_unlock(&initMutex);
|
|
U_ASSERT(uio.fState == 2);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// This function is called by the thread that ran an initialization function,
|
|
// just after completing the function.
|
|
// Some threads may be waiting on the condition, requiring the broadcast wakeup.
|
|
// Some threads may be racing to test the fState variable outside of the mutex,
|
|
// requiring the use of store/release when changing its value.
|
|
|
|
U_COMMON_API void U_EXPORT2
|
|
umtx_initImplPostInit(UInitOnce &uio) {
|
|
pthread_mutex_lock(&initMutex);
|
|
umtx_storeRelease(uio.fState, 2);
|
|
pthread_cond_broadcast(&initCondition);
|
|
pthread_mutex_unlock(&initMutex);
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
// End of POSIX specific umutex implementation.
|
|
|
|
#else // Platform #define chain.
|
|
|
|
#error Unknown Platform
|
|
|
|
#endif // Platform #define chain.
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
//
|
|
// Atomic Operations, out-of-line versions.
|
|
// These are conditional, only defined if better versions
|
|
// were not available for the platform.
|
|
//
|
|
// These versions are platform neutral.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
#if defined U_NO_PLATFORM_ATOMICS
|
|
static UMutex gIncDecMutex = U_MUTEX_INITIALIZER;
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
U_COMMON_API int32_t U_EXPORT2
|
|
umtx_atomic_inc(u_atomic_int32_t *p) {
|
|
int32_t retVal;
|
|
umtx_lock(&gIncDecMutex);
|
|
retVal = ++(*p);
|
|
umtx_unlock(&gIncDecMutex);
|
|
return retVal;
|
|
}
|
|
|
|
|
|
U_COMMON_API int32_t U_EXPORT2
|
|
umtx_atomic_dec(u_atomic_int32_t *p) {
|
|
int32_t retVal;
|
|
umtx_lock(&gIncDecMutex);
|
|
retVal = --(*p);
|
|
umtx_unlock(&gIncDecMutex);
|
|
return retVal;
|
|
}
|
|
|
|
U_COMMON_API int32_t U_EXPORT2
|
|
umtx_loadAcquire(u_atomic_int32_t &var) {
|
|
umtx_lock(&gIncDecMutex);
|
|
int32_t val = var;
|
|
umtx_unlock(&gIncDecMutex);
|
|
return val;
|
|
}
|
|
|
|
U_COMMON_API void U_EXPORT2
|
|
umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
|
|
umtx_lock(&gIncDecMutex);
|
|
var = val;
|
|
umtx_unlock(&gIncDecMutex);
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
#endif
|
|
|
|
//--------------------------------------------------------------------------
|
|
//
|
|
// Deprecated functions for setting user mutexes.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
U_DEPRECATED void U_EXPORT2
|
|
u_setMutexFunctions(const void * /*context */, UMtxInitFn *, UMtxFn *,
|
|
UMtxFn *, UMtxFn *, UErrorCode *status) {
|
|
if (U_SUCCESS(*status)) {
|
|
*status = U_UNSUPPORTED_ERROR;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
U_DEPRECATED void U_EXPORT2
|
|
u_setAtomicIncDecFunctions(const void * /*context */, UMtxAtomicFn *, UMtxAtomicFn *,
|
|
UErrorCode *status) {
|
|
if (U_SUCCESS(*status)) {
|
|
*status = U_UNSUPPORTED_ERROR;
|
|
}
|
|
return;
|
|
}
|