[llvm] r216336 - Support: make LLVM Mutexes STL-compatible
Dylan Noblesmith
nobled at dreamwidth.org
Sat Aug 23 15:49:23 PDT 2014
Author: nobled
Date: Sat Aug 23 17:49:22 2014
New Revision: 216336
URL: http://llvm.org/viewvc/llvm-project?rev=216336&view=rev
Log:
Support: make LLVM Mutexes STL-compatible
Use lock/unlock() convention instead of acquire/release().
Modified:
llvm/trunk/include/llvm/IR/ValueMap.h
llvm/trunk/include/llvm/Support/Mutex.h
llvm/trunk/include/llvm/Support/MutexGuard.h
llvm/trunk/include/llvm/Support/RWMutex.h
llvm/trunk/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
llvm/trunk/lib/Support/Unix/Signals.inc
llvm/trunk/unittests/IR/ValueMapTest.cpp
Modified: llvm/trunk/include/llvm/IR/ValueMap.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/ValueMap.h?rev=216336&r1=216335&r2=216336&view=diff
==============================================================================
--- llvm/trunk/include/llvm/IR/ValueMap.h (original)
+++ llvm/trunk/include/llvm/IR/ValueMap.h Sat Aug 23 17:49:22 2014
@@ -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<KeySansPointerT>(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<KeySansPointerT>(new_key);
// Can destroy *this:
@@ -246,7 +246,7 @@ public:
}
}
if (M)
- M->release();
+ M->unlock();
}
};
Modified: llvm/trunk/include/llvm/Support/Mutex.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/Mutex.h?rev=216336&r1=216335&r2=216336&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/Mutex.h (original)
+++ llvm/trunk/include/llvm/Support/Mutex.h Sat Aug 23 17:49:22 2014
@@ -86,16 +86,17 @@ namespace llvm
/// indicates whether this mutex should become a no-op when we're not
/// running in multithreaded mode.
template<bool mt_only>
- 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<mt_only>& m) : mtx(m) {
- mtx.acquire();
+ mtx.lock();
}
~SmartScopedLock() {
- mtx.release();
+ mtx.unlock();
}
};
Modified: llvm/trunk/include/llvm/Support/MutexGuard.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/MutexGuard.h?rev=216336&r1=216335&r2=216336&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/MutexGuard.h (original)
+++ llvm/trunk/include/llvm/Support/MutexGuard.h Sat Aug 23 17:49:22 2014
@@ -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.
Modified: llvm/trunk/include/llvm/Support/RWMutex.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/RWMutex.h?rev=216336&r1=216335&r2=216336&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/RWMutex.h (original)
+++ llvm/trunk/include/llvm/Support/RWMutex.h Sat Aug 23 17:49:22 2014
@@ -85,14 +85,15 @@ namespace llvm
/// indicates whether this mutex should become a no-op when we're not
/// running in multithreaded mode.
template<bool mt_only>
- 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<mt_only>& mutex;
explicit SmartScopedReader(SmartRWMutex<mt_only>& m) : mutex(m) {
- mutex.reader_acquire();
+ mutex.lock_shared();
}
~SmartScopedReader() {
- mutex.reader_release();
+ mutex.unlock_shared();
}
};
typedef SmartScopedReader<false> ScopedReader;
@@ -160,11 +161,11 @@ namespace llvm
SmartRWMutex<mt_only>& mutex;
explicit SmartScopedWriter(SmartRWMutex<mt_only>& m) : mutex(m) {
- mutex.writer_acquire();
+ mutex.lock();
}
~SmartScopedWriter() {
- mutex.writer_release();
+ mutex.unlock();
}
};
typedef SmartScopedWriter<false> ScopedWriter;
Modified: llvm/trunk/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp?rev=216336&r1=216335&r2=216336&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp Sat Aug 23 17:49:22 2014
@@ -248,14 +248,14 @@ GenericValue Interpreter::callExternalFu
const std::vector<GenericValue> &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<const Function *, ExFunc>::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::callExternalFu
RawFn = RF->second;
}
- FunctionsLock->release();
+ FunctionsLock->unlock();
GenericValue Result;
if (RawFn != 0 && ffiInvoke(RawFn, F, ArgVals, getDataLayout(), Result))
Modified: llvm/trunk/lib/Support/Unix/Signals.inc
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/Unix/Signals.inc?rev=216336&r1=216335&r2=216336&view=diff
==============================================================================
--- llvm/trunk/lib/Support/Unix/Signals.inc (original)
+++ llvm/trunk/lib/Support/Unix/Signals.inc Sat Aug 23 17:49:22 2014
@@ -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)
Modified: llvm/trunk/unittests/IR/ValueMapTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/IR/ValueMapTest.cpp?rev=216336&r1=216335&r2=216336&view=diff
==============================================================================
--- llvm/trunk/unittests/IR/ValueMapTest.cpp (original)
+++ llvm/trunk/unittests/IR/ValueMapTest.cpp Sat Aug 23 17:49:22 2014
@@ -186,11 +186,11 @@ struct LockMutex : ValueMapConfig<KeyT,
};
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; }
};
More information about the llvm-commits
mailing list