tbb::internal::tbb_thread_v3 Class Reference

Versioned thread class. More...

#include <tbb_thread.h>

Collaboration diagram for tbb::internal::tbb_thread_v3:

Classes
class	id

Public Types
typedef pthread_t	native_handle_type

Public Member Functions
	tbb_thread_v3 () __TBB_NOEXCEPT(true)
	Constructs a thread object that does not represent a thread of execution. More...
template<class F >
	tbb_thread_v3 (F f)
	Constructs an object and executes f() in a new thread. More...
template<class F , class X >
	tbb_thread_v3 (F f, X x)
	Constructs an object and executes f(x) in a new thread. More...
template<class F , class X , class Y >
	tbb_thread_v3 (F f, X x, Y y)
	Constructs an object and executes f(x,y) in a new thread. More...
	tbb_thread_v3 (tbb_thread_v3 &&x) __TBB_NOEXCEPT(true)
tbb_thread_v3 &	operator= (tbb_thread_v3 &&x) __TBB_NOEXCEPT(true)
void	swap (tbb_thread_v3 &t) __TBB_NOEXCEPT(true)
bool	joinable () const __TBB_NOEXCEPT(true)
void __TBB_EXPORTED_METHOD	join ()
	The completion of the thread represented by *this happens before join() returns. More...
void __TBB_EXPORTED_METHOD	detach ()
	When detach() returns, *this no longer represents the possibly continuing thread of execution. More...
	~tbb_thread_v3 ()
id	get_id () const __TBB_NOEXCEPT(true)
native_handle_type	native_handle ()

Static Public Member Functions
static unsigned __TBB_EXPORTED_FUNC	hardware_concurrency () __TBB_NOEXCEPT(true)
	The number of hardware thread contexts. More...

Private Member Functions
	tbb_thread_v3 (const tbb_thread_v3 &)
tbb_thread_v3 &	operator= (const tbb_thread_v3 &x)
void	internal_wipe () __TBB_NOEXCEPT(true)
void	internal_move (tbb_thread_v3 &x) __TBB_NOEXCEPT(true)
void __TBB_EXPORTED_METHOD	internal_start (__TBB_NATIVE_THREAD_ROUTINE_PTR(start_routine), void *closure)

Private Attributes
native_handle_type	my_handle

Friends
void __TBB_EXPORTED_FUNC	move_v3 (tbb_thread_v3 &t1, tbb_thread_v3 &t2)
void	tbb::swap (tbb_thread_v3 &t1, tbb_thread_v3 &t2) __TBB_NOEXCEPT(true)

Detailed Description

Versioned thread class.

Definition at line 112 of file tbb_thread.h.

Member Typedef Documentation

native_handle_type

typedef pthread_t tbb::internal::tbb_thread_v3::native_handle_type

Definition at line 124 of file tbb_thread.h.

Constructor & Destructor Documentation

tbb_thread_v3() [1/6]

tbb::internal::tbb_thread_v3::tbb_thread_v3 ( const tbb_thread_v3 &  )

private

tbb_thread_v3() [2/6]

tbb::internal::tbb_thread_v3::tbb_thread_v3 ( )

inline

Constructs a thread object that does not represent a thread of execution.

Definition at line 129 of file tbb_thread.h.

                                             : my_handle(0)
#if _WIN32||_WIN64
            , my_thread_id(0)
#endif // _WIN32||_WIN64
        {}

tbb_thread_v3() [3/6]

template<class F >

tbb::internal::tbb_thread_v3::tbb_thread_v3 ( F  f )

inlineexplicit

Constructs an object and executes f() in a new thread.

Definition at line 136 of file tbb_thread.h.

                                                       {
            typedef internal::thread_closure_0<F> closure_type;
            internal_start(closure_type::start_routine, new closure_type(f));
        }

tbb_thread_v3() [4/6]

template<class F , class X >

tbb::internal::tbb_thread_v3::tbb_thread_v3 ( F  f, X  x  )

inline

Constructs an object and executes f(x) in a new thread.

Definition at line 141 of file tbb_thread.h.

                                                            {
            typedef internal::thread_closure_1<F,X> closure_type;
            internal_start(closure_type::start_routine, new closure_type(f,x));
        }

tbb_thread_v3() [5/6]

template<class F , class X , class Y >

tbb::internal::tbb_thread_v3::tbb_thread_v3 ( F  f, X  x, Y  y  )

inline

Constructs an object and executes f(x,y) in a new thread.

Definition at line 146 of file tbb_thread.h.

                                                                          {
            typedef internal::thread_closure_2<F,X,Y> closure_type;
            internal_start(closure_type::start_routine, new closure_type(f,x,y));
        }

tbb_thread_v3() [6/6]

tbb::internal::tbb_thread_v3::tbb_thread_v3 ( tbb_thread_v3 &&  x )

inline

