scheduler.h

Go to the documentation of this file.

// Copyright (c) 2015 The Bitcoin Core developers
// Copyright (c) 2017-2021 The PIVX Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_SCHEDULER_H
#define PIVX_SCHEDULER_H
 
//
// NOTE:
// boost::thread should be ported to std::thread
// when we support C++11.
//
#include <condition_variable>
#include <functional>
#include <list>
#include <map>
 
#include "sync.h"
 
//
// Simple class for background tasks that should be run
// periodically or once "after a while"
//
// Usage:
//
// CScheduler* s = new CScheduler();
// s->scheduleFromNow(doSomething, 11); // Assuming a: void doSomething() { }
// s->scheduleFromNow(std::bind(Class::func, this, argument), 3);
// boost::thread* t = new boost::thread(std::bind(CScheduler::serviceQueue, s));
//
// ... then at program shutdown, make sure to call stop() to clean up the thread(s) running serviceQueue:
// s->stop();
// t->join();
// delete t;
// delete s; // Must be done after thread is interrupted/joined.
//
 
class CScheduler
{
public:
    CScheduler();
    ~CScheduler();
 
    typedef std::function<void(void)> Function;
 
    // Call func at/after time t
    void schedule(Function f, std::chrono::system_clock::time_point t);
 
    // Convenience method: call f once deltaMilliSeconds from now
    void scheduleFromNow(Function f, int64_t deltaMilliSeconds);
 
    // Another convenience method: call f approximately
    // every deltaMilliSeconds forever, starting deltaMilliSeconds from now.
    // To be more precise: every time f is finished, it
    // is rescheduled to run deltaMilliSeconds later. If you
    // need more accurate scheduling, don't use this method.
    void scheduleEvery(Function f, int64_t deltaMilliSeconds);
 
    // To keep things as simple as possible, there is no unschedule.
 
    // Services the queue 'forever'. Should be run in a thread,
    // and interrupted using boost::interrupt_thread
    void serviceQueue();
 
    // Tell any threads running serviceQueue to stop as soon as they're
    // done servicing whatever task they're currently servicing (drain=false)
    // or when there is no work left to be done (drain=true)
    void stop(bool drain=false);
 
    // Returns number of tasks waiting to be serviced,
    // and first and last task times
    size_t getQueueInfo(std::chrono::system_clock::time_point &first,
                        std::chrono::system_clock::time_point &last) const;
 
    // Returns true if there are threads actively running in serviceQueue()
    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);
    bool stopRequested GUARDED_BY(newTaskMutex);
    bool stopWhenEmpty GUARDED_BY(newTaskMutex);
    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 (void)>> m_callbacks_pending;
    bool m_are_callbacks_running = false;
 
    void MaybeScheduleProcessQueue();
    void ProcessQueue();
 
public:
    explicit SingleThreadedSchedulerClient(CScheduler *pschedulerIn) : m_pscheduler(pschedulerIn) {}
 
    void AddToProcessQueue(std::function<void (void)> func);
 
    // Processes all remaining queue members on the calling thread, blocking until queue is empty
    // Must be called after the CScheduler has no remaining processing threads!
    void EmptyQueue();
 
    size_t CallbacksPending();
};
 
#endif // PIVX_SCHEDULER_H