tbb::interface7::internal::delegated_task Class Reference

Inheritance diagram for tbb::interface7::internal::delegated_task:

Collaboration diagram for tbb::interface7::internal::delegated_task:

Public Member Functions
	delegated_task (internal::delegate_base &d, concurrent_monitor &s, task *t)
bool	operator() (uintptr_t ctx) const
Public Member Functions inherited from tbb::task
virtual	~task ()
	Destructor. More...
internal::allocate_continuation_proxy &	allocate_continuation ()
	Returns proxy for overloaded new that allocates a continuation task of *this. More...
internal::allocate_child_proxy &	allocate_child ()
	Returns proxy for overloaded new that allocates a child task of *this. More...
void	recycle_as_continuation ()
	Change this to be a continuation of its former self. More...
void	recycle_as_safe_continuation ()
	Recommended to use, safe variant of recycle_as_continuation. More...
void	recycle_as_child_of (task &new_parent)
	Change this to be a child of new_parent. More...
void	recycle_to_reexecute ()
	Schedule this for reexecution after current execute() returns. More...
void	set_ref_count (int count)
	Set reference count. More...
void	increment_ref_count ()
	Atomically increment reference count. More...
int	add_ref_count (int count)
	Atomically adds to reference count and returns its new value. More...
int	decrement_ref_count ()
	Atomically decrement reference count and returns its new value. More...
void	spawn_and_wait_for_all (task &child)
	Similar to spawn followed by wait_for_all, but more efficient. More...
void __TBB_EXPORTED_METHOD	spawn_and_wait_for_all (task_list &list)
	Similar to spawn followed by wait_for_all, but more efficient. More...
void	wait_for_all ()
	Wait for reference count to become one, and set reference count to zero. More...
task *	parent () const
	task on whose behalf this task is working, or NULL if this is a root. More...
void	set_parent (task *p)
	sets parent task pointer to specified value More...
task_group_context *	context ()
	This method is deprecated and will be removed in the future. More...
task_group_context *	group ()
	Pointer to the task group descriptor. More...
bool	is_stolen_task () const
	True if task was stolen from the task pool of another thread. More...
state_type	state () const
	Current execution state. More...
int	ref_count () const
	The internal reference count. More...
bool __TBB_EXPORTED_METHOD	is_owned_by_current_thread () const
	Obsolete, and only retained for the sake of backward compatibility. Always returns true. More...
void	set_affinity (affinity_id id)
	Set affinity for this task. More...
affinity_id	affinity () const
	Current affinity of this task. More...
virtual void __TBB_EXPORTED_METHOD	note_affinity (affinity_id id)
	Invoked by scheduler to notify task that it ran on unexpected thread. More...
void __TBB_EXPORTED_METHOD	change_group (task_group_context &ctx)
	Moves this task from its current group into another one. More...
bool	cancel_group_execution ()
	Initiates cancellation of all tasks in this cancellation group and its subordinate groups. More...
bool	is_cancelled () const
	Returns true if the context has received cancellation request. More...
void	set_group_priority (priority_t p)
	Changes priority of the task group this task belongs to. More...
priority_t	group_priority () const
	Retrieves current priority of the task group this task belongs to. More...

Private Member Functions
task *	execute () __TBB_override
	Should be overridden by derived classes. More...
	~delegated_task ()

Private Attributes
internal::delegate_base &	my_delegate
concurrent_monitor &	my_monitor
task *	my_root

Additional Inherited Members
Public Types inherited from tbb::task
enum	state_type {   executing, reexecute, ready, allocated,   freed, recycle }
	Enumeration of task states that the scheduler considers. More...
typedef internal::affinity_id	affinity_id
	An id as used for specifying affinity. More...
Static Public Member Functions inherited from tbb::task
static internal::allocate_root_proxy	allocate_root ()
	Returns proxy for overloaded new that allocates a root task. More...
static internal::allocate_root_with_context_proxy	allocate_root (task_group_context &ctx)
	Returns proxy for overloaded new that allocates a root task associated with user supplied context. More...
static void	spawn_root_and_wait (task &root)
	Spawn task allocated by allocate_root, wait for it to complete, and deallocate it. More...
