-
Notifications
You must be signed in to change notification settings - Fork 59
Expand file tree
/
Copy pathtbb_misc.h
More file actions
269 lines (228 loc) · 9.52 KB
/
tbb_misc.h
File metadata and controls
269 lines (228 loc) · 9.52 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
/*
Copyright (c) 2005-2019 Intel Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#ifndef _TBB_tbb_misc_H
#define _TBB_tbb_misc_H
#include "tbb/tbb_stddef.h"
#include "tbb/tbb_machine.h"
#include "tbb/atomic.h" // For atomic_xxx definitions
#if __linux__ || __FreeBSD__
#include <sys/param.h> // __FreeBSD_version
#if __FreeBSD_version >= 701000
#include <sys/cpuset.h>
#endif
#endif
// Does the operating system have a system call to pin a thread to a set of OS processors?
#define __TBB_OS_AFFINITY_SYSCALL_PRESENT ((__linux__ && !__ANDROID__) || (__FreeBSD_version >= 701000))
// On IBM* Blue Gene* CNK nodes, the affinity API has restrictions that prevent its usability for TBB,
// and also sysconf(_SC_NPROCESSORS_ONLN) already takes process affinity into account.
#define __TBB_USE_OS_AFFINITY_SYSCALL (__TBB_OS_AFFINITY_SYSCALL_PRESENT && !__bg__)
namespace tbb {
namespace internal {
const size_t MByte = 1024*1024;
#if __TBB_WIN8UI_SUPPORT && (_WIN32_WINNT < 0x0A00)
// In Win8UI mode (Windows 8 Store* applications), TBB uses a thread creation API
// that does not allow to specify the stack size.
// Still, the thread stack size value, either explicit or default, is used by the scheduler.
// So here we set the default value to match the platform's default of 1MB.
const size_t ThreadStackSize = 1*MByte;
#else
const size_t ThreadStackSize = (sizeof(uintptr_t) <= 4 ? 2 : 4 )*MByte;
#endif
#ifndef __TBB_HardwareConcurrency
//! Returns maximal parallelism level supported by the current OS configuration.
int AvailableHwConcurrency();
#else
inline int AvailableHwConcurrency() {
int n = __TBB_HardwareConcurrency();
return n > 0 ? n : 1; // Fail safety strap
}
#endif /* __TBB_HardwareConcurrency */
#if _WIN32||_WIN64
//! Returns number of processor groups in the current OS configuration.
/** AvailableHwConcurrency must be called at least once before calling this method. **/
int NumberOfProcessorGroups();
//! Retrieves index of processor group containing processor with the given index
int FindProcessorGroupIndex ( int processorIndex );
//! Affinitizes the thread to the specified processor group
void MoveThreadIntoProcessorGroup( void* hThread, int groupIndex );
#endif /* _WIN32||_WIN64 */
//! Throws std::runtime_error with what() returning error_code description prefixed with aux_info
void handle_win_error( int error_code );
//! Prints TBB version information on stderr
void PrintVersion();
//! Prints arbitrary extra TBB version information on stderr
void PrintExtraVersionInfo( const char* category, const char* format, ... );
//! A callback routine to print RML version information on stderr
void PrintRMLVersionInfo( void* arg, const char* server_info );
// For TBB compilation only; not to be used in public headers
#if defined(min) || defined(max)
#undef min
#undef max
#endif
//! Utility template function returning lesser of the two values.
/** Provided here to avoid including not strict safe <algorithm>.\n
In case operands cause signed/unsigned or size mismatch warnings it is caller's
responsibility to do the appropriate cast before calling the function. **/
template<typename T>
T min ( const T& val1, const T& val2 ) {
return val1 < val2 ? val1 : val2;
}
//! Utility template function returning greater of the two values.
/** Provided here to avoid including not strict safe <algorithm>.\n
In case operands cause signed/unsigned or size mismatch warnings it is caller's
responsibility to do the appropriate cast before calling the function. **/
template<typename T>
T max ( const T& val1, const T& val2 ) {
return val1 < val2 ? val2 : val1;
}
//! Utility helper structure to ease overload resolution
template<int > struct int_to_type {};
//------------------------------------------------------------------------
// FastRandom
//------------------------------------------------------------------------
/** Defined in tbb_main.cpp **/
unsigned GetPrime ( unsigned seed );
//! A fast random number generator.
/** Uses linear congruential method. */
class FastRandom {
private:
#if __TBB_OLD_PRIMES_RNG
unsigned x, a;
static const unsigned c = 1;
#else
unsigned x, c;
static const unsigned a = 0x9e3779b1; // a big prime number
#endif //__TBB_OLD_PRIMES_RNG
public:
//! Get a random number.
unsigned short get() {
return get(x);
}
//! Get a random number for the given seed; update the seed for next use.
unsigned short get( unsigned& seed ) {
unsigned short r = (unsigned short)(seed>>16);
__TBB_ASSERT(c&1, "c must be odd for big rng period");
seed = seed*a+c;
return r;
}
//! Construct a random number generator.
FastRandom( void* unique_ptr ) { init(uintptr_t(unique_ptr)); }
FastRandom( uint32_t seed) { init(seed); }
FastRandom( uint64_t seed) { init(seed); }
template <typename T>
void init( T seed ) {
init(seed,int_to_type<sizeof(seed)>());
}
void init( uint64_t seed , int_to_type<8> ) {
init(uint32_t((seed>>32)+seed), int_to_type<4>());
}
void init( uint32_t seed, int_to_type<4> ) {
#if __TBB_OLD_PRIMES_RNG
x = seed;
a = GetPrime( seed );
#else
// threads use different seeds for unique sequences
c = (seed|1)*0xba5703f5; // c must be odd, shuffle by a prime number
x = c^(seed>>1); // also shuffle x for the first get() invocation
#endif
}
};
//------------------------------------------------------------------------
// Atomic extensions
//------------------------------------------------------------------------
//! Atomically replaces value of dst with newValue if they satisfy condition of compare predicate
/** Return value semantics is the same as for CAS. **/
template<typename T1, typename T2, class Pred>
T1 atomic_update ( tbb::atomic<T1>& dst, T2 newValue, Pred compare ) {
T1 oldValue = dst;
while ( compare(oldValue, newValue) ) {
if ( dst.compare_and_swap((T1)newValue, oldValue) == oldValue )
break;
oldValue = dst;
}
return oldValue;
}
//! One-time initialization states
enum do_once_state {
do_once_uninitialized = 0, ///< No execution attempts have been undertaken yet
do_once_pending, ///< A thread is executing associated do-once routine
do_once_executed, ///< Do-once routine has been executed
initialization_complete = do_once_executed ///< Convenience alias
};
//! One-time initialization function
/** /param initializer Pointer to function without arguments
The variant that returns bool is used for cases when initialization can fail
and it is OK to continue execution, but the state should be reset so that
the initialization attempt was repeated the next time.
/param state Shared state associated with initializer that specifies its
initialization state. Must be initially set to #uninitialized value
(e.g. by means of default static zero initialization). **/
template <typename F>
void atomic_do_once ( const F& initializer, atomic<do_once_state>& state ) {
// tbb::atomic provides necessary acquire and release fences.
// The loop in the implementation is necessary to avoid race when thread T2
// that arrived in the middle of initialization attempt by another thread T1
// has just made initialization possible.
// In such a case T2 has to rely on T1 to initialize, but T1 may already be past
// the point where it can recognize the changed conditions.
while ( state != do_once_executed ) {
if( state == do_once_uninitialized ) {
if( state.compare_and_swap( do_once_pending, do_once_uninitialized ) == do_once_uninitialized ) {
run_initializer( initializer, state );
break;
}
}
spin_wait_while_eq( state, do_once_pending );
}
}
// Run the initializer which can not fail
inline void run_initializer( void (*f)(), atomic<do_once_state>& state ) {
f();
state = do_once_executed;
}
// Run the initializer which can require repeated call
inline void run_initializer( bool (*f)(), atomic<do_once_state>& state ) {
state = f() ? do_once_executed : do_once_uninitialized;
}
#if __TBB_USE_OS_AFFINITY_SYSCALL
#if __linux__
typedef cpu_set_t basic_mask_t;
#elif __FreeBSD_version >= 701000
typedef cpuset_t basic_mask_t;
#else
#error affinity_helper is not implemented in this OS
#endif
class affinity_helper : no_copy {
basic_mask_t* threadMask;
int is_changed;
public:
affinity_helper() : threadMask(NULL), is_changed(0) {}
~affinity_helper();
void protect_affinity_mask( bool restore_process_mask );
void dismiss();
};
void destroy_process_mask();
#else
class affinity_helper : no_copy {
public:
void protect_affinity_mask( bool ) {}
void dismiss() {}
};
inline void destroy_process_mask(){}
#endif /* __TBB_USE_OS_AFFINITY_SYSCALL */
bool cpu_has_speculation();
bool gcc_rethrow_exception_broken();
void fix_broken_rethrow();
} // namespace internal
} // namespace tbb
#endif /* _TBB_tbb_misc_H */