scheduler.h

Go to the documentation of this file.

// Copyright (c) 2015 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_SCHEDULER_H
#define BITCOIN_SCHEDULER_H
 
#include <attributes.h>
#include <sync.h>
#include <threadsafety.h>
#include <util/task_runner.h>
 
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <functional>
#include <list>
#include <map>
#include <thread>
#include <utility>
 
class CScheduler {
public:
    CScheduler();
    ~CScheduler();
 
    std::thread m_service_thread;
 
    typedef std::function<void()> Function;
    typedef std::function<bool()> Predicate;
 
    void schedule(Function f, std::chrono::steady_clock::time_point t)
        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
    void scheduleFromNow(Function f, std::chrono::milliseconds delta)
        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex) {
        schedule(std::move(f), std::chrono::steady_clock::now() + delta);
    }
 
    void scheduleEvery(Predicate p, std::chrono::milliseconds delta)
        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
    void MockForward(std::chrono::seconds delta_seconds)
        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
    void serviceQueue() EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
    void stop() EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex) {
        WITH_LOCK(newTaskMutex, stopRequested = true);
        newTaskScheduled.notify_all();
        if (m_service_thread.joinable()) {
            m_service_thread.join();
        }
    }
 
    void StopWhenDrained() EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex) {
        WITH_LOCK(newTaskMutex, stopWhenEmpty = true);
        newTaskScheduled.notify_all();
        if (m_service_thread.joinable()) {
            m_service_thread.join();
        }
    }
 
    size_t getQueueInfo(std::chrono::steady_clock::time_point &first,
                        std::chrono::steady_clock::time_point &last) const
        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
    bool AreThreadsServicingQueue() const
        EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex);
 
private:
    mutable Mutex newTaskMutex;
    std::condition_variable newTaskScheduled;
    std::multimap<std::chrono::steady_clock::time_point, Function>
        taskQueue GUARDED_BY(newTaskMutex);
    int nThreadsServicingQueue GUARDED_BY(newTaskMutex){0};
    bool stopRequested GUARDED_BY(newTaskMutex){false};
    bool stopWhenEmpty GUARDED_BY(newTaskMutex){false};
    bool shouldStop() const EXCLUSIVE_LOCKS_REQUIRED(newTaskMutex) {
        return stopRequested || (stopWhenEmpty && taskQueue.empty());
    }
};
 
class SerialTaskRunner : public util::TaskRunnerInterface {
private:
    CScheduler &m_scheduler;
 
    Mutex m_callbacks_mutex;
 
    // We are not allowed to assume the scheduler only runs in one thread,
    // but must ensure all callbacks happen in-order, so we end up creating
    // our own queue here :(
    std::list<std::function<void()>>
        m_callbacks_pending GUARDED_BY(m_callbacks_mutex);
    bool m_are_callbacks_running GUARDED_BY(m_callbacks_mutex) = false;
 
    void MaybeScheduleProcessQueue()
        EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
    void ProcessQueue() EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
 
public:
    explicit SerialTaskRunner(CScheduler &scheduler LIFETIMEBOUND)
        : m_scheduler{scheduler} {}
 
    void insert(std::function<void()> func) override
        EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
 
    void flush() override EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
 
    size_t size() override EXCLUSIVE_LOCKS_REQUIRED(!m_callbacks_mutex);
};
 
#endif // BITCOIN_SCHEDULER_H