static void	spawn_root_and_wait (task_list &root_list)
	Spawn root tasks on list and wait for all of them to finish. More...
static void	enqueue (task &t)
	Enqueue task for starvation-resistant execution. More...
static void	enqueue (task &t, priority_t p)
	Enqueue task for starvation-resistant execution on the specified priority level. More...
static task &__TBB_EXPORTED_FUNC	self ()
	The innermost task being executed or destroyed by the current thread at the moment. More...
Protected Member Functions inherited from tbb::task
	task ()
	Default constructor. More...

Detailed Description

Definition at line 813 of file arena.cpp.

Constructor & Destructor Documentation

~delegated_task()

tbb::interface7::internal::delegated_task::~delegated_task ( )

inlineprivate

Definition at line 849 of file arena.cpp.

References __TBB_ASSERT, tbb::internal::__TBB_store_with_release(), tbb::internal::concurrent_monitor::notify(), tbb::task::prefix(), and tbb::task::ref_count().

                      {
        // potential exception was already registered. It must happen before the notification
        __TBB_ASSERT(my_root->ref_count()==2, NULL);
        __TBB_store_with_release(my_root->prefix().ref_count, 1); // must precede the wakeup
        my_monitor.notify(*this); // do not relax, it needs a fence!
    }

Here is the call graph for this function:

delegated_task()

tbb::interface7::internal::delegated_task::delegated_task ( internal::delegate_base &  d, concurrent_monitor &  s, task *  t  )

inline

Definition at line 856 of file arena.cpp.

        : my_delegate(d), my_monitor(s), my_root(t) {}

Member Function Documentation

execute()

task* tbb::interface7::internal::delegated_task::execute ( )

inlineprivatevirtual

Should be overridden by derived classes.

Implements tbb::task.

Definition at line 817 of file arena.cpp.

References __TBB_ASSERT, tbb::internal::scheduler_properties::master, tbb::internal::scheduler_state::my_arena, tbb::internal::generic_scheduler::my_dummy_task, tbb::internal::scheduler_state::my_innermost_running_task, tbb::internal::scheduler_state::my_properties, tbb::internal::generic_scheduler::outermost_level(), s, scope, and tbb::internal::scheduler_properties::type.

                                   {
        generic_scheduler& s = *(generic_scheduler*)prefix().owner;
        __TBB_ASSERT(s.outermost_level(), "expected to be enqueued and received on the outermost level");
        struct outermost_context : internal::no_copy {
            delegated_task * t;
            generic_scheduler & s;
            task * orig_dummy;
            task_group_context * orig_ctx;
            scheduler_properties orig_props;
            outermost_context(delegated_task *_t, generic_scheduler &_s)
                : t(_t), s(_s), orig_dummy(s.my_dummy_task), orig_props(s.my_properties) {
                __TBB_ASSERT(s.my_innermost_running_task == t, NULL);
#if __TBB_TASK_GROUP_CONTEXT
                orig_ctx = t->prefix().context;
                t->prefix().context = s.my_arena->my_default_ctx;
#endif
                // Mimics outermost master
                s.my_dummy_task = t;
                s.my_properties.type = scheduler_properties::master;
            }
            ~outermost_context() {
#if __TBB_TASK_GROUP_CONTEXT
                // Restore context for sake of registering potential exception
                t->prefix().context = orig_ctx;
#endif
                s.my_properties = orig_props;
                s.my_dummy_task = orig_dummy;
            }
        } scope(this, s);
        my_delegate();
        return NULL;
    }

Here is the call graph for this function:

operator()()

bool tbb::interface7::internal::delegated_task::operator() ( uintptr_t  ctx ) const

inline

Definition at line 859 of file arena.cpp.

{ return (void*)ctx == (void*)&my_delegate; }

Member Data Documentation

my_delegate

internal::delegate_base& tbb::interface7::internal::delegated_task::my_delegate

private

Definition at line 814 of file arena.cpp.

my_monitor

concurrent_monitor& tbb::interface7::internal::delegated_task::my_monitor

private

Definition at line 815 of file arena.cpp.

my_root

task* tbb::interface7::internal::delegated_task::my_root

private

Definition at line 816 of file arena.cpp.

---

The documentation for this class was generated from the following file:

• arena.cpp