//! No longer used, but retained for binary layout compatibility. Always NULL.

task* self;

task& parent;

public:

explicit allocate_additional_child_of_proxy( task& parent_ ) : self(NULL), parent(parent_) {

suppress_unused_warning( self );

}

task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;

void __TBB_EXPORTED_METHOD free( task& ) const;

__TBB_TASK_BASE_ACCESS:

friend class tbb::task;

//! Schedule task for execution when a worker becomes available.

static void spawn( task& t );

//! Spawn multiple tasks and clear list.

static void spawn( task_list& list );

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

/** Typically used in conjunction with schedule_to_reexecute to implement while loops.

static tbb::internal::allocate_additional_child_of_proxy allocate_additional_child_of( task& t ) {

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

}

//! Destroy a task.

/** Usually, calling this method is unnecessary, because a task is

static void __TBB_EXPORTED_FUNC destroy( task& victim );

public:

//! For internal use only

virtual void spawn( task& first, task*& next ) = 0;

//! For internal use only

virtual void wait_for_all( task& parent, task* child ) = 0;

//! For internal use only

virtual void spawn_root_and_wait( task& first, task*& next ) = 0;

//! Pure virtual destructor;

// Have to have it just to shut up overzealous compilation warnings

virtual ~scheduler() = 0;

//! For internal use only

virtual void enqueue( task& t, void* reserved ) = 0;

task_group_context& my_context;

public:

allocate_root_with_context_proxy ( task_group_context& ctx ) : my_context(ctx) {}

task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;

void __TBB_EXPORTED_METHOD free( task& ) const;

public:

static task& __TBB_EXPORTED_FUNC allocate( size_t size );

static void __TBB_EXPORTED_FUNC free( task& );

public:

task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;

void __TBB_EXPORTED_METHOD free( task& ) const;

public:

task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;

void __TBB_EXPORTED_METHOD free( task& ) const;

priority_normal = internal::priority_stride_v4 * 2,

priority_low = priority_normal - internal::priority_stride_v4,

priority_high = priority_normal + internal::priority_stride_v4

friend class internal::generic_scheduler;

friend class task_scheduler_init;

friend class task_arena;

#if TBB_USE_CAPTURED_EXCEPTION

typedef tbb_exception exception_container_type;

#else

typedef internal::tbb_exception_ptr exception_container_type;

#endif

enum version_traits_word_layout {

traits_offset = 16,

version_mask = 0xFFFF,

traits_mask = 0xFFFFul << traits_offset

};

enum kind_type {

isolated,

bound

};

enum traits_type {

exact_exception = 0x0001ul << traits_offset,

#if __TBB_FP_CONTEXT

fp_settings = 0x0002ul << traits_offset,

#endif

concurrent_wait = 0x0004ul << traits_offset,

#if TBB_USE_CAPTURED_EXCEPTION

default_traits = 0

#else

default_traits = exact_exception

#endif /* !TBB_USE_CAPTURED_EXCEPTION */

};

enum state {

may_have_children = 1,

// the following enumerations must be the last, new 2^x values must go above

next_state_value, low_unused_state_bit = (next_state_value-1)*2

};

union {

//! Flavor of this context: bound or isolated.

// TODO: describe asynchronous use, and whether any memory semantics are needed

__TBB_atomic kind_type my_kind;

uintptr_t _my_kind_aligner;

};

//! Pointer to the context of the parent cancellation group. NULL for isolated contexts.

task_group_context *my_parent;

//! Used to form the thread specific list of contexts without additional memory allocation.

/** A context is included into the list of the current thread when its binding to

internal::context_list_node_t my_node;

//! Used to set and maintain stack stitching point for Intel Performance Tools.

__itt_caller itt_caller;

//! Leading padding protecting accesses to frequently used members from false sharing.

/** Read accesses to the field my_cancellation_requested are on the hot path inside

char _leading_padding[internal::NFS_MaxLineSize

- 2 * sizeof(uintptr_t)- sizeof(void*) - sizeof(internal::context_list_node_t)

- sizeof(__itt_caller)

#if __TBB_FP_CONTEXT

- sizeof(internal::cpu_ctl_env_space)

#endif

];

#if __TBB_FP_CONTEXT

//! Space for platform-specific FPU settings.

/** Must only be accessed inside TBB binaries, and never directly in user

internal::cpu_ctl_env_space my_cpu_ctl_env;

#endif

//! Specifies whether cancellation was requested for this task group.

uintptr_t my_cancellation_requested;

//! Version for run-time checks and behavioral traits of the context.

/** Version occupies low 16 bits, and traits (zero or more ORed enumerators

uintptr_t my_version_and_traits;

//! Pointer to the container storing exception being propagated across this task group.

exception_container_type *my_exception;

//! Scheduler instance that registered this context in its thread specific list.

internal::generic_scheduler *my_owner;

//! Internal state (combination of state flags, currently only may_have_children).

uintptr_t my_state;

#if __TBB_TASK_PRIORITY

//! Priority level of the task group (in normalized representation)

intptr_t my_priority;

#endif /* __TBB_TASK_PRIORITY */

//! Description of algorithm for scheduler based instrumentation.

internal::string_index my_name;

//! Trailing padding protecting accesses to frequently used members from false sharing

/** \sa _leading_padding **/

char _trailing_padding[internal::NFS_MaxLineSize - 2 * sizeof(uintptr_t) - 2 * sizeof(void*)

#if __TBB_TASK_PRIORITY

- sizeof(intptr_t)

#endif /* __TBB_TASK_PRIORITY */

- sizeof(internal::string_index)

];

//! Default & binding constructor.

/** By default a bound context is created. That is this context will be bound

task_group_context ( kind_type relation_with_parent = bound,

uintptr_t t = default_traits )

: my_kind(relation_with_parent)

, my_version_and_traits(3 | t)

, my_name(internal::CUSTOM_CTX)

{

init();

}

// Custom constructor for instrumentation of tbb algorithm

task_group_context ( internal::string_index name )

: my_kind(bound)

, my_version_and_traits(3 | default_traits)

, my_name(name)

{

init();

}

// Do not introduce standalone unbind method since it will break state propagation assumptions

__TBB_EXPORTED_METHOD ~task_group_context ();

//! Forcefully reinitializes the context after the task tree it was associated with is completed.

/** Because the method assumes that all the tasks that used to be associated with

void __TBB_EXPORTED_METHOD reset ();

//! Initiates cancellation of all tasks in this cancellation group and its subordinate groups.

/** \return false if cancellation has already been requested, true otherwise.

bool __TBB_EXPORTED_METHOD cancel_group_execution ();

//! Returns true if the context received cancellation request.

bool __TBB_EXPORTED_METHOD is_group_execution_cancelled () const;

//! Records the pending exception, and cancels the task group.

/** May be called only from inside a catch-block. If the context is already

void __TBB_EXPORTED_METHOD register_pending_exception ();

#if __TBB_FP_CONTEXT

//! Captures the current FPU control settings to the context.

/** Because the method assumes that all the tasks that used to be associated with

void __TBB_EXPORTED_METHOD capture_fp_settings ();

#endif

#if __TBB_TASK_PRIORITY

//! Changes priority of the task group

void set_priority ( priority_t );

//! Retrieves current priority of the current task group

priority_t priority () const;

#endif /* __TBB_TASK_PRIORITY */

//! Returns the context's trait

uintptr_t traits() const { return my_version_and_traits & traits_mask; }

//! Out-of-line part of the constructor.

/** Singled out to ensure backward binary compatibility of the future versions. **/

void __TBB_EXPORTED_METHOD init ();

friend class task;

friend class internal::allocate_root_with_context_proxy;

static const kind_type binding_required = bound;

static const kind_type binding_completed = kind_type(bound+1);

static const kind_type detached = kind_type(binding_completed+1);

static const kind_type dying = kind_type(detached+1);

//! Propagates any state change detected to *this, and as an optimisation possibly also upward along the heritage line.

template <typename T>

void propagate_task_group_state ( T task_group_context::*mptr_state, task_group_context& src, T new_state );

//! Registers this context with the local scheduler and binds it to its parent context

void bind_to ( internal::generic_scheduler *local_sched );

//! Registers this context with the local scheduler

void register_with ( internal::generic_scheduler *local_sched );

#if __TBB_FP_CONTEXT

//! Copies FPU control setting from another context

// TODO: Consider adding #else stub in order to omit #if sections in other code

void copy_fp_settings( const task_group_context &src );

#endif /* __TBB_FP_CONTEXT */

//! Set reference count

void __TBB_EXPORTED_METHOD internal_set_ref_count( int count );

//! Decrement reference count and return its new value.

internal::reference_count __TBB_EXPORTED_METHOD internal_decrement_ref_count();

//! Default constructor.

task() {prefix().extra_state=1;}

//! Destructor.

virtual ~task() {}

//! Should be overridden by derived classes.

virtual task* execute() = 0;

//! Enumeration of task states that the scheduler considers.

enum state_type {

//! task is running, and will be destroyed after method execute() completes.

executing,

//! task to be rescheduled.

reexecute,

//! task is in ready pool, or is going to be put there, or was just taken off.

ready,

//! task object is freshly allocated or recycled.

allocated,

//! task object is on free list, or is going to be put there, or was just taken off.

freed,

//! task to be recycled as continuation

recycle

#if __TBB_RECYCLE_TO_ENQUEUE

//! task to be scheduled for starvation-resistant execution

,to_enqueue

#endif

};

//------------------------------------------------------------------------

// Allocating tasks

//------------------------------------------------------------------------

//! Returns proxy for overloaded new that allocates a root task.

static internal::allocate_root_proxy allocate_root() {

return internal::allocate_root_proxy();

}

#if __TBB_TASK_GROUP_CONTEXT

//! Returns proxy for overloaded new that allocates a root task associated with user supplied context.

static internal::allocate_root_with_context_proxy allocate_root( task_group_context& ctx ) {

return internal::allocate_root_with_context_proxy(ctx);

}

#endif /* __TBB_TASK_GROUP_CONTEXT */

//! Returns proxy for overloaded new that allocates a continuation task of *this.

/** The continuation's parent becomes the parent of *this. */

internal::allocate_continuation_proxy& allocate_continuation() {

return *reinterpret_cast<internal::allocate_continuation_proxy*>(this);

}

//! Returns proxy for overloaded new that allocates a child task of *this.

internal::allocate_child_proxy& allocate_child() {

return *reinterpret_cast<internal::allocate_child_proxy*>(this);

}

//! Define recommended static form via import from base class.

using task_base::allocate_additional_child_of;

#if __TBB_DEPRECATED_TASK_INTERFACE

//! Destroy a task.

/** Usually, calling this method is unnecessary, because a task is

void __TBB_EXPORTED_METHOD destroy( task& t );

#else /* !__TBB_DEPRECATED_TASK_INTERFACE */

//! Define recommended static form via import from base class.

using task_base::destroy;

#endif /* !__TBB_DEPRECATED_TASK_INTERFACE */

//------------------------------------------------------------------------

// Recycling of tasks

//------------------------------------------------------------------------

//! Change this to be a continuation of its former self.

/** The caller must guarantee that the task's refcount does not become zero until

void recycle_as_continuation() {

__TBB_ASSERT( prefix().state==executing, "execute not running?" );

prefix().state = allocated;

}

//! Recommended to use, safe variant of recycle_as_continuation

/** For safety, it requires additional increment of ref_count.

void recycle_as_safe_continuation() {

__TBB_ASSERT( prefix().state==executing, "execute not running?" );

prefix().state = recycle;

}

//! Change this to be a child of new_parent.

void recycle_as_child_of( task& new_parent ) {

internal::task_prefix& p = prefix();

__TBB_ASSERT( prefix().state==executing||prefix().state==allocated, "execute not running, or already recycled" );

__TBB_ASSERT( prefix().ref_count==0, "no child tasks allowed when recycled as a child" );

__TBB_ASSERT( p.parent==NULL, "parent must be null" );

__TBB_ASSERT( new_parent.prefix().state<=recycle, "corrupt parent's state" );

__TBB_ASSERT( new_parent.prefix().state!=freed, "parent already freed" );

p.state = allocated;

p.parent = &new_parent;

#if __TBB_TASK_GROUP_CONTEXT

p.context = new_parent.prefix().context;

#endif /* __TBB_TASK_GROUP_CONTEXT */

}

//! Schedule this for reexecution after current execute() returns.

/** Made obsolete by recycle_as_safe_continuation; may become deprecated. */

void recycle_to_reexecute() {

__TBB_ASSERT( prefix().state==executing, "execute not running, or already recycled" );

__TBB_ASSERT( prefix().ref_count==0, "no child tasks allowed when recycled for reexecution" );

prefix().state = reexecute;

}

#if __TBB_RECYCLE_TO_ENQUEUE

//! Schedule this to enqueue after descendant tasks complete.

/** Save enqueue/spawn difference, it has the semantics of recycle_as_safe_continuation. */

void recycle_to_enqueue() {

__TBB_ASSERT( prefix().state==executing, "execute not running, or already recycled" );

prefix().state = to_enqueue;

}

#endif /* __TBB_RECYCLE_TO_ENQUEUE */

//------------------------------------------------------------------------

// Spawning and blocking

//------------------------------------------------------------------------

//! Set reference count

void set_ref_count( int count ) {

#if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT

internal_set_ref_count(count);

#else

prefix().ref_count = count;

#endif /* TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT */

}

//! Atomically increment reference count.

/** Has acquire semantics */

void increment_ref_count() {

__TBB_FetchAndIncrementWacquire( &prefix().ref_count );

}

//! Atomically adds to reference count and returns its new value.

/** Has release-acquire semantics */

int add_ref_count( int count ) {

internal::call_itt_notify( internal::releasing, &prefix().ref_count );

internal::reference_count k = count+__TBB_FetchAndAddW( &prefix().ref_count, count );

__TBB_ASSERT( k>=0, "task's reference count underflowed" );

if( k==0 )

internal::call_itt_notify( internal::acquired, &prefix().ref_count );

return int(k);

}

//! Atomically decrement reference count and returns its new value.

/** Has release semantics. */

int decrement_ref_count() {

#if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT

return int(internal_decrement_ref_count());

#else

return int(__TBB_FetchAndDecrementWrelease( &prefix().ref_count ))-1;

#endif /* TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT */

}

//! Define recommended static forms via import from base class.

using task_base::spawn;

//! Similar to spawn followed by wait_for_all, but more efficient.

void spawn_and_wait_for_all( task& child ) {

prefix().owner->wait_for_all( *this, &child );

}

//! Similar to spawn followed by wait_for_all, but more efficient.

void __TBB_EXPORTED_METHOD spawn_and_wait_for_all( task_list& list );

//! Spawn task allocated by allocate_root, wait for it to complete, and deallocate it.

static void spawn_root_and_wait( task& root ) {

root.prefix().owner->spawn_root_and_wait( root, root.prefix().next );

}

//! Spawn root tasks on list and wait for all of them to finish.

/** If there are more tasks than worker threads, the tasks are spawned in

static void spawn_root_and_wait( task_list& root_list );

//! Wait for reference count to become one, and set reference count to zero.

/** Works on tasks while waiting. */

void wait_for_all() {

prefix().owner->wait_for_all( *this, NULL );

}

//! Enqueue task for starvation-resistant execution.

#if __TBB_TASK_PRIORITY

/** The task will be enqueued on the normal priority level disregarding the

#endif /* __TBB_TASK_PRIORITY */

static void enqueue( task& t ) {

t.prefix().owner->enqueue( t, NULL );

}

#if __TBB_TASK_PRIORITY

//! Enqueue task for starvation-resistant execution on the specified priority level.

static void enqueue( task& t, priority_t p ) {

#if __TBB_PREVIEW_CRITICAL_TASKS

__TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high

|| p == internal::priority_critical, "Invalid priority level value");

#else

__TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value");

#endif

t.prefix().owner->enqueue( t, (void*)p );

}

#endif /* __TBB_TASK_PRIORITY */

//! Enqueue task in task_arena

//! The implementation is in task_arena.h

inline static void enqueue( task& t, task_arena& arena

#if __TBB_TASK_PRIORITY

, priority_t p = priority_t(0)

#endif

);

//! The innermost task being executed or destroyed by the current thread at the moment.

static task& __TBB_EXPORTED_FUNC self();

//! task on whose behalf this task is working, or NULL if this is a root.

task* parent() const {return prefix().parent;}

//! sets parent task pointer to specified value

void set_parent(task* p) {

#if __TBB_TASK_GROUP_CONTEXT

__TBB_ASSERT(!p || prefix().context == p->prefix().context, "The tasks must be in the same context");

#endif

prefix().parent = p;

}

#if __TBB_TASK_GROUP_CONTEXT

//! This method is deprecated and will be removed in the future.

/** Use method group() instead. **/

task_group_context* context() {return prefix().context;}

//! Pointer to the task group descriptor.

task_group_context* group () { return prefix().context; }

#endif /* __TBB_TASK_GROUP_CONTEXT */

//! True if task was stolen from the task pool of another thread.

bool is_stolen_task() const {

return (prefix().extra_state & 0x80)!=0;

}

//------------------------------------------------------------------------

// Debugging

//------------------------------------------------------------------------

//! Current execution state

state_type state() const {return state_type(prefix().state);}

//! The internal reference count.

int ref_count() const {

#if TBB_USE_ASSERT

internal::reference_count ref_count_ = prefix().ref_count;

__TBB_ASSERT( ref_count_==int(ref_count_), "integer overflow error");

#endif

return int(prefix().ref_count);

}

//! Obsolete, and only retained for the sake of backward compatibility. Always returns true.

bool __TBB_EXPORTED_METHOD is_owned_by_current_thread() const;

//------------------------------------------------------------------------

// Affinity

//------------------------------------------------------------------------

//! An id as used for specifying affinity.

/** Guaranteed to be integral type. Value of 0 means no affinity. */

typedef internal::affinity_id affinity_id;

//! Set affinity for this task.

void set_affinity( affinity_id id ) {prefix().affinity = id;}

//! Current affinity of this task

affinity_id affinity() const {return prefix().affinity;}

//! Invoked by scheduler to notify task that it ran on unexpected thread.

/** Invoked before method execute() runs, if task is stolen, or task has

virtual void __TBB_EXPORTED_METHOD note_affinity( affinity_id id );

#if __TBB_TASK_GROUP_CONTEXT

//! Moves this task from its current group into another one.

/** Argument ctx specifies the new group.

void __TBB_EXPORTED_METHOD change_group ( task_group_context& ctx );

//! Initiates cancellation of all tasks in this cancellation group and its subordinate groups.

/** \return false if cancellation has already been requested, true otherwise. **/

bool cancel_group_execution () { return prefix().context->cancel_group_execution(); }

//! Returns true if the context has received cancellation request.

bool is_cancelled () const { return prefix().context->is_group_execution_cancelled(); }

#else

bool is_cancelled () const { return false; }

#endif /* __TBB_TASK_GROUP_CONTEXT */

#if __TBB_TASK_PRIORITY

//! Changes priority of the task group this task belongs to.

void set_group_priority ( priority_t p ) { prefix().context->set_priority(p); }

//! Retrieves current priority of the task group this task belongs to.

priority_t group_priority () const { return prefix().context->priority(); }

#endif /* __TBB_TASK_PRIORITY */

friend class interface5::internal::task_base;

friend class task_list;

friend class internal::scheduler;

friend class internal::allocate_root_proxy;

#if __TBB_TASK_GROUP_CONTEXT

friend class internal::allocate_root_with_context_proxy;

#endif /* __TBB_TASK_GROUP_CONTEXT */

friend class internal::allocate_continuation_proxy;

friend class internal::allocate_child_proxy;

friend class internal::allocate_additional_child_of_proxy;

//! Get reference to corresponding task_prefix.

/** Version tag prevents loader on Linux from using the wrong symbol in debug builds. **/

internal::task_prefix& prefix( internal::version_tag* = NULL ) const {

return reinterpret_cast<internal::task_prefix*>(const_cast<task*>(this))[-1];

}

#if __TBB_PREVIEW_CRITICAL_TASKS

friend void internal::make_critical( task& );

friend bool internal::is_critical( task& );

#endif

task* execute() __TBB_override {

return NULL;

}

#if __TBB_ALLOW_MUTABLE_FUNCTORS

F my_func;

#else

const F my_func;

#endif

task* execute() __TBB_override {

my_func();

return NULL;

}

public:

function_task( const F& f ) : my_func(f) {}

#if __TBB_CPP11_RVALUE_REF_PRESENT

function_task( F&& f ) : my_func( std::move(f) ) {}

#endif

task* first;

task** next_ptr;

friend class task;

friend class interface5::internal::task_base;