Branch data Line data Source code
1 : : // Copyright (c) 2015-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <scheduler.h>
6 : :
7 : : #include <sync.h>
8 : : #include <util/time.h>
9 : :
10 : : #include <cassert>
11 : : #include <functional>
12 : : #include <utility>
13 : :
14 : 1593 : CScheduler::CScheduler() = default;
15 : :
16 : 1593 : CScheduler::~CScheduler()
17 : : {
18 [ - + ]: 1593 : assert(nThreadsServicingQueue == 0);
19 [ - + - - ]: 1593 : if (stopWhenEmpty) assert(taskQueue.empty());
20 : 1593 : }
21 : :
22 : :
23 : 1593 : void CScheduler::serviceQueue()
24 : : {
25 : 1593 : WAIT_LOCK(newTaskMutex, lock);
26 : 1593 : ++nThreadsServicingQueue;
27 : :
28 : : // newTaskMutex is locked throughout this loop EXCEPT
29 : : // when the thread is waiting or when the user's function
30 : : // is called.
31 [ + + ]: 1448619 : while (!shouldStop()) {
32 : : try {
33 [ + + + + ]: 4569054 : while (!shouldStop() && taskQueue.empty()) {
34 : : // Wait until there is something to do.
35 [ + - ]: 838291 : newTaskScheduled.wait(lock);
36 : : }
37 : :
38 : : // Wait until either there is a new task, or until
39 : : // the time of the first item on the queue:
40 : :
41 [ + + + - ]: 2892472 : while (!shouldStop() && !taskQueue.empty()) {
42 [ + - ]: 1445446 : std::chrono::steady_clock::time_point timeToWaitFor = taskQueue.begin()->first;
43 [ - + + - ]: 1445446 : if (newTaskScheduled.wait_until(lock, timeToWaitFor) == std::cv_status::timeout) {
44 : : break; // Exit loop after timeout, it means we reached the time of the event
45 : : }
46 : : }
47 : :
48 : : // If there are multiple threads, the queue can empty while we're waiting (another
49 : : // thread may service the task we were waiting on).
50 [ + + + - ]: 2892466 : if (shouldStop() || taskQueue.empty())
51 : 1586 : continue;
52 : :
53 [ + - ]: 1445440 : Function f = taskQueue.begin()->second;
54 : 1445440 : taskQueue.erase(taskQueue.begin());
55 : :
56 : 1445440 : {
57 : : // Unlock before calling f, so it can reschedule itself or another task
58 : : // without deadlocking:
59 [ + - ]: 1445440 : REVERSE_LOCK(lock);
60 [ + - ]: 1445440 : f();
61 : 1445440 : }
62 : 1445440 : } catch (...) {
63 : 0 : --nThreadsServicingQueue;
64 : 0 : throw;
65 : 0 : }
66 : : }
67 : 1593 : --nThreadsServicingQueue;
68 [ + - ]: 1593 : newTaskScheduled.notify_one();
69 : 1593 : }
70 : :
71 : 1445630 : void CScheduler::schedule(CScheduler::Function f, std::chrono::steady_clock::time_point t)
72 : : {
73 : 1445630 : {
74 : 1445630 : LOCK(newTaskMutex);
75 [ + - + - : 2891260 : taskQueue.insert(std::make_pair(t, f));
+ - ]
76 : 1445630 : }
77 : 1445630 : newTaskScheduled.notify_one();
78 : 1445630 : }
79 : :
80 : 5 : void CScheduler::MockForward(std::chrono::seconds delta_seconds)
81 : : {
82 [ + - - + ]: 5 : assert(delta_seconds > 0s && delta_seconds <= 1h);
83 : :
84 : 5 : {
85 : 5 : LOCK(newTaskMutex);
86 : :
87 : : // use temp_queue to maintain updated schedule
88 : 5 : std::multimap<std::chrono::steady_clock::time_point, Function> temp_queue;
89 : :
90 [ - + ]: 5 : for (const auto& element : taskQueue) {
91 [ # # ]: 0 : temp_queue.emplace_hint(temp_queue.cend(), element.first - delta_seconds, element.second);
92 : : }
93 : :
94 : : // point taskQueue to temp_queue
95 : 5 : taskQueue = std::move(temp_queue);
96 [ + - ]: 5 : }
97 : :
98 : : // notify that the taskQueue needs to be processed
99 : 5 : newTaskScheduled.notify_one();
100 : 5 : }
101 : :
102 : 0 : static void Repeat(CScheduler& s, CScheduler::Function f, std::chrono::milliseconds delta)
103 : : {
104 : 0 : f();
105 [ # # # # : 0 : s.scheduleFromNow([=, &s] { Repeat(s, f, delta); }, delta);
# # # # ]
106 : 0 : }
107 : :
108 : 0 : void CScheduler::scheduleEvery(CScheduler::Function f, std::chrono::milliseconds delta)
109 : : {
110 [ # # # # : 0 : scheduleFromNow([this, f, delta] { Repeat(*this, f, delta); }, delta);
# # # # ]
111 : 0 : }
112 : :
113 : 0 : size_t CScheduler::getQueueInfo(std::chrono::steady_clock::time_point& first,
114 : : std::chrono::steady_clock::time_point& last) const
115 : : {
116 : 0 : LOCK(newTaskMutex);
117 [ # # ]: 0 : size_t result = taskQueue.size();
118 [ # # ]: 0 : if (!taskQueue.empty()) {
119 : 0 : first = taskQueue.begin()->first;
120 : 0 : last = taskQueue.rbegin()->first;
121 : : }
122 [ # # ]: 0 : return result;
123 : 0 : }
124 : :
125 : 1593 : bool CScheduler::AreThreadsServicingQueue() const
126 : : {
127 : 1593 : LOCK(newTaskMutex);
128 [ + - ]: 1593 : return nThreadsServicingQueue;
129 : 1593 : }
130 : :
131 : :
132 : 2363754 : void SerialTaskRunner::MaybeScheduleProcessQueue()
133 : : {
134 : 2363754 : {
135 : 2363754 : LOCK(m_callbacks_mutex);
136 : : // Try to avoid scheduling too many copies here, but if we
137 : : // accidentally have two ProcessQueue's scheduled at once its
138 : : // not a big deal.
139 [ + + ]: 2363754 : if (m_are_callbacks_running) return;
140 [ + + ]: 2297423 : if (m_callbacks_pending.empty()) return;
141 : 918124 : }
142 [ + - ]: 4336700 : m_scheduler.schedule([this] { this->ProcessQueue(); }, std::chrono::steady_clock::now());
143 : : }
144 : :
145 : 1447033 : void SerialTaskRunner::ProcessQueue()
146 : : {
147 [ + - ]: 1447033 : std::function<void()> callback;
148 : 1447033 : {
149 [ + - ]: 1447033 : LOCK(m_callbacks_mutex);
150 [ + - ]: 1447033 : if (m_are_callbacks_running) return;
151 [ + + ]: 1447033 : if (m_callbacks_pending.empty()) return;
152 : 1181877 : m_are_callbacks_running = true;
153 : :
154 : 1181877 : callback = std::move(m_callbacks_pending.front());
155 [ + - ]: 1181877 : m_callbacks_pending.pop_front();
156 : 265156 : }
157 : :
158 : : // RAII the setting of fCallbacksRunning and calling MaybeScheduleProcessQueue
159 : : // to ensure both happen safely even if callback() throws.
160 : 1181877 : struct RAIICallbacksRunning {
161 : : SerialTaskRunner* instance;
162 : 1181877 : explicit RAIICallbacksRunning(SerialTaskRunner* _instance) : instance(_instance) {}
163 : 1181877 : ~RAIICallbacksRunning()
164 : : {
165 : 1181877 : {
166 : 1181877 : LOCK(instance->m_callbacks_mutex);
167 [ + - ]: 1181877 : instance->m_are_callbacks_running = false;
168 : 1181877 : }
169 : 1181877 : instance->MaybeScheduleProcessQueue();
170 : 1181877 : }
171 : 1181877 : } raiicallbacksrunning(this);
172 : :
173 [ + - ]: 1181877 : callback();
174 : 1447033 : }
175 : :
176 : 1181877 : void SerialTaskRunner::insert(std::function<void()> func)
177 : : {
178 : 1181877 : {
179 : 1181877 : LOCK(m_callbacks_mutex);
180 [ + - ]: 1181877 : m_callbacks_pending.emplace_back(std::move(func));
181 : 1181877 : }
182 : 1181877 : MaybeScheduleProcessQueue();
183 : 1181877 : }
184 : :
185 : 1593 : void SerialTaskRunner::flush()
186 : : {
187 [ + - ]: 1593 : assert(!m_scheduler.AreThreadsServicingQueue());
188 : : bool should_continue = true;
189 [ + + ]: 3186 : while (should_continue) {
190 : 1593 : ProcessQueue();
191 : 1593 : LOCK(m_callbacks_mutex);
192 [ + - ]: 1593 : should_continue = !m_callbacks_pending.empty();
193 : 1593 : }
194 : 1593 : }
195 : :
196 : 142903 : size_t SerialTaskRunner::size()
197 : : {
198 : 142903 : LOCK(m_callbacks_mutex);
199 [ + - ]: 142903 : return m_callbacks_pending.size();
200 : : }
|
