tbb::interface5::internal::task_base Class Reference

Base class for methods that became static in TBB 3.0. More...

#include <task.h>

Inheritance diagram for tbb::interface5::internal::task_base:

Collaboration diagram for tbb::interface5::internal::task_base:

Static Private Member Functions
static void	spawn (task &t)
	Schedule task for execution when a worker becomes available. More...
static void	spawn (task_list &list)
	Spawn multiple tasks and clear list. More...
static tbb::internal::allocate_additional_child_of_proxy	allocate_additional_child_of (task &t)
	Like allocate_child, except that task's parent becomes "t", not this. More...
static void __TBB_EXPORTED_FUNC	destroy (task &victim)
	Destroy a task. More...

Private Attributes
__TBB_TASK_BASE_ACCESS	__pad0__: friend class tbb::task

Additional Inherited Members
Private Member Functions inherited from tbb::internal::no_copy
	no_copy (const no_copy &)=delete
	no_copy ()=default

Detailed Description

Base class for methods that became static in TBB 3.0.

TBB's evolution caused the "this" argument for several methods to become obsolete. However, for backwards binary compatibility, the new methods need distinct names, otherwise the One Definition Rule would be broken. Hence the new methods are defined in this private base class, and then exposed in class task via using declarations.

Definition at line 80 of file task.h.

Member Function Documentation

allocate_additional_child_of()

static tbb::internal::allocate_additional_child_of_proxy tbb::interface5::internal::task_base::allocate_additional_child_of ( task &  t )

inlinestaticprivate

Like allocate_child, except that task's parent becomes "t", not this.

Typically used in conjunction with schedule_to_reexecute to implement while loops. Atomically increments the reference count of t.parent()

Definition at line 93 of file task.h.

                                                                                                         {
                return tbb::internal::allocate_additional_child_of_proxy(t);
            }

destroy()

void tbb::interface5::internal::task_base::destroy ( task &  victim )

staticprivate

Destroy a task.

Usually, calling this method is unnecessary, because a task is implicitly deleted after its execute() method runs. However, sometimes a task needs to be explicitly deallocated, such as when a root task is used as the parent in spawn_and_wait_for_all.

Definition at line 212 of file task.cpp.

                                                        {
    // 1 may be a guard reference for wait_for_all, which was not reset because
    // of concurrent_wait mode or because prepared root task was not actually used
    // for spawning tasks (as in structured_task_group).
    __TBB_ASSERT( (intptr_t)victim.prefix().ref_count <= 1, "Task being destroyed must not have children" );
    __TBB_ASSERT( victim.state()==task::allocated, "illegal state for victim task" );
    task* parent = victim.parent();
    victim.~task();
    if( parent ) {
        __TBB_ASSERT( parent->state()!=task::freed && parent->state()!=task::ready,
                      "attempt to destroy child of running or corrupted parent?" );
        // 'reexecute' and 'executing' are also signs of a race condition, since most tasks
        // set their ref_count upon entry but "es_ref_count_active" should detect this
        parent->internal_decrement_ref_count();
        // Even if the last reference to *parent is removed, it should not be spawned (documented behavior).
    }
    governor::local_scheduler_weak()->free_task<no_cache>( victim );
}

References __TBB_ASSERT, tbb::task::allocated, tbb::internal::generic_scheduler::free_task(), tbb::task::freed, tbb::internal::governor::local_scheduler_weak(), tbb::internal::no_cache, parent, tbb::task::parent(), tbb::task::prefix(), tbb::task::ready, tbb::internal::task_prefix::ref_count, tbb::task::state(), and tbb::task::~task().

Here is the call graph for this function:

spawn() [1/2]

void tbb::interface5::internal::task_base::spawn ( task &  t )

inlinestaticprivate

Schedule task for execution when a worker becomes available.

Definition at line 1124 of file task.h.

                                                        {
    t.prefix().owner->spawn( t, t.prefix().next );
}

References tbb::internal::task_prefix::next, tbb::internal::task_prefix::owner, tbb::task::prefix(), and tbb::internal::scheduler::spawn().

Here is the call graph for this function:

spawn() [2/2]

void tbb::interface5::internal::task_base::spawn ( task_list &  list )

inlinestaticprivate

Spawn multiple tasks and clear list.

Definition at line 1128 of file task.h.

                                                                {
    if( task* t = list.first ) {
        t->prefix().owner->spawn( *t, *list.next_ptr );
        list.clear();
    }
}

References tbb::task_list::clear(), tbb::task_list::first, and tbb::task_list::next_ptr.

Here is the call graph for this function:

Member Data Documentation

__pad0__

__TBB_TASK_BASE_ACCESS tbb::interface5::internal::task_base::__pad0__

private

Definition at line 82 of file task.h.

---

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

• task.h
• task.cpp