From: Chris Bieneman Date: Thu, 30 Oct 2014 22:07:09 +0000 (+0000) Subject: Removing the static initializer in ManagedStatic.cpp by using llvm_call_once to initi... X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=8744520b533617fbbd55ef12ea936961f5225cf5 Removing the static initializer in ManagedStatic.cpp by using llvm_call_once to initialize the ManagedStatic mutex. Summary: This patch adds an llvm_call_once which is a wrapper around std::call_once on platforms where it is available and devoid of bugs. The patch also migrates the ManagedStatic mutex to be allocated using llvm_call_once. These changes are philosophically equivalent to the changes added in r219638, which were reverted due to a hang on Win32 which was the result of a bug in the Windows implementation of std::call_once. Reviewers: aaron.ballman, chapuni, chandlerc, rnk Reviewed By: rnk Subscribers: majnemer, llvm-commits Differential Revision: http://reviews.llvm.org/D5922 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@220932 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Support/Threading.h b/include/llvm/Support/Threading.h index 7e8758407c7..d6d6da61f9e 100644 --- a/include/llvm/Support/Threading.h +++ b/include/llvm/Support/Threading.h @@ -15,6 +15,14 @@ #ifndef LLVM_SUPPORT_THREADING_H #define LLVM_SUPPORT_THREADING_H +#include "llvm/Config/llvm-config.h" // for LLVM_ON_UNIX + +#if defined(LLVM_ON_UNIX) +#include +#else +#include "llvm/Support/Atomic.h" +#endif + namespace llvm { /// Returns true if LLVM is compiled with support for multi-threading, and /// false otherwise. @@ -33,6 +41,35 @@ namespace llvm { /// the thread stack. void llvm_execute_on_thread(void (*UserFn)(void*), void *UserData, unsigned RequestedStackSize = 0); + +#if defined(LLVM_ON_UNIX) +typedef std::once_flag once_flag; +#define LLVM_DEFINE_ONCE_FLAG(flag) static once_flag flag +#else +enum InitStatus { + Done = -1, + Uninitialized = 0, + Wait = 1 +}; +typedef volatile sys::cas_flag once_flag; + +#define LLVM_DEFINE_ONCE_FLAG(flag) static once_flag flag = Uninitialized +#endif + +/// \brief Execute the function specified as a parameter once. +/// +/// Typical usage: +/// \code +/// void foo() {...}; +/// ... +/// LLVM_DEFINE_ONCE_FLAG(flag); +/// call_once(flag, foo); +/// \endcode +/// +/// \param flag Flag used for tracking whether or not this has run. +/// \param UserFn Function to call once. +void call_once(once_flag&, void (*)(void)); + } #endif diff --git a/lib/Support/CMakeLists.txt b/lib/Support/CMakeLists.txt index daed4f12e2b..32b96fa379d 100644 --- a/lib/Support/CMakeLists.txt +++ b/lib/Support/CMakeLists.txt @@ -102,6 +102,7 @@ add_llvm_library(LLVMSupport Unix/Program.inc Unix/RWMutex.inc Unix/Signals.inc + Unix/Threading.inc Unix/ThreadLocal.inc Unix/TimeValue.inc Unix/Watchdog.inc @@ -114,6 +115,7 @@ add_llvm_library(LLVMSupport Windows/Program.inc Windows/RWMutex.inc Windows/Signals.inc + Windows/Threading.inc Windows/ThreadLocal.inc Windows/TimeValue.inc Windows/Watchdog.inc diff --git a/lib/Support/ManagedStatic.cpp b/lib/Support/ManagedStatic.cpp index b8fb2841e52..b1feddc09ec 100644 --- a/lib/Support/ManagedStatic.cpp +++ b/lib/Support/ManagedStatic.cpp @@ -16,16 +16,23 @@ #include "llvm/Support/Atomic.h" #include "llvm/Support/Mutex.h" #include "llvm/Support/MutexGuard.h" +#include "llvm/Support/Threading.h" #include using namespace llvm; static const ManagedStaticBase *StaticList = nullptr; +static sys::Mutex *ManagedStaticMutex = nullptr; +LLVM_DEFINE_ONCE_FLAG(mutex_init_flag); -static sys::Mutex& getManagedStaticMutex() { +static void initializeMutex() { + ManagedStaticMutex = new sys::Mutex(); +} + +static sys::Mutex* getManagedStaticMutex() { // We need to use a function local static here, since this can get called // during a static constructor and we need to guarantee that it's initialized // correctly. - static sys::Mutex ManagedStaticMutex; + call_once(mutex_init_flag, initializeMutex); return ManagedStaticMutex; } @@ -33,7 +40,7 @@ void ManagedStaticBase::RegisterManagedStatic(void *(*Creator)(), void (*Deleter)(void*)) const { assert(Creator); if (llvm_is_multithreaded()) { - MutexGuard Lock(getManagedStaticMutex()); + MutexGuard Lock(*getManagedStaticMutex()); if (!Ptr) { void* tmp = Creator(); @@ -83,7 +90,7 @@ void ManagedStaticBase::destroy() const { /// llvm_shutdown - Deallocate and destroy all ManagedStatic variables. void llvm::llvm_shutdown() { - MutexGuard Lock(getManagedStaticMutex()); + MutexGuard Lock(*getManagedStaticMutex()); while (StaticList) StaticList->destroy(); diff --git a/lib/Support/Threading.cpp b/lib/Support/Threading.cpp index ca7f3f64aa3..59b937d9842 100644 --- a/lib/Support/Threading.cpp +++ b/lib/Support/Threading.cpp @@ -110,3 +110,10 @@ void llvm::llvm_execute_on_thread(void (*Fn)(void*), void *UserData, } #endif + +#if defined(LLVM_ON_UNIX) +#include "Unix/Threading.inc" +#else +#include "Windows/Threading.inc" +#endif + diff --git a/lib/Support/Unix/Threading.inc b/lib/Support/Unix/Threading.inc new file mode 100644 index 00000000000..35ec876904a --- /dev/null +++ b/lib/Support/Unix/Threading.inc @@ -0,0 +1,5 @@ +#include + +void llvm::call_once(once_flag& flag, void (*fptr)(void)) { + std::call_once(flag, fptr); +} diff --git a/lib/Support/Windows/Threading.inc b/lib/Support/Windows/Threading.inc new file mode 100644 index 00000000000..099c6b28bf6 --- /dev/null +++ b/lib/Support/Windows/Threading.inc @@ -0,0 +1,19 @@ +#include + +void llvm::call_once(once_flag &flag, void (*fptr)(void)) { + while (flag != Done) { + if (flag == Wait) { + ::Sleep(1); + continue; + } + + sys::cas_flag old_val = sys::CompareAndSwap(&flag, Wait, Uninitialized); + if (old_val == Uninitialized) { + fptr(); + sys::MemoryFence(); + flag = Done; + return; + } + } + sys::MemoryFence(); +}