342 lines
13 KiB
C++
342 lines
13 KiB
C++
/*
|
|
Copyright 2005-2016 Intel Corporation. All Rights Reserved.
|
|
|
|
This file is part of Threading Building Blocks. Threading Building Blocks is free software;
|
|
you can redistribute it and/or modify it under the terms of the GNU General Public License
|
|
version 2 as published by the Free Software Foundation. Threading Building Blocks is
|
|
distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
See the GNU General Public License for more details. You should have received a copy of
|
|
the GNU General Public License along with Threading Building Blocks; if not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
As a special exception, you may use this file as part of a free software library without
|
|
restriction. Specifically, if other files instantiate templates or use macros or inline
|
|
functions from this file, or you compile this file and link it with other files to produce
|
|
an executable, this file does not by itself cause the resulting executable to be covered
|
|
by the GNU General Public License. This exception does not however invalidate any other
|
|
reasons why the executable file might be covered by the GNU General Public License.
|
|
*/
|
|
|
|
#ifndef __TBB_tbb_thread_H
|
|
#define __TBB_tbb_thread_H
|
|
|
|
#include "tbb_stddef.h"
|
|
|
|
#if _WIN32||_WIN64
|
|
#include "machine/windows_api.h"
|
|
#define __TBB_NATIVE_THREAD_ROUTINE unsigned WINAPI
|
|
#define __TBB_NATIVE_THREAD_ROUTINE_PTR(r) unsigned (WINAPI* r)( void* )
|
|
namespace tbb { namespace internal {
|
|
#if __TBB_WIN8UI_SUPPORT
|
|
typedef size_t thread_id_type;
|
|
#else // __TBB_WIN8UI_SUPPORT
|
|
typedef DWORD thread_id_type;
|
|
#endif // __TBB_WIN8UI_SUPPORT
|
|
}} //namespace tbb::internal
|
|
#else
|
|
#define __TBB_NATIVE_THREAD_ROUTINE void*
|
|
#define __TBB_NATIVE_THREAD_ROUTINE_PTR(r) void* (*r)( void* )
|
|
#include <pthread.h>
|
|
namespace tbb { namespace internal {
|
|
typedef pthread_t thread_id_type;
|
|
}} //namespace tbb::internal
|
|
#endif // _WIN32||_WIN64
|
|
|
|
#include "atomic.h"
|
|
#include "internal/_tbb_hash_compare_impl.h"
|
|
#include "tick_count.h"
|
|
|
|
#if !TBB_USE_EXCEPTIONS && _MSC_VER
|
|
// Suppress "C++ exception handler used, but unwind semantics are not enabled" warning in STL headers
|
|
#pragma warning (push)
|
|
#pragma warning (disable: 4530)
|
|
#endif
|
|
|
|
#include <utility> //for swap
|
|
#include <iosfwd>
|
|
|
|
#if !TBB_USE_EXCEPTIONS && _MSC_VER
|
|
#pragma warning (pop)
|
|
#endif
|
|
|
|
namespace tbb {
|
|
|
|
namespace internal {
|
|
class tbb_thread_v3;
|
|
}
|
|
|
|
inline void swap( internal::tbb_thread_v3& t1, internal::tbb_thread_v3& t2 ) __TBB_NOEXCEPT(true);
|
|
|
|
namespace internal {
|
|
|
|
//! Allocate a closure
|
|
void* __TBB_EXPORTED_FUNC allocate_closure_v3( size_t size );
|
|
//! Free a closure allocated by allocate_closure_v3
|
|
void __TBB_EXPORTED_FUNC free_closure_v3( void* );
|
|
|
|
struct thread_closure_base {
|
|
void* operator new( size_t size ) {return allocate_closure_v3(size);}
|
|
void operator delete( void* ptr ) {free_closure_v3(ptr);}
|
|
};
|
|
|
|
template<class F> struct thread_closure_0: thread_closure_base {
|
|
F function;
|
|
|
|
static __TBB_NATIVE_THREAD_ROUTINE start_routine( void* c ) {
|
|
thread_closure_0 *self = static_cast<thread_closure_0*>(c);
|
|
self->function();
|
|
delete self;
|
|
return 0;
|
|
}
|
|
thread_closure_0( const F& f ) : function(f) {}
|
|
};
|
|
//! Structure used to pass user function with 1 argument to thread.
|
|
template<class F, class X> struct thread_closure_1: thread_closure_base {
|
|
F function;
|
|
X arg1;
|
|
//! Routine passed to Windows's _beginthreadex by thread::internal_start() inside tbb.dll
|
|
static __TBB_NATIVE_THREAD_ROUTINE start_routine( void* c ) {
|
|
thread_closure_1 *self = static_cast<thread_closure_1*>(c);
|
|
self->function(self->arg1);
|
|
delete self;
|
|
return 0;
|
|
}
|
|
thread_closure_1( const F& f, const X& x ) : function(f), arg1(x) {}
|
|
};
|
|
template<class F, class X, class Y> struct thread_closure_2: thread_closure_base {
|
|
F function;
|
|
X arg1;
|
|
Y arg2;
|
|
//! Routine passed to Windows's _beginthreadex by thread::internal_start() inside tbb.dll
|
|
static __TBB_NATIVE_THREAD_ROUTINE start_routine( void* c ) {
|
|
thread_closure_2 *self = static_cast<thread_closure_2*>(c);
|
|
self->function(self->arg1, self->arg2);
|
|
delete self;
|
|
return 0;
|
|
}
|
|
thread_closure_2( const F& f, const X& x, const Y& y ) : function(f), arg1(x), arg2(y) {}
|
|
};
|
|
|
|
//! Versioned thread class.
|
|
class tbb_thread_v3 {
|
|
#if __TBB_IF_NO_COPY_CTOR_MOVE_SEMANTICS_BROKEN
|
|
// Workaround for a compiler bug: declaring the copy constructor as public
|
|
// enables use of the moving constructor.
|
|
// The definition is not provided in order to prohibit copying.
|
|
public:
|
|
#endif
|
|
tbb_thread_v3(const tbb_thread_v3&); // = delete; // Deny access
|
|
public:
|
|
#if _WIN32||_WIN64
|
|
typedef HANDLE native_handle_type;
|
|
#else
|
|
typedef pthread_t native_handle_type;
|
|
#endif // _WIN32||_WIN64
|
|
|
|
class id;
|
|
//! Constructs a thread object that does not represent a thread of execution.
|
|
tbb_thread_v3() __TBB_NOEXCEPT(true) : my_handle(0)
|
|
#if _WIN32||_WIN64
|
|
, my_thread_id(0)
|
|
#endif // _WIN32||_WIN64
|
|
{}
|
|
|
|
//! Constructs an object and executes f() in a new thread
|
|
template <class F> explicit tbb_thread_v3(F f) {
|
|
typedef internal::thread_closure_0<F> closure_type;
|
|
internal_start(closure_type::start_routine, new closure_type(f));
|
|
}
|
|
//! Constructs an object and executes f(x) in a new thread
|
|
template <class F, class X> tbb_thread_v3(F f, X x) {
|
|
typedef internal::thread_closure_1<F,X> closure_type;
|
|
internal_start(closure_type::start_routine, new closure_type(f,x));
|
|
}
|
|
//! Constructs an object and executes f(x,y) in a new thread
|
|
template <class F, class X, class Y> tbb_thread_v3(F f, X x, Y y) {
|
|
typedef internal::thread_closure_2<F,X,Y> closure_type;
|
|
internal_start(closure_type::start_routine, new closure_type(f,x,y));
|
|
}
|
|
|
|
#if __TBB_CPP11_RVALUE_REF_PRESENT
|
|
tbb_thread_v3(tbb_thread_v3&& x) __TBB_NOEXCEPT(true)
|
|
: my_handle(x.my_handle)
|
|
#if _WIN32||_WIN64
|
|
, my_thread_id(x.my_thread_id)
|
|
#endif
|
|
{
|
|
x.internal_wipe();
|
|
}
|
|
tbb_thread_v3& operator=(tbb_thread_v3&& x) __TBB_NOEXCEPT(true) {
|
|
internal_move(x);
|
|
return *this;
|
|
}
|
|
private:
|
|
tbb_thread_v3& operator=(const tbb_thread_v3& x); // = delete;
|
|
public:
|
|
#else // __TBB_CPP11_RVALUE_REF_PRESENT
|
|
tbb_thread_v3& operator=(tbb_thread_v3& x) {
|
|
internal_move(x);
|
|
return *this;
|
|
}
|
|
#endif // __TBB_CPP11_RVALUE_REF_PRESENT
|
|
|
|
void swap( tbb_thread_v3& t ) __TBB_NOEXCEPT(true) {tbb::swap( *this, t );}
|
|
bool joinable() const __TBB_NOEXCEPT(true) {return my_handle!=0; }
|
|
//! The completion of the thread represented by *this happens before join() returns.
|
|
void __TBB_EXPORTED_METHOD join();
|
|
//! When detach() returns, *this no longer represents the possibly continuing thread of execution.
|
|
void __TBB_EXPORTED_METHOD detach();
|
|
~tbb_thread_v3() {if( joinable() ) detach();}
|
|
inline id get_id() const __TBB_NOEXCEPT(true);
|
|
native_handle_type native_handle() { return my_handle; }
|
|
|
|
//! 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. **/
|
|
static unsigned __TBB_EXPORTED_FUNC hardware_concurrency() __TBB_NOEXCEPT(true);
|
|
private:
|
|
native_handle_type my_handle;
|
|
#if _WIN32||_WIN64
|
|
thread_id_type my_thread_id;
|
|
#endif // _WIN32||_WIN64
|
|
|
|
void internal_wipe() __TBB_NOEXCEPT(true) {
|
|
my_handle = 0;
|
|
#if _WIN32||_WIN64
|
|
my_thread_id = 0;
|
|
#endif
|
|
}
|
|
void internal_move(tbb_thread_v3& x) __TBB_NOEXCEPT(true) {
|
|
if (joinable()) detach();
|
|
my_handle = x.my_handle;
|
|
#if _WIN32||_WIN64
|
|
my_thread_id = x.my_thread_id;
|
|
#endif // _WIN32||_WIN64
|
|
x.internal_wipe();
|
|
}
|
|
|
|
/** Runs start_routine(closure) on another thread and sets my_handle to the handle of the created thread. */
|
|
void __TBB_EXPORTED_METHOD internal_start( __TBB_NATIVE_THREAD_ROUTINE_PTR(start_routine),
|
|
void* closure );
|
|
friend void __TBB_EXPORTED_FUNC move_v3( tbb_thread_v3& t1, tbb_thread_v3& t2 );
|
|
friend void tbb::swap( tbb_thread_v3& t1, tbb_thread_v3& t2 ) __TBB_NOEXCEPT(true);
|
|
};
|
|
|
|
class tbb_thread_v3::id {
|
|
thread_id_type my_id;
|
|
id( thread_id_type id_ ) : my_id(id_) {}
|
|
|
|
friend class tbb_thread_v3;
|
|
public:
|
|
id() __TBB_NOEXCEPT(true) : my_id(0) {}
|
|
|
|
friend bool operator==( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
|
|
friend bool operator!=( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
|
|
friend bool operator<( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
|
|
friend bool operator<=( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
|
|
friend bool operator>( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
|
|
friend bool operator>=( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
|
|
|
|
template<class charT, class traits>
|
|
friend std::basic_ostream<charT, traits>&
|
|
operator<< (std::basic_ostream<charT, traits> &out,
|
|
tbb_thread_v3::id id)
|
|
{
|
|
out << id.my_id;
|
|
return out;
|
|
}
|
|
friend tbb_thread_v3::id __TBB_EXPORTED_FUNC thread_get_id_v3();
|
|
|
|
friend inline size_t tbb_hasher( const tbb_thread_v3::id& id ) {
|
|
__TBB_STATIC_ASSERT(sizeof(id.my_id) <= sizeof(size_t), "Implementaion assumes that thread_id_type fits into machine word");
|
|
return tbb::tbb_hasher(id.my_id);
|
|
}
|
|
|
|
// A workaround for lack of tbb::atomic<id> (which would require id to be POD in C++03).
|
|
friend id atomic_compare_and_swap(id& location, const id& value, const id& comparand){
|
|
return as_atomic(location.my_id).compare_and_swap(value.my_id, comparand.my_id);
|
|
}
|
|
}; // tbb_thread_v3::id
|
|
|
|
tbb_thread_v3::id tbb_thread_v3::get_id() const __TBB_NOEXCEPT(true) {
|
|
#if _WIN32||_WIN64
|
|
return id(my_thread_id);
|
|
#else
|
|
return id(my_handle);
|
|
#endif // _WIN32||_WIN64
|
|
}
|
|
|
|
void __TBB_EXPORTED_FUNC move_v3( tbb_thread_v3& t1, tbb_thread_v3& t2 );
|
|
tbb_thread_v3::id __TBB_EXPORTED_FUNC thread_get_id_v3();
|
|
void __TBB_EXPORTED_FUNC thread_yield_v3();
|
|
void __TBB_EXPORTED_FUNC thread_sleep_v3(const tick_count::interval_t &i);
|
|
|
|
inline bool operator==(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
|
|
{
|
|
return x.my_id == y.my_id;
|
|
}
|
|
inline bool operator!=(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
|
|
{
|
|
return x.my_id != y.my_id;
|
|
}
|
|
inline bool operator<(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
|
|
{
|
|
return x.my_id < y.my_id;
|
|
}
|
|
inline bool operator<=(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
|
|
{
|
|
return x.my_id <= y.my_id;
|
|
}
|
|
inline bool operator>(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
|
|
{
|
|
return x.my_id > y.my_id;
|
|
}
|
|
inline bool operator>=(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
|
|
{
|
|
return x.my_id >= y.my_id;
|
|
}
|
|
|
|
} // namespace internal;
|
|
|
|
//! Users reference thread class by name tbb_thread
|
|
typedef internal::tbb_thread_v3 tbb_thread;
|
|
|
|
using internal::operator==;
|
|
using internal::operator!=;
|
|
using internal::operator<;
|
|
using internal::operator>;
|
|
using internal::operator<=;
|
|
using internal::operator>=;
|
|
|
|
inline void move( tbb_thread& t1, tbb_thread& t2 ) {
|
|
internal::move_v3(t1, t2);
|
|
}
|
|
|
|
inline void swap( internal::tbb_thread_v3& t1, internal::tbb_thread_v3& t2 ) __TBB_NOEXCEPT(true) {
|
|
std::swap(t1.my_handle, t2.my_handle);
|
|
#if _WIN32||_WIN64
|
|
std::swap(t1.my_thread_id, t2.my_thread_id);
|
|
#endif /* _WIN32||_WIN64 */
|
|
}
|
|
|
|
namespace this_tbb_thread {
|
|
inline tbb_thread::id get_id() { return internal::thread_get_id_v3(); }
|
|
//! Offers the operating system the opportunity to schedule another thread.
|
|
inline void yield() { internal::thread_yield_v3(); }
|
|
//! The current thread blocks at least until the time specified.
|
|
inline void sleep(const tick_count::interval_t &i) {
|
|
internal::thread_sleep_v3(i);
|
|
}
|
|
} // namespace this_tbb_thread
|
|
|
|
} // namespace tbb
|
|
|
|
#endif /* __TBB_tbb_thread_H */
|