| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4Threading << 26 // $Id$
27 // 27 //
28 // Description: << 28 // ---------------------------------------------------------------
>> 29 // GEANT 4 class header file
29 // 30 //
30 // This unit defines types and macros used to << 31 // Class Description:
>> 32 //
>> 33 // This file defines types and macros used to expose Geant4 threading model.
31 34
32 // Author: Andrea Dotti, 15 February 2013 - Fi << 35 // ---------------------------------------------------------------
33 // Revision: Jonathan R. Madsen, 21 February 2 << 36 // Author: Andrea Dotti (15 Feb 2013): First Implementation
34 // ------------------------------------------- << 37 // ---------------------------------------------------------------
35 #ifndef G4Threading_hh 38 #ifndef G4Threading_hh
36 #define G4Threading_hh 1 << 39 #define G4Threading_hh
37 40
38 #include "G4Types.hh" 41 #include "G4Types.hh"
39 #include "globals.hh" <<
40 <<
41 #include <chrono> <<
42 #include <condition_variable> <<
43 #include <future> <<
44 #include <mutex> <<
45 #include <thread> <<
46 #include <vector> <<
47 42
48 // Macro to put current thread to sleep 43 // Macro to put current thread to sleep
49 // 44 //
50 #define G4THREADSLEEP(tick) << 45 #if defined(WIN32)
51 std::this_thread::sleep_for(std::chrono::sec << 46 #define G4THREADSLEEP( tick ) { Sleep(tick); }
52 << 47 #else
53 // Will be used in the future when migrating t << 48 #include <unistd.h> // needed for sleep()
54 template <typename _Tp> << 49 #define G4THREADSLEEP( tick ) { sleep(tick); }
55 using G4Future = std::future<_Tp>; << 50 #endif
56 template <typename _Tp> <<
57 using G4SharedFuture = std::shared_future<_Tp> <<
58 template <typename _Tp> <<
59 using G4Promise = std::promise<_Tp>; <<
60 <<
61 // NOTE ON GEANT4 SERIAL BUILDS AND M <<
62 // ================================== <<
63 // <<
64 // G4Mutex and G4RecursiveMutex are always C++ <<
65 // however, in serial mode, using G4MUTEXLOCK <<
66 // types has no effect -- i.e. the mutexes are <<
67 // <<
68 // Additionally, when a G4Mutex or G4Recursive <<
69 // and G4RecursiveAutoLock, respectively, thes <<
70 // the locking and unlocking of the mutex. Reg <<
71 // G4AutoLock and G4RecursiveAutoLock inherit <<
72 // and std::unique_lock<std::recursive_mutex>, <<
73 // that in situations (such as is needed by th <<
74 // G4AutoLock and G4RecursiveAutoLock can be p <<
75 // a std::unique_lock. Within these functions, <<
76 // member functions are not virtual, they will <<
77 // and unlocking behavior <<
78 // --> An example of this behavior can be foun <<
79 <<
80 // Global mutex types <<
81 using G4Mutex = std::mutex; <<
82 using G4RecursiveMutex = std::recursive_mutex; <<
83 <<
84 // Mutex macros <<
85 #define G4MUTEX_INITIALIZER <<
86 {} <<
87 #define G4MUTEXINIT(mutex) <<
88 ; <<
89 ; <<
90 #define G4MUTEXDESTROY(mutex) <<
91 ; <<
92 ; <<
93 <<
94 // Static functions: get_id(), sleep_for(...), <<
95 namespace G4ThisThread <<
96 { <<
97 using namespace std::this_thread; <<
98 } <<
99 <<
100 // Will be used in the future when migrating t <<
101 // and are currently used in unit tests <<
102 template <typename _Tp> <<
103 using G4Promise = std::promise<_Tp>; <<
104 template <typename _Tp> <<
105 using G4Future = std::future<_Tp>; <<
106 template <typename _Tp> <<
107 using G4SharedFuture = std::shared_future<_Tp> <<
108 <<
109 // Some useful types <<
110 using G4ThreadFunReturnType = void*; <<
111 using G4ThreadFunArgType = void*; <<
112 using thread_lock = <<
113 G4int (*)(G4Mutex*); // typedef G4int (*thr <<
114 using thread_unlock = <<
115 G4int (*)(G4Mutex*); // typedef G4int (*thr <<
116 <<
117 // Helper function for getting a unique static <<
118 // class or type <<
119 // Usage example: <<
120 // a template class "G4Cache<T>" that requir <<
121 // mutex for specific to type T: <<
122 // G4AutoLock l(G4TypeMutex<G4Cache<T>>() <<
123 template <typename _Tp> <<
124 G4Mutex& G4TypeMutex() <<
125 { <<
126 static G4Mutex _mutex; <<
127 return _mutex; <<
128 } <<
129 <<
130 // Helper function for getting a unique static <<
131 // specific class or type <<
132 // Usage example: <<
133 // a template class "G4Cache<T> <<
134 // recursive_mutex for specific <<
135 // G4RecursiveAutoLock <<
136 // l(G4TypeRecursiveMut <<
137 template <typename _Tp> <<
138 G4RecursiveMutex& G4TypeRecursiveMutex() <<
139 { <<
140 static G4RecursiveMutex _mutex; <<
141 return _mutex; <<
142 } <<
143 51
144 #if defined(G4MULTITHREADED) 52 #if defined(G4MULTITHREADED)
145 //========================================== << 53 //===============================
146 // G4MULTITHREADED is ON - threading enabled << 54 // Multi-threaded build
147 //========================================== << 55 //===============================
148 << 56 #if ( defined(__MACH__) && defined(__clang__) && defined(__x86_64__) ) || \
149 // global thread types << 57 ( defined(__MACH__) && defined(__GNUC__) && (__GNUC__>=4 && __GNUC_MINOR__>=7 || __GNUC__>=5) ) || \
150 using G4Thread = std::thread; << 58 defined(__linux__) || defined(_AIX)
151 using G4NativeThread = std::thread::native_han << 59 //
152 << 60 // Multi-threaded build: for POSIX systems
153 // mutex macros << 61 //
154 # define G4MUTEXLOCK(mutex) << 62 #include <pthread.h>
155 { << 63 #if defined(__MACH__) // needed only for MacOSX for definition of pid_t
156 (mutex)->lock(); << 64 #include <sys/types.h>
157 } << 65 #endif
158 # define G4MUTEXUNLOCK(mutex) << 66
159 { << 67 typedef pthread_mutex_t G4Mutex;
160 (mutex)->unlock(); << 68 typedef pthread_t G4Thread;
>> 69
>> 70 // G4Mutex initializer macro
>> 71 //
>> 72 #define G4MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
>> 73
>> 74 // Lock/unlock a G4Mutex function name
>> 75 //
>> 76 #define G4MUTEXLOCK pthread_mutex_lock
>> 77 #define G4MUTEXUNLOCK pthread_mutex_unlock
>> 78
>> 79 // Macro to initialize a Mutex
>> 80 //
>> 81 #define G4MUTEXINIT(mutex) pthread_mutex_init( &mutex , NULL);
>> 82 #define G4MUTEXDESTROY(mutex) pthread_mutex_destroy( &mutex );
>> 83
>> 84 // Macro to create a G4Thread object
>> 85 //
>> 86 #define G4THREADCREATE( worker , func , arg ) { \
>> 87 pthread_attr_t attr; \
>> 88 pthread_attr_init(&attr); \
>> 89 pthread_attr_setstacksize(&attr,16*1024*1024); \
>> 90 pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE); \
>> 91 pthread_create( worker, &attr, func , arg ); \
161 } 92 }
162 93
163 // Macro to join thread << 94 // Macro to join thread
164 # define G4THREADJOIN(worker) (worker).join() << 95 //
165 << 96 #define G4THREADJOIN( worker ) pthread_join( worker , NULL)
166 // std::thread::id does not cast to integer << 97
167 using G4Pid_t = std::thread::id; << 98 // Macro to retrieve caller thread
168 << 99 //
169 // Instead of previous macro taking one argume << 100 #define G4THREADSELF pthread_self
170 // unlimited arguments << 101
171 template <typename _Worker, typename _Func, ty << 102 // Some useful types
172 void G4THREADCREATE(_Worker*& worker, _Func fu << 103 //
173 { << 104 typedef void* G4ThreadFunReturnType;
174 *worker = G4Thread(func, std::forward<_Args> << 105 typedef void* G4ThreadFunArgType;
175 } << 106 typedef G4int (*thread_lock)(G4Mutex*);
176 << 107 typedef G4int (*thread_unlock)(G4Mutex*);
177 // Conditions << 108
178 // << 109 typedef pid_t G4Pid_t;
179 // See G4MTRunManager for example on how to us << 110
180 // << 111 // Conditions
181 using G4Condition = std::condition_variable; << 112 //
182 # define G4CONDITION_INITIALIZER << 113 // See G4MTRunManager for example on how to use these
183 {} << 114 // This complication is needed to be portable with WIN32
184 # define G4CONDITIONWAIT(cond, lock) (cond)-> << 115 // Note that WIN32 requires an additional initialization step.
185 # define G4CONDITIONWAITLAMBDA(cond, lock, la << 116 // See example code
186 # define G4CONDITIONNOTIFY(cond) (cond)->noti << 117 //
187 # define G4CONDITIONBROADCAST(cond) (cond)->n << 118 typedef pthread_cond_t G4Condition;
188 // << 119 #define G4CONDITION_INITIALIZER PTHREAD_COND_INITIALIZER
189 // we don't define above globally so single-th << 120
190 // caught in condition with no other thread to << 121 #define G4CONDITIONWAIT( cond, mutex ) pthread_cond_wait( cond , mutex );
191 // << 122 #define G4CONDTIONBROADCAST( cond ) pthread_cond_broadcast( cond );
>> 123
>> 124 #elif defined(WIN32)
>> 125 //
>> 126 // Multi-threaded build: for Windows systems
>> 127 //
>> 128 #include "windefs.hh" // Include 'safe...' <windows.h>
>> 129
>> 130 typedef HANDLE G4Mutex;
>> 131 typedef HANDLE G4Thread;
>> 132
>> 133 #define G4MUTEX_INITIALIZER CreateMutex(NULL,FALSE,NULL)
>> 134 DWORD /*WINAPI*/ G4WaitForSingleObjectInf( __in G4Mutex m );
>> 135 #define G4MUTEXLOCK G4WaitForSingleObjectInf
>> 136
>> 137 // #define G4MUTEXINIT(mutex) InitializeCriticalSection( &mutex );
>> 138 #define G4MUTEXINIT(mutex);
>> 139 #define G4MUTEXDESTROY(mutex);
>> 140
>> 141 // Not clear why following two lines are needed...
>> 142 //
>> 143 BOOL G4ReleaseMutex( __in G4Mutex m);
>> 144 #define G4MUTEXUNLOCK G4ReleaseMutex
>> 145
>> 146 #define G4THREADCREATE( worker, func, arg ) { *worker = CreateThread( NULL, 16*1024*1024 , func , arg , 0 , NULL ); }
>> 147 #define G4THREADJOIN( worker ) WaitForSingleObject( worker , INFINITE);
>> 148 #define G4THREADSELF GetCurrentThreadId
>> 149 #define G4ThreadFunReturnType DWORD WINAPI
>> 150 typedef LPVOID G4ThreadFunArgType;
>> 151 typedef DWORD (*thread_lock)(G4Mutex);
>> 152 typedef BOOL (*thread_unlock)(G4Mutex);
>> 153 typedef DWORD G4Pid_t;
>> 154
>> 155 // Conditions
>> 156 //
>> 157 typedef CONDITION_VARIABLE G4Condition;
>> 158 #define G4CONDITION_INITIALIZER CONDITION_VARIABLE_INIT
>> 159
>> 160 #define G4CONDITIONWAIT( cond , criticalsectionmutex ) SleepConditionVariableCS( cond, criticalsectionmutex , INFINITE );
>> 161 #define G4CONDTIONBROADCAST( cond ) WakeAllConditionVariable( cond );
>> 162
>> 163 #else
>> 164
>> 165 #error "No Threading model technology supported for this platform. Use sequential build !"
>> 166
>> 167 #endif
>> 168
>> 169 #else
>> 170 //==========================================
>> 171 // G4MULTITHREADED is OFF - Sequential build
>> 172 //==========================================
>> 173 typedef G4int G4Mutex;
>> 174 typedef G4int G4Thread;
>> 175 #define G4MUTEX_INITIALIZER 1
>> 176 G4int fake_mutex_lock_unlock( G4Mutex* );// { return 0; }
>> 177 #define G4MUTEXINIT(mutex) ;;
>> 178 #define G4MUTEXDESTROY(mutex) ;;
>> 179 #define G4MUTEXLOCK fake_mutex_lock_unlock
>> 180 #define G4MUTEXUNLOCK fake_mutex_lock_unlock
>> 181 #define G4THREADCREATE( worker , func , arg ) ;;
>> 182 #define G4THREADJOIN( worker ) ;;
>> 183 #define G4THREADSELF( nothing ) G4Thread(nothing);
>> 184 typedef void* G4ThreadFunReturnType;
>> 185 typedef void* G4ThreadFunArgType;
>> 186 typedef G4int (*thread_lock)(G4Mutex*);
>> 187 typedef G4int (*thread_unlock)(G4Mutex*);
>> 188 typedef G4int G4Pid_t;
>> 189 typedef G4int G4Condition;
>> 190 #define G4CONDITION_INITIALIZER 1
>> 191 #define G4CONDITIONWAIT( cond, mutex ) ;;
>> 192 #define G4CONDTIONBROADCAST( cond ) ;;
192 193
193 #else << 194 #endif //G4MULTITHREADING
194 //========================================== <<
195 // G4MULTITHREADED is OFF - Sequential build <<
196 //========================================== <<
197 <<
198 // implement a dummy thread class that acts li <<
199 class G4DummyThread <<
200 { <<
201 public: <<
202 using native_handle_type = G4int; <<
203 using id = std::thread::id; <<
204 <<
205 public: <<
206 // does nothing <<
207 G4DummyThread() {} <<
208 // a std::thread-like constructor that execu <<
209 template <typename _Func, typename... _Args> <<
210 G4DummyThread(_Func func, _Args&&... _args) <<
211 { <<
212 func(std::forward<_Args>(_args)...); <<
213 } <<
214 <<
215 public: <<
216 native_handle_type native_handle() const { r <<
217 G4bool joinable() const { return true; } <<
218 id get_id() const noexcept { return std::thi <<
219 void swap(G4DummyThread&) {} <<
220 void join() {} <<
221 void detach() {} <<
222 <<
223 public: <<
224 static unsigned int hardware_concurrency() n <<
225 { <<
226 return std::thread::hardware_concurrency() <<
227 } <<
228 }; <<
229 <<
230 // global thread types <<
231 using G4Thread = G4DummyThread; <<
232 using G4NativeThread = G4DummyThread::native_h <<
233 <<
234 // mutex macros <<
235 # define G4MUTEXLOCK(mutex) <<
236 ; <<
237 ; <<
238 # define G4MUTEXUNLOCK(mutex) <<
239 ; <<
240 ; <<
241 <<
242 // Macro to join thread <<
243 # define G4THREADJOIN(worker) <<
244 ; <<
245 ; <<
246 <<
247 using G4Pid_t = G4int; <<
248 <<
249 // Instead of previous macro taking one argume <<
250 // unlimited arguments <<
251 template <typename _Worker, typename _Func, ty <<
252 void G4THREADCREATE(_Worker*& worker, _Func fu <<
253 { <<
254 *worker = G4Thread(func, std::forward<_Args> <<
255 } <<
256 <<
257 using G4Condition = G4int; <<
258 # define G4CONDITION_INITIALIZER 1 <<
259 # define G4CONDITIONWAIT(cond, mutex) G4Consu <<
260 # define G4CONDITIONWAITLAMBDA(cond, mutex, l <<
261 G4ConsumeParameters(cond, mutex, lambda); <<
262 # define G4CONDITIONNOTIFY(cond) G4ConsumePar <<
263 # define G4CONDITIONBROADCAST(cond) G4Consume <<
264 <<
265 #endif // G4MULTITHREADING <<
266 <<
267 //============================================ <<
268 <<
269 // Define here after G4Thread has been typedef <<
270 using G4ThreadId = G4Thread::id; <<
271 <<
272 //============================================ <<
273 195
274 namespace G4Threading 196 namespace G4Threading
275 { 197 {
276 enum << 198 enum {
277 { << 199 SEQUENTIAL_ID = -2,
278 SEQUENTIAL_ID = -2, << 200 MASTER_ID = -1,
279 MASTER_ID = -1, << 201 WORKER_ID = 0,
280 WORKER_ID = 0, << 202 GENERICTHREAD_ID = -1000
281 GENERICTHREAD_ID = -1000 << 203 };
282 }; <<
283 <<
284 G4Pid_t G4GetPidId(); 204 G4Pid_t G4GetPidId();
285 G4int G4GetNumberOfCores(); 205 G4int G4GetNumberOfCores();
286 G4int G4GetThreadId(); 206 G4int G4GetThreadId();
287 G4bool IsWorkerThread(); 207 G4bool IsWorkerThread();
288 G4bool IsMasterThread(); << 208 void G4SetThreadId( G4int aNewValue );
289 void G4SetThreadId(G4int aNewValue); << 209 G4bool G4SetPinAffinity( G4int idx , G4Thread& at);
290 G4bool G4SetPinAffinity(G4int idx, G4NativeT <<
291 void SetMultithreadedApplication(G4bool valu 210 void SetMultithreadedApplication(G4bool value);
292 G4bool IsMultithreadedApplication(); 211 G4bool IsMultithreadedApplication();
293 G4int WorkerThreadLeavesPool(); << 212 }
294 G4int WorkerThreadJoinsPool(); <<
295 G4int GetNumberOfRunningWorkerThreads(); <<
296 } // namespace G4Threading <<
297 213
298 #endif // G4Threading_hh << 214 #endif //G4Threading_hh
299 215