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                 :       1672 : CScheduler::CScheduler() = default;
      15                 :            : 
      16                 :        836 : CScheduler::~CScheduler()
      17                 :            : {
      18         [ +  - ]:        836 :     assert(nThreadsServicingQueue == 0);
      19   [ +  -  #  # ]:        836 :     if (stopWhenEmpty) assert(taskQueue.empty());
      20                 :        836 : }
      21                 :            : 
      22                 :            : 
      23                 :        836 : void CScheduler::serviceQueue()
      24                 :            : {
      25                 :        836 :     WAIT_LOCK(newTaskMutex, lock);
      26                 :        836 :     ++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   [ +  -  +  + ]:     388949 :     while (!shouldStop()) {
      32                 :            :         try {
      33   [ +  -  +  +  :     602923 :             while (!shouldStop() && taskQueue.empty()) {
                   +  + ]
      34                 :            :                 // Wait until there is something to do.
      35                 :     214810 :                 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   [ +  -  +  +  :     388113 :             while (!shouldStop() && !taskQueue.empty()) {
                   +  + ]
      42                 :     387277 :                 std::chrono::steady_clock::time_point timeToWaitFor = taskQueue.begin()->first;
      43   [ +  -  -  + ]:     387277 :                 if (newTaskScheduled.wait_until(lock, timeToWaitFor) == std::cv_status::timeout) {
      44                 :     387277 :                     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   [ +  -  +  +  :     388113 :             if (shouldStop() || taskQueue.empty())
                   +  - ]
      51                 :        836 :                 continue;
      52                 :            : 
      53         [ +  - ]:     387277 :             Function f = taskQueue.begin()->second;
      54         [ +  - ]:     387277 :             taskQueue.erase(taskQueue.begin());
      55                 :            : 
      56                 :            :             {
      57                 :            :                 // Unlock before calling f, so it can reschedule itself or another task
      58                 :            :                 // without deadlocking:
      59         [ +  - ]:     387277 :                 REVERSE_LOCK(lock);
      60         [ +  - ]:     387277 :                 f();
      61                 :     387277 :             }
      62                 :     387277 :         } catch (...) {
      63                 :          0 :             --nThreadsServicingQueue;
      64         [ #  # ]:          0 :             throw;
      65         [ #  # ]:          0 :         }
      66                 :            :     }
      67                 :        836 :     --nThreadsServicingQueue;
      68                 :        836 :     newTaskScheduled.notify_one();
      69                 :        836 : }
      70                 :            : 
      71                 :     387278 : void CScheduler::schedule(CScheduler::Function f, std::chrono::steady_clock::time_point t)
      72                 :            : {
      73                 :            :     {
      74                 :     387278 :         LOCK(newTaskMutex);
      75   [ +  -  -  + ]:     387278 :         taskQueue.insert(std::make_pair(t, f));
      76                 :     387278 :     }
      77                 :     387278 :     newTaskScheduled.notify_one();
      78                 :     387278 : }
      79                 :            : 
      80                 :          1 : void CScheduler::MockForward(std::chrono::seconds delta_seconds)
      81                 :            : {
      82   [ -  +  +  - ]:          1 :     assert(delta_seconds > 0s && delta_seconds <= 1h);
      83                 :            : 
      84                 :            :     {
      85                 :          1 :         LOCK(newTaskMutex);
      86                 :            : 
      87                 :            :         // use temp_queue to maintain updated schedule
      88                 :          1 :         std::multimap<std::chrono::steady_clock::time_point, Function> temp_queue;
      89                 :            : 
      90         [ +  - ]:          1 :         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                 :          1 :         taskQueue = std::move(temp_queue);
      96                 :          1 :     }
      97                 :            : 
      98                 :            :     // notify that the taskQueue needs to be processed
      99                 :          1 :     newTaskScheduled.notify_one();
     100                 :          1 : }
     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                 :        836 : 
     108                 :        836 : void CScheduler::scheduleEvery(CScheduler::Function f, std::chrono::milliseconds delta)
     109                 :        836 : {
     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                 :          0 :     }
     122                 :          0 :     return result;
     123                 :          0 : }
     124                 :            : 
     125                 :        836 : bool CScheduler::AreThreadsServicingQueue() const
     126                 :            : {
     127                 :        836 :     LOCK(newTaskMutex);
     128                 :        836 :     return nThreadsServicingQueue;
     129                 :        836 : }
     130                 :            : 
     131                 :            : 
     132                 :     616156 : void SingleThreadedSchedulerClient::MaybeScheduleProcessQueue()
     133                 :            : {
     134                 :            :     {
     135                 :     616156 :         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         [ +  + ]:     616156 :         if (m_are_callbacks_running) return;
     140         [ +  + ]:     602284 :         if (m_callbacks_pending.empty()) return;
     141      [ -  +  + ]:     616156 :     }
     142         [ +  - ]:     774555 :     m_scheduler.schedule([this] { this->ProcessQueue(); }, std::chrono::steady_clock::now());
     143                 :     616156 : }
     144                 :            : 
     145                 :     388113 : void SingleThreadedSchedulerClient::ProcessQueue()
     146                 :            : {
     147                 :     388113 :     std::function<void()> callback;
     148                 :            :     {
     149   [ +  -  +  - ]:     388113 :         LOCK(m_callbacks_mutex);
     150         [ -  + ]:     388113 :         if (m_are_callbacks_running) return;
     151         [ +  + ]:     388113 :         if (m_callbacks_pending.empty()) return;
     152                 :     308078 :         m_are_callbacks_running = true;
     153                 :            : 
     154                 :     308078 :         callback = std::move(m_callbacks_pending.front());
     155                 :     308078 :         m_callbacks_pending.pop_front();
     156         [ +  + ]:     388113 :     }
     157                 :            : 
     158                 :            :     // RAII the setting of fCallbacksRunning and calling MaybeScheduleProcessQueue
     159                 :            :     // to ensure both happen safely even if callback() throws.
     160                 :            :     struct RAIICallbacksRunning {
     161                 :            :         SingleThreadedSchedulerClient* instance;
     162                 :     308078 :         explicit RAIICallbacksRunning(SingleThreadedSchedulerClient* _instance) : instance(_instance) {}
     163                 :     308078 :         ~RAIICallbacksRunning()
     164                 :            :         {
     165                 :            :             {
     166         [ +  - ]:     308078 :                 LOCK(instance->m_callbacks_mutex);
     167                 :     308078 :                 instance->m_are_callbacks_running = false;
     168                 :     308078 :             }
     169         [ +  - ]:     308078 :             instance->MaybeScheduleProcessQueue();
     170                 :     308078 :         }
     171         [ +  - ]:     308078 :     } raiicallbacksrunning(this);
     172                 :            : 
     173         [ +  - ]:     308078 :     callback();
     174         [ -  + ]:     388113 : }
     175                 :            : 
     176                 :     308078 : void SingleThreadedSchedulerClient::AddToProcessQueue(std::function<void()> func)
     177                 :            : {
     178                 :            :     {
     179                 :     308078 :         LOCK(m_callbacks_mutex);
     180         [ +  - ]:     308078 :         m_callbacks_pending.emplace_back(std::move(func));
     181                 :     308078 :     }
     182                 :     308078 :     MaybeScheduleProcessQueue();
     183                 :     308078 : }
     184                 :            : 
     185                 :        836 : void SingleThreadedSchedulerClient::EmptyQueue()
     186                 :            : {
     187         [ +  - ]:        836 :     assert(!m_scheduler.AreThreadsServicingQueue());
     188                 :        836 :     bool should_continue = true;
     189         [ +  + ]:       1672 :     while (should_continue) {
     190                 :        836 :         ProcessQueue();
     191                 :        836 :         LOCK(m_callbacks_mutex);
     192                 :        836 :         should_continue = !m_callbacks_pending.empty();
     193                 :        836 :     }
     194                 :        836 : }
     195                 :            : 
     196                 :      75967 : size_t SingleThreadedSchedulerClient::CallbacksPending()
     197                 :            : {
     198                 :      75967 :     LOCK(m_callbacks_mutex);
     199                 :      75967 :     return m_callbacks_pending.size();
     200                 :      75967 : }