tor-browser

umutex.cpp (6182B)

---

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
******************************************************************************
*
*   Copyright (C) 1997-2016, 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 "ucln_cmn.h"
#include "cmemory.h"

U_NAMESPACE_BEGIN


#if defined(U_USER_MUTEX_CPP)
// Support for including an alternate implementation of mutexes has been withdrawn.
// See issue ICU-20185.
#error U_USER_MUTEX_CPP not supported
#endif


/*************************************************************************************************
*
*  ICU Mutex wrappers.
*
*************************************************************************************************/

#ifndef __wasi__
namespace {
std::mutex *initMutex;
std::condition_variable *initCondition;

// The ICU global mutex.
// Used when ICU implementation code passes nullptr for the mutex pointer.
UMutex globalMutex;

std::once_flag initFlag;
std::once_flag *pInitFlag = &initFlag;

}  // Anonymous namespace
#endif

U_CDECL_BEGIN
static UBool U_CALLCONV umtx_cleanup() {
#ifndef __wasi__
   initMutex->~mutex();
   initCondition->~condition_variable();
   UMutex::cleanup();

   // Reset the once_flag, by destructing it and creating a fresh one in its place.
   // Do not use this trick anywhere else in ICU; use umtx_initOnce, not std::call_once().
   pInitFlag->~once_flag();
   pInitFlag = new(&initFlag) std::once_flag();
#endif
   return true;
}

static void U_CALLCONV umtx_init() {
#ifndef __wasi__
   initMutex = STATIC_NEW(std::mutex);
   initCondition = STATIC_NEW(std::condition_variable);
   ucln_common_registerCleanup(UCLN_COMMON_MUTEX, umtx_cleanup);
#endif
}
U_CDECL_END


#ifndef __wasi__
std::mutex *UMutex::getMutex() {
   std::mutex *retPtr = fMutex.load(std::memory_order_acquire);
   if (retPtr == nullptr) {
       std::call_once(*pInitFlag, umtx_init);
       std::lock_guard<std::mutex> guard(*initMutex);
       retPtr = fMutex.load(std::memory_order_acquire);
       if (retPtr == nullptr) {
           fMutex = new(fStorage) std::mutex();
           retPtr = fMutex;
           fListLink = gListHead;
           gListHead = this;
       }
   }
   U_ASSERT(retPtr != nullptr);
   return retPtr;
}
#endif

UMutex *UMutex::gListHead = nullptr;

void UMutex::cleanup() {
   UMutex *next = nullptr;
   for (UMutex *m = gListHead; m != nullptr; m = next) {
#ifndef __wasi__
       (*m->fMutex).~mutex();
       m->fMutex = nullptr;
#endif
       next = m->fListLink;
       m->fListLink = nullptr;
   }
   gListHead = nullptr;
}


U_CAPI void  U_EXPORT2
umtx_lock(UMutex *mutex) {
#ifndef __wasi__
   if (mutex == nullptr) {
       mutex = &globalMutex;
   }
   mutex->lock();
#endif
}


U_CAPI void  U_EXPORT2
umtx_unlock(UMutex* mutex)
{
#ifndef __wasi__
   if (mutex == nullptr) {
       mutex = &globalMutex;
   }
   mutex->unlock();
#endif
}


/*************************************************************************************************
*
*  UInitOnce Implementation
*
*************************************************************************************************/

// This function is called when a test of a UInitOnce::fState reveals that
//   initialization has not completed, that we either need to call the init
//   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) {
#ifndef __wasi__
   std::call_once(*pInitFlag, umtx_init);
   std::unique_lock<std::mutex> lock(*initMutex);
#endif
   if (umtx_loadAcquire(uio.fState) == 0) {
       umtx_storeRelease(uio.fState, 1);
       return true;      // Caller will next call the init function.
   } else {
#ifndef __wasi__
       while (umtx_loadAcquire(uio.fState) == 1) {
           // Another thread is currently running the initialization.
           // Wait until it completes.
           initCondition->wait(lock);
       }
       U_ASSERT(uio.fState == 2);
#endif
       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) {
#ifndef __wasi__
   {
       std::unique_lock<std::mutex> lock(*initMutex);
       umtx_storeRelease(uio.fState, 2);
   }
   initCondition->notify_all();
#endif
}

U_NAMESPACE_END

/*************************************************************************************************
*
*  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;
   }
}



U_DEPRECATED void U_EXPORT2
u_setAtomicIncDecFunctions(const void * /*context */, UMtxAtomicFn *, UMtxAtomicFn *,
                          UErrorCode *status) {
   if (U_SUCCESS(*status)) {
       *status = U_UNSUPPORTED_ERROR;
   }
}