organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-06 14:05:32 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 9

ICU-20179 Remove platform-specific mutex and atomics implementations.

Browse source 
Remove all POSIX and Win32 specific mutex, atomic and threading implementations
in favor of C++11 std library functions.

Move the related (internal) ICU types and functions into the icu namespace.
This commit is contained in:
Andy Heninger 2018-10-31 17:08:38 -07:00
parent c0799c141b
commit 47d455a725
19 changed files with 92 additions and 897 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
icu4c/source/common/characterproperties.cpp
View file

@ -45,7 +45,7 @@ UnicodeSet *sets[UCHAR_BINARY_LIMIT] = {};
UCPMap *maps[UCHAR_INT_LIMIT - UCHAR_INT_START] = {};
UMutex cpMutex = U_MUTEX_INITIALIZER;
icu::UMutex cpMutex = U_MUTEX_INITIALIZER;
//----------------------------------------------------------------
// Inclusions list

4
icu4c/source/common/ucln_cmn.cpp
View file

@ -40,8 +40,8 @@ U_CAPI void U_EXPORT2
u_cleanup(void)
{
UTRACE_ENTRY_OC(UTRACE_U_CLEANUP);
umtx_lock(NULL); /* Force a memory barrier, so that we are sure to see */
umtx_unlock(NULL); /* all state left around by any other threads. */
icu::umtx_lock(NULL); /* Force a memory barrier, so that we are sure to see */
icu::umtx_unlock(NULL); /* all state left around by any other threads. */
ucln_lib_cleanup();

6
icu4c/source/common/ucnv_bld.cpp
View file

@ -194,9 +194,9 @@ static struct {
/*initializes some global variables */
static UHashtable *SHARED_DATA_HASHTABLE = NULL;
static UMutex cnvCacheMutex = U_MUTEX_INITIALIZER; /* Mutex for synchronizing cnv cache access. */
/* Note: the global mutex is used for */
/* reference count updates. */
static icu::UMutex cnvCacheMutex = U_MUTEX_INITIALIZER; /* Mutex for synchronizing cnv cache access. */
/* Note: the global mutex is used for */
/* reference count updates. */
static const char **gAvailableConverters = NULL;
static uint16_t gAvailableConverterCount = 0;

8
icu4c/source/common/ucnvmbcs.cpp
View file

@ -1383,7 +1383,7 @@ _EBCDICSwapLFNL(UConverterSharedData *sharedData, UErrorCode *pErrorCode) {
uprv_strcat(name, UCNV_SWAP_LFNL_OPTION_STRING);
/* set the pointers */
umtx_lock(NULL);
icu::umtx_lock(NULL);
if(mbcsTable->swapLFNLStateTable==NULL) {
mbcsTable->swapLFNLStateTable=newStateTable;
mbcsTable->swapLFNLFromUnicodeBytes=(uint8_t *)newResults;
@ -1391,7 +1391,7 @@ _EBCDICSwapLFNL(UConverterSharedData *sharedData, UErrorCode *pErrorCode) {
newStateTable=NULL;
}
umtx_unlock(NULL);
icu::umtx_unlock(NULL);
/* release the allocated memory if another thread beat us to it */
if(newStateTable!=NULL) {
@ -1919,9 +1919,9 @@ ucnv_MBCSOpen(UConverter *cnv,
/* do this because double-checked locking is broken */
UBool isCached;
umtx_lock(NULL);
icu::umtx_lock(NULL);
isCached=mbcsTable->swapLFNLStateTable!=NULL;
umtx_unlock(NULL);
icu::umtx_unlock(NULL);
if(!isCached) {
if(!_EBCDICSwapLFNL(cnv->sharedData, pErrorCode)) {

350
icu4c/source/common/umutex.cpp
View file

@ -26,14 +26,8 @@
#include "uassert.h"
#include "cmemory.h"
U_NAMESPACE_BEGIN
// 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)
// Support for including an alternate implementation of mutexes has been withdrawn.
@ -41,10 +35,14 @@ static UMutex globalMutex = U_MUTEX_INITIALIZER;
#error U_USER_MUTEX_CPP not supported
#endif
#if U_HAVE_STD_MUTEX
/*************************************************************************************************
*
* ICU Mutex wrappers.
*
*************************************************************************************************/
// C++11 std::mutex based implementation of ICU mutex wrappers.
//
// The ICU global mutex. Used when ICU implementation code passes NULL for the mutex pointer.
static UMutex globalMutex = U_MUTEX_INITIALIZER;
U_CAPI void U_EXPORT2
umtx_lock(UMutex *mutex) {
@ -91,7 +89,11 @@ umtx_condSignal(UConditionVar *cond) {
}
U_NAMESPACE_BEGIN
/*************************************************************************************************
*
* UInitOnce Implementation
*
*************************************************************************************************/
static std::mutex initMutex;
static std::condition_variable initCondition;
@ -141,327 +143,11 @@ umtx_initImplPostInit(UInitOnce &uio) {
U_NAMESPACE_END
// End of std::mutex specific umutex implementation.
#elif U_PLATFORM_USES_ONLY_WIN32_API
#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(
(LONG volatile *) // this is the type given in the API doc for this function.
&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.
//
//--------------------------------------------------------------------------
/*************************************************************************************************
*
* Deprecated functions for setting user mutexes.
*
*************************************************************************************************/
U_DEPRECATED void U_EXPORT2
u_setMutexFunctions(const void * /*context */, UMtxInitFn *, UMtxFn *,

290
icu4c/source/common/umutex.h
View file

@ -20,38 +20,22 @@
#ifndef UMUTEX_H
#define UMUTEX_H
#include <atomic>
#include <condition_variable>
#include <mutex>
#include "unicode/utypes.h"
#include "unicode/uclean.h"
#include "unicode/uobject.h"
#include "putilimp.h"
// Forward Declarations. UMutex is not in the ICU namespace (yet) because
// there are some remaining references from plain C.
struct UMutex;
struct UConditionVar;
U_NAMESPACE_BEGIN
struct UInitOnce;
U_NAMESPACE_END
/****************************************************************************
*
* Low Level Atomic Operations.
* Compiler dependent. Not operating system dependent.
*
****************************************************************************/
#if defined(U_USER_ATOMICS_H)
// Support for including an alternate implementation of atomic operations has been withdrawn.
#if defined(U_USER_ATOMICS_H) || defined(U_USER_MUTEX_H)
// Support for including an alternate implementation of atomic & mutex operations has been withdrawn.
// See issue ICU-20185.
#error U_USER_ATOMICS not supported
#error U_USER_ATOMICS and U_USER_MUTEX_H are not supported
#endif
#if U_HAVE_STD_ATOMICS
// C++11 atomics are available.
#include <atomic>
// Export an explicit template instantiation of std::atomic<int32_t>.
// When building DLLs for Windows this is required as it is used as a data member of the exported SharedObject class.
@ -68,8 +52,15 @@ template struct U_COMMON_API std::atomic<int32_t>;
#endif
#endif
U_NAMESPACE_BEGIN
/****************************************************************************
*
* Low Level Atomic Operations, ICU wrappers for.
*
****************************************************************************/
typedef std::atomic<int32_t> u_atomic_int32_t;
#define ATOMIC_INT32_T_INITIALIZER(val) ATOMIC_VAR_INIT(val)
@ -88,150 +79,14 @@ inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) {
inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) {
return var->fetch_sub(1) - 1;
}
U_NAMESPACE_END
#elif U_PLATFORM_HAS_WIN32_API
// MSVC compiler. Reads and writes of volatile variables have
// acquire and release memory semantics, respectively.
// This is a Microsoft extension, not standard C++ behavior.
//
// Update: can't use this because of MinGW, built with gcc.
// Original plan was to use gcc atomics for MinGW, but they
// aren't supported, so we fold MinGW into this path.
#ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN
#endif
# define VC_EXTRALEAN
# define NOUSER
# define NOSERVICE
# define NOIME
# define NOMCX
# ifndef NOMINMAX
# define NOMINMAX
# endif
# include <windows.h>
U_NAMESPACE_BEGIN
typedef volatile LONG u_atomic_int32_t;
#define ATOMIC_INT32_T_INITIALIZER(val) val
inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) {
return InterlockedCompareExchange(&var, 0, 0);
}
inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
InterlockedExchange(&var, val);
}
inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) {
return InterlockedIncrement(var);
}
inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) {
return InterlockedDecrement(var);
}
U_NAMESPACE_END
#elif U_HAVE_CLANG_ATOMICS
/*
* Clang __c11 atomic built-ins
*/
U_NAMESPACE_BEGIN
typedef _Atomic(int32_t) u_atomic_int32_t;
#define ATOMIC_INT32_T_INITIALIZER(val) val
inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) {
return __c11_atomic_load(&var, __ATOMIC_ACQUIRE);
}
inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
return __c11_atomic_store(&var, val, __ATOMIC_RELEASE);
}
inline int32_t umtx_atomic_inc(u_atomic_int32_t *var) {
return __c11_atomic_fetch_add(var, 1, __ATOMIC_SEQ_CST) + 1;
}
inline int32_t umtx_atomic_dec(u_atomic_int32_t *var) {
return __c11_atomic_fetch_sub(var, 1, __ATOMIC_SEQ_CST) - 1;
}
U_NAMESPACE_END
#elif U_HAVE_GCC_ATOMICS
/*
* gcc atomic ops. These are available on several other compilers as well.
*/
U_NAMESPACE_BEGIN
typedef int32_t u_atomic_int32_t;
#define ATOMIC_INT32_T_INITIALIZER(val) val
inline int32_t umtx_loadAcquire(u_atomic_int32_t &var) {
int32_t val = var;
__sync_synchronize();
return val;
}
inline void umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
__sync_synchronize();
var = val;
}
inline int32_t umtx_atomic_inc(u_atomic_int32_t *p) {
return __sync_add_and_fetch(p, 1);
}
inline int32_t umtx_atomic_dec(u_atomic_int32_t *p) {
return __sync_sub_and_fetch(p, 1);
}
U_NAMESPACE_END
#else
/*
* Unknown Platform. Use out-of-line functions, which in turn use mutexes.
* Slow but correct.
*/
#define U_NO_PLATFORM_ATOMICS
U_NAMESPACE_BEGIN
typedef int32_t u_atomic_int32_t;
#define ATOMIC_INT32_T_INITIALIZER(val) val
U_COMMON_API int32_t U_EXPORT2
umtx_loadAcquire(u_atomic_int32_t &var);
U_COMMON_API void U_EXPORT2
umtx_storeRelease(u_atomic_int32_t &var, int32_t val);
U_COMMON_API int32_t U_EXPORT2
umtx_atomic_inc(u_atomic_int32_t *p);
U_COMMON_API int32_t U_EXPORT2
umtx_atomic_dec(u_atomic_int32_t *p);
U_NAMESPACE_END
#endif /* Low Level Atomic Ops Platform Chain */
/*************************************************************************************************
*
* UInitOnce Definitions.
* These are platform neutral.
*
*************************************************************************************************/
U_NAMESPACE_BEGIN
struct UInitOnce {
u_atomic_int32_t fState;
UErrorCode fErrCode;
@ -320,29 +175,15 @@ template<class T> void umtx_initOnce(UInitOnce &uio, void (U_CALLCONV *fp)(T, UE
}
}
U_NAMESPACE_END
/*************************************************************************************************
*
* Mutex Definitions. Platform Dependent, #if platform chain follows.
* ICU Mutex wrappers. Originally wrapped operating system mutexes, giving the rest of ICU a
* platform independent set of mutex operations. Now vestigial, wrapping std::mutex only.
* For internal ICU use only.
*
*************************************************************************************************/
#if defined(U_USER_MUTEX_H)
// Support for including an alternate implementation of mutexes has been withdrawn.
// See issue ICU-20185.
#error U_USER_MUTEX_H not supported
#endif
#if U_HAVE_STD_MUTEX
#include <mutex>
#include <condition_variable>
#include "unicode/uobject.h"
struct UMutex : public icu::UMemory {
UMutex() = default;
~UMutex() = default;
@ -378,91 +219,6 @@ struct UConditionVar : public icu::UMemory {
// and destructor, to avoid Windows build problems with attempting to export the
// std::condition_variable_any.
#elif U_PLATFORM_USES_ONLY_WIN32_API
/* For CRITICAL_SECTION */
/*
* Note: there is an earlier include of windows.h in this file, but it is in
* different conditionals.
* This one is needed if we are using C++11 for atomic ops, but
* win32 APIs for Critical Sections.
*/
#ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN
#endif
# define VC_EXTRALEAN
# define NOUSER
# define NOSERVICE
# define NOIME
# define NOMCX
# ifndef NOMINMAX
# define NOMINMAX
# endif
# include <windows.h>
typedef struct UMutex {
icu::UInitOnce fInitOnce;
CRITICAL_SECTION fCS;
} UMutex;
/* Initializer for a static UMUTEX. Deliberately contains no value for the
* CRITICAL_SECTION.
*/
#define U_MUTEX_INITIALIZER {U_INITONCE_INITIALIZER}
struct UConditionVar {
HANDLE fEntryGate;
HANDLE fExitGate;
int32_t fWaitCount;
};
#define U_CONDITION_INITIALIZER {NULL, NULL, 0}
#elif U_PLATFORM_IMPLEMENTS_POSIX
/*
* POSIX platform
*/
#include <pthread.h>
struct UMutex {
pthread_mutex_t fMutex;
};
typedef struct UMutex UMutex;
#define U_MUTEX_INITIALIZER {PTHREAD_MUTEX_INITIALIZER}
struct UConditionVar {
pthread_cond_t fCondition;
};
#define U_CONDITION_INITIALIZER {PTHREAD_COND_INITIALIZER}
#else
/*
* Unknown platform type.
* This is an error condition. ICU requires mutexes.
*/
#error Unknown Platform.
#endif
/**************************************************************************************
*
* Mutex Implementation function declarations.
* Declarations are platform neutral.
* Implementations, in umutex.cpp, are platform specific.
*
************************************************************************************/
/* Lock a mutex.
* @param mutex The given mutex to be locked. Pass NULL to specify
* the global ICU mutex. Recursive locks are an error
@ -490,18 +246,18 @@ U_INTERNAL void U_EXPORT2 umtx_condWait(UConditionVar *cond, UMutex *mutex);
/*
* Broadcast wakeup of all threads waiting on a Condition.
* The associated mutex must be locked by the calling thread when calling
* this function; this is a temporary ICU restriction.
*
*
* @param cond the condition variable.
*/
U_INTERNAL void U_EXPORT2 umtx_condBroadcast(UConditionVar *cond);
/*
* Signal a condition variable, waking up one waiting thread.
* CAUTION: Do not use. Place holder only. Not implemented for Windows.
*/
U_INTERNAL void U_EXPORT2 umtx_condSignal(UConditionVar *cond);
U_NAMESPACE_END
#endif /* UMUTEX_H */
/*eof*/

4
icu4c/source/common/unifiedcache.cpp
View file

@ -21,8 +21,8 @@
#include "umutex.h"
static icu::UnifiedCache *gCache = NULL;
static UMutex gCacheMutex = U_MUTEX_INITIALIZER;
static UConditionVar gInProgressValueAddedCond = U_CONDITION_INITIALIZER;
static icu::UMutex gCacheMutex = U_MUTEX_INITIALIZER;
static icu::UConditionVar gInProgressValueAddedCond = U_CONDITION_INITIALIZER;
static icu::UInitOnce gCacheInitOnce = U_INITONCE_INITIALIZER;
static const int32_t MAX_EVICT_ITERATIONS = 10;

12
icu4c/source/common/ustr_cnv.cpp
View file

@ -40,14 +40,14 @@ u_getDefaultConverter(UErrorCode *status)
UConverter *converter = NULL;
if (gDefaultConverter != NULL) {
umtx_lock(NULL);
icu::umtx_lock(NULL);
/* need to check to make sure it wasn't taken out from under us */
if (gDefaultConverter != NULL) {
converter = gDefaultConverter;
gDefaultConverter = NULL;
}
umtx_unlock(NULL);
icu::umtx_unlock(NULL);
}
/* if the cache was empty, create a converter */
@ -70,12 +70,12 @@ u_releaseDefaultConverter(UConverter *converter)
ucnv_reset(converter);
}
ucnv_enableCleanup();
umtx_lock(NULL);
icu::umtx_lock(NULL);
if(gDefaultConverter == NULL) {
gDefaultConverter = converter;
converter = NULL;
}
umtx_unlock(NULL);
icu::umtx_unlock(NULL);
}
if(converter != NULL) {
@ -89,14 +89,14 @@ u_flushDefaultConverter()
UConverter *converter = NULL;
if (gDefaultConverter != NULL) {
umtx_lock(NULL);
icu::umtx_lock(NULL);
/* need to check to make sure it wasn't taken out from under us */
if (gDefaultConverter != NULL) {
converter = gDefaultConverter;
gDefaultConverter = NULL;
}
umtx_unlock(NULL);
icu::umtx_unlock(NULL);
}
/* if the cache was populated, flush it */

2
icu4c/source/i18n/astro.cpp
View file

@ -65,7 +65,7 @@ static inline UBool isINVALID(double d) {
return(uprv_isNaN(d));
}
static UMutex ccLock = U_MUTEX_INITIALIZER;
static icu::UMutex ccLock = U_MUTEX_INITIALIZER;
U_CDECL_BEGIN
static UBool calendar_astro_cleanup(void) {

2
icu4c/source/i18n/chnsecal.cpp
View file

@ -51,7 +51,7 @@ static void debug_chnsecal_msg(const char *pat, ...)
// --- The cache --
static UMutex astroLock = U_MUTEX_INITIALIZER; // Protects access to gChineseCalendarAstro.
static icu::UMutex astroLock = U_MUTEX_INITIALIZER; // Protects access to gChineseCalendarAstro.
static icu::CalendarAstronomer *gChineseCalendarAstro = NULL;
// Lazy Creation & Access synchronized by class CalendarCache with a mutex.

2
icu4c/source/i18n/gender.cpp
View file

@ -32,7 +32,7 @@
#include "uhash.h"
static UHashtable* gGenderInfoCache = NULL;
static UMutex gGenderMetaLock = U_MUTEX_INITIALIZER;
static icu::UMutex gGenderMetaLock = U_MUTEX_INITIALIZER;
static const char* gNeutralStr = "neutral";
static const char* gMailTaintsStr = "maleTaints";
static const char* gMixedNeutralStr = "mixedNeutral";

2
icu4c/source/i18n/islamcal.cpp
View file

@ -54,7 +54,7 @@ static void debug_islamcal_msg(const char *pat, ...)
// --- The cache --
// cache of months
static UMutex astroLock = U_MUTEX_INITIALIZER; // pod bay door lock
static icu::UMutex astroLock = U_MUTEX_INITIALIZER; // pod bay door lock
static icu::CalendarCache *gMonthCache = NULL;
static icu::CalendarAstronomer *gIslamicCalendarAstro = NULL;

2
icu4c/source/i18n/numfmt.cpp
View file

@ -156,7 +156,7 @@ static const icu::number::impl::CldrPatternStyle gFormatCldrStyles[UNUM_FORMAT_S
// Static hashtable cache of NumberingSystem objects used by NumberFormat
static UHashtable * NumberingSystem_cache = NULL;
static UMutex nscacheMutex = U_MUTEX_INITIALIZER;
static icu::UMutex nscacheMutex = U_MUTEX_INITIALIZER;
static icu::UInitOnce gNSCacheInitOnce = U_INITONCE_INITIALIZER;
#if !UCONFIG_NO_SERVICE

2
icu4c/source/i18n/reldatefmt.cpp
View file

@ -44,7 +44,7 @@
// Copied from uscript_props.cpp
static UMutex gBrkIterMutex = U_MUTEX_INITIALIZER;
static icu::UMutex gBrkIterMutex = U_MUTEX_INITIALIZER;
U_NAMESPACE_BEGIN

2
icu4c/source/i18n/translit.cpp
View file

@ -91,7 +91,7 @@ static const char RB_RULE_BASED_IDS[] = "RuleBasedTransliteratorIDs";
/**
* The mutex controlling access to registry object.
*/
static UMutex registryMutex = U_MUTEX_INITIALIZER;
static icu::UMutex registryMutex = U_MUTEX_INITIALIZER;
/**
* System transliterator registry; non-null when initialized.

2
icu4c/source/i18n/zonemeta.cpp
View file

@ -30,7 +30,7 @@
#include "olsontz.h"
#include "uinvchar.h"
static UMutex gZoneMetaLock = U_MUTEX_INITIALIZER;
static icu::UMutex gZoneMetaLock = U_MUTEX_INITIALIZER;
// CLDR Canonical ID mapping table
static UHashtable *gCanonicalIDCache = NULL;

2
icu4c/source/io/locbund.cpp
View file

@ -45,7 +45,7 @@ static UBool U_CALLCONV locbund_cleanup(void) {
}
U_CDECL_END
static UMutex gLock = U_MUTEX_INITIALIZER;
static icu::UMutex gLock = U_MUTEX_INITIALIZER;
static inline UNumberFormat * copyInvariantFormatter(ULocaleBundle *result, UNumberFormatStyle style) {
U_NAMESPACE_USE
Mutex lock(&gLock);

275
icu4c/source/test/intltest/simplethread.cpp Normal file → Executable file
View file

@ -6,284 +6,32 @@
* others. All Rights Reserved.
********************************************************************/
#if defined(hpux)
# ifndef _INCLUDE_POSIX_SOURCE
# define _INCLUDE_POSIX_SOURCE
# endif
#endif
/* Define __EXTENSIONS__ for Solaris and old friends in strict mode. */
#ifndef __EXTENSIONS__
#define __EXTENSIONS__
#endif
// Defines _XOPEN_SOURCE for access to POSIX functions.
// Must be before any other #includes.
#include "uposixdefs.h"
#include "simplethread.h"
#include <thread>
#include "unicode/utypes.h"
#include "unicode/ustring.h"
#include "umutex.h"
#include "cmemory.h"
#include "cstring.h"
#include "uparse.h"
#include "unicode/resbund.h"
#include "unicode/udata.h"
#include "unicode/uloc.h"
#include "unicode/locid.h"
#include "putilimp.h"
#include "intltest.h"
#include <stdio.h>
#include <string.h>
#include <ctype.h> // tolower, toupper
#if U_PLATFORM_USES_ONLY_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
/* Needed by z/OS to get usleep */
#if U_PLATFORM == U_PF_OS390
#define __DOT1 1
#ifndef __UU
# define __UU
#endif
#ifndef _XPG4_2
# define _XPG4_2
#endif
#include <unistd.h>
#endif
#if defined(POSIX)
#define HAVE_IMP
#include <pthread.h>
#if U_PLATFORM == U_PF_OS390
#include <sys/types.h>
#endif
#if U_PLATFORM != U_PF_OS390
#include <signal.h>
#endif
/* Define _XPG4_2 for Solaris and friends. */
#ifndef _XPG4_2
#define _XPG4_2
#endif
/* Define __USE_XOPEN_EXTENDED for Linux and glibc. */
#ifndef __USE_XOPEN_EXTENDED
#define __USE_XOPEN_EXTENDED
#endif
/* Define _INCLUDE_XOPEN_SOURCE_EXTENDED for HP/UX (11?). */
#ifndef _INCLUDE_XOPEN_SOURCE_EXTENDED
#define _INCLUDE_XOPEN_SOURCE_EXTENDED
#endif
#include <unistd.h>
#endif
/* HPUX */
#ifdef sleep
#undef sleep
#endif
#include "unicode/putil.h"
/* for mthreadtest*/
#include "unicode/numfmt.h"
#include "unicode/choicfmt.h"
#include "unicode/msgfmt.h"
#include "unicode/locid.h"
#include "unicode/ucol.h"
#include "unicode/calendar.h"
#include "ucaconf.h"
#if U_PLATFORM_USES_ONLY_WIN32_API
#define HAVE_IMP
# define VC_EXTRALEAN
# define WIN32_LEAN_AND_MEAN
# define NOUSER
# define NOSERVICE
# define NOIME
# define NOMCX
#include <windows.h>
#include <process.h>
//-----------------------------------------------------------------------------------
//
// class SimpleThread Windows Implementation
//
//-----------------------------------------------------------------------------------
struct Win32ThreadImplementation
{
HANDLE fHandle;
unsigned int fThreadID;
};
extern "C" unsigned int __stdcall SimpleThreadProc(void *arg)
{
((SimpleThread*)arg)->run();
return 0;
SimpleThread::SimpleThread() {
}
SimpleThread::SimpleThread()
:fImplementation(0)
{
Win32ThreadImplementation *imp = new Win32ThreadImplementation;
imp->fHandle = 0;
fImplementation = imp;
SimpleThread::~SimpleThread() {
this->join(); // Avoid crashes if user neglected to join().
}
SimpleThread::~SimpleThread()
{
// Destructor. Because we start the thread running with _beginthreadex(),
// we own the Windows HANDLE for the thread and must
// close it here.
Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
if (imp != 0) {
if (imp->fHandle != 0) {
CloseHandle(imp->fHandle);
imp->fHandle = 0;
}
}
delete (Win32ThreadImplementation*)fImplementation;
}
int32_t SimpleThread::start()
{
Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
if(imp->fHandle != NULL) {
// The thread appears to have already been started.
// This is probably an error on the part of our caller.
return -1;
}
imp->fHandle = (HANDLE) _beginthreadex(
NULL, // Security
0x20000, // Stack Size
SimpleThreadProc, // Function to Run
(void *)this, // Arg List
0, // initflag. Start running, not suspended
&imp->fThreadID // thraddr
);
if (imp->fHandle == 0) {
// An error occured
int err = errno;
if (err == 0) {
err = -1;
}
return err;
}
return 0;
}
void SimpleThread::join() {
Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
if (imp->fHandle == 0) {
// No handle, thread must not be running.
return;
}
WaitForSingleObject(imp->fHandle, INFINITE);
}
#endif
//-----------------------------------------------------------------------------------
//
// class SimpleThread POSIX implementation
//
//-----------------------------------------------------------------------------------
#if defined(POSIX)
#define HAVE_IMP
struct PosixThreadImplementation
{
pthread_t fThread;
};
extern "C" void* SimpleThreadProc(void *arg)
{
// This is the code that is run in the new separate thread.
SimpleThread *This = (SimpleThread *)arg;
This->run();
return 0;
}
SimpleThread::SimpleThread()
{
PosixThreadImplementation *imp = new PosixThreadImplementation;
fImplementation = imp;
}
SimpleThread::~SimpleThread()
{
PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
delete imp;
fImplementation = (void *)0xdeadbeef;
}
int32_t SimpleThread::start()
{
int32_t rc;
static pthread_attr_t attr;
static UBool attrIsInitialized = FALSE;
PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
if (attrIsInitialized == FALSE) {
rc = pthread_attr_init(&attr);
#if U_PLATFORM == U_PF_OS390
{
int detachstate = 0; // jdc30: detach state of zero causes
//threads created with this attr to be in
//an undetached state. An undetached
//thread will keep its resources after
//termination.
pthread_attr_setdetachstate(&attr, &detachstate);
}
#else
// pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
#endif
attrIsInitialized = TRUE;
}
rc = pthread_create(&(imp->fThread), &attr, &SimpleThreadProc, (void*)this);
if (rc != 0) {
// some kind of error occured, the thread did not start.
}
return rc;
int SimpleThread::start() {
fThread = std::thread(&SimpleThread::run, this);
return fThread.joinable() ? 0 : 1;
}
void SimpleThread::join() {
PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
pthread_join(imp->fThread, NULL);
if (fThread.joinable()) {
fThread.join();
}
}
#endif
// end POSIX
#ifndef HAVE_IMP
#error No implementation for threads! Cannot test.
#endif
class ThreadPoolThread: public SimpleThread {
@ -337,6 +85,3 @@ ThreadPoolBase::~ThreadPoolBase() {
fThreads = NULL;
}
}

20
icu4c/source/test/intltest/simplethread.h Normal file → Executable file
View file

@ -9,20 +9,29 @@
#ifndef SIMPLETHREAD_H
#define SIMPLETHREAD_H
#include "mutex.h"
#include <thread>
#include "unicode/utypes.h"
class U_EXPORT SimpleThread
/*
* Simple class for creating threads in ICU tests.
* Originally created to provide a portable abstraction over platform
* (POSIX or Win32) threading interfaces.
*
* New threaded tests should consider skipping this class and directly using C++ std library
* threading functions. SimpleThread is retained primarily to support existing use.
*/
class SimpleThread
{
public:
SimpleThread();
virtual ~SimpleThread();
int32_t start(void); // start the thread. Return 0 if successfull.
int32_t start(); // start the thread. Return 0 if successfull.
void join(); // A thread must be joined before deleting its SimpleThread.
virtual void run(void) = 0; // Override this to provide the code to run
virtual void run() = 0; // Override this to provide the code to run
// in the thread.
private:
void *fImplementation;
std::thread fThread = {};
};
@ -76,4 +85,3 @@ class ThreadPool : public ThreadPoolBase {
}
};
#endif