1 #ifndef theplu_yat_utility_scheduler 2 #define theplu_yat_utility_scheduler 25 #include "PriorityQueue.h" 28 #include <boost/exception_ptr.hpp> 29 #include <boost/shared_ptr.hpp> 99 explicit Job(
unsigned int prio=0);
117 friend class JobHandler;
118 void add_prerequisite(
const boost::shared_ptr<Job>&,
119 const std::unique_lock<std::mutex>& lock);
122 size_t remove_prerequisite(
const boost::shared_ptr<Job>&,
123 const std::unique_lock<std::mutex>& lock);
125 std::set<boost::shared_ptr<Job> > prerequisite_;
128 std::set<boost::shared_ptr<Job> >&
129 prerequisite(
const std::unique_lock<std::mutex>& lock);
130 const std::set<boost::shared_ptr<Job> >&
131 prerequisite(
const std::unique_lock<std::mutex>& lock)
const;
137 enum status_type { pristine, prepared, running, completed};
139 status_type status(
const std::unique_lock<std::mutex>& lock)
const;
140 void status(
const std::unique_lock<std::mutex>& lock, status_type s);
143 boost::exception_ptr error_;
163 boost::shared_ptr<Job> prerequisite);
175 size_t jobs(
void)
const;
183 void submit(
const boost::shared_ptr<Job>& job);
190 unsigned int threads(
void)
const;
213 typedef boost::shared_ptr<Scheduler::Job> JobPtr;
218 virtual void operator()(JobHandler& handler)=0;
221 typedef boost::shared_ptr<Messenger> MessengerPtr;
224 class JobMessenger :
public Messenger
227 JobMessenger(
const JobPtr&);
228 void operator()(JobHandler& handler);
234 class SchedulerIsWaiting :
public Messenger
237 void operator()(JobHandler& handler);
241 class InterruptWorkers :
public Messenger
244 void operator()(JobHandler& handler);
249 class WorkForceSizer :
public Messenger
252 void operator()(JobHandler& handler);
258 bool operator()(
const JobPtr& lhs,
const JobPtr& rhs)
const;
262 typedef PriorityQueue<JobPtr, LowerPriority> JobQueue;
273 Worker(JobQueue& queue, MessengerQueue& completed);
274 void operator()(
void);
277 MessengerQueue& completed_;
284 typedef std::unique_lock<std::mutex> Lock;
286 void add(
const JobPtr& child,
const JobPtr& parent,
const Lock& lock);
287 void remove(
const JobPtr& parent,
const Lock& lock);
288 std::vector<JobPtr>& children(
const JobPtr& key,
const Lock& lock);
289 std::mutex& mutex(
void);
294 std::map<JobPtr, std::vector<JobPtr> > children_;
296 std::vector<JobPtr> empty_vector_;
308 explicit Count(
int x=0);
318 mutable std::mutex mutex_;
322 JobHandlerData(
void);
325 Dependency& dependency(
void);
326 const Dependency& dependency(
void)
const;
333 const Count& running_jobs(
void)
const;
334 Count& running_jobs(
void);
336 const Count& n_threads(
void)
const;
337 Count& n_threads(
void);
349 Dependency dependency_;
357 JobHandler(JobHandlerData& data);
359 void operator()(
void);
360 void create_workers(
unsigned int n);
361 JobHandlerData& data(
void);
362 void interrupt_workers(
void);
363 void kill_workers(
void);
364 void kill_workers(
unsigned int n);
368 void process(JobPtr& job);
369 void remove_joined_workers(
void);
370 void scheduler_is_waiting(
bool value);
371 unsigned int n_target_workers(
void)
const;
372 void wait_workers(
void)
const;
377 void prepare(JobPtr job,
const Dependency::Lock& lock);
384 void post_process(JobPtr job,
const Dependency::Lock& lock);
386 void send2queue(JobPtr& job,
387 const std::unique_lock<std::mutex>& lock);
389 JobHandlerData* data_;
390 bool scheduler_is_waiting_;
391 unsigned int job_count_;
392 void join_workers(
void);
394 typedef std::list<boost::shared_ptr<std::thread> > WorkerList;
400 unsigned int n_target_workers_;
404 void throw_if_error(
void)
const;
406 mutable std::mutex mutex_;
407 JobHandlerData data_;
408 std::thread job_handler_;
Handle a number of jobs and send them to threads.
Definition: Scheduler.h:85
void submit(const boost::shared_ptr< Job > &job)
submit a job to Scheduler
Job(unsigned int prio=0)
constructor
The Department of Theoretical Physics namespace as we define it.
void increment(void)
decrease value with 1
unsigned int threads(void) const
virtual void operator()(void)=0
unsigned int priority(void) const
virtual ~Job(void)
destructor
Definition: Scheduler.h:91
void decrement(void)
increase value with 1
thread-safe class around int
Definition: Scheduler.h:304
void add(T &o, ForwardIterator first, ForwardIterator last, const classifier::Target &target)
Definition: utility.h:320
void interrupt(void)
interrrupt all jobs
void add_dependency(boost::shared_ptr< Job > job, boost::shared_ptr< Job > prerequisite)
add a dependency rule
Count(int x=0)
Constructor.
Scheduler(unsigned int threads)
constructor
void wait(void)
wait for all jobs to finish