scheduler.h

Go to the documentation of this file.

// Copyright (c) 2015-2020 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 <condition_variable>
#include <functional>
#include <list>
#include <map>
#include <thread>

#include <sync.h>

class CScheduler
{
public:
    CScheduler();
    ~CScheduler();

    std::thread m_service_thread;

    typedef std::function<void()> Function;

    void schedule(Function f, std::chrono::system_clock::time_point t);

    void scheduleFromNow(Function f, std::chrono::milliseconds delta)
    {
        schedule(std::move(f), std::chrono::system_clock::now() + delta);
    }

    void scheduleEvery(Function f, std::chrono::milliseconds delta);

    void MockForward(std::chrono::seconds delta_seconds);

    void serviceQueue();

    void stop()
    {
        WITH_LOCK(newTaskMutex, stopRequested = true);
        newTaskScheduled.notify_all();
        if (m_service_thread.joinable()) m_service_thread.join();
    }
    void StopWhenDrained()
    {
        WITH_LOCK(newTaskMutex, stopWhenEmpty = true);
        newTaskScheduled.notify_all();
        if (m_service_thread.joinable()) m_service_thread.join();
    }

    size_t getQueueInfo(std::chrono::system_clock::time_point& first,
                        std::chrono::system_clock::time_point& last) const;

    bool AreThreadsServicingQueue() const;

private:
    mutable Mutex newTaskMutex;
    std::condition_variable newTaskScheduled;
    std::multimap<std::chrono::system_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 SingleThreadedSchedulerClient
{
private:
    CScheduler* m_pscheduler;

    RecursiveMutex m_cs_callbacks_pending;
    std::list<std::function<void()>> m_callbacks_pending GUARDED_BY(m_cs_callbacks_pending);
    bool m_are_callbacks_running GUARDED_BY(m_cs_callbacks_pending) = false;

    void MaybeScheduleProcessQueue();
    void ProcessQueue();

public:
    explicit SingleThreadedSchedulerClient(CScheduler* pschedulerIn) : m_pscheduler(pschedulerIn) {}

    void AddToProcessQueue(std::function<void()> func);

    void EmptyQueue();

    size_t CallbacksPending();
};

#endif