The Tor Browser: intl/icu/source/common/umutex.cpp@fc2d59ddac77 (annotated)

intl/icu/source/common/umutex.cpp@fc2d59ddac77 (annotated)

intl/icu/source/common/umutex.cpp

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /*
 ******************************************************************************
 *
 *   Copyright (C) 1997-2013, 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"
 #include "ucln_cmn.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)
            (LONG volatile *) // this is the type given in the API doc for this function.
 #endif
             &uio.fState,  //  Destination
 ,            //  Exchange Value
 );           //  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.
 //
 //   success: True:  the inialization succeeded. No further calls to the init
 //                   function will be made.
 //            False: the initializtion failed. The next call to umtx_initOnce()
 //                   will retry the initialization.
 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);
 }
 #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_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) {
     int32_t val = var;
     umtx_lock(&gIncDecMutex);
     umtx_unlock(&gIncDecMutex);
     return val;
 }
 U_COMMON_API void U_EXPORT2
 umtx_storeRelease(u_atomic_int32_t &var, int32_t val) {
     umtx_lock(&gIncDecMutex);
     umtx_unlock(&gIncDecMutex);
     var = val;
 }
 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;
 }

The Tor Browser / annotate

intl/icu/source/common/umutex.cpp@fc2d59ddac77 (annotated)

intl/icu/source/common/umutex.cpp