Use LOCK macros for non-recursive locks

ryanofsky · ryanofsky · commit 674dcfea1d0a · 2017-12-07T12:37:43.000-05:00
Instead of std::unique_lock.
diff --git a/src/httpserver.cpp b/src/httpserver.cpp
@@ -68,7 +68,7 @@ class WorkQueue
 {
 private:
     /** Mutex protects entire object */
-    std::mutex cs;
+    CWaitableCriticalSection cs;
     std::condition_variable cond;
     std::deque<std::unique_ptr<WorkItem>> queue;
     bool running;
@@ -108,7 +108,7 @@ class WorkQueue
     /** Enqueue a work item */
     bool Enqueue(WorkItem* item)
     {
-        std::unique_lock<std::mutex> lock(cs);
+        LOCK(cs);
         if (queue.size() >= maxDepth) {
             return false;
         }
@@ -123,7 +123,7 @@ class WorkQueue
         while (true) {
             std::unique_ptr<WorkItem> i;
             {
-                std::unique_lock<std::mutex> lock(cs);
+                WAIT_LOCK(cs, lock);
                 while (running && queue.empty())
                     cond.wait(lock);
                 if (!running)
@@ -137,14 +137,14 @@ class WorkQueue
     /** Interrupt and exit loops */
     void Interrupt()
     {
-        std::unique_lock<std::mutex> lock(cs);
+        LOCK(cs);
         running = false;
         cond.notify_all();
     }
     /** Wait for worker threads to exit */
     void WaitExit()
     {
-        std::unique_lock<std::mutex> lock(cs);
+        WAIT_LOCK(cs, lock);
         while (numThreads > 0)
             cond.wait(lock);
     }
diff --git a/src/init.cpp b/src/init.cpp
@@ -549,7 +549,7 @@ static void BlockNotifyGenesisWait(bool, const CBlockIndex *pBlockIndex)
 {
     if (pBlockIndex != nullptr) {
         {
-            WaitableLock lock_GenesisWait(cs_GenesisWait);
+            LOCK(cs_GenesisWait);
             fHaveGenesis = true;
         }
         condvar_GenesisWait.notify_all();
@@ -1634,7 +1634,7 @@ bool AppInitMain(boost::thread_group& threadGroup, CScheduler& scheduler)
 
     // Wait for genesis block to be processed
     {
-        WaitableLock lock(cs_GenesisWait);
+        WAIT_LOCK(cs_GenesisWait, lock);
         while (!fHaveGenesis) {
             condvar_GenesisWait.wait(lock);
         }
diff --git a/src/net.cpp b/src/net.cpp
@@ -2030,7 +2030,7 @@ void CConnman::ThreadMessageHandler()
                 pnode->Release();
         }
 
-        std::unique_lock<std::mutex> lock(mutexMsgProc);
+        WAIT_LOCK(mutexMsgProc, lock);
         if (!fMoreWork) {
             condMsgProc.wait_until(lock, std::chrono::steady_clock::now() + std::chrono::milliseconds(100), [this] { return fMsgProcWake; });
         }
@@ -2349,7 +2349,7 @@ bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)
     flagInterruptMsgProc = false;
 
     {
-        std::unique_lock<std::mutex> lock(mutexMsgProc);
+        LOCK(mutexMsgProc);
         fMsgProcWake = false;
     }
 
diff --git a/src/net.h b/src/net.h
@@ -422,7 +422,7 @@ class CConnman
     bool fMsgProcWake;
 
     std::condition_variable condMsgProc;
-    std::mutex mutexMsgProc;
+    CWaitableCriticalSection mutexMsgProc;
     std::atomic<bool> flagInterruptMsgProc;
 
     CThreadInterrupt interruptNet;
diff --git a/src/random.cpp b/src/random.cpp
@@ -294,7 +294,7 @@ void RandAddSeedSleep()
 }
 
 
-static std::mutex cs_rng_state;
+static CWaitableCriticalSection cs_rng_state;
 static unsigned char rng_state[32] = {0};
 static uint64_t rng_counter = 0;
 
@@ -304,7 +304,7 @@ static void AddDataToRng(void* data, size_t len) {
     hasher.Write((const unsigned char*)data, len);
     unsigned char buf[64];
     {
-        std::unique_lock<std::mutex> lock(cs_rng_state);
+        WAIT_LOCK(cs_rng_state, lock);
         hasher.Write(rng_state, sizeof(rng_state));
         hasher.Write((const unsigned char*)&rng_counter, sizeof(rng_counter));
         ++rng_counter;
@@ -336,7 +336,7 @@ void GetStrongRandBytes(unsigned char* out, int num)
 
     // Combine with and update state
     {
-        std::unique_lock<std::mutex> lock(cs_rng_state);
+        WAIT_LOCK(cs_rng_state, lock);
         hasher.Write(rng_state, sizeof(rng_state));
         hasher.Write((const unsigned char*)&rng_counter, sizeof(rng_counter));
         ++rng_counter;
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
@@ -41,7 +41,7 @@ struct CUpdatedBlock
     int height;
 };
 
-static std::mutex cs_blockchange;
+static CWaitableCriticalSection cs_blockchange;
 static std::condition_variable cond_blockchange;
 static CUpdatedBlock latestblock;
 
@@ -218,7 +218,7 @@ UniValue waitfornewblock(const JSONRPCRequest& request)
 
     CUpdatedBlock block;
     {
-        std::unique_lock<std::mutex> lock(cs_blockchange);
+        WAIT_LOCK(cs_blockchange, lock);
         block = latestblock;
         if(timeout)
             cond_blockchange.wait_for(lock, std::chrono::milliseconds(timeout), [&block]{return latestblock.height != block.height || latestblock.hash != block.hash || !IsRPCRunning(); });
@@ -260,7 +260,7 @@ UniValue waitforblock(const JSONRPCRequest& request)
 
     CUpdatedBlock block;
     {
-        std::unique_lock<std::mutex> lock(cs_blockchange);
+        WAIT_LOCK(cs_blockchange, lock);
         if(timeout)
             cond_blockchange.wait_for(lock, std::chrono::milliseconds(timeout), [&hash]{return latestblock.hash == hash || !IsRPCRunning();});
         else
@@ -303,7 +303,7 @@ UniValue waitforblockheight(const JSONRPCRequest& request)
 
     CUpdatedBlock block;
     {
-        std::unique_lock<std::mutex> lock(cs_blockchange);
+        WAIT_LOCK(cs_blockchange, lock);
         if(timeout)
             cond_blockchange.wait_for(lock, std::chrono::milliseconds(timeout), [&height]{return latestblock.height >= height || !IsRPCRunning();});
         else
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
@@ -478,7 +478,7 @@ UniValue getblocktemplate(const JSONRPCRequest& request)
         {
             checktxtime = std::chrono::steady_clock::now() + std::chrono::minutes(1);
 
-            WaitableLock lock(csBestBlock);
+            WAIT_LOCK(csBestBlock, lock);
             while (chainActive.Tip()->GetBlockHash() == hashWatchedChain && IsRPCRunning())
             {
                 if (cvBlockChange.wait_until(lock, checktxtime) == std::cv_status::timeout)
diff --git a/src/sync.h b/src/sync.h
@@ -112,9 +112,6 @@ typedef AnnotatedMixin<std::mutex> CWaitableCriticalSection;
 /** Just a typedef for std::condition_variable, can be wrapped later if desired */
 typedef std::condition_variable CConditionVariable;
 
-/** Just a typedef for std::unique_lock, can be wrapped later if desired */
-typedef std::unique_lock<std::mutex> WaitableLock;
-
 #ifdef DEBUG_LOCKCONTENTION
 void PrintLockContention(const char* pszName, const char* pszFile, int nLine);
 #endif
diff --git a/src/threadinterrupt.cpp b/src/threadinterrupt.cpp
@@ -5,6 +5,8 @@
 
 #include <threadinterrupt.h>
 
+#include "sync.h"
+
 CThreadInterrupt::operator bool() const
 {
     return flag.load(std::memory_order_acquire);
@@ -18,15 +20,15 @@ void CThreadInterrupt::reset()
 void CThreadInterrupt::operator()()
 {
     {
-        std::unique_lock<std::mutex> lock(mut);
+        LOCK(mut);
         flag.store(true, std::memory_order_release);
     }
     cond.notify_all();
 }
 
 bool CThreadInterrupt::sleep_for(std::chrono::milliseconds rel_time)
 {
-    std::unique_lock<std::mutex> lock(mut);
+    WAIT_LOCK(mut, lock);
     return !cond.wait_for(lock, rel_time, [this]() { return flag.load(std::memory_order_acquire); });
 }
 
diff --git a/src/threadinterrupt.h b/src/threadinterrupt.h
@@ -5,6 +5,8 @@
 #ifndef BITCOIN_THREADINTERRUPT_H
 #define BITCOIN_THREADINTERRUPT_H
 
+#include "sync.h"
+
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
@@ -27,7 +29,7 @@ class CThreadInterrupt
 
 private:
     std::condition_variable cond;
-    std::mutex mut;
+    CWaitableCriticalSection mut;
     std::atomic<bool> flag;
 };
 

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ class WorkQueue`
`68`	`68`	`{`
`69`	`69`	`private:`
`70`	`70`	`/** Mutex protects entire object */`
`71`		`- std::mutex cs;`
	`71`	`+ CWaitableCriticalSection cs;`
`72`	`72`	`std::condition_variable cond;`
`73`	`73`	`std::deque<std::unique_ptr<WorkItem>> queue;`
`74`	`74`	`bool running;`
`@@ -108,7 +108,7 @@ class WorkQueue`
`108`	`108`	`/** Enqueue a work item */`
`109`	`109`	`bool Enqueue(WorkItem* item)`
`110`	`110`	`{`
`111`		`- std::unique_lock<std::mutex> lock(cs);`
	`111`	`+ LOCK(cs);`
`112`	`112`	`if (queue.size() >= maxDepth) {`
`113`	`113`	`return false;`
`114`	`114`	`}`
`@@ -123,7 +123,7 @@ class WorkQueue`
`123`	`123`	`while (true) {`
`124`	`124`	`std::unique_ptr<WorkItem> i;`
`125`	`125`	`{`
`126`		`- std::unique_lock<std::mutex> lock(cs);`
	`126`	`+ WAIT_LOCK(cs, lock);`
`127`	`127`	`while (running && queue.empty())`
`128`	`128`	`cond.wait(lock);`
`129`	`129`	`if (!running)`
`@@ -137,14 +137,14 @@ class WorkQueue`
`137`	`137`	`/** Interrupt and exit loops */`
`138`	`138`	`void Interrupt()`
`139`	`139`	`{`
`140`		`- std::unique_lock<std::mutex> lock(cs);`
	`140`	`+ LOCK(cs);`
`141`	`141`	`running = false;`
`142`	`142`	`cond.notify_all();`
`143`	`143`	`}`
`144`	`144`	`/** Wait for worker threads to exit */`
`145`	`145`	`void WaitExit()`
`146`	`146`	`{`
`147`		`- std::unique_lock<std::mutex> lock(cs);`
	`147`	`+ WAIT_LOCK(cs, lock);`
`148`	`148`	`while (numThreads > 0)`
`149`	`149`	`cond.wait(lock);`
`150`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -549,7 +549,7 @@ static void BlockNotifyGenesisWait(bool, const CBlockIndex *pBlockIndex)`
`549`	`549`	`{`
`550`	`550`	`if (pBlockIndex != nullptr) {`
`551`	`551`	`{`
`552`		`- WaitableLock lock_GenesisWait(cs_GenesisWait);`
	`552`	`+ LOCK(cs_GenesisWait);`
`553`	`553`	`fHaveGenesis = true;`
`554`	`554`	`}`
`555`	`555`	`condvar_GenesisWait.notify_all();`
`@@ -1634,7 +1634,7 @@ bool AppInitMain(boost::thread_group& threadGroup, CScheduler& scheduler)`
`1634`	`1634`
`1635`	`1635`	`// Wait for genesis block to be processed`
`1636`	`1636`	`{`
`1637`		`- WaitableLock lock(cs_GenesisWait);`
	`1637`	`+ WAIT_LOCK(cs_GenesisWait, lock);`
`1638`	`1638`	`while (!fHaveGenesis) {`
`1639`	`1639`	`condvar_GenesisWait.wait(lock);`
`1640`	`1640`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2030,7 +2030,7 @@ void CConnman::ThreadMessageHandler()`
`2030`	`2030`	`pnode->Release();`
`2031`	`2031`	`}`
`2032`	`2032`
`2033`		`- std::unique_lock<std::mutex> lock(mutexMsgProc);`
	`2033`	`+ WAIT_LOCK(mutexMsgProc, lock);`
`2034`	`2034`	`if (!fMoreWork) {`
`2035`	`2035`	`condMsgProc.wait_until(lock, std::chrono::steady_clock::now() + std::chrono::milliseconds(100), [this] { return fMsgProcWake; });`
`2036`	`2036`	`}`
`@@ -2349,7 +2349,7 @@ bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)`
`2349`	`2349`	`flagInterruptMsgProc = false;`
`2350`	`2350`
`2351`	`2351`	`{`
`2352`		`- std::unique_lock<std::mutex> lock(mutexMsgProc);`
	`2352`	`+ LOCK(mutexMsgProc);`
`2353`	`2353`	`fMsgProcWake = false;`
`2354`	`2354`	`}`
`2355`	`2355`
Original file line number	Diff line number	Diff line change
`@@ -478,7 +478,7 @@ UniValue getblocktemplate(const JSONRPCRequest& request)`
`478`	`478`	`{`
`479`	`479`	`checktxtime = std::chrono::steady_clock::now() + std::chrono::minutes(1);`
`480`	`480`
`481`		`- WaitableLock lock(csBestBlock);`
	`481`	`+ WAIT_LOCK(csBestBlock, lock);`
`482`	`482`	`while (chainActive.Tip()->GetBlockHash() == hashWatchedChain && IsRPCRunning())`
`483`	`483`	`{`
`484`	`484`	`if (cvBlockChange.wait_until(lock, checktxtime) == std::cv_status::timeout)`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,8 @@`
`5`	`5`
`6`	`6`	`#include <threadinterrupt.h>`
`7`	`7`
	`8`	`+#include "sync.h"`
	`9`	`+`
`8`	`10`	`CThreadInterrupt::operator bool() const`
`9`	`11`	`{`
`10`	`12`	`return flag.load(std::memory_order_acquire);`
`@@ -18,15 +20,15 @@ void CThreadInterrupt::reset()`
`18`	`20`	`void CThreadInterrupt::operator()()`
`19`	`21`	`{`
`20`	`22`	`{`
`21`		`- std::unique_lock<std::mutex> lock(mut);`
	`23`	`+ LOCK(mut);`
`22`	`24`	`flag.store(true, std::memory_order_release);`
`23`	`25`	`}`
`24`	`26`	`cond.notify_all();`
`25`	`27`	`}`
`26`	`28`
`27`	`29`	`bool CThreadInterrupt::sleep_for(std::chrono::milliseconds rel_time)`
`28`	`30`	`{`
`29`		`- std::unique_lock<std::mutex> lock(mut);`
	`31`	`+ WAIT_LOCK(mut, lock);`
`30`	`32`	`return !cond.wait_for(lock, rel_time, [this]() { return flag.load(std::memory_order_acquire); });`
`31`	`33`	`}`
`32`	`34`