Dash Core Source Documentation (0.16.0.1)

Find detailed information regarding the Dash Core source code.

scheduler.h
Go to the documentation of this file.
1 // Copyright (c) 2015 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 #ifndef BITCOIN_SCHEDULER_H
6 #define BITCOIN_SCHEDULER_H
7 
8 //
9 // NOTE:
10 // boost::thread / boost::chrono should be ported to std::thread / std::chrono
11 // when we support C++11.
12 //
13 #include <boost/chrono/chrono.hpp>
14 #include <boost/thread.hpp>
15 #include <map>
16 
17 #include <sync.h>
18 
19 //
20 // Simple class for background tasks that should be run
21 // periodically or once "after a while"
22 //
23 // Usage:
24 //
25 // CScheduler* s = new CScheduler();
26 // s->scheduleFromNow(doSomething, 11); // Assuming a: void doSomething() { }
27 // s->scheduleFromNow(std::bind(Class::func, this, argument), 3);
28 // boost::thread* t = new boost::thread(boost::bind(CScheduler::serviceQueue, s));
29 //
30 // ... then at program shutdown, clean up the thread running serviceQueue:
31 // t->interrupt();
32 // t->join();
33 // delete t;
34 // delete s; // Must be done after thread is interrupted/joined.
35 //
36 
38 {
39 public:
40  CScheduler();
41  ~CScheduler();
42 
43  typedef std::function<void(void)> Function;
44 
45  // Call func at/after time t
46  void schedule(Function f, boost::chrono::system_clock::time_point t=boost::chrono::system_clock::now());
47 
48  // Convenience method: call f once deltaSeconds from now
49  void scheduleFromNow(Function f, int64_t deltaMilliSeconds);
50 
51  // Another convenience method: call f approximately
52  // every deltaSeconds forever, starting deltaSeconds from now.
53  // To be more precise: every time f is finished, it
54  // is rescheduled to run deltaSeconds later. If you
55  // need more accurate scheduling, don't use this method.
56  void scheduleEvery(Function f, int64_t deltaMilliSeconds);
57 
58  // To keep things as simple as possible, there is no unschedule.
59 
60  // Services the queue 'forever'. Should be run in a thread,
61  // and interrupted using boost::interrupt_thread
62  void serviceQueue();
63 
64  // Tell any threads running serviceQueue to stop as soon as they're
65  // done servicing whatever task they're currently servicing (drain=false)
66  // or when there is no work left to be done (drain=true)
67  void stop(bool drain=false);
68 
69  // Returns number of tasks waiting to be serviced,
70  // and first and last task times
73 
74  // Returns true if there are threads actively running in serviceQueue()
75  bool AreThreadsServicingQueue() const;
76 
77 private:
78  std::multimap<boost::chrono::system_clock::time_point, Function> taskQueue;
79  boost::condition_variable newTaskScheduled;
80  mutable boost::mutex newTaskMutex;
84  bool shouldStop() const { return stopRequested || (stopWhenEmpty && taskQueue.empty()); }
85 };
86 
94 private:
96 
98  std::list<std::function<void (void)>> m_callbacks_pending;
100 
102  void ProcessQueue();
103 
104 public:
105  explicit SingleThreadedSchedulerClient(CScheduler *pschedulerIn) : m_pscheduler(pschedulerIn) {}
106  void AddToProcessQueue(std::function<void (void)> func);
107 
108  // Processes all remaining queue members on the calling thread, blocking until queue is empty
109  // Must be called after the CScheduler has no remaining processing threads!
110  void EmptyQueue();
111 
112  size_t CallbacksPending();
113 };
114 
115 #endif
Class used by CScheduler clients which may schedule multiple jobs which are required to be run serial...
Definition: scheduler.h:93
bool stopWhenEmpty
Definition: scheduler.h:83
std::multimap< boost::chrono::system_clock::time_point, Function > taskQueue
Definition: scheduler.h:78
bool shouldStop() const
Definition: scheduler.h:84
void scheduleEvery(Function f, int64_t deltaMilliSeconds)
Definition: scheduler.cpp:126
void scheduleFromNow(Function f, int64_t deltaMilliSeconds)
Definition: scheduler.cpp:115
void schedule(Function f, boost::chrono::system_clock::time_point t=boost::chrono::system_clock::now())
Definition: scheduler.cpp:106
void stop(bool drain=false)
Definition: scheduler.cpp:94
std::function< void(void)> Function
Definition: scheduler.h:43
SingleThreadedSchedulerClient(CScheduler *pschedulerIn)
Definition: scheduler.h:105
boost::condition_variable newTaskScheduled
Definition: scheduler.h:79
void serviceQueue()
Definition: scheduler.cpp:33
boost::mutex newTaskMutex
Definition: scheduler.h:80
std::list< std::function< void(void)> > m_callbacks_pending
Definition: scheduler.h:98
bool stopRequested
Definition: scheduler.h:82
CCriticalSection m_cs_callbacks_pending
Definition: scheduler.h:97
bool AreThreadsServicingQueue() const
Definition: scheduler.cpp:143
clock::time_point time_point
Definition: bench.h:47
int nThreadsServicingQueue
Definition: scheduler.h:81
size_t getQueueInfo(boost::chrono::system_clock::time_point &first, boost::chrono::system_clock::time_point &last) const
Definition: scheduler.cpp:131
void AddToProcessQueue(std::function< void(void)> func)
Definition: scheduler.cpp:190
Wrapped mutex: supports recursive locking, but no waiting TODO: We should move away from using the re...
Definition: sync.h:94
Released under the MIT license