#include <task_arena.h>
Public Member Functions | |
task_arena (int max_concurrency=automatic) | |
Creates task_arena with certain concurrency limit. | |
task_arena (const task_arena &s) | |
Copies settings from another task_arena. | |
~task_arena () | |
template<typename F > | |
void | enqueue (const F &f) |
template<typename F > | |
void | enqueue (const F &f, priority_t p) |
template<typename F > | |
void | execute (F &f) |
template<typename F > | |
void | execute (const F &f) |
void | wait_until_empty () |
void | initialize (int max_concurrency) |
Sets concurrency level and initializes internal representation. | |
Static Public Member Functions | |
static int __TBB_EXPORTED_FUNC | current_slot () |
Returns the index, aka slot number, of the calling thread in its current arena. | |
Static Public Attributes | |
static const int | automatic = -1 |
Typedef for number of threads that is automatic. | |
Friends | |
class | internal::task_scheduler_observer_v3 |
1-to-1 proxy representation class of scheduler's arena Constructors set up settings only, real construction is deferred till the first method invocation TODO: A side effect of this is that it's impossible to create a const task_arena object. Rethink? Destructor only removes one of the references to the inner arena representation. Final destruction happens when all the references (and the work) are gone.
tbb::interface6::task_arena::~task_arena | ( | ) | [inline] |
Removes the reference to the internal arena representation, and destroys the external object Not thread safe wrt concurrent invocations of other methods
void tbb::interface6::task_arena::enqueue | ( | const F & | f, | |
priority_t | p | |||
) | [inline] |
Enqueues a task with priority p into the arena to process a functor f, and immediately returns. Does not require the calling thread to join the arena
References tbb::task::allocate_root().
void tbb::interface6::task_arena::enqueue | ( | const F & | f | ) | [inline] |
Enqueues a task into the arena to process a functor, and immediately returns. Does not require the calling thread to join the arena
References tbb::task::allocate_root().
void tbb::interface6::task_arena::execute | ( | const F & | f | ) | [inline] |
void tbb::interface6::task_arena::execute | ( | F & | f | ) | [inline] |
void tbb::interface6::task_arena::wait_until_empty | ( | ) | [inline] |
Wait for all work in the arena to be completed Even submitted by other application threads Joins arena if/when possible (in the same way as execute())