From 660ff174f299a6dfb28f7725dfbb08f140a5474b Mon Sep 17 00:00:00 2001 From: Pieter Wuille Date: Sun, 13 May 2012 17:55:23 +0200 Subject: [PATCH] Use boost::thread locking instead of interprocess --- src/sync.cpp | 31 +++++++++++---------- src/sync.h | 77 ++++++++++++++++++++++++---------------------------- src/util.cpp | 1 + 3 files changed, 52 insertions(+), 57 deletions(-) diff --git a/src/sync.cpp b/src/sync.cpp index fd9bcb62bc..d8d86d525e 100644 --- a/src/sync.cpp +++ b/src/sync.cpp @@ -3,8 +3,9 @@ // file license.txt or http://www.opensource.org/licenses/mit-license.php. #include "sync.h" +#include "util.h" - +#include #ifdef DEBUG_LOCKORDER // @@ -40,7 +41,7 @@ private: typedef std::vector< std::pair > LockStack; -static boost::interprocess::interprocess_mutex dd_mutex; +static boost::mutex dd_mutex; static std::map, LockStack> lockorders; static boost::thread_specific_ptr lockstack; @@ -66,7 +67,6 @@ static void potential_deadlock_detected(const std::pair& mismatch, static void push_lock(void* c, const CLockLocation& locklocation, bool fTry) { - bool fOrderOK = true; if (lockstack.get() == NULL) lockstack.reset(new LockStack); @@ -75,20 +75,21 @@ static void push_lock(void* c, const CLockLocation& locklocation, bool fTry) (*lockstack).push_back(std::make_pair(c, locklocation)); - if (!fTry) BOOST_FOREACH(const PAIRTYPE(void*, CLockLocation)& i, (*lockstack)) - { - if (i.first == c) break; + if (!fTry) { + BOOST_FOREACH(const PAIRTYPE(void*, CLockLocation)& i, (*lockstack)) { + if (i.first == c) break; - std::pair p1 = std::make_pair(i.first, c); - if (lockorders.count(p1)) - continue; - lockorders[p1] = (*lockstack); + std::pair p1 = std::make_pair(i.first, c); + if (lockorders.count(p1)) + continue; + lockorders[p1] = (*lockstack); - std::pair p2 = std::make_pair(c, i.first); - if (lockorders.count(p2)) - { - potential_deadlock_detected(p1, lockorders[p2], lockorders[p1]); - break; + std::pair p2 = std::make_pair(c, i.first); + if (lockorders.count(p2)) + { + potential_deadlock_detected(p1, lockorders[p2], lockorders[p1]); + break; + } } } dd_mutex.unlock(); diff --git a/src/sync.h b/src/sync.h index 44d753ac15..1604338fb6 100644 --- a/src/sync.h +++ b/src/sync.h @@ -5,19 +5,19 @@ #ifndef BITCOIN_SYNC_H #define BITCOIN_SYNC_H -#include -#include -#include -#include +#include +#include +#include +#include /** Wrapped boost mutex: supports recursive locking, but no waiting */ -typedef boost::interprocess::interprocess_recursive_mutex CCriticalSection; +typedef boost::recursive_mutex CCriticalSection; /** Wrapped boost mutex: supports waiting but not recursive locking */ -typedef boost::interprocess::interprocess_mutex CWaitableCriticalSection; +typedef boost::mutex CWaitableCriticalSection; #ifdef DEBUG_LOCKORDER void EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs, bool fTry = false); @@ -32,12 +32,12 @@ template class CMutexLock { private: - boost::interprocess::scoped_lock lock; + boost::unique_lock lock; public: void Enter(const char* pszName, const char* pszFile, int nLine) { - if (!lock.owns()) + if (!lock.owns_lock()) { EnterCritical(pszName, pszFile, nLine, (void*)(lock.mutex())); #ifdef DEBUG_LOCKCONTENTION @@ -55,7 +55,7 @@ public: void Leave() { - if (lock.owns()) + if (lock.owns_lock()) { lock.unlock(); LeaveCritical(); @@ -64,17 +64,17 @@ public: bool TryEnter(const char* pszName, const char* pszFile, int nLine) { - if (!lock.owns()) + if (!lock.owns_lock()) { EnterCritical(pszName, pszFile, nLine, (void*)(lock.mutex()), true); lock.try_lock(); - if (!lock.owns()) + if (!lock.owns_lock()) LeaveCritical(); } - return lock.owns(); + return lock.owns_lock(); } - CMutexLock(Mutex& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) : lock(mutexIn, boost::interprocess::defer_lock) + CMutexLock(Mutex& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) : lock(mutexIn, boost::defer_lock) { if (fTry) TryEnter(pszName, pszFile, nLine); @@ -84,16 +84,16 @@ public: ~CMutexLock() { - if (lock.owns()) + if (lock.owns_lock()) LeaveCritical(); } operator bool() { - return lock.owns(); + return lock.owns_lock(); } - boost::interprocess::scoped_lock &GetLock() + boost::unique_lock &GetLock() { return lock; } @@ -117,47 +117,40 @@ typedef CMutexLock CCriticalBlock; LeaveCritical(); \ } -#ifdef MAC_OSX -// boost::interprocess::interprocess_semaphore seems to spinlock on OSX; prefer polling instead class CSemaphore { private: - CCriticalSection cs; - int val; + boost::condition_variable condition; + boost::mutex mutex; + int value; public: - CSemaphore(int init) : val(init) {} + CSemaphore(int init) : value(init) {} void wait() { - do { - { - LOCK(cs); - if (val>0) { - val--; - return; - } - } - Sleep(100); - } while(1); + boost::unique_lock lock(mutex); + while (value < 1) { + condition.wait(lock); + } + value--; } bool try_wait() { - LOCK(cs); - if (val>0) { - val--; - return true; - } - return false; + boost::unique_lock lock(mutex); + if (value < 1) + return false; + value--; + return true; } void post() { - LOCK(cs); - val++; + { + boost::unique_lock lock(mutex); + value++; + } + condition.notify_one(); } }; -#else -typedef boost::interprocess::interprocess_semaphore CSemaphore; -#endif /** RAII-style semaphore lock */ class CSemaphoreGrant diff --git a/src/util.cpp b/src/util.cpp index 7a163632c8..b0c80f6dfc 100644 --- a/src/util.cpp +++ b/src/util.cpp @@ -27,6 +27,7 @@ namespace boost { #include #include #include +#include #ifdef WIN32 #ifdef _MSC_VER