libcaf
0.13.2
|
Implements scheduling of actors via work stealing. More...
#include <work_stealing.hpp>
Public Types | |
using | queue_type = detail::double_ended_queue< resumable > |
Public Member Functions | |
template<class WorkerOrCoordinator > | |
auto | d (WorkerOrCoordinator *self) -> decltype(self->data()) |
template<class Worker > | |
resumable * | try_steal (Worker *self) |
template<class Coordinator > | |
void | central_enqueue (Coordinator *self, resumable *job) |
template<class Worker > | |
void | external_enqueue (Worker *self, resumable *job) |
template<class Worker > | |
void | internal_enqueue (Worker *self, resumable *job) |
template<class Worker > | |
void | resume_job_later (Worker *self, resumable *job) |
template<class Worker > | |
resumable * | dequeue (Worker *self) |
template<class Worker > | |
void | before_shutdown (Worker *) |
template<class Worker > | |
void | before_resume (Worker *, resumable *) |
template<class Worker > | |
void | after_resume (Worker *, resumable *) |
template<class Worker > | |
void | after_completion (Worker *, resumable *) |
template<class Worker , class UnaryFunction > | |
void | foreach_resumable (Worker *self, UnaryFunction f) |
template<class Coordinator , class UnaryFunction > | |
void | foreach_central_resumable (Coordinator *, UnaryFunction) |
![]() | |
template<class Coordinator > | |
void | central_enqueue (Coordinator *self, resumable *job) |
Enqueues a new job to coordinator. | |
template<class Worker > | |
void | external_enqueue (Worker *self, resumable *job) |
Enqueues a new job to the worker's queue from an external source, i.e., from any other thread. More... | |
template<class Worker > | |
void | internal_enqueue (Worker *self, resumable *job) |
Enqueues a new job to the worker's queue from an internal source, i.e., from the same thread. More... | |
template<class Worker > | |
void | resume_job_later (Worker *self, resumable *job) |
Called whenever resumable returned for reason resumable::resume_later . | |
template<class Worker > | |
resumable * | dequeue (Worker *self) |
Blocks until a job could be dequeued. More... | |
template<class Worker > | |
void | before_shutdown (Worker *self) |
Performs cleanup action before a shutdown takes place. | |
template<class Worker > | |
void | before_resume (Worker *self, resumable *job) |
Called immediately before resuming an actor. | |
template<class Worker > | |
void | after_resume (Worker *self, resumable *job) |
Called whenever an actor has been resumed. More... | |
template<class Worker > | |
void | after_completion (Worker *self, resumable *job) |
Called whenever an actor has completed a job. | |
template<class Worker , typename UnaryFunction > | |
void | foreach_resumable (Worker *self, UnaryFunction f) |
Applies given functor to all resumables attached to a worker. | |
template<class Coordinator , typename UnaryFunction > | |
void | foreach_central_resumable (Coordinator *self, UnaryFunction f) |
Applies given functor to all resumables attached to the coordinator. | |
Implements scheduling of actors via work stealing.
This implementation uses two queues: a synchronized queue accessible by other threads and an internal queue. Access to the synchronized queue is minimized. The reasoning behind this design decision is that it has been shown that stealing actually is very rare for most workloads [1]. Hence, implementations should focus on the performance in the non-stealing case. For this reason, each worker has an exposed job queue that can be accessed by the central scheduler instance as well as other workers, but it also has a private job list it is currently working on. To account for the load balancing aspect, each worker makes sure that at least one job is left in its exposed queue to allow other workers to steal it.