From d930a308333a640aba76d2dbc01b0ba097ee4cee Mon Sep 17 00:00:00 2001 From: Dylan Noblesmith Date: Sat, 23 Aug 2014 22:49:22 +0000 Subject: [PATCH] Support: make LLVM Mutexes STL-compatible Use lock/unlock() convention instead of acquire/release(). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@216336 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/ValueMap.h | 10 +++---- include/llvm/Support/Mutex.h | 21 +++++++------- include/llvm/Support/MutexGuard.h | 4 +-- include/llvm/Support/RWMutex.h | 29 ++++++++++--------- .../Interpreter/ExternalFunctions.cpp | 6 ++-- lib/Support/Unix/Signals.inc | 8 ++--- unittests/IR/ValueMapTest.cpp | 4 +-- 7 files changed, 42 insertions(+), 40 deletions(-) diff --git a/include/llvm/IR/ValueMap.h b/include/llvm/IR/ValueMap.h index 43a79c7db2b..993694889a5 100644 --- a/include/llvm/IR/ValueMap.h +++ b/include/llvm/IR/ValueMap.h @@ -111,7 +111,7 @@ public: void clear() { Map.clear(); } - /// Return 1 if the specified key is in the map, 0 otherwise. + /// Return 1 if the specified key is in the map, 0 otherwise. size_type count(const KeyT &Val) const { return Map.find_as(Val) == Map.end() ? 0 : 1; } @@ -217,11 +217,11 @@ public: ValueMapCallbackVH Copy(*this); typename Config::mutex_type *M = Config::getMutex(Copy.Map->Data); if (M) - M->acquire(); + M->lock(); Config::onDelete(Copy.Map->Data, Copy.Unwrap()); // May destroy *this. Copy.Map->Map.erase(Copy); // Definitely destroys *this. if (M) - M->release(); + M->unlock(); } void allUsesReplacedWith(Value *new_key) override { assert(isa(new_key) && @@ -230,7 +230,7 @@ public: ValueMapCallbackVH Copy(*this); typename Config::mutex_type *M = Config::getMutex(Copy.Map->Data); if (M) - M->acquire(); + M->lock(); KeyT typed_new_key = cast(new_key); // Can destroy *this: @@ -246,7 +246,7 @@ public: } } if (M) - M->release(); + M->unlock(); } }; diff --git a/include/llvm/Support/Mutex.h b/include/llvm/Support/Mutex.h index 496a4381f3f..97dd5011532 100644 --- a/include/llvm/Support/Mutex.h +++ b/include/llvm/Support/Mutex.h @@ -86,16 +86,17 @@ namespace llvm /// indicates whether this mutex should become a no-op when we're not /// running in multithreaded mode. template - class SmartMutex : public MutexImpl { + class SmartMutex { + MutexImpl impl; unsigned acquired; bool recursive; public: explicit SmartMutex(bool rec = true) : - MutexImpl(rec), acquired(0), recursive(rec) { } + impl(rec), acquired(0), recursive(rec) { } - bool acquire() { + bool lock() { if (!mt_only || llvm_is_multithreaded()) { - return MutexImpl::acquire(); + return impl.acquire(); } else { // Single-threaded debugging code. This would be racy in // multithreaded mode, but provides not sanity checks in single @@ -106,9 +107,9 @@ namespace llvm } } - bool release() { + bool unlock() { if (!mt_only || llvm_is_multithreaded()) { - return MutexImpl::release(); + return impl.release(); } else { // Single-threaded debugging code. This would be racy in // multithreaded mode, but provides not sanity checks in single @@ -120,9 +121,9 @@ namespace llvm } } - bool tryacquire() { + bool try_lock() { if (!mt_only || llvm_is_multithreaded()) - return MutexImpl::tryacquire(); + return impl.tryacquire(); else return true; } @@ -140,11 +141,11 @@ namespace llvm public: SmartScopedLock(SmartMutex& m) : mtx(m) { - mtx.acquire(); + mtx.lock(); } ~SmartScopedLock() { - mtx.release(); + mtx.unlock(); } }; diff --git a/include/llvm/Support/MutexGuard.h b/include/llvm/Support/MutexGuard.h index 6bb162277e2..b9f941dab32 100644 --- a/include/llvm/Support/MutexGuard.h +++ b/include/llvm/Support/MutexGuard.h @@ -29,8 +29,8 @@ namespace llvm { MutexGuard(const MutexGuard &) LLVM_DELETED_FUNCTION; void operator=(const MutexGuard &) LLVM_DELETED_FUNCTION; public: - MutexGuard(sys::Mutex &m) : M(m) { M.acquire(); } - ~MutexGuard() { M.release(); } + MutexGuard(sys::Mutex &m) : M(m) { M.lock(); } + ~MutexGuard() { M.unlock(); } /// holds - Returns true if this locker instance holds the specified lock. /// This is mostly used in assertions to validate that the correct mutex /// is held. diff --git a/include/llvm/Support/RWMutex.h b/include/llvm/Support/RWMutex.h index 735cc0ad4e3..b80b8557576 100644 --- a/include/llvm/Support/RWMutex.h +++ b/include/llvm/Support/RWMutex.h @@ -85,14 +85,15 @@ namespace llvm /// indicates whether this mutex should become a no-op when we're not /// running in multithreaded mode. template - class SmartRWMutex : public RWMutexImpl { + class SmartRWMutex { + RWMutexImpl impl; unsigned readers, writers; public: - explicit SmartRWMutex() : RWMutexImpl(), readers(0), writers(0) { } + explicit SmartRWMutex() : impl(), readers(0), writers(0) { } - bool reader_acquire() { + bool lock_shared() { if (!mt_only || llvm_is_multithreaded()) - return RWMutexImpl::reader_acquire(); + return impl.reader_acquire(); // Single-threaded debugging code. This would be racy in multithreaded // mode, but provides not sanity checks in single threaded mode. @@ -100,9 +101,9 @@ namespace llvm return true; } - bool reader_release() { + bool unlock_shared() { if (!mt_only || llvm_is_multithreaded()) - return RWMutexImpl::reader_release(); + return impl.reader_release(); // Single-threaded debugging code. This would be racy in multithreaded // mode, but provides not sanity checks in single threaded mode. @@ -111,9 +112,9 @@ namespace llvm return true; } - bool writer_acquire() { + bool lock() { if (!mt_only || llvm_is_multithreaded()) - return RWMutexImpl::writer_acquire(); + return impl.writer_acquire(); // Single-threaded debugging code. This would be racy in multithreaded // mode, but provides not sanity checks in single threaded mode. @@ -122,9 +123,9 @@ namespace llvm return true; } - bool writer_release() { + bool unlock() { if (!mt_only || llvm_is_multithreaded()) - return RWMutexImpl::writer_release(); + return impl.writer_release(); // Single-threaded debugging code. This would be racy in multithreaded // mode, but provides not sanity checks in single threaded mode. @@ -145,11 +146,11 @@ namespace llvm SmartRWMutex& mutex; explicit SmartScopedReader(SmartRWMutex& m) : mutex(m) { - mutex.reader_acquire(); + mutex.lock_shared(); } ~SmartScopedReader() { - mutex.reader_release(); + mutex.unlock_shared(); } }; typedef SmartScopedReader ScopedReader; @@ -160,11 +161,11 @@ namespace llvm SmartRWMutex& mutex; explicit SmartScopedWriter(SmartRWMutex& m) : mutex(m) { - mutex.writer_acquire(); + mutex.lock(); } ~SmartScopedWriter() { - mutex.writer_release(); + mutex.unlock(); } }; typedef SmartScopedWriter ScopedWriter; diff --git a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp index 671bbeea8d0..e4b89c60b46 100644 --- a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp +++ b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp @@ -248,14 +248,14 @@ GenericValue Interpreter::callExternalFunction(Function *F, const std::vector &ArgVals) { TheInterpreter = this; - FunctionsLock->acquire(); + FunctionsLock->lock(); // Do a lookup to see if the function is in our cache... this should just be a // deferred annotation! std::map::iterator FI = ExportedFunctions->find(F); if (ExFunc Fn = (FI == ExportedFunctions->end()) ? lookupFunction(F) : FI->second) { - FunctionsLock->release(); + FunctionsLock->unlock(); return Fn(F->getFunctionType(), ArgVals); } @@ -273,7 +273,7 @@ GenericValue Interpreter::callExternalFunction(Function *F, RawFn = RF->second; } - FunctionsLock->release(); + FunctionsLock->unlock(); GenericValue Result; if (RawFn != 0 && ffiInvoke(RawFn, F, ArgVals, getDataLayout(), Result)) diff --git a/lib/Support/Unix/Signals.inc b/lib/Support/Unix/Signals.inc index 8161bfbf2a3..34c39c9ad92 100644 --- a/lib/Support/Unix/Signals.inc +++ b/lib/Support/Unix/Signals.inc @@ -162,24 +162,24 @@ static RETSIGTYPE SignalHandler(int Sig) { sigfillset(&SigMask); sigprocmask(SIG_UNBLOCK, &SigMask, nullptr); - SignalsMutex.acquire(); + SignalsMutex.lock(); RemoveFilesToRemove(); if (std::find(IntSigs, IntSigsEnd, Sig) != IntSigsEnd) { if (InterruptFunction) { void (*IF)() = InterruptFunction; - SignalsMutex.release(); + SignalsMutex.unlock(); InterruptFunction = nullptr; IF(); // run the interrupt function. return; } - SignalsMutex.release(); + SignalsMutex.unlock(); raise(Sig); // Execute the default handler. return; } - SignalsMutex.release(); + SignalsMutex.unlock(); // Otherwise if it is a fault (like SEGV) run any handler. for (unsigned i = 0, e = CallBacksToRun.size(); i != e; ++i) diff --git a/unittests/IR/ValueMapTest.cpp b/unittests/IR/ValueMapTest.cpp index 0b7198fc6ec..a6bad71cf63 100644 --- a/unittests/IR/ValueMapTest.cpp +++ b/unittests/IR/ValueMapTest.cpp @@ -186,11 +186,11 @@ struct LockMutex : ValueMapConfig { }; static void onRAUW(const ExtraData &Data, KeyT Old, KeyT New) { *Data.CalledRAUW = true; - EXPECT_FALSE(Data.M->tryacquire()) << "Mutex should already be locked."; + EXPECT_FALSE(Data.M->try_lock()) << "Mutex should already be locked."; } static void onDelete(const ExtraData &Data, KeyT Old) { *Data.CalledDeleted = true; - EXPECT_FALSE(Data.M->tryacquire()) << "Mutex should already be locked."; + EXPECT_FALSE(Data.M->try_lock()) << "Mutex should already be locked."; } static MutexT *getMutex(const ExtraData &Data) { return Data.M; } };