Use LOCK macros for non-recursive locks

ryanofsky · ryanofsky · commit b6c88a148db1 · 2018-02-08T07:51:13.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;
@@ -87,7 +87,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;
         }
@@ -101,7 +101,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)
@@ -115,7 +115,7 @@ class WorkQueue
     /** Interrupt and exit loops */
     void Interrupt()
     {
-        std::unique_lock<std::mutex> lock(cs);
+        LOCK(cs);
         running = false;
         cond.notify_all();
     }
diff --git a/src/init.cpp b/src/init.cpp
@@ -557,7 +557,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();
@@ -1644,7 +1644,7 @@ bool AppInitMain()
 
     // Wait for genesis block to be processed
     {
-        WaitableLock lock(cs_GenesisWait);
+        WAIT_LOCK(cs_GenesisWait, lock);
         // We previously could hang here if StartShutdown() is called prior to
         // ThreadImport getting started, so instead we just wait on a timer to
         // check ShutdownRequested() regularly.
diff --git a/src/net.cpp b/src/net.cpp
@@ -2032,7 +2032,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; });
         }
@@ -2328,7 +2328,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
@@ -42,7 +42,7 @@ struct CUpdatedBlock
     int height;
 };
 
-static std::mutex cs_blockchange;
+static CWaitableCriticalSection cs_blockchange;
 static std::condition_variable cond_blockchange;
 static CUpdatedBlock latestblock;
 
@@ -226,7 +226,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(); });
@@ -268,7 +268,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
@@ -311,7 +311,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
@@ -476,7 +476,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;`
`@@ -87,7 +87,7 @@ class WorkQueue`
`87`	`87`	`/** Enqueue a work item */`
`88`	`88`	`bool Enqueue(WorkItem* item)`
`89`	`89`	`{`
`90`		`- std::unique_lock<std::mutex> lock(cs);`
	`90`	`+ LOCK(cs);`
`91`	`91`	`if (queue.size() >= maxDepth) {`
`92`	`92`	`return false;`
`93`	`93`	`}`
`@@ -101,7 +101,7 @@ class WorkQueue`
`101`	`101`	`while (true) {`
`102`	`102`	`std::unique_ptr<WorkItem> i;`
`103`	`103`	`{`
`104`		`- std::unique_lock<std::mutex> lock(cs);`
	`104`	`+ WAIT_LOCK(cs, lock);`
`105`	`105`	`while (running && queue.empty())`
`106`	`106`	`cond.wait(lock);`
`107`	`107`	`if (!running)`
`@@ -115,7 +115,7 @@ class WorkQueue`
`115`	`115`	`/** Interrupt and exit loops */`
`116`	`116`	`void Interrupt()`
`117`	`117`	`{`
`118`		`- std::unique_lock<std::mutex> lock(cs);`
	`118`	`+ LOCK(cs);`
`119`	`119`	`running = false;`
`120`	`120`	`cond.notify_all();`
`121`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -557,7 +557,7 @@ static void BlockNotifyGenesisWait(bool, const CBlockIndex *pBlockIndex)`
`557`	`557`	`{`
`558`	`558`	`if (pBlockIndex != nullptr) {`
`559`	`559`	`{`
`560`		`- WaitableLock lock_GenesisWait(cs_GenesisWait);`
	`560`	`+ LOCK(cs_GenesisWait);`
`561`	`561`	`fHaveGenesis = true;`
`562`	`562`	`}`
`563`	`563`	`condvar_GenesisWait.notify_all();`
`@@ -1644,7 +1644,7 @@ bool AppInitMain()`
`1644`	`1644`
`1645`	`1645`	`// Wait for genesis block to be processed`
`1646`	`1646`	`{`
`1647`		`- WaitableLock lock(cs_GenesisWait);`
	`1647`	`+ WAIT_LOCK(cs_GenesisWait, lock);`
`1648`	`1648`	`// We previously could hang here if StartShutdown() is called prior to`
`1649`	`1649`	`// ThreadImport getting started, so instead we just wait on a timer to`
`1650`	`1650`	`// check ShutdownRequested() regularly.`
Original file line number	Diff line number	Diff line change
`@@ -2032,7 +2032,7 @@ void CConnman::ThreadMessageHandler()`
`2032`	`2032`	`pnode->Release();`
`2033`	`2033`	`}`
`2034`	`2034`
`2035`		`- std::unique_lock<std::mutex> lock(mutexMsgProc);`
	`2035`	`+ WAIT_LOCK(mutexMsgProc, lock);`
`2036`	`2036`	`if (!fMoreWork) {`
`2037`	`2037`	`condMsgProc.wait_until(lock, std::chrono::steady_clock::now() + std::chrono::milliseconds(100), [this] { return fMsgProcWake; });`
`2038`	`2038`	`}`
`@@ -2328,7 +2328,7 @@ bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)`
`2328`	`2328`	`flagInterruptMsgProc = false;`
`2329`	`2329`
`2330`	`2330`	`{`
`2331`		`- std::unique_lock<std::mutex> lock(mutexMsgProc);`
	`2331`	`+ LOCK(mutexMsgProc);`
`2332`	`2332`	`fMsgProcWake = false;`
`2333`	`2333`	`}`
`2334`	`2334`
Original file line number	Diff line number	Diff line change
`@@ -476,7 +476,7 @@ UniValue getblocktemplate(const JSONRPCRequest& request)`
`476`	`476`	`{`
`477`	`477`	`checktxtime = std::chrono::steady_clock::now() + std::chrono::minutes(1);`
`478`	`478`
`479`		`- WaitableLock lock(csBestBlock);`
	`479`	`+ WAIT_LOCK(csBestBlock, lock);`
`480`	`480`	`while (chainActive.Tip()->GetBlockHash() == hashWatchedChain && IsRPCRunning())`
`481`	`481`	`{`
`482`	`482`	`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`