mirror of
https://github.com/unicode-org/icu.git
synced 2025-04-06 14:05:32 +00:00
ICU-3156 u_setMemoryFuncs(), partial u_setMutexFunctions()
X-SVN-Rev: 12760
This commit is contained in:
Andy Heninger
parent
2919851e9e
commit
ed7b79ac52
15 changed files with 535 additions and 121 deletions
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
******************************************************************************
|
||||
*
|
||||
* Copyright (C) 2002, International Business Machines
|
||||
* Copyright (C) 2002-2003, International Business Machines
|
||||
* Corporation and others. All Rights Reserved.
|
||||
*
|
||||
******************************************************************************
|
||||
|
|
@ -19,14 +19,30 @@
|
|||
******************************************************************************
|
||||
*/
|
||||
#include "cmemory.h"
|
||||
#include "unicode/uclean.h"
|
||||
|
||||
/* uprv_malloc(0) returns a pointer to this read-only data. */
|
||||
static const int32_t zeroMem[] = {0, 0, 0, 0, 0, 0};
|
||||
|
||||
/* Function Pointers for user-supplied heap functions */
|
||||
static void *pContext;
|
||||
static UMemAlloc *pAlloc;
|
||||
static UMemRealloc *pRealloc;
|
||||
static UMemFree *pFree;
|
||||
|
||||
/* Flag indicating whether any heap allocations have happened.
|
||||
* Used to prevent changing out the heap functions after allocations have been made */
|
||||
static UBool gHeapInUse;
|
||||
|
||||
U_CAPI void * U_EXPORT2
|
||||
uprv_malloc(size_t s) {
|
||||
if (s > 0) {
|
||||
return malloc(s);
|
||||
gHeapInUse = TRUE;
|
||||
if (pAlloc) {
|
||||
return (*pAlloc)(pContext, s);
|
||||
} else {
|
||||
return malloc(s);
|
||||
}
|
||||
} else {
|
||||
return (void *)zeroMem;
|
||||
}
|
||||
|
|
@ -37,17 +53,74 @@ uprv_realloc(void * buffer, size_t size) {
|
|||
if (buffer == zeroMem) {
|
||||
return uprv_malloc(size);
|
||||
} else if (size == 0) {
|
||||
free(buffer);
|
||||
if (pFree) {
|
||||
(*pFree)(pContext, buffer);
|
||||
} else {
|
||||
free(buffer);
|
||||
}
|
||||
return (void *)zeroMem;
|
||||
} else {
|
||||
return realloc(buffer, size);
|
||||
gHeapInUse = TRUE;
|
||||
if (pRealloc) {
|
||||
return (*pRealloc)(pContext, buffer, size);
|
||||
} else {
|
||||
return realloc(buffer, size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
U_CAPI void U_EXPORT2
|
||||
uprv_free(void *buffer) {
|
||||
if (buffer != zeroMem) {
|
||||
free(buffer);
|
||||
if (pFree) {
|
||||
(*pFree)(pContext, buffer);
|
||||
} else {
|
||||
free(buffer);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
U_CAPI void U_EXPORT2
|
||||
u_setMemoryFunctions(void *context, UMemAlloc *a, UMemRealloc *r, UMemFree *f, UErrorCode *status)
|
||||
{
|
||||
if (U_FAILURE(*status)) {
|
||||
return;
|
||||
}
|
||||
if (a==NULL || r==NULL || f==NULL) {
|
||||
*status = U_ILLEGAL_ARGUMENT_ERROR;
|
||||
return;
|
||||
}
|
||||
if (gHeapInUse) {
|
||||
*status = U_INVALID_STATE_ERROR;
|
||||
return;
|
||||
}
|
||||
pContext = context;
|
||||
pAlloc = a;
|
||||
pRealloc = r;
|
||||
pFree = f;
|
||||
}
|
||||
|
||||
|
||||
U_CFUNC UBool cmemory_cleanup(void) {
|
||||
pContext = NULL;
|
||||
pAlloc = NULL;
|
||||
pRealloc = NULL;
|
||||
pFree = NULL;
|
||||
gHeapInUse = FALSE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* gHeapInUse
|
||||
* Return True if ICU has allocated any memory.
|
||||
* Used by u_SetMutexFunctions() and similar to verify that ICU has not
|
||||
* been used, that it is in a pristine initial state.
|
||||
*/
|
||||
U_CFUNC UBool cmemory_inUse() {
|
||||
return gHeapInUse;
|
||||
}
|
||||
|
||||
U_CFUNC void cmemory_clearInUse() {
|
||||
gHeapInUse = FALSE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,4 +65,28 @@ typedef union {
|
|||
*/
|
||||
#define U_ALIGNMENT_OFFSET_UP(ptr) (sizeof(UAlignedMemory) - U_ALIGNMENT_OFFSET(ptr))
|
||||
|
||||
/**
|
||||
* Indicate whether the ICU allocation functions have been used.
|
||||
* This is used to determine whether ICU is in an initial, unused state.
|
||||
*/
|
||||
U_CFUNC UBool
|
||||
cmemory_inUse();
|
||||
|
||||
/**
|
||||
* Mark the ICU heap as not being in use, even if it is.
|
||||
* Needed so that we can ignore any allocations triggered by ICU
|
||||
* static initialization, and still pretend that we are in a pristine state.
|
||||
* TODO: this is awkward. Think about something cleaner.
|
||||
*/
|
||||
U_CFUNC void
|
||||
cmemory_clearInUse();
|
||||
|
||||
/**
|
||||
* Heap clean up function, called from u_cleanup()
|
||||
* Clears any user heap functions from u_setMemoryFunctions()
|
||||
* Does NOT deallocate any remaining allocated memory.
|
||||
*/
|
||||
U_CFUNC UBool
|
||||
cmemory_cleanup(void);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -5,30 +5,15 @@
|
|||
**********************************************************************
|
||||
*/
|
||||
|
||||
#include "mutex.h"
|
||||
// C++ static initialization.
|
||||
//
|
||||
// The purpose of this C++ file is to trigger the calling of
|
||||
// u_ICUStaticInitFunc() during static initialization.
|
||||
// (The function itself is in ucln_cmn.c, along with the rest
|
||||
// of ICU's initialization and clean up code.)
|
||||
//
|
||||
#include "ucln_cmn.h"
|
||||
|
||||
/* Initialize the global mutex only when we can use it. */
|
||||
#if (ICU_USE_THREADS == 1)
|
||||
static UBool initializesGlobalMutex = u_ICUStaticInitFunc();
|
||||
|
||||
/*
|
||||
* NOTE: This function replicates functionality from the start
|
||||
* u_init(). Any changes must be made in both places.
|
||||
* TODO: combine them.
|
||||
*
|
||||
* This function runs only during C++ static initialization.
|
||||
*/
|
||||
static int GlobalMutexInitialize()
|
||||
{
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
|
||||
umtx_init(NULL);
|
||||
ucnv_init(&status);
|
||||
ures_init(&status);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int initializesGlobalMutex = GlobalMutexInitialize();
|
||||
|
||||
#endif /* ICU_USE_THREADS==1 */
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@
|
|||
U_NAMESPACE_BEGIN
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Code within this library which accesses protected data
|
||||
// Code within that accesses shared static or global data should
|
||||
// should instantiate a Mutex object while doing so. You should make your own
|
||||
// private mutex where possible.
|
||||
|
||||
|
|
@ -45,7 +45,7 @@ U_NAMESPACE_BEGIN
|
|||
//
|
||||
// void Function(int arg1, int arg2)
|
||||
// {
|
||||
// static Object* foo; // Shared read-write object
|
||||
// static Object* foo; // Shared read-write object
|
||||
// Mutex mutex(&myMutex); // or no args for the global lock
|
||||
// foo->Method();
|
||||
// // When 'mutex' goes out of scope and gets destroyed here, the lock is released
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@
|
|||
#include "ucln_cmn.h"
|
||||
#include "umutex.h"
|
||||
#include "ucln.h"
|
||||
#include "cmemory.h"
|
||||
|
||||
static cleanupFunc *gCleanupFunctions[UCLN_COMMON] = {
|
||||
NULL,
|
||||
|
|
@ -89,6 +90,7 @@ u_cleanup(void)
|
|||
* resource checkers don't complain. [grhoten]
|
||||
*/
|
||||
umtx_destroy(NULL);
|
||||
cmemory_cleanup(); /* undo any heap functions set by u_setMemoryFunctions(). */
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -103,14 +105,7 @@ u_cleanup(void)
|
|||
U_CAPI void U_EXPORT2
|
||||
u_init(UErrorCode *status) {
|
||||
/* Make sure the global mutexes are initialized. */
|
||||
/*
|
||||
* NOTE: This section of code replicates functionality from GlobalMutexInitialize()
|
||||
* in the file mutex.cpp. Any changes must be made in both places.
|
||||
* TODO: combine them.
|
||||
*/
|
||||
umtx_init(NULL);
|
||||
ucnv_init(status);
|
||||
ures_init(status);
|
||||
u_ICUStaticInitFunc();
|
||||
|
||||
/* Do any required init for services that don't have open operations
|
||||
* and use "only" the double-check initialization method for performance
|
||||
|
|
@ -126,3 +121,52 @@ u_init(UErrorCode *status) {
|
|||
unorm_haveData(status);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* ICU Static Initialization Function
|
||||
*
|
||||
* Does that portion of ICU's initialization that wants to happen at C++
|
||||
* static initialization time. Can also be called directly if the same
|
||||
* initialization is needed later.
|
||||
*
|
||||
* The effect is to initialize mutexes that are required during the
|
||||
* lazy initialization of other parts of ICU.
|
||||
*/
|
||||
U_CFUNC UBool u_ICUStaticInitFunc()
|
||||
{
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
|
||||
#if (ICU_USE_THREADS == 1)
|
||||
/* Initialize mutexes only if threading is supported */
|
||||
UBool heapInUse = cmemory_inUse();
|
||||
umtx_init(NULL);
|
||||
ucnv_init(&status);
|
||||
ures_init(&status);
|
||||
if (heapInUse == FALSE) {
|
||||
/* If there was no use of ICU prior to calling this static init function,
|
||||
* pretend that there is still no use, even though the various inits may
|
||||
* have done some heap allocation. */
|
||||
cmemory_clearInUse();
|
||||
}
|
||||
#endif /* ICU_USE_THREADS==1 */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Static Uninitialization Function
|
||||
*
|
||||
* Reverse the effects of ICU static initialization.
|
||||
* This is needed by u_setMutexFunctions(), which must get rid of any mutexes,
|
||||
* and associated memory, before swapping in the user's mutex funcs.
|
||||
*
|
||||
* Do NOT call cmemory_cleanup(). We don't want to cancel the effect of
|
||||
* any u_setHeapFunctions().
|
||||
*/
|
||||
U_CFUNC void u_ICUStaticUnInitFunc() {
|
||||
ucnv_cleanup();
|
||||
ures_cleanup();
|
||||
umtx_destroy(NULL);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -51,6 +51,8 @@ U_CFUNC UBool uset_cleanup(void);
|
|||
|
||||
U_CFUNC UBool service_cleanup(void);
|
||||
|
||||
U_CFUNC UBool cmemory_cleanup(void);
|
||||
|
||||
|
||||
/* Only mutexes should be initialized in these functions. */
|
||||
|
||||
|
|
@ -58,4 +60,9 @@ U_CFUNC void ucnv_init(UErrorCode *status);
|
|||
|
||||
U_CFUNC void ures_init(UErrorCode *status);
|
||||
|
||||
/* Static Initialization and un-initializatin functions. */
|
||||
U_CFUNC UBool u_ICUStaticInitFunc();
|
||||
U_CFUNC void u_ICUStaticUnInitFunc();
|
||||
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@
|
|||
/* Check our settings... */
|
||||
#include "unicode/utypes.h"
|
||||
#include "uassert.h"
|
||||
#include "ucln_cmn.h"
|
||||
|
||||
|
||||
#if defined(POSIX) && (ICU_USE_THREADS==1)
|
||||
|
|
@ -71,12 +72,15 @@
|
|||
|
||||
#if (ICU_USE_THREADS == 1)
|
||||
|
||||
/* the global mutex. Use it proudly and wash it often. */
|
||||
/* the global mutex. */
|
||||
static UMTX gGlobalMutex = NULL;
|
||||
|
||||
/* Detect Recursive entries. For debugging only. */
|
||||
# ifdef _DEBUG
|
||||
static int32_t gRecursionCount = 0; /* Detect Recursive entries. For debugging only. */
|
||||
static int32_t gRecursionCount = 0;
|
||||
# endif
|
||||
|
||||
/* Declare the predefined mutexes. */
|
||||
#if defined(WIN32)
|
||||
static CRITICAL_SECTION gPlatformMutex;
|
||||
|
||||
|
|
@ -88,7 +92,20 @@ static pthread_mutex_t gIncDecMutex; /* For use by atomic inc/dec, on Unixe
|
|||
#endif /* ICU_USE_THREADS==1 */
|
||||
|
||||
|
||||
/*
|
||||
* User mutex implementatin functions. If non-null, call back to these rather than
|
||||
* directly using the system (Posix or Windows) APIs.
|
||||
* (declarations are in uclean.h)
|
||||
*/
|
||||
static UMtxInit *pMutexInit = NULL;
|
||||
static UMtxDestroy *pMutexDestroy = NULL;
|
||||
static UMtxLock *pMutexLock = NULL;
|
||||
static UMtxUnlock *pMutexUnlock = NULL;
|
||||
static void *gMutexContext = NULL;
|
||||
|
||||
/*
|
||||
* umtx_isInitialized
|
||||
*/
|
||||
U_CAPI UBool U_EXPORT2
|
||||
umtx_isInitialized(UMTX *mutex)
|
||||
{
|
||||
|
|
@ -108,6 +125,11 @@ umtx_isInitialized(UMTX *mutex)
|
|||
#endif /* ICU_USE_THREADS==1 */
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* umtx_lock
|
||||
*/
|
||||
U_CAPI void U_EXPORT2
|
||||
umtx_lock(UMTX *mutex)
|
||||
{
|
||||
|
|
@ -133,35 +155,43 @@ umtx_lock(UMTX *mutex)
|
|||
}
|
||||
}
|
||||
|
||||
if (pMutexLock != NULL) {
|
||||
(*pMutexLock)(gMutexContext, mutex);
|
||||
} else {
|
||||
|
||||
#if defined(WIN32)
|
||||
|
||||
EnterCriticalSection((CRITICAL_SECTION*) *mutex);
|
||||
#ifdef _DEBUG
|
||||
if (mutex == &gGlobalMutex) {
|
||||
gRecursionCount++;
|
||||
U_ASSERT(gRecursionCount == 1);
|
||||
}
|
||||
#endif /*_DEBUG*/
|
||||
|
||||
EnterCriticalSection((CRITICAL_SECTION*) *mutex);
|
||||
#ifdef _DEBUG
|
||||
if (mutex == &gGlobalMutex) {
|
||||
gRecursionCount++;
|
||||
U_ASSERT(gRecursionCount == 1);
|
||||
}
|
||||
#endif /*_DEBUG*/
|
||||
|
||||
#elif defined(POSIX)
|
||||
|
||||
# ifdef POSIX_DEBUG_REENTRANCY
|
||||
if (gInMutex == TRUE && mutex == &gGlobalMutex) /* in the mutex -- possible deadlock*/
|
||||
if(pthread_equal(gLastThread, pthread_self()))
|
||||
WeAreDeadlocked();
|
||||
if (gInMutex == TRUE && mutex == &gGlobalMutex) /* in the mutex -- possible deadlock*/
|
||||
if(pthread_equal(gLastThread, pthread_self()))
|
||||
WeAreDeadlocked();
|
||||
# endif
|
||||
pthread_mutex_lock((pthread_mutex_t*) *mutex);
|
||||
|
||||
pthread_mutex_lock((pthread_mutex_t*) *mutex);
|
||||
|
||||
# ifdef POSIX_DEBUG_REENTRANCY
|
||||
if (mutex == &gGlobalMutex) {
|
||||
gLastThread = pthread_self();
|
||||
gInMutex = TRUE;
|
||||
if (mutex == &gGlobalMutex) {
|
||||
gLastThread = pthread_self();
|
||||
gInMutex = TRUE;
|
||||
}
|
||||
# endif /* POSIX_DEBUG_REENTRANCY */
|
||||
#endif /* cascade of platforms */
|
||||
}
|
||||
# endif
|
||||
#endif
|
||||
#endif /* ICU_USE_THREADS==1 */
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* umtx_unlock
|
||||
*/
|
||||
U_CAPI void U_EXPORT2
|
||||
umtx_unlock(UMTX* mutex)
|
||||
{
|
||||
|
|
@ -176,9 +206,12 @@ umtx_unlock(UMTX* mutex)
|
|||
return; /* jitterbug 135, fix for multiprocessor machines */
|
||||
}
|
||||
|
||||
if (pMutexUnlock) {
|
||||
(*pMutexUnlock)(gMutexContext, mutex);
|
||||
} else {
|
||||
#if defined (WIN32)
|
||||
#ifdef _DEBUG
|
||||
if (mutex == &gGlobalMutex) {
|
||||
if (mutex == &gGlobalMutex) {
|
||||
gRecursionCount--;
|
||||
U_ASSERT(gRecursionCount == 0);
|
||||
}
|
||||
|
|
@ -194,7 +227,8 @@ umtx_unlock(UMTX* mutex)
|
|||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* cascade of platforms */
|
||||
}
|
||||
#endif /* ICU_USE_THREADS == 1 */
|
||||
}
|
||||
|
||||
|
|
@ -205,6 +239,20 @@ umtx_unlock(UMTX* mutex)
|
|||
*/
|
||||
#if (ICU_USE_THREADS == 1)
|
||||
static UMTX umtx_raw_init(void *mem) {
|
||||
if (pMutexInit != NULL) {
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
if (mem == NULL) {
|
||||
mem = uprv_malloc(sizeof(UMTX));
|
||||
if (mem == NULL) {return NULL;}
|
||||
}
|
||||
(*pMutexInit)(gMutexContext, (UMTX *)mem, &status);
|
||||
if (U_FAILURE(status)) {
|
||||
/* TODO: how should errors here be handled? */
|
||||
uprv_free(mem);
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
|
||||
#if defined (WIN32)
|
||||
if (mem == NULL) {
|
||||
mem = uprv_malloc(sizeof(CRITICAL_SECTION));
|
||||
|
|
@ -213,6 +261,7 @@ static UMTX umtx_raw_init(void *mem) {
|
|||
InitializeCriticalSection((CRITICAL_SECTION*)mem);
|
||||
#elif defined( POSIX )
|
||||
if (mem == NULL) {
|
||||
/* TODO: think about eliminating this malloc. */
|
||||
mem = uprv_malloc(sizeof(pthread_mutex_t));
|
||||
if (mem == NULL) {return NULL;}
|
||||
}
|
||||
|
|
@ -221,7 +270,9 @@ static UMTX umtx_raw_init(void *mem) {
|
|||
# else
|
||||
pthread_mutex_init((pthread_mutex_t*)mem, NULL);
|
||||
# endif
|
||||
#endif
|
||||
#endif /* cascade of platforms */
|
||||
}
|
||||
|
||||
return (UMTX *)mem;
|
||||
}
|
||||
#endif /* ICU_USE_THREADS */
|
||||
|
|
@ -274,7 +325,9 @@ umtx_init(UMTX *mutex)
|
|||
}
|
||||
umtx_unlock(NULL);
|
||||
|
||||
umtx_destroy(&tMutex); /* NOP if (tmutex == NULL) */
|
||||
if (tMutex != NULL) {
|
||||
umtx_destroy(&tMutex);
|
||||
}
|
||||
}
|
||||
#endif /* ICU_USE_THREADS==1 */
|
||||
}
|
||||
|
|
@ -308,13 +361,48 @@ umtx_destroy(UMTX *mutex) {
|
|||
}
|
||||
|
||||
|
||||
#if (ICU_USE_THREADS == 1)
|
||||
|
||||
U_CAPI void U_EXPORT2
|
||||
u_setMutexFunctions(void *context, UMtxInit *i, UMtxDestroy *d, UMtxLock *l, UMtxUnlock *u,
|
||||
UErrorCode *status) {
|
||||
if (U_FAILURE(*status)) {
|
||||
return;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
/* Destroy the mutexes that C++ static initialization creates */
|
||||
u_ICUStaticUnInitFunc();
|
||||
|
||||
/* Swap in the mutex function pointers. */
|
||||
pMutexInit = i;
|
||||
pMutexDestroy = d;
|
||||
pMutexLock = l;
|
||||
pMutexUnlock = u;
|
||||
gMutexContext = context;
|
||||
|
||||
/*
|
||||
* Re-do the equivalent of ICU's static initialization,
|
||||
* which will recreate the default, resource bundle and converter mutexes
|
||||
*/
|
||||
u_ICUStaticInitFunc();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* umtx_atomic_inc
|
||||
* umtx_atomic_dec
|
||||
*/
|
||||
#if (ICU_USE_THREADS == 1)
|
||||
|
||||
#if defined (WIN32)
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -19,12 +19,8 @@
|
|||
#define UMUTEX_H
|
||||
|
||||
#include "unicode/utypes.h"
|
||||
#include "unicode/uclean.h"
|
||||
|
||||
/**
|
||||
* Mutex data type.
|
||||
* @internal
|
||||
*/
|
||||
typedef void *UMTX;
|
||||
|
||||
/* APP_NO_THREADS is an old symbol. We'll honour it if present. */
|
||||
#ifdef APP_NO_THREADS
|
||||
|
|
@ -37,36 +33,34 @@ typedef void *UMTX;
|
|||
#endif
|
||||
|
||||
/*
|
||||
* Code within this library which accesses protected data should
|
||||
* instantiate a Mutex object while doing so. Notice that there is
|
||||
* only one coarse-grained lock which applies to this entire library,
|
||||
* so keep locking short and sweet.
|
||||
* Code within ICU that accesses shared static or global data should
|
||||
* instantiate a Mutex object while doing so. The unnamed global mutex
|
||||
* is used throughout ICU, so keep locking short and sweet.
|
||||
*
|
||||
* For example:
|
||||
*
|
||||
* void Function(int arg1, int arg2)
|
||||
* {
|
||||
* static Object* foo; // Shared read-write object
|
||||
* Mutex mutex;
|
||||
* static Object* foo; // Shared read-write object
|
||||
* umtx_lock(NULL); // Lock the ICU global mutex
|
||||
* foo->Method();
|
||||
* // When 'mutex' goes out of scope and gets destroyed here
|
||||
* // the lock is released
|
||||
* umtx_unlock(NULL);
|
||||
* }
|
||||
*
|
||||
* Note: Do NOT use the form 'Mutex mutex();' as that merely
|
||||
* forward-declares a function returning a Mutex. This is a common
|
||||
* mistake which silently slips through the compiler!! */
|
||||
* an alternative C++ mutex API is defined in the file common/mutex.h
|
||||
*/
|
||||
|
||||
|
||||
/* Lock a mutex. Pass in NULL if you want the (ick) Single Global
|
||||
Mutex.
|
||||
* @param mutex The given mutex to be locked
|
||||
/* Lock a mutex.
|
||||
* @param mutex The given mutex to be locked. Pass NULL to specify
|
||||
* the global ICU mutex. Recursive locks are an error
|
||||
* and may cause a deadlock on some platforms.
|
||||
*/
|
||||
U_CAPI void U_EXPORT2 umtx_lock ( UMTX* mutex );
|
||||
|
||||
/* Unlock a mutex. Pass in NULL if you want the single global
|
||||
mutex.
|
||||
* @param mutex The given mutex to be unlocked
|
||||
* @param mutex The given mutex to be unlocked. Pass NULL to specify
|
||||
* the global ICU mutex.
|
||||
*/
|
||||
U_CAPI void U_EXPORT2 umtx_unlock ( UMTX* mutex );
|
||||
|
||||
|
|
@ -85,15 +79,18 @@ U_CAPI void U_EXPORT2 umtx_init ( UMTX* mutex );
|
|||
*/
|
||||
U_CAPI void U_EXPORT2 umtx_destroy( UMTX *mutex );
|
||||
|
||||
/* Is a mutex initialized?
|
||||
Use it this way:
|
||||
umtx_isInitialized( &aMutex );
|
||||
This function is not normally needed. It is more efficient to
|
||||
unconditionally call umtx_init(&aMutex) than it is to check first.
|
||||
/* Test whether an ICU mutex is initialized.
|
||||
* This function is intended for use from test programs only,
|
||||
* there should be no need for it from normal code.
|
||||
* If there is any question about whether a mutex has been initialized,
|
||||
* simply initialize it again with umtx_init(), which will have
|
||||
* no effect if the mutex is already initialized.
|
||||
* @param mutex The given mutex to be tested
|
||||
*/
|
||||
U_CAPI UBool U_EXPORT2 umtx_isInitialized( UMTX *mutex );
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Atomic Increment and Decrement of an int32_t value.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -33,6 +33,10 @@
|
|||
* application must guarantee that the first call to u_init() happen
|
||||
* without contention, in a single thread only.
|
||||
* <p>
|
||||
* If <code>u_setMemoryFunctions()</code> or
|
||||
* <code>u_setMutexFunctions</code> are needed (uncommon), they must be
|
||||
* called _before_ <code>u_init()</code>.
|
||||
* <p>
|
||||
* Extra, repeated, or otherwise unneeded calls to u_init() do no harm,
|
||||
* other than taking a small amount of time.
|
||||
*
|
||||
|
|
@ -86,4 +90,38 @@ u_init(UErrorCode *status);
|
|||
U_CAPI void U_EXPORT2
|
||||
u_cleanup(void);
|
||||
|
||||
|
||||
/**
|
||||
* An opaque type that represents an ICU mutex.
|
||||
* @draft ICU 2.8
|
||||
* @system
|
||||
*/
|
||||
typedef void *UMTX;
|
||||
|
||||
typedef void U_CALLCONV UMtxInit (void *context, UMTX *mutex, UErrorCode*pError);
|
||||
typedef void U_CALLCONV UMtxDestroy(void *context, UMTX *mutex);
|
||||
typedef void U_CALLCONV UMtxLock (void *context, UMTX *mutex);
|
||||
typedef void U_CALLCONV UMtxUnlock (void *context, UMTX *mutex);
|
||||
|
||||
U_CAPI void U_EXPORT2
|
||||
u_setMutexFunctions(void *context, UMtxInit *i, UMtxDestroy *d, UMtxLock *l, UMtxUnlock *u,
|
||||
UErrorCode *status);
|
||||
|
||||
|
||||
typedef void U_CALLCONV UMtxAtomicInc (void *context, UMTX *mutex);
|
||||
typedef void U_CALLCONV UMtxAtomicDec (void *context, UMTX *mutex);
|
||||
|
||||
U_CAPI void U_EXPORT2
|
||||
u_setAtomicIncDecFunctions(void *context, UMtxAtomicInc *inc, UMtxAtomicDec *dec,
|
||||
UErrorCode *status);
|
||||
|
||||
|
||||
typedef void *U_CALLCONV UMemAlloc (void *context, size_t size);
|
||||
typedef void *U_CALLCONV UMemRealloc(void *context, void *mem, size_t size);
|
||||
typedef void U_CALLCONV UMemFree (void *context, void *mem);
|
||||
|
||||
U_CAPI void U_EXPORT2
|
||||
u_setMemoryFunctions(void *context, UMemAlloc *a, UMemRealloc *r, UMemFree *f,
|
||||
UErrorCode *status);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ cucdapi.o cucdtst.o custrtst.o cstrcase.o cutiltst.o encoll.o nucnvtst.o nccbtst
|
|||
cbiditst.o cbididat.o eurocreg.o udatatst.o utf16tst.o utransts.o \
|
||||
ncnvfbts.o ncnvtst.o putiltst.o cstrtest.o mstrmtst.o utf8tst.o ucmptst.o \
|
||||
stdnmtst.o ctstdep.o usrchtst.o custrtrn.o sorttest.o trietest.o usettest.o uenumtst.o \
|
||||
idnatest.o nfsprep.o spreptst.o sprpdata.o
|
||||
idnatest.o nfsprep.o spreptst.o sprpdata.o hpmufn.o
|
||||
|
||||
DEPS = $(OBJECTS:.o=.d)
|
||||
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ void addUCharTransformTest(TestNode** root);
|
|||
void addUSetTest(TestNode** root);
|
||||
void addUStringPrepTest(TestNode** root);
|
||||
void addIDNATest(TestNode** root);
|
||||
void addHeapMutexTest(TestNode **root);
|
||||
|
||||
void addAllTests(TestNode** root)
|
||||
{
|
||||
|
|
@ -67,5 +68,7 @@ void addAllTests(TestNode** root)
|
|||
addUStringPrepTest(root);
|
||||
addIDNATest(root);
|
||||
#endif
|
||||
addHeapMutexTest(root);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -530,6 +530,10 @@ SOURCE=.\cutiltst.c
|
|||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hpmufn.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mstrmtst.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@
|
|||
#include "unicode/ustring.h"
|
||||
#include "cstring.h"
|
||||
#include "filestrm.h"
|
||||
#include "cmemory.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
#define RESTEST_HEAP_CHECK 0
|
||||
|
||||
|
|
@ -517,7 +517,7 @@ static void TestFileStream(void){
|
|||
int32_t c1=0;
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
const char* testdatapath = loadTestData(&status);
|
||||
char* fileName = (char*) uprv_malloc(uprv_strlen(testdatapath) +10);
|
||||
char* fileName = (char*) malloc(uprv_strlen(testdatapath) +10);
|
||||
FileStream* stream = NULL;
|
||||
/* these should not be closed */
|
||||
FileStream* pStdin = T_FileStream_stdin();
|
||||
|
|
@ -526,7 +526,7 @@ static void TestFileStream(void){
|
|||
|
||||
const char* testline = "This is a test line";
|
||||
int32_t bufLen =uprv_strlen(testline)+10;
|
||||
char* buf = (char*) uprv_malloc(bufLen);
|
||||
char* buf = (char*) malloc(bufLen);
|
||||
int32_t retLen = 0;
|
||||
|
||||
if(pStdin==NULL){
|
||||
|
|
@ -629,7 +629,7 @@ static void TestFileStream(void){
|
|||
}
|
||||
|
||||
|
||||
uprv_free(fileName);
|
||||
uprv_free(buf);
|
||||
free(fileName);
|
||||
free(buf);
|
||||
|
||||
}
|
||||
|
|
|
|||
151
icu4c/source/test/cintltst/hpmufn.c
Normal file
151
icu4c/source/test/cintltst/hpmufn.c
Normal file
|
|
@ -0,0 +1,151 @@
|
|||
/********************************************************************
|
||||
* COPYRIGHT:
|
||||
* Copyright (c) 2003, International Business Machines Corporation and
|
||||
* others. All Rights Reserved.
|
||||
********************************************************************/
|
||||
/*
|
||||
* File hpmufn.c
|
||||
*
|
||||
*/
|
||||
|
||||
#include "unicode/utypes.h"
|
||||
#include "unicode/uclean.h"
|
||||
#include "unicode/uchar.h"
|
||||
#include "unicode/ures.h"
|
||||
|
||||
#include "cintltst.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <malloc.h>
|
||||
|
||||
|
||||
static void TestHeapFunctions(void);
|
||||
|
||||
void addHeapMutexTest(TestNode **root);
|
||||
|
||||
|
||||
void
|
||||
addHeapMutexTest(TestNode** root)
|
||||
{
|
||||
addTest(root, &TestHeapFunctions, "tsutil/TestHeapFunctions" );
|
||||
|
||||
}
|
||||
|
||||
|
||||
#define TEST_STATUS(status, expected) \
|
||||
if (status != expected) { \
|
||||
log_err("FAIL at %s:%d. Actual status = \"%s\"; Expected status = \"%s\"\n", \
|
||||
__FILE__, __LINE__, u_errorName(status), u_errorName(expected)); }
|
||||
|
||||
/*
|
||||
* Test Heap Functions.
|
||||
* Implemented on top of the standard malloc heap.
|
||||
* All blocks increased in size by 8 bytes, and the poiner returned to ICU is
|
||||
* offset up by 8, which should cause a good heap corruption if one of our "blocks"
|
||||
* ends up being freed directly, without coming through us.
|
||||
* Allocations are counted, to check that ICU actually does call back to us.
|
||||
*/
|
||||
int gBlockCount = 0;
|
||||
void *gContext;
|
||||
|
||||
void *myMemAlloc(void *context, size_t size) {
|
||||
char *retPtr = (char *)malloc(size+8);
|
||||
if (retPtr != NULL) {
|
||||
retPtr += 8;
|
||||
}
|
||||
gBlockCount ++;
|
||||
return retPtr;
|
||||
}
|
||||
|
||||
void myMemFree(void *context, void *mem) {
|
||||
char *freePtr = (char *)mem;
|
||||
if (freePtr != NULL) {
|
||||
freePtr -= 8;
|
||||
}
|
||||
free(freePtr);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void *myMemRealloc(void *context, void *mem, size_t size) {
|
||||
char *p = (char *)mem;
|
||||
char *retPtr;
|
||||
|
||||
if (p!=NULL) {
|
||||
p -= 8;
|
||||
}
|
||||
retPtr = realloc(p, size+8);
|
||||
if (retPtr != NULL) {
|
||||
p += 8;
|
||||
}
|
||||
return retPtr;
|
||||
}
|
||||
|
||||
|
||||
static void TestHeapFunctions() {
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
UResourceBundle *rb = NULL;
|
||||
|
||||
|
||||
/* Can not set memory functions if ICU is already initialized */
|
||||
u_setMemoryFunctions(&gContext, myMemAlloc, myMemRealloc, myMemFree, &status);
|
||||
TEST_STATUS(status, U_INVALID_STATE_ERROR);
|
||||
|
||||
/* Un-initialize ICU */
|
||||
u_cleanup();
|
||||
|
||||
/* Can not set memory functions with NULL values */
|
||||
status = U_ZERO_ERROR;
|
||||
u_setMemoryFunctions(&gContext, NULL, myMemRealloc, myMemFree, &status);
|
||||
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
|
||||
status = U_ZERO_ERROR;
|
||||
u_setMemoryFunctions(&gContext, myMemAlloc, NULL, myMemFree, &status);
|
||||
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
|
||||
status = U_ZERO_ERROR;
|
||||
u_setMemoryFunctions(&gContext, myMemAlloc, myMemRealloc, NULL, &status);
|
||||
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
|
||||
|
||||
/* u_setMemoryFunctions() should work with null or non-null context pointer */
|
||||
status = U_ZERO_ERROR;
|
||||
u_setMemoryFunctions(NULL, myMemAlloc, myMemRealloc, myMemFree, &status);
|
||||
TEST_STATUS(status, U_ZERO_ERROR);
|
||||
u_setMemoryFunctions(&gContext, myMemAlloc, myMemRealloc, myMemFree, &status);
|
||||
TEST_STATUS(status, U_ZERO_ERROR);
|
||||
|
||||
|
||||
/* After reinitializing ICU, we should not be able to set the memory funcs again. */
|
||||
status = U_ZERO_ERROR;
|
||||
u_init(&status);
|
||||
TEST_STATUS(status, U_ZERO_ERROR);
|
||||
u_setMemoryFunctions(NULL, myMemAlloc, myMemRealloc, myMemFree, &status);
|
||||
TEST_STATUS(status, U_INVALID_STATE_ERROR);
|
||||
|
||||
/* Doing ICU operations should cause allocations to come through our test heap */
|
||||
gBlockCount = 0;
|
||||
status = U_ZERO_ERROR;
|
||||
rb = ures_open(NULL, "es", &status);
|
||||
TEST_STATUS(status, U_ZERO_ERROR);
|
||||
if (gBlockCount == 0) {
|
||||
log_err("Heap functions are not being called from ICU.\n");
|
||||
}
|
||||
ures_close(rb);
|
||||
|
||||
/* Cleanup should put the heap back to its default implementation. */
|
||||
u_cleanup();
|
||||
status = U_ZERO_ERROR;
|
||||
u_init(&status);
|
||||
TEST_STATUS(status, U_ZERO_ERROR);
|
||||
|
||||
/* ICU operations should no longer cause allocations to come through our test heap */
|
||||
gBlockCount = 0;
|
||||
status = U_ZERO_ERROR;
|
||||
rb = ures_open(NULL, "fr", &status);
|
||||
TEST_STATUS(status, U_ZERO_ERROR);
|
||||
if (gBlockCount != 0) {
|
||||
log_err("Heap functions did not reset after u_cleanup.\n");
|
||||
}
|
||||
ures_close(rb);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -28,8 +28,8 @@
|
|||
static void
|
||||
parseMappings(const char *filename, UStringPrepProfile* data, UBool reportError, UErrorCode *pErrorCode);
|
||||
|
||||
static void
|
||||
compareMapping(UStringPrepProfile* data, uint32_t codepoint, uint32_t* mapping, int32_t mapLength,
|
||||
static void
|
||||
compareMapping(UStringPrepProfile* data, uint32_t codepoint, uint32_t* mapping, int32_t mapLength,
|
||||
UStringPrepType option);
|
||||
|
||||
static void
|
||||
|
|
@ -48,10 +48,10 @@ strprepProfileLineFn(void *context,
|
|||
const char* typeName;
|
||||
uint32_t rangeStart=0,rangeEnd =0;
|
||||
const char* filename = (const char*) context;
|
||||
|
||||
|
||||
typeName = fields[2][0];
|
||||
map = fields[1][0];
|
||||
|
||||
|
||||
if(strstr(typeName, usprepTypeNames[USPREP_UNASSIGNED])!=NULL){
|
||||
|
||||
u_parseCodePointRange(fields[0][0], &rangeStart,&rangeEnd, pErrorCode);
|
||||
|
|
@ -72,7 +72,7 @@ strprepProfileLineFn(void *context,
|
|||
|
||||
/* parse the mapping string */
|
||||
length=u_parseCodePoints(map, mapping, sizeof(mapping)/4, pErrorCode);
|
||||
|
||||
|
||||
/* compare the mapping */
|
||||
compareMapping(data, code,mapping, length,USPREP_MAP);
|
||||
|
||||
|
|
@ -113,8 +113,8 @@ getValues(uint32_t result, int32_t* value, UBool* isIndex){
|
|||
|
||||
UStringPrepType type;
|
||||
if(result == 0){
|
||||
/*
|
||||
* Initial value stored in the mapping table
|
||||
/*
|
||||
* Initial value stored in the mapping table
|
||||
* just return USPREP_TYPE_LIMIT .. so that
|
||||
* the source codepoint is copied to the destination
|
||||
*/
|
||||
|
|
@ -127,7 +127,7 @@ getValues(uint32_t result, int32_t* value, UBool* isIndex){
|
|||
/* ascertain if the value is index or delta */
|
||||
if(result & 0x02){
|
||||
*isIndex = TRUE;
|
||||
*value = result >> 2;
|
||||
*value = result >> 2;
|
||||
|
||||
}else{
|
||||
*isIndex = FALSE;
|
||||
|
|
@ -144,8 +144,8 @@ getValues(uint32_t result, int32_t* value, UBool* isIndex){
|
|||
return type;
|
||||
}
|
||||
|
||||
static void
|
||||
compareMapping(UStringPrepProfile* data, uint32_t codepoint, uint32_t* mapping,int32_t mapLength,
|
||||
static void
|
||||
compareMapping(UStringPrepProfile* data, uint32_t codepoint, uint32_t* mapping,int32_t mapLength,
|
||||
UStringPrepType type){
|
||||
uint32_t result = 0;
|
||||
int32_t length=0;
|
||||
|
|
@ -153,12 +153,12 @@ compareMapping(UStringPrepProfile* data, uint32_t codepoint, uint32_t* mapping,i
|
|||
UStringPrepType retType;
|
||||
int32_t value=0, index=0, delta=0;
|
||||
int32_t* indexes = data->indexes;
|
||||
UTrie trie = data->sprepTrie;
|
||||
UTrie trie = data->sprepTrie;
|
||||
const uint16_t* mappingData = data->mappingData;
|
||||
int32_t realLength =0;
|
||||
int32_t j=0;
|
||||
int8_t i=0;
|
||||
|
||||
|
||||
UTRIE_GET16(&trie, codepoint, result);
|
||||
retType = getValues(result,&value,&isIndex);
|
||||
|
||||
|
|
@ -188,19 +188,19 @@ compareMapping(UStringPrepProfile* data, uint32_t codepoint, uint32_t* mapping,i
|
|||
length = (retType == USPREP_DELETE)? 0 : 1;
|
||||
}
|
||||
|
||||
/* figure out the real length */
|
||||
/* figure out the real length */
|
||||
for(j=0; j<mapLength; j++){
|
||||
if(mapping[j] > 0xFFFF){
|
||||
realLength +=2;
|
||||
}else{
|
||||
realLength++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(realLength != length){
|
||||
log_err( "Did not get the expected length. Expected: %i Got: %i\n", mapLength, length);
|
||||
}
|
||||
|
||||
|
||||
if(isIndex){
|
||||
for(i =0; i< mapLength; i++){
|
||||
if(mapping[i] <= 0xFFFF){
|
||||
|
|
@ -225,7 +225,7 @@ compareMapping(UStringPrepProfile* data, uint32_t codepoint, uint32_t* mapping,i
|
|||
}
|
||||
|
||||
static void
|
||||
compareFlagsForRange(UStringPrepProfile* data,
|
||||
compareFlagsForRange(UStringPrepProfile* data,
|
||||
uint32_t start, uint32_t end,
|
||||
UStringPrepType type){
|
||||
|
||||
|
|
@ -233,17 +233,17 @@ compareFlagsForRange(UStringPrepProfile* data,
|
|||
UStringPrepType retType;
|
||||
UBool isIndex=FALSE;
|
||||
int32_t value=0;
|
||||
UTrie trie = data->sprepTrie;
|
||||
/*
|
||||
// supplementary code point
|
||||
UTrie trie = data->sprepTrie;
|
||||
/*
|
||||
// supplementary code point
|
||||
UChar __lead16=UTF16_LEAD(0x2323E);
|
||||
int32_t __offset;
|
||||
|
||||
// get data for lead surrogate
|
||||
// get data for lead surrogate
|
||||
(result)=_UTRIE_GET_RAW((&idnTrie), index, 0, (__lead16));
|
||||
__offset=(&idnTrie)->getFoldingOffset(result);
|
||||
|
||||
// get the real data from the folded lead/trail units
|
||||
// get the real data from the folded lead/trail units
|
||||
if(__offset>0) {
|
||||
(result)=_UTRIE_GET_RAW((&idnTrie), index, __offset, (0x2323E)&0x3ff);
|
||||
} else {
|
||||
|
|
@ -267,10 +267,10 @@ compareFlagsForRange(UStringPrepProfile* data,
|
|||
|
||||
start++;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
doStringPrepTest(const char* binFileName, const char* txtFileName, int32_t options, UErrorCode* errorCode){
|
||||
|
||||
const char *testdatapath = loadTestData(errorCode);
|
||||
|
|
@ -301,4 +301,4 @@ doStringPrepTest(const char* binFileName, const char* txtFileName, int32_t optio
|
|||
* indent-tabs-mode: nil
|
||||
* End:
|
||||
*
|
||||
*/
|
||||
*/
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue