| 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 <<
48 // Macro to put current thread to sleep <<
49 // <<
50 #define G4THREADSLEEP(tick) <<
51 std::this_thread::sleep_for(std::chrono::sec <<
52 <<
53 // Will be used in the future when migrating t <<
54 template <typename _Tp> <<
55 using G4Future = std::future<_Tp>; <<
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 42
144 #if defined(G4MULTITHREADED) 43 #if defined(G4MULTITHREADED)
145 //========================================== << 44 //===============================
146 // G4MULTITHREADED is ON - threading enabled << 45 // Multi-threaded build
147 //========================================== << 46 //===============================
148 << 47 #if ( defined(__MACH__) && defined(__clang__) && defined(__x86_64__) ) || \
149 // global thread types << 48 ( defined(__MACH__) && defined(__GNUC__) && __GNUC__>=4 && __GNUC_MINOR__>=7 ) || \
150 using G4Thread = std::thread; << 49 defined(__linux__) || defined(_AIX)
151 using G4NativeThread = std::thread::native_han << 50 //
152 << 51 // Multi-threaded build: for POSIX systems
153 // mutex macros << 52 //
154 # define G4MUTEXLOCK(mutex) << 53 #include <pthread.h>
155 { << 54 #if defined(__MACH__) // needed only for MacOSX for definition of pid_t
156 (mutex)->lock(); << 55 #include <sys/types.h>
>> 56 #endif
>> 57
>> 58 typedef pthread_mutex_t G4Mutex;
>> 59 typedef pthread_t G4Thread;
>> 60
>> 61 // G4Mutex initializer macro
>> 62 //
>> 63 #define G4MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
>> 64
>> 65 // Lock/unlock a G4Mutex function name
>> 66 //
>> 67 #define G4MUTEXLOCK pthread_mutex_lock
>> 68 #define G4MUTEXUNLOCK pthread_mutex_unlock
>> 69
>> 70 // Macro to iniaizlie a Mutex
>> 71 #define G4MUTEXINIT(mutex) pthread_mutex_init( &mutex , NULL);
>> 72
>> 73 // Macro to create a G4Thread object
>> 74 //
>> 75 #define G4THREADCREATE( worker , func , arg ) { \
>> 76 pthread_attr_t attr; \
>> 77 pthread_attr_init(&attr); \
>> 78 pthread_attr_setstacksize(&attr,16*1024*1024); \
>> 79 pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE); \
>> 80 pthread_create( worker, &attr, func , arg ); \
157 } 81 }
158 # define G4MUTEXUNLOCK(mutex) <<
159 { <<
160 (mutex)->unlock(); <<
161 } <<
162 <<
163 // Macro to join thread <<
164 # define G4THREADJOIN(worker) (worker).join() <<
165 82
166 // std::thread::id does not cast to integer << 83 // Macro to join a G4Thread
167 using G4Pid_t = std::thread::id; << 84 //
>> 85 #define G4THREADJOIN( worker ) pthread_join( worker , NULL)
>> 86
>> 87 // Some useful types
>> 88 //
>> 89 typedef void* G4ThreadFunReturnType;
>> 90 typedef void* G4ThreadFunArgType;
>> 91 typedef G4int (*thread_lock)(G4Mutex*);
>> 92 typedef G4int (*thread_unlock)(G4Mutex*);
>> 93
>> 94 typedef pid_t G4Pid_t;
>> 95
>> 96 // Conditions
>> 97 //
>> 98 // See G4MTRunManager for example on how to use these
>> 99 // This complication is needed to be portable with WIN32
>> 100 // Note that WIN32 requires an additional initialization step.
>> 101 // See example code
>> 102 //
>> 103 typedef pthread_cond_t G4Condition;
>> 104 #define G4CONDITION_INITIALIZER PTHREAD_COND_INITIALIZER
>> 105
>> 106 #define G4CONDITIONWAIT( cond, mutex ) pthread_cond_wait( cond , mutex );
>> 107 #define G4CONDTIONBROADCAST( cond ) pthread_cond_broadcast( cond );
>> 108
>> 109 #elif defined(WIN32)
>> 110 //
>> 111 // Multi-threaded build: for Windows systems
>> 112 //
>> 113 #include "windefs.hh" // Include 'safe...' <windows.h>
>> 114
>> 115 typedef HANDLE G4Mutex;
>> 116 typedef HANDLE G4Thread;
>> 117
>> 118 #define G4MUTEX_INITIALIZER CreateMutex(NULL,FALSE,NULL)
>> 119 DWORD /*WINAPI*/ G4WaitForSingleObjectInf( __in G4Mutex m );
>> 120 #define G4MUTEXLOCK G4WaitForSingleObjectInf
>> 121
>> 122 // #define G4MUTEXINIT(mutex) InitializeCriticalSection( &mutex );
>> 123 #define G4MUTEXINIT(mutex);
>> 124
>> 125 // Not clear why following two lines are needed...
>> 126 //
>> 127 BOOL G4ReleaseMutex( __in G4Mutex m);
>> 128 #define G4MUTEXUNLOCK G4ReleaseMutex
>> 129
>> 130 #define G4THREADCREATE( worker, func, arg ) { *worker = CreateThread( NULL, 16*1024*1024 , func , arg , 0 , NULL ); }
>> 131 #define G4THREADJOIN( worker ) WaitForSingleObject( worker , INFINITE);
>> 132 #define G4ThreadFunReturnType DWORD WINAPI
>> 133 typedef LPVOID G4ThreadFunArgType;
>> 134 typedef DWORD (*thread_lock)(G4Mutex);
>> 135 typedef BOOL (*thread_unlock)(G4Mutex);
>> 136 typedef DWORD G4Pid_t;
>> 137
>> 138 // Conditions
>> 139 //
>> 140 typedef CONDITION_VARIABLE G4Condition;
>> 141 #define G4CONDITION_INITIALIZER CONDITION_VARIABLE_INIT
>> 142
>> 143 #define G4CONDITIONWAIT( cond , criticalsectionmutex ) SleepConditionVariableCS( cond, criticalsectionmutex , INFINITE );
>> 144 #define G4CONDTIONBROADCAST( cond ) WakeAllConditionVariable( cond );
>> 145
>> 146 #else
>> 147
>> 148 #error "No Threading model technology supported for this platform. Use sequential build !"
>> 149
>> 150 #endif
>> 151
>> 152 #else
>> 153 //==========================================
>> 154 // G4MULTITHREADED is OFF - Sequential build
>> 155 //==========================================
>> 156 typedef G4int G4Mutex;
>> 157 typedef G4int G4Thread;
>> 158 #define G4MUTEX_INITIALIZER 1
>> 159 G4int fake_mutex_lock_unlock( G4Mutex* );// { return 0; }
>> 160 #define G4MUTEXINIT(mutex) ;;
>> 161 #define G4MUTEXLOCK fake_mutex_lock_unlock
>> 162 #define G4MUTEXUNLOCK fake_mutex_lock_unlock
>> 163 #define G4THREADCREATE( worker , func , arg ) ;;
>> 164 #define G4THREADJOIN( worker ) ;;
>> 165 typedef void* G4ThreadFunReturnType;
>> 166 typedef void* G4ThreadFunArgType;
>> 167 typedef G4int (*thread_lock)(G4Mutex*);
>> 168 typedef G4int (*thread_unlock)(G4Mutex*);
>> 169 typedef G4int G4Pid_t;
>> 170 typedef G4int G4Condition;
>> 171 #define G4CONDITION_INITIALIZER 1
>> 172 #define G4CONDITIONWAIT( cond, mutex ) ;;
>> 173 #define G4CONDTIONBROADCAST( cond ) ;;
168 174
169 // Instead of previous macro taking one argume << 175 #endif //G4MULTITHREADING
170 // unlimited arguments <<
171 template <typename _Worker, typename _Func, ty <<
172 void G4THREADCREATE(_Worker*& worker, _Func fu <<
173 { <<
174 *worker = G4Thread(func, std::forward<_Args> <<
175 } <<
176 <<
177 // Conditions <<
178 // <<
179 // See G4MTRunManager for example on how to us <<
180 // <<
181 using G4Condition = std::condition_variable; <<
182 # define G4CONDITION_INITIALIZER <<
183 {} <<
184 # define G4CONDITIONWAIT(cond, lock) (cond)-> <<
185 # define G4CONDITIONWAITLAMBDA(cond, lock, la <<
186 # define G4CONDITIONNOTIFY(cond) (cond)->noti <<
187 # define G4CONDITIONBROADCAST(cond) (cond)->n <<
188 // <<
189 // we don't define above globally so single-th <<
190 // caught in condition with no other thread to <<
191 // <<
192 <<
193 #else <<
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 <<
274 namespace G4Threading <<
275 { <<
276 enum <<
277 { <<
278 SEQUENTIAL_ID = -2, <<
279 MASTER_ID = -1, <<
280 WORKER_ID = 0, <<
281 GENERICTHREAD_ID = -1000 <<
282 }; <<
283 176
>> 177 namespace G4Threading {
284 G4Pid_t G4GetPidId(); 178 G4Pid_t G4GetPidId();
285 G4int G4GetNumberOfCores(); 179 G4int G4GetNumberOfCores();
286 G4int G4GetThreadId(); 180 G4int G4GetThreadId();
287 G4bool IsWorkerThread(); 181 G4bool IsWorkerThread();
288 G4bool IsMasterThread(); << 182 void G4SetThreadId( G4int aNewValue );
289 void G4SetThreadId(G4int aNewValue); << 183 }
290 G4bool G4SetPinAffinity(G4int idx, G4NativeT << 184 #endif //G4Threading_hh
291 void SetMultithreadedApplication(G4bool valu <<
292 G4bool IsMultithreadedApplication(); <<
293 G4int WorkerThreadLeavesPool(); <<
294 G4int WorkerThreadJoinsPool(); <<
295 G4int GetNumberOfRunningWorkerThreads(); <<
296 } // namespace G4Threading <<
297 <<
298 #endif // G4Threading_hh <<
299 185