1/*
2 Copyright (c) 2005-2019 Intel Corporation
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15*/
16
17#ifndef __TBB_tbb_thread_H
18#define __TBB_tbb_thread_H
19
20#include "tbb_stddef.h"
21
22#if _WIN32||_WIN64
23#include "machine/windows_api.h"
24#define __TBB_NATIVE_THREAD_ROUTINE unsigned WINAPI
25#define __TBB_NATIVE_THREAD_ROUTINE_PTR(r) unsigned (WINAPI* r)( void* )
26namespace tbb { namespace internal {
27#if __TBB_WIN8UI_SUPPORT
28 typedef size_t thread_id_type;
29#else // __TBB_WIN8UI_SUPPORT
30 typedef DWORD thread_id_type;
31#endif // __TBB_WIN8UI_SUPPORT
32}} //namespace tbb::internal
33#else
34#define __TBB_NATIVE_THREAD_ROUTINE void*
35#define __TBB_NATIVE_THREAD_ROUTINE_PTR(r) void* (*r)( void* )
36#include <pthread.h>
37namespace tbb { namespace internal {
38 typedef pthread_t thread_id_type;
39}} //namespace tbb::internal
40#endif // _WIN32||_WIN64
41
42#include "atomic.h"
43#include "internal/_tbb_hash_compare_impl.h"
44#include "tick_count.h"
45
46#include __TBB_STD_SWAP_HEADER
47#include <iosfwd>
48
49namespace tbb {
50
51namespace internal {
52 class tbb_thread_v3;
53}
54
55inline void swap( internal::tbb_thread_v3& t1, internal::tbb_thread_v3& t2 ) __TBB_NOEXCEPT(true);
56
57namespace internal {
58
59 //! Allocate a closure
60 void* __TBB_EXPORTED_FUNC allocate_closure_v3( size_t size );
61 //! Free a closure allocated by allocate_closure_v3
62 void __TBB_EXPORTED_FUNC free_closure_v3( void* );
63
64 struct thread_closure_base {
65 void* operator new( size_t size ) {return allocate_closure_v3(size);}
66 void operator delete( void* ptr ) {free_closure_v3(ptr);}
67 };
68
69 template<class F> struct thread_closure_0: thread_closure_base {
70 F function;
71
72 static __TBB_NATIVE_THREAD_ROUTINE start_routine( void* c ) {
73 thread_closure_0 *self = static_cast<thread_closure_0*>(c);
74 self->function();
75 delete self;
76 return 0;
77 }
78 thread_closure_0( const F& f ) : function(f) {}
79 };
80 //! Structure used to pass user function with 1 argument to thread.
81 template<class F, class X> struct thread_closure_1: thread_closure_base {
82 F function;
83 X arg1;
84 //! Routine passed to Windows's _beginthreadex by thread::internal_start() inside tbb.dll
85 static __TBB_NATIVE_THREAD_ROUTINE start_routine( void* c ) {
86 thread_closure_1 *self = static_cast<thread_closure_1*>(c);
87 self->function(self->arg1);
88 delete self;
89 return 0;
90 }
91 thread_closure_1( const F& f, const X& x ) : function(f), arg1(x) {}
92 };
93 template<class F, class X, class Y> struct thread_closure_2: thread_closure_base {
94 F function;
95 X arg1;
96 Y arg2;
97 //! Routine passed to Windows's _beginthreadex by thread::internal_start() inside tbb.dll
98 static __TBB_NATIVE_THREAD_ROUTINE start_routine( void* c ) {
99 thread_closure_2 *self = static_cast<thread_closure_2*>(c);
100 self->function(self->arg1, self->arg2);
101 delete self;
102 return 0;
103 }
104 thread_closure_2( const F& f, const X& x, const Y& y ) : function(f), arg1(x), arg2(y) {}
105 };
106
107 //! Versioned thread class.
108 class tbb_thread_v3 {
109#if __TBB_IF_NO_COPY_CTOR_MOVE_SEMANTICS_BROKEN
110 // Workaround for a compiler bug: declaring the copy constructor as public
111 // enables use of the moving constructor.
112 // The definition is not provided in order to prohibit copying.
113 public:
114#endif
115 tbb_thread_v3(const tbb_thread_v3&); // = delete; // Deny access
116 public:
117#if _WIN32||_WIN64
118 typedef HANDLE native_handle_type;
119#else
120 typedef pthread_t native_handle_type;
121#endif // _WIN32||_WIN64
122
123 class id;
124 //! Constructs a thread object that does not represent a thread of execution.
125 tbb_thread_v3() __TBB_NOEXCEPT(true) : my_handle(0)
126#if _WIN32||_WIN64
127 , my_thread_id(0)
128#endif // _WIN32||_WIN64
129 {}
130
131 //! Constructs an object and executes f() in a new thread
132 template <class F> explicit tbb_thread_v3(F f) {
133 typedef internal::thread_closure_0<F> closure_type;
134 internal_start(closure_type::start_routine, new closure_type(f));
135 }
136 //! Constructs an object and executes f(x) in a new thread
137 template <class F, class X> tbb_thread_v3(F f, X x) {
138 typedef internal::thread_closure_1<F,X> closure_type;
139 internal_start(closure_type::start_routine, new closure_type(f,x));
140 }
141 //! Constructs an object and executes f(x,y) in a new thread
142 template <class F, class X, class Y> tbb_thread_v3(F f, X x, Y y) {
143 typedef internal::thread_closure_2<F,X,Y> closure_type;
144 internal_start(closure_type::start_routine, new closure_type(f,x,y));
145 }
146
147#if __TBB_CPP11_RVALUE_REF_PRESENT
148 tbb_thread_v3(tbb_thread_v3&& x) __TBB_NOEXCEPT(true)
149 : my_handle(x.my_handle)
150#if _WIN32||_WIN64
151 , my_thread_id(x.my_thread_id)
152#endif
153 {
154 x.internal_wipe();
155 }
156 tbb_thread_v3& operator=(tbb_thread_v3&& x) __TBB_NOEXCEPT(true) {
157 internal_move(x);
158 return *this;
159 }
160 private:
161 tbb_thread_v3& operator=(const tbb_thread_v3& x); // = delete;
162 public:
163#else // __TBB_CPP11_RVALUE_REF_PRESENT
164 tbb_thread_v3& operator=(tbb_thread_v3& x) {
165 internal_move(x);
166 return *this;
167 }
168#endif // __TBB_CPP11_RVALUE_REF_PRESENT
169
170 void swap( tbb_thread_v3& t ) __TBB_NOEXCEPT(true) {tbb::swap( *this, t );}
171 bool joinable() const __TBB_NOEXCEPT(true) {return my_handle!=0; }
172 //! The completion of the thread represented by *this happens before join() returns.
173 void __TBB_EXPORTED_METHOD join();
174 //! When detach() returns, *this no longer represents the possibly continuing thread of execution.
175 void __TBB_EXPORTED_METHOD detach();
176 ~tbb_thread_v3() {if( joinable() ) detach();}
177 inline id get_id() const __TBB_NOEXCEPT(true);
178 native_handle_type native_handle() { return my_handle; }
179
180 //! The number of hardware thread contexts.
181 /** Before TBB 3.0 U4 this methods returned the number of logical CPU in
182 the system. Currently on Windows, Linux and FreeBSD it returns the
183 number of logical CPUs available to the current process in accordance
184 with its affinity mask.
185
186 NOTE: The return value of this method never changes after its first
187 invocation. This means that changes in the process affinity mask that
188 took place after this method was first invoked will not affect the
189 number of worker threads in the TBB worker threads pool. **/
190 static unsigned __TBB_EXPORTED_FUNC hardware_concurrency() __TBB_NOEXCEPT(true);
191 private:
192 native_handle_type my_handle;
193#if _WIN32||_WIN64
194 thread_id_type my_thread_id;
195#endif // _WIN32||_WIN64
196
197 void internal_wipe() __TBB_NOEXCEPT(true) {
198 my_handle = 0;
199#if _WIN32||_WIN64
200 my_thread_id = 0;
201#endif
202 }
203 void internal_move(tbb_thread_v3& x) __TBB_NOEXCEPT(true) {
204 if (joinable()) detach();
205 my_handle = x.my_handle;
206#if _WIN32||_WIN64
207 my_thread_id = x.my_thread_id;
208#endif // _WIN32||_WIN64
209 x.internal_wipe();
210 }
211
212 /** Runs start_routine(closure) on another thread and sets my_handle to the handle of the created thread. */
213 void __TBB_EXPORTED_METHOD internal_start( __TBB_NATIVE_THREAD_ROUTINE_PTR(start_routine),
214 void* closure );
215 friend void __TBB_EXPORTED_FUNC move_v3( tbb_thread_v3& t1, tbb_thread_v3& t2 );
216 friend void tbb::swap( tbb_thread_v3& t1, tbb_thread_v3& t2 ) __TBB_NOEXCEPT(true);
217 };
218
219 class tbb_thread_v3::id {
220 thread_id_type my_id;
221 id( thread_id_type id_ ) : my_id(id_) {}
222
223 friend class tbb_thread_v3;
224 public:
225 id() __TBB_NOEXCEPT(true) : my_id(0) {}
226
227 friend bool operator==( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
228 friend bool operator!=( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
229 friend bool operator<( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
230 friend bool operator<=( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
231 friend bool operator>( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
232 friend bool operator>=( tbb_thread_v3::id x, tbb_thread_v3::id y ) __TBB_NOEXCEPT(true);
233
234 template<class charT, class traits>
235 friend std::basic_ostream<charT, traits>&
236 operator<< (std::basic_ostream<charT, traits> &out,
237 tbb_thread_v3::id id)
238 {
239 out << id.my_id;
240 return out;
241 }
242 friend tbb_thread_v3::id __TBB_EXPORTED_FUNC thread_get_id_v3();
243
244 friend inline size_t tbb_hasher( const tbb_thread_v3::id& id ) {
245 __TBB_STATIC_ASSERT(sizeof(id.my_id) <= sizeof(size_t), "Implementation assumes that thread_id_type fits into machine word");
246 return tbb::tbb_hasher(id.my_id);
247 }
248
249 // A workaround for lack of tbb::atomic<id> (which would require id to be POD in C++03).
250 friend id atomic_compare_and_swap(id& location, const id& value, const id& comparand){
251 return as_atomic(location.my_id).compare_and_swap(value.my_id, comparand.my_id);
252 }
253 }; // tbb_thread_v3::id
254
255 tbb_thread_v3::id tbb_thread_v3::get_id() const __TBB_NOEXCEPT(true) {
256#if _WIN32||_WIN64
257 return id(my_thread_id);
258#else
259 return id(my_handle);
260#endif // _WIN32||_WIN64
261 }
262
263 void __TBB_EXPORTED_FUNC move_v3( tbb_thread_v3& t1, tbb_thread_v3& t2 );
264 tbb_thread_v3::id __TBB_EXPORTED_FUNC thread_get_id_v3();
265 void __TBB_EXPORTED_FUNC thread_yield_v3();
266 void __TBB_EXPORTED_FUNC thread_sleep_v3(const tick_count::interval_t &i);
267
268 inline bool operator==(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
269 {
270 return x.my_id == y.my_id;
271 }
272 inline bool operator!=(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
273 {
274 return x.my_id != y.my_id;
275 }
276 inline bool operator<(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
277 {
278 return x.my_id < y.my_id;
279 }
280 inline bool operator<=(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
281 {
282 return x.my_id <= y.my_id;
283 }
284 inline bool operator>(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
285 {
286 return x.my_id > y.my_id;
287 }
288 inline bool operator>=(tbb_thread_v3::id x, tbb_thread_v3::id y) __TBB_NOEXCEPT(true)
289 {
290 return x.my_id >= y.my_id;
291 }
292
293} // namespace internal;
294
295//! Users reference thread class by name tbb_thread
296typedef internal::tbb_thread_v3 tbb_thread;
297
298using internal::operator==;
299using internal::operator!=;
300using internal::operator<;
301using internal::operator>;
302using internal::operator<=;
303using internal::operator>=;
304
305inline void move( tbb_thread& t1, tbb_thread& t2 ) {
306 internal::move_v3(t1, t2);
307}
308
309inline void swap( internal::tbb_thread_v3& t1, internal::tbb_thread_v3& t2 ) __TBB_NOEXCEPT(true) {
310 std::swap(t1.my_handle, t2.my_handle);
311#if _WIN32||_WIN64
312 std::swap(t1.my_thread_id, t2.my_thread_id);
313#endif /* _WIN32||_WIN64 */
314}
315
316namespace this_tbb_thread {
317 inline tbb_thread::id get_id() { return internal::thread_get_id_v3(); }
318 //! Offers the operating system the opportunity to schedule another thread.
319 inline void yield() { internal::thread_yield_v3(); }
320 //! The current thread blocks at least until the time specified.
321 inline void sleep(const tick_count::interval_t &i) {
322 internal::thread_sleep_v3(i);
323 }
324} // namespace this_tbb_thread
325
326} // namespace tbb
327
328#endif /* __TBB_tbb_thread_H */
329