From f03585d240d73828d6f5e9821a69ae7d70dae4df Mon Sep 17 00:00:00 2001 From: Mehdi Amini Date: Sat, 14 May 2016 20:55:52 +0000 Subject: [PATCH] Revert "Revert 220932.": "Removing the static initializer in ManagedStatic.cpp by using llvm_call_once to initialize the ManagedStatic mutex" This reverts commit r221331 and reinstate r220932 as discussed in D19271. Original commit message was: 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. Differential Revision: http://reviews.llvm.org/D5922 From: Mehdi Amini llvm-svn: 269577 --- include/llvm/Support/Threading.h | 36 +++++++++++++++++++++++++++++++ lib/Support/ManagedStatic.cpp | 15 +++++++++---- lib/Support/Threading.cpp | 7 ++++++ lib/Support/Unix/Threading.inc | 5 +++++ lib/Support/Windows/Threading.inc | 24 +++++++++++++++++++++ 5 files changed, 83 insertions(+), 4 deletions(-) create mode 100644 lib/Support/Unix/Threading.inc create mode 100644 lib/Support/Windows/Threading.inc diff --git a/include/llvm/Support/Threading.h b/include/llvm/Support/Threading.h index 9007c132a99..452b042bd8e 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. @@ -34,6 +42,34 @@ 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 &flag, void (*UserFn)(void)); } #endif 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..196be890dbf --- /dev/null +++ b/lib/Support/Windows/Threading.inc @@ -0,0 +1,24 @@ + #include + +#ifdef MemoryFence +// WinNT.h seems to define a MemoryFence macro. +#undef MemoryFence +#endif + +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(); +}