Definition at line 152 of file tbb_thread.h.

            : my_handle(x.my_handle)
#if _WIN32||_WIN64
            , my_thread_id(x.my_thread_id)
#endif
        {
            x.internal_wipe();
        }

~tbb_thread_v3()

tbb::internal::tbb_thread_v3::~tbb_thread_v3 ( )

inline

Definition at line 180 of file tbb_thread.h.

References __TBB_NOEXCEPT, and tbb::this_tbb_thread::get_id().

{if( joinable() ) detach();}

Here is the call graph for this function:

Member Function Documentation

detach()

void tbb::internal::tbb_thread_v3::detach

(

)

When detach() returns, *this no longer represents the possibly continuing thread of execution.

Definition at line 78 of file tbb_thread.cpp.

References tbb::internal::handle_perror(), tbb::internal::handle_win_error(), joinable(), and my_handle.

Referenced by tbb::internal::move_v3().

                           {
    if (!joinable())
        handle_perror( EINVAL, "tbb_thread::detach" ); // Invalid argument
#if _WIN32||_WIN64
    BOOL status = CloseHandle( my_handle );
    if ( status == 0 )
      handle_win_error( GetLastError() );
    my_thread_id = 0;
#else
    int status = pthread_detach( my_handle );
    if( status )
        handle_perror( status, "pthread_detach" );
#endif // _WIN32||_WIN64
    my_handle = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_id()

tbb_thread_v3::id tbb::internal::tbb_thread_v3::get_id ( ) const

inline

Definition at line 259 of file tbb_thread.h.

References __TBB_EXPORTED_FUNC, id, tbb::internal::move_v3(), tbb::internal::thread_get_id_v3(), tbb::internal::thread_sleep_v3(), and tbb::internal::thread_yield_v3().

Referenced by join().

                                                                     {
#if _WIN32||_WIN64
        return id(my_thread_id);
#else
        return id(my_handle);
#endif // _WIN32||_WIN64
    }

Here is the call graph for this function:

Here is the caller graph for this function:

hardware_concurrency()

unsigned tbb::internal::tbb_thread_v3::hardware_concurrency ( )

static

The number of hardware thread contexts.

Before TBB 3.0 U4 this methods returned the number of logical CPU in the system. Currently on Windows, Linux and FreeBSD it returns the number of logical CPUs available to the current process in accordance with its affinity mask.

NOTE: The return value of this method never changes after its first invocation. This means that changes in the process affinity mask that took place after this method was first invoked will not affect the number of worker threads in the TBB worker threads pool.

Definition at line 139 of file tbb_thread.cpp.

References tbb::internal::governor::default_num_threads().

                                                                  {
    return governor::default_num_threads();
}

Here is the call graph for this function:

internal_move()

void tbb::internal::tbb_thread_v3::internal_move ( tbb_thread_v3 &  x )

inlineprivate

Definition at line 207 of file tbb_thread.h.

References __TBB_EXPORTED_FUNC, __TBB_EXPORTED_METHOD, __TBB_NATIVE_THREAD_ROUTINE_PTR, __TBB_NOEXCEPT, internal_wipe(), tbb::internal::move_v3(), my_handle, and tbb::swap().

                                                                  {
            if (joinable()) detach();
            my_handle = x.my_handle;
#if _WIN32||_WIN64
            my_thread_id = x.my_thread_id;
#endif // _WIN32||_WIN64
            x.internal_wipe();
        }

Here is the call graph for this function:

internal_start()

void tbb::internal::tbb_thread_v3::internal_start ( __TBB_NATIVE_THREAD_ROUTINE_PTR(start_routine)  , void *  closure  )

private

Runs start_routine(closure) on another thread and sets my_handle to the handle of the created thread.

Definition at line 94 of file tbb_thread.cpp.

References tbb::interface9::global_control::active_value(), tbb::internal::handle_perror(), my_handle, and tbb::interface9::global_control::thread_stack_size.

                                                    {
#if _WIN32||_WIN64
#if __TBB_WIN8UI_SUPPORT
    std::thread* thread_tmp=new std::thread(start_routine, closure);
    my_handle  = thread_tmp->native_handle();
//  TODO: to find out the way to find thread_id without GetThreadId and other
//  desktop functions.
//  Now tbb_thread does have its own thread_id that stores std::thread object
    my_thread_id = (size_t)thread_tmp;
#else
    unsigned thread_id;
    // The return type of _beginthreadex is "uintptr_t" on new MS compilers,
    // and 'unsigned long' on old MS compilers.  uintptr_t works for both.
    uintptr_t status = _beginthreadex( NULL, (unsigned)global_control::active_value(global_control::thread_stack_size),
                                       start_routine, closure, 0, &thread_id );
    if( status==0 )
        handle_perror(errno,"__beginthreadex");
    else {
        my_handle = (HANDLE)status;
        my_thread_id = thread_id;
    }
#endif
#else
    pthread_t thread_handle;
    int status;
    pthread_attr_t stack_size;
    status = pthread_attr_init( &stack_size );
    if( status )
        handle_perror( status, "pthread_attr_init" );
    status = pthread_attr_setstacksize( &stack_size, global_control::active_value(global_control::thread_stack_size) );
    if( status )
        handle_perror( status, "pthread_attr_setstacksize" );

    status = pthread_create( &thread_handle, &stack_size, start_routine, closure );
    if( status )
        handle_perror( status, "pthread_create" );
    status = pthread_attr_destroy( &stack_size );
    if( status )
        handle_perror( status, "pthread_attr_destroy" );

    my_handle = thread_handle;
#endif // _WIN32||_WIN64
}

Here is the call graph for this function:

internal_wipe()

void tbb::internal::tbb_thread_v3::internal_wipe ( )

inlineprivate

Definition at line 201 of file tbb_thread.h.

Referenced by internal_move().

                                                  {
            my_handle = 0;
#if _WIN32||_WIN64
            my_thread_id = 0;
#endif
        }

Here is the caller graph for this function:

join()

void tbb::internal::tbb_thread_v3::join

(

)

The completion of the thread represented by *this happens before join() returns.

Definition at line 50 of file tbb_thread.cpp.

References get_id(), tbb::this_tbb_thread::get_id(), tbb::internal::handle_perror(), tbb::internal::handle_win_error(), joinable(), and my_handle.

{
    if (!joinable())
        handle_perror( EINVAL, "tbb_thread::join" ); // Invalid argument
    if (this_tbb_thread::get_id() == get_id())
        handle_perror( EDEADLK, "tbb_thread::join" ); // Resource deadlock avoided
#if _WIN32||_WIN64
#if __TBB_WIN8UI_SUPPORT
    std::thread* thread_tmp=(std::thread*)my_thread_id;
    thread_tmp->join();
    delete thread_tmp;
#else // __TBB_WIN8UI_SUPPORT
    DWORD status = WaitForSingleObjectEx( my_handle, INFINITE, FALSE );
    if ( status == WAIT_FAILED )
        handle_win_error( GetLastError() );
    BOOL close_stat = CloseHandle( my_handle );
    if ( close_stat == 0 )
        handle_win_error( GetLastError() );
    my_thread_id = 0;
#endif // __TBB_WIN8UI_SUPPORT
#else
    int status = pthread_join( my_handle, NULL );
    if( status )
        handle_perror( status, "pthread_join" );
#endif // _WIN32||_WIN64
    my_handle = 0;
}

Here is the call graph for this function:

joinable()

bool tbb::internal::tbb_thread_v3::joinable ( ) const

inline

Definition at line 175 of file tbb_thread.h.

References __TBB_EXPORTED_METHOD.

Referenced by detach(), join(), and tbb::internal::move_v3().

{return my_handle!=0; }

Here is the caller graph for this function:

native_handle()

native_handle_type tbb::internal::tbb_thread_v3::native_handle ( )

inline

Definition at line 182 of file tbb_thread.h.

References __TBB_EXPORTED_FUNC, and __TBB_NOEXCEPT.

{ return my_handle; }

operator=() [1/2]

tbb_thread_v3& tbb::internal::tbb_thread_v3::operator= ( tbb_thread_v3 &&  x )

inline

Definition at line 160 of file tbb_thread.h.

                                                                         {
            internal_move(x);
            return *this;
        }

operator=() [2/2]

tbb_thread_v3& tbb::internal::tbb_thread_v3::operator= ( const tbb_thread_v3 &  x )

private

swap()

void tbb::internal::tbb_thread_v3::swap ( tbb_thread_v3 &  t )

inline

Definition at line 174 of file tbb_thread.h.

References tbb::swap().

{tbb::swap( *this, t );}

Here is the call graph for this function:

Friends And Related Function Documentation

move_v3

void __TBB_EXPORTED_FUNC move_v3 ( tbb_thread_v3 &  t1, tbb_thread_v3 &  t2  )

friend

Definition at line 151 of file tbb_thread.cpp.

{
    if (t1.joinable())
        t1.detach();
    t1.my_handle = t2.my_handle;
    t2.my_handle = 0;
#if _WIN32||_WIN64
    t1.my_thread_id = t2.my_thread_id;
    t2.my_thread_id = 0;
#endif // _WIN32||_WIN64
}

tbb::swap

void tbb::swap ( tbb_thread_v3 &  t1, tbb_thread_v3 &  t2  )

friend

Member Data Documentation

my_handle

native_handle_type tbb::internal::tbb_thread_v3::my_handle

private

Definition at line 196 of file tbb_thread.h.

Referenced by detach(), internal_move(), internal_start(), join(), and tbb::internal::move_v3().

---

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

• tbb_thread.h
• tbb_thread.cpp