tbb::internal::task_group_base Class Reference

#include <task_group.h>

Inheritance diagram for tbb::internal::task_group_base:

Collaboration diagram for tbb::internal::task_group_base:

Classes
class	ref_count_guard

Public Member Functions
	task_group_base (uintptr_t traits=0)
	~task_group_base () __TBB_NOEXCEPT(false)
template<typename F >
void	run (task_handle< F > &h)
task_group_status	wait ()
bool	is_canceling ()
void	cancel ()

Protected Member Functions
template<typename F >
task_group_status	internal_run_and_wait (F &f)
template<typename Task , typename F >
task *	prepare_task (__TBB_FORWARDING_REF(F) f)

Protected Attributes
empty_task *	my_root
task_group_context	my_context

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

Detailed Description

Definition at line 92 of file task_group.h.

Constructor & Destructor Documentation

task_group_base()

tbb::internal::task_group_base::task_group_base ( uintptr_t  traits = 0 )

inline

Definition at line 128 of file task_group.h.

        : my_context(task_group_context::bound, task_group_context::default_traits | traits)
    {
        my_root = new( task::allocate_root(my_context) ) empty_task;
        my_root->set_ref_count(1);
    }

References tbb::task::allocate_root(), my_context, my_root, and tbb::task::set_ref_count().

Here is the call graph for this function:

~task_group_base()

tbb::internal::task_group_base::~task_group_base ( )

inline

Definition at line 135 of file task_group.h.

                                             {
        if( my_root->ref_count() > 1 ) {
#if __TBB_CPP17_UNCAUGHT_EXCEPTIONS_PRESENT
            bool stack_unwinding_in_progress = std::uncaught_exceptions() > 0;
#else
            bool stack_unwinding_in_progress = std::uncaught_exception();
#endif
            // Always attempt to do proper cleanup to avoid inevitable memory corruption
            // in case of missing wait (for the sake of better testability & debuggability)
            if ( !is_canceling() )
                cancel();
            __TBB_TRY {
                my_root->wait_for_all();
            } __TBB_CATCH (...) {
                task::destroy(*my_root);
                __TBB_RETHROW();
            }
            task::destroy(*my_root);
            if ( !stack_unwinding_in_progress )
                internal::throw_exception( internal::eid_missing_wait );
        }
        else {
            task::destroy(*my_root);
        }
    }

References __TBB_CATCH, __TBB_RETHROW, __TBB_TRY, cancel(), tbb::internal::eid_missing_wait, is_canceling(), my_root, tbb::task::ref_count(), tbb::internal::throw_exception(), and tbb::task::wait_for_all().

Here is the call graph for this function:

Member Function Documentation

cancel()

void tbb::internal::task_group_base::cancel ( )

inline

Definition at line 185 of file task_group.h.

                  {
        my_context.cancel_group_execution();
    }

References tbb::task_group_context::cancel_group_execution(), and my_context.

Referenced by ~task_group_base().

Here is the call graph for this function:

Here is the caller graph for this function:

internal_run_and_wait()

template<typename F >

task_group_status tbb::internal::task_group_base::internal_run_and_wait ( F &  f )

inlineprotected

Definition at line 108 of file task_group.h.

                                                    {
        __TBB_TRY {
            if ( !my_context.is_group_execution_cancelled() ) {
                // We need to increase the reference count of the root task to notify waiters that
                // this task group has some work in progress.
                ref_count_guard guard(*my_root);
                f();
            }
        } __TBB_CATCH( ... ) {
            my_context.register_pending_exception();
        }
        return wait();
    }

References __TBB_CATCH, __TBB_TRY, tbb::task_group_context::is_group_execution_cancelled(), my_context, my_root, tbb::task_group_context::register_pending_exception(), and wait().

Here is the call graph for this function:

is_canceling()

bool tbb::internal::task_group_base::is_canceling ( )

inline

Definition at line 181 of file task_group.h.

                        {
        return my_context.is_group_execution_cancelled();
    }

References tbb::task_group_context::is_group_execution_cancelled(), and my_context.

Referenced by ~task_group_base().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_task()

template<typename Task , typename F >

task* tbb::internal::task_group_base::prepare_task ( __TBB_FORWARDING_REF(F)  f )

inlineprotected

Definition at line 123 of file task_group.h.

                                                    {
        return new( task::allocate_additional_child_of(*my_root) ) Task( internal::forward<F>(f) );
    }

References my_root.

Referenced by run(), and tbb::task_group::run().

Here is the caller graph for this function:

run()

template<typename F >

void tbb::internal::task_group_base::run ( task_handle< F > &  h )

inline

Definition at line 162 of file task_group.h.

                                  {
        task::spawn( *prepare_task< internal::task_handle_task<F> >(h) );
    }

References h, and prepare_task().

Here is the call graph for this function:

wait()

task_group_status tbb::internal::task_group_base::wait ( )

inline

Definition at line 166 of file task_group.h.

                             {
        __TBB_TRY {
            my_root->wait_for_all();
        } __TBB_CATCH( ... ) {
            my_context.reset();
            __TBB_RETHROW();
        }
        if ( my_context.is_group_execution_cancelled() ) {
            // TODO: the reset method is not thread-safe. Ensure the correct behavior.
            my_context.reset();
            return canceled;
        }
        return complete;
    }

References __TBB_CATCH, __TBB_RETHROW, __TBB_TRY, tbb::canceled, tbb::complete, tbb::task_group_context::is_group_execution_cancelled(), my_context, my_root, tbb::task_group_context::reset(), and tbb::task::wait_for_all().

Referenced by internal_run_and_wait(), and tbb::structured_task_group::wait().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

my_context

task_group_context tbb::internal::task_group_base::my_context

protected

Definition at line 105 of file task_group.h.

Referenced by cancel(), internal_run_and_wait(), is_canceling(), task_group_base(), and wait().

my_root

empty_task* tbb::internal::task_group_base::my_root

protected

Definition at line 104 of file task_group.h.

Referenced by internal_run_and_wait(), prepare_task(), task_group_base(), wait(), and ~task_group_base().

---

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

• task_group.h