tbb::internal::stage_task Class Reference

Inheritance diagram for tbb::internal::stage_task:

Collaboration diagram for tbb::internal::stage_task:

Public Member Functions
	stage_task (pipeline &pipeline)
	Construct stage_task for first stage in a pipeline. More...
	stage_task (pipeline &pipeline, filter *filter_, const task_info &info)
	Construct stage_task for a subsequent stage in a pipeline. More...
void	reset ()
	Roughly equivalent to the constructor of input stage task. More...
task *	execute () __TBB_override
	The virtual task execution method. More...
void	spawn_stage_task (const task_info &info)
	Creates and spawns stage_task from task_info. More...
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...
bool	is_enqueued_task () const
	True if the task was enqueued. 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...
__TBB_DEPRECATED void	set_group_priority (priority_t p)
	Changes priority of the task group this task belongs to. More...
__TBB_DEPRECATED priority_t	group_priority () const
	Retrieves current priority of the task group this task belongs to. More...
Public Member Functions inherited from tbb::internal::task_info
void	reset ()
	Set to initial state (no object, no token) More...

Private Attributes
pipeline &	my_pipeline
filter *	my_filter
bool	my_at_start
	True if this task has not yet read the input. More...

Friends
class	tbb::pipeline

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 void	enqueue (task &t, task_arena &arena, priority_t p=priority_t(0))
	Enqueue task in task_arena. More...
static task &__TBB_EXPORTED_FUNC	self ()
	The innermost task being executed or destroyed by the current thread at the moment. More...
Public Attributes inherited from tbb::internal::task_info
void *	my_object
Token	my_token
	Invalid unless a task went through an ordered stage. More...
bool	my_token_ready
	False until my_token is set. More...
bool	is_valid
	True if my_object is valid. More...
Protected Member Functions inherited from tbb::task
	task ()
	Default constructor. More...

Detailed Description

Definition at line 249 of file pipeline.cpp.

Constructor & Destructor Documentation

stage_task() [1/2]

tbb::internal::stage_task::stage_task ( pipeline &  pipeline )

inline

Construct stage_task for first stage in a pipeline.

Such a stage has not read any input yet.

Definition at line 260 of file pipeline.cpp.

                                     :
        my_pipeline(pipeline),
        my_filter(pipeline.filter_list),
        my_at_start(true)
    {
        task_info::reset();
    }

References tbb::internal::task_info::reset().

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

stage_task() [2/2]

tbb::internal::stage_task::stage_task ( pipeline &  pipeline, filter *  filter_, const task_info &  info  )

inline

Construct stage_task for a subsequent stage in a pipeline.

Definition at line 268 of file pipeline.cpp.

                                                                             :
        task_info(info),
        my_pipeline(pipeline),
        my_filter(filter_),
        my_at_start(false)
    {}

Member Function Documentation

execute()

task * tbb::internal::stage_task::execute ( )

virtual

The virtual task execution method.

Implements tbb::task.

Definition at line 301 of file pipeline.cpp.

                          {
    __TBB_ASSERT( !my_at_start || !my_object, NULL );
    __TBB_ASSERT( !my_filter->is_bound(), NULL );
    if( my_at_start ) {
        if( my_filter->is_serial() ) {
            my_object = (*my_filter)(my_object);
            if( my_object || ( my_filter->object_may_be_null() && !my_pipeline.end_of_input) )
            {
                if( my_filter->is_ordered() ) {
                    my_token = my_pipeline.token_counter++; // ideally, with relaxed semantics
                    my_token_ready = true;
                } else if( (my_filter->my_filter_mode & my_filter->version_mask) >= __TBB_PIPELINE_VERSION(5) ) {
                    if( my_pipeline.has_thread_bound_filters )
                        my_pipeline.token_counter++; // ideally, with relaxed semantics
                }
                if( !my_filter->next_filter_in_pipeline ) { // we're only filter in pipeline
                    reset();
                    goto process_another_stage;
                } else {
                    ITT_NOTIFY( sync_releasing, &my_pipeline.input_tokens );
                    if( --my_pipeline.input_tokens>0 )
                        spawn( *new( allocate_additional_child_of(*parent()) ) stage_task( my_pipeline ) );
                }
            } else {
                my_pipeline.end_of_input = true;
                return NULL;
            }
        } else /*not is_serial*/ {
            if( my_pipeline.end_of_input )
                return NULL;
            if( (my_filter->my_filter_mode & my_filter->version_mask) >= __TBB_PIPELINE_VERSION(5) ) {
                if( my_pipeline.has_thread_bound_filters )
                    my_pipeline.token_counter++;
            }
            ITT_NOTIFY( sync_releasing, &my_pipeline.input_tokens );
            if( --my_pipeline.input_tokens>0 )
                spawn( *new( allocate_additional_child_of(*parent()) ) stage_task( my_pipeline ) );
            my_object = (*my_filter)(my_object);
            if( !my_object && (!my_filter->object_may_be_null() || my_filter->my_input_buffer->my_tls_end_of_input()) )
            {
                my_pipeline.end_of_input = true;
                if( (my_filter->my_filter_mode & my_filter->version_mask) >= __TBB_PIPELINE_VERSION(5) ) {
                    if( my_pipeline.has_thread_bound_filters )
                        my_pipeline.token_counter--;  // fix token_counter
                }
                return NULL;
            }
        }
        my_at_start = false;
    } else {
        my_object = (*my_filter)(my_object);
        if( my_filter->is_serial() )
            my_filter->my_input_buffer->note_done(my_token, *this);
    }
    my_filter = my_filter->next_filter_in_pipeline;
    if( my_filter ) {
        // There is another filter to execute.
        if( my_filter->is_serial() ) {
            // The next filter must execute tokens in order
            if( my_filter->my_input_buffer->put_token(*this) ){
                // Can't proceed with the same item
                if( my_filter->is_bound() ) {
                    // Find the next non-thread-bound filter
                    do {
                        my_filter = my_filter->next_filter_in_pipeline;
                    } while( my_filter && my_filter->is_bound() );
                    // Check if there is an item ready to process
                    if( my_filter && my_filter->my_input_buffer->return_item(*this, !my_filter->is_serial()))
                        goto process_another_stage;
                }
                my_filter = NULL; // To prevent deleting my_object twice if exception occurs
                return NULL;
            }
        }
    } else {
        // Reached end of the pipe.
        size_t ntokens_avail = ++my_pipeline.input_tokens;
        if(my_pipeline.filter_list->is_bound() ) {
            if(ntokens_avail == 1) {
                my_pipeline.filter_list->my_input_buffer->sema_V();
            }
            return NULL;
        }
        if( ntokens_avail>1  // Only recycle if there is one available token
                || my_pipeline.end_of_input ) {
            return NULL; // No need to recycle for new input
        }
        ITT_NOTIFY( sync_acquired, &my_pipeline.input_tokens );
        // Recycle as an input stage task.
        reset();
    }
process_another_stage:
    /* A semi-hackish way to reexecute the same task object immediately without spawning.
       recycle_as_continuation marks the task for future execution,
       and then 'this' pointer is returned to bypass spawning. */
    recycle_as_continuation();
    return this;
}

References __TBB_ASSERT, __TBB_PIPELINE_VERSION, tbb::filter::is_bound(), tbb::filter::is_ordered(), tbb::filter::is_serial(), ITT_NOTIFY, my_at_start, my_filter, tbb::filter::my_filter_mode, tbb::filter::my_input_buffer, tbb::internal::task_info::my_object, my_pipeline, tbb::internal::input_buffer::my_tls_end_of_input(), tbb::internal::task_info::my_token, tbb::internal::task_info::my_token_ready, tbb::filter::next_filter_in_pipeline, tbb::internal::input_buffer::note_done(), tbb::filter::object_may_be_null(), tbb::task::parent(), tbb::internal::input_buffer::put_token(), tbb::task::recycle_as_continuation(), reset(), tbb::internal::input_buffer::return_item(), stage_task(), sync_releasing, and tbb::filter::version_mask.

Here is the call graph for this function:

reset()

void tbb::internal::stage_task::reset ( )

inline

Roughly equivalent to the constructor of input stage task.

Definition at line 275 of file pipeline.cpp.

                 {
        task_info::reset();
        my_filter = my_pipeline.filter_list;
        my_at_start = true;
    }

References my_at_start, my_filter, my_pipeline, and tbb::internal::task_info::reset().

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

spawn_stage_task()

void tbb::internal::stage_task::spawn_stage_task ( const task_info &  info )

inline

Creates and spawns stage_task from task_info.

Definition at line 293 of file pipeline.cpp.

    {
        stage_task* clone = new (allocate_additional_child_of(*parent()))
                                stage_task( my_pipeline, my_filter, info );
        spawn(*clone);
    }

Friends And Related Function Documentation

tbb::pipeline

friend class tbb::pipeline

friend

Definition at line 251 of file pipeline.cpp.

Member Data Documentation

my_at_start

bool tbb::internal::stage_task::my_at_start

private

True if this task has not yet read the input.

Definition at line 255 of file pipeline.cpp.

Referenced by execute(), and reset().

my_filter

filter* tbb::internal::stage_task::my_filter

private

Definition at line 253 of file pipeline.cpp.

Referenced by execute(), and reset().

my_pipeline

pipeline& tbb::internal::stage_task::my_pipeline

private

Definition at line 252 of file pipeline.cpp.

Referenced by execute(), and reset().

---

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

• pipeline.cpp