Pass lifetimebound reference to SingleThreadedSchedulerClient

MacroFake · MacroFake · commit fa4652ce5995 · 2022-04-30T09:17:17.000+02:00
diff --git a/src/scheduler.cpp b/src/scheduler.cpp
@@ -143,7 +143,7 @@ void SingleThreadedSchedulerClient::MaybeScheduleProcessQueue()
         if (m_are_callbacks_running) return;
         if (m_callbacks_pending.empty()) return;
     }
-    m_pscheduler->schedule(std::bind(&SingleThreadedSchedulerClient::ProcessQueue, this), std::chrono::system_clock::now());
+    m_scheduler.schedule([this] { this->ProcessQueue(); }, std::chrono::system_clock::now());
 }
 
 void SingleThreadedSchedulerClient::ProcessQueue()
@@ -179,8 +179,6 @@ void SingleThreadedSchedulerClient::ProcessQueue()
 
 void SingleThreadedSchedulerClient::AddToProcessQueue(std::function<void()> func)
 {
-    assert(m_pscheduler);
-
     {
         LOCK(m_callbacks_mutex);
         m_callbacks_pending.emplace_back(std::move(func));
@@ -190,7 +188,7 @@ void SingleThreadedSchedulerClient::AddToProcessQueue(std::function<void()> func
 
 void SingleThreadedSchedulerClient::EmptyQueue()
 {
-    assert(!m_pscheduler->AreThreadsServicingQueue());
+    assert(!m_scheduler.AreThreadsServicingQueue());
     bool should_continue = true;
     while (should_continue) {
         ProcessQueue();
diff --git a/src/scheduler.h b/src/scheduler.h
@@ -5,13 +5,18 @@
 #ifndef BITCOIN_SCHEDULER_H
 #define BITCOIN_SCHEDULER_H
 
+#include <attributes.h>
+#include <sync.h>
+#include <threadsafety.h>
+
+#include <chrono>
 #include <condition_variable>
+#include <cstddef>
 #include <functional>
 #include <list>
 #include <map>
 #include <thread>
-
-#include <sync.h>
+#include <utility>
 
 /**
  * Simple class for background tasks that should be run
@@ -117,7 +122,7 @@ class CScheduler
 class SingleThreadedSchedulerClient
 {
 private:
-    CScheduler* m_pscheduler;
+    CScheduler& m_scheduler;
 
     Mutex m_callbacks_mutex;
     std::list<std::function<void()>> m_callbacks_pending GUARDED_BY(m_callbacks_mutex);
@@ -127,7 +132,7 @@ class SingleThreadedSchedulerClient
     void ProcessQueue();
 
 public:
-    explicit SingleThreadedSchedulerClient(CScheduler* pschedulerIn) : m_pscheduler(pschedulerIn) {}
+    explicit SingleThreadedSchedulerClient(CScheduler& scheduler LIFETIMEBOUND) : m_scheduler{scheduler} {}
 
     /**
      * Add a callback to be executed. Callbacks are executed serially
diff --git a/src/test/scheduler_tests.cpp b/src/test/scheduler_tests.cpp
@@ -128,16 +128,16 @@ BOOST_AUTO_TEST_CASE(singlethreadedscheduler_ordered)
     CScheduler scheduler;
 
     // each queue should be well ordered with respect to itself but not other queues
-    SingleThreadedSchedulerClient queue1(&scheduler);
-    SingleThreadedSchedulerClient queue2(&scheduler);
+    SingleThreadedSchedulerClient queue1(scheduler);
+    SingleThreadedSchedulerClient queue2(scheduler);
 
     // create more threads than queues
     // if the queues only permit execution of one task at once then
     // the extra threads should effectively be doing nothing
     // if they don't we'll get out of order behaviour
     std::vector<std::thread> threads;
     for (int i = 0; i < 5; ++i) {
-        threads.emplace_back(std::bind(&CScheduler::serviceQueue, &scheduler));
+        threads.emplace_back([&] { scheduler.serviceQueue(); });
     }
 
     // these are not atomic, if SinglethreadedSchedulerClient prevents
diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp
@@ -40,7 +40,7 @@ struct MainSignalsInstance {
     // our own queue here :(
     SingleThreadedSchedulerClient m_schedulerClient;
 
-    explicit MainSignalsInstance(CScheduler *pscheduler) : m_schedulerClient(pscheduler) {}
+    explicit MainSignalsInstance(CScheduler& scheduler LIFETIMEBOUND) : m_schedulerClient(scheduler) {}
 
     void Register(std::shared_ptr<CValidationInterface> callbacks)
     {
@@ -92,7 +92,7 @@ static CMainSignals g_signals;
 void CMainSignals::RegisterBackgroundSignalScheduler(CScheduler& scheduler)
 {
     assert(!m_internals);
-    m_internals.reset(new MainSignalsInstance(&scheduler));
+    m_internals = std::make_unique<MainSignalsInstance>(scheduler);
 }
 
 void CMainSignals::UnregisterBackgroundSignalScheduler()

Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ void SingleThreadedSchedulerClient::MaybeScheduleProcessQueue()`
`143`	`143`	`if (m_are_callbacks_running) return;`
`144`	`144`	`if (m_callbacks_pending.empty()) return;`
`145`	`145`	`}`
`146`		`- m_pscheduler->schedule(std::bind(&SingleThreadedSchedulerClient::ProcessQueue, this), std::chrono::system_clock::now());`
	`146`	`+ m_scheduler.schedule([this] { this->ProcessQueue(); }, std::chrono::system_clock::now());`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`void SingleThreadedSchedulerClient::ProcessQueue()`
`@@ -179,8 +179,6 @@ void SingleThreadedSchedulerClient::ProcessQueue()`
`179`	`179`
`180`	`180`	`void SingleThreadedSchedulerClient::AddToProcessQueue(std::function<void()> func)`
`181`	`181`	`{`
`182`		`- assert(m_pscheduler);`
`183`		`-`
`184`	`182`	`{`
`185`	`183`	`LOCK(m_callbacks_mutex);`
`186`	`184`	`m_callbacks_pending.emplace_back(std::move(func));`
`@@ -190,7 +188,7 @@ void SingleThreadedSchedulerClient::AddToProcessQueue(std::function<void()> func`
`190`	`188`
`191`	`189`	`void SingleThreadedSchedulerClient::EmptyQueue()`
`192`	`190`	`{`
`193`		`- assert(!m_pscheduler->AreThreadsServicingQueue());`
	`191`	`+ assert(!m_scheduler.AreThreadsServicingQueue());`
`194`	`192`	`bool should_continue = true;`
`195`	`193`	`while (should_continue) {`
`196`	`194`	`ProcessQueue();`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ struct MainSignalsInstance {`
`40`	`40`	`// our own queue here :(`
`41`	`41`	`SingleThreadedSchedulerClient m_schedulerClient;`
`42`	`42`
`43`		`- explicit MainSignalsInstance(CScheduler *pscheduler) : m_schedulerClient(pscheduler) {}`
	`43`	`+ explicit MainSignalsInstance(CScheduler& scheduler LIFETIMEBOUND) : m_schedulerClient(scheduler) {}`
`44`	`44`
`45`	`45`	`void Register(std::shared_ptr<CValidationInterface> callbacks)`
`46`	`46`	`{`
`@@ -92,7 +92,7 @@ static CMainSignals g_signals;`
`92`	`92`	`void CMainSignals::RegisterBackgroundSignalScheduler(CScheduler& scheduler)`
`93`	`93`	`{`
`94`	`94`	`assert(!m_internals);`
`95`		`- m_internals.reset(new MainSignalsInstance(&scheduler));`
	`95`	`+ m_internals = std::make_unique<MainSignalsInstance>(scheduler);`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`void CMainSignals::UnregisterBackgroundSignalScheduler()`