| 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 // G4Threading
27 // 27 //
28 // Description: 28 // Description:
29 // 29 //
30 // This unit defines types and macros used to 30 // This unit defines types and macros used to expose Geant4 threading model.
31 31
32 // Author: Andrea Dotti, 15 February 2013 - Fi 32 // Author: Andrea Dotti, 15 February 2013 - First Implementation
33 // Revision: Jonathan R. Madsen, 21 February 2 33 // Revision: Jonathan R. Madsen, 21 February 2018
34 // ------------------------------------------- 34 // --------------------------------------------------------------------
35 #ifndef G4Threading_hh 35 #ifndef G4Threading_hh
36 #define G4Threading_hh 1 36 #define G4Threading_hh 1
37 37
38 #include "G4Types.hh" 38 #include "G4Types.hh"
39 #include "globals.hh" 39 #include "globals.hh"
40 40
41 #include <chrono> 41 #include <chrono>
42 #include <condition_variable> 42 #include <condition_variable>
43 #include <future> 43 #include <future>
44 #include <mutex> 44 #include <mutex>
45 #include <thread> 45 #include <thread>
46 #include <vector> 46 #include <vector>
47 47
48 // Macro to put current thread to sleep 48 // Macro to put current thread to sleep
49 // 49 //
50 #define G4THREADSLEEP(tick) 50 #define G4THREADSLEEP(tick) \
51 std::this_thread::sleep_for(std::chrono::sec 51 std::this_thread::sleep_for(std::chrono::seconds(tick))
52 52
53 // Will be used in the future when migrating t 53 // Will be used in the future when migrating threading to task-based style
54 template <typename _Tp> 54 template <typename _Tp>
55 using G4Future = std::future<_Tp>; 55 using G4Future = std::future<_Tp>;
56 template <typename _Tp> 56 template <typename _Tp>
57 using G4SharedFuture = std::shared_future<_Tp> 57 using G4SharedFuture = std::shared_future<_Tp>;
58 template <typename _Tp> 58 template <typename _Tp>
59 using G4Promise = std::promise<_Tp>; 59 using G4Promise = std::promise<_Tp>;
60 60
61 // NOTE ON GEANT4 SERIAL BUILDS AND M 61 // NOTE ON GEANT4 SERIAL BUILDS AND MUTEX/UNIQUE_LOCK
62 // ================================== 62 // ==================================================
63 // 63 //
64 // G4Mutex and G4RecursiveMutex are always C++ 64 // G4Mutex and G4RecursiveMutex are always C++11 std::mutex types
65 // however, in serial mode, using G4MUTEXLOCK 65 // however, in serial mode, using G4MUTEXLOCK and G4MUTEXUNLOCK on these
66 // types has no effect -- i.e. the mutexes are 66 // types has no effect -- i.e. the mutexes are not actually locked or unlocked
67 // 67 //
68 // Additionally, when a G4Mutex or G4Recursive 68 // Additionally, when a G4Mutex or G4RecursiveMutex is used with G4AutoLock
69 // and G4RecursiveAutoLock, respectively, thes 69 // and G4RecursiveAutoLock, respectively, these classes also suppressing
70 // the locking and unlocking of the mutex. Reg 70 // the locking and unlocking of the mutex. Regardless of the build type,
71 // G4AutoLock and G4RecursiveAutoLock inherit 71 // G4AutoLock and G4RecursiveAutoLock inherit from std::unique_lock<std::mutex>
72 // and std::unique_lock<std::recursive_mutex>, 72 // and std::unique_lock<std::recursive_mutex>, respectively. This means
73 // that in situations (such as is needed by th 73 // that in situations (such as is needed by the analysis category), the
74 // G4AutoLock and G4RecursiveAutoLock can be p 74 // G4AutoLock and G4RecursiveAutoLock can be passed to functions requesting
75 // a std::unique_lock. Within these functions, 75 // a std::unique_lock. Within these functions, since std::unique_lock
76 // member functions are not virtual, they will 76 // member functions are not virtual, they will not retain the dummy locking
77 // and unlocking behavior 77 // and unlocking behavior
78 // --> An example of this behavior can be foun 78 // --> An example of this behavior can be found in G4AutoLock.hh
79 79
80 // Global mutex types 80 // Global mutex types
81 using G4Mutex = std::mutex; 81 using G4Mutex = std::mutex;
82 using G4RecursiveMutex = std::recursive_mutex; 82 using G4RecursiveMutex = std::recursive_mutex;
83 83
84 // Mutex macros 84 // Mutex macros
85 #define G4MUTEX_INITIALIZER 85 #define G4MUTEX_INITIALIZER \
86 {} 86 {}
87 #define G4MUTEXINIT(mutex) 87 #define G4MUTEXINIT(mutex) \
88 ; 88 ; \
89 ; 89 ;
90 #define G4MUTEXDESTROY(mutex) 90 #define G4MUTEXDESTROY(mutex) \
91 ; 91 ; \
92 ; 92 ;
93 93
94 // Static functions: get_id(), sleep_for(...), 94 // Static functions: get_id(), sleep_for(...), sleep_until(...), yield(),
95 namespace G4ThisThread 95 namespace G4ThisThread
96 { 96 {
97 using namespace std::this_thread; 97 using namespace std::this_thread;
98 } 98 }
99 99
100 // Will be used in the future when migrating t 100 // Will be used in the future when migrating threading to task-based style
101 // and are currently used in unit tests 101 // and are currently used in unit tests
102 template <typename _Tp> 102 template <typename _Tp>
103 using G4Promise = std::promise<_Tp>; 103 using G4Promise = std::promise<_Tp>;
104 template <typename _Tp> 104 template <typename _Tp>
105 using G4Future = std::future<_Tp>; 105 using G4Future = std::future<_Tp>;
106 template <typename _Tp> 106 template <typename _Tp>
107 using G4SharedFuture = std::shared_future<_Tp> 107 using G4SharedFuture = std::shared_future<_Tp>;
108 108
109 // Some useful types 109 // Some useful types
110 using G4ThreadFunReturnType = void*; 110 using G4ThreadFunReturnType = void*;
111 using G4ThreadFunArgType = void*; 111 using G4ThreadFunArgType = void*;
112 using thread_lock = 112 using thread_lock =
113 G4int (*)(G4Mutex*); // typedef G4int (*thr 113 G4int (*)(G4Mutex*); // typedef G4int (*thread_lock)(G4Mutex*);
114 using thread_unlock = 114 using thread_unlock =
115 G4int (*)(G4Mutex*); // typedef G4int (*thr 115 G4int (*)(G4Mutex*); // typedef G4int (*thread_unlock)(G4Mutex*);
116 116
117 // Helper function for getting a unique static 117 // Helper function for getting a unique static mutex for a specific
118 // class or type 118 // class or type
119 // Usage example: 119 // Usage example:
120 // a template class "G4Cache<T>" that requir 120 // a template class "G4Cache<T>" that required a static
121 // mutex for specific to type T: 121 // mutex for specific to type T:
122 // G4AutoLock l(G4TypeMutex<G4Cache<T>>() 122 // G4AutoLock l(G4TypeMutex<G4Cache<T>>());
123 template <typename _Tp> 123 template <typename _Tp>
124 G4Mutex& G4TypeMutex() 124 G4Mutex& G4TypeMutex()
125 { 125 {
126 static G4Mutex _mutex; 126 static G4Mutex _mutex;
127 return _mutex; 127 return _mutex;
128 } 128 }
129 129
130 // Helper function for getting a unique static 130 // Helper function for getting a unique static recursive_mutex for a
131 // specific class or type 131 // specific class or type
132 // Usage example: 132 // Usage example:
133 // a template class "G4Cache<T> 133 // a template class "G4Cache<T>" that required a static
134 // recursive_mutex for specific 134 // recursive_mutex for specific to type T:
135 // G4RecursiveAutoLock 135 // G4RecursiveAutoLock
136 // l(G4TypeRecursiveMut 136 // l(G4TypeRecursiveMutex<G4Cache<T>>());
137 template <typename _Tp> 137 template <typename _Tp>
138 G4RecursiveMutex& G4TypeRecursiveMutex() 138 G4RecursiveMutex& G4TypeRecursiveMutex()
139 { 139 {
140 static G4RecursiveMutex _mutex; 140 static G4RecursiveMutex _mutex;
141 return _mutex; 141 return _mutex;
142 } 142 }
143 143
144 #if defined(G4MULTITHREADED) 144 #if defined(G4MULTITHREADED)
145 //========================================== 145 //==========================================
146 // G4MULTITHREADED is ON - threading enabled 146 // G4MULTITHREADED is ON - threading enabled
147 //========================================== 147 //==========================================
148 148
149 // global thread types 149 // global thread types
150 using G4Thread = std::thread; 150 using G4Thread = std::thread;
151 using G4NativeThread = std::thread::native_han 151 using G4NativeThread = std::thread::native_handle_type;
152 152
153 // mutex macros 153 // mutex macros
154 # define G4MUTEXLOCK(mutex) 154 # define G4MUTEXLOCK(mutex) \
155 { 155 { \
156 (mutex)->lock(); 156 (mutex)->lock(); \
157 } 157 }
158 # define G4MUTEXUNLOCK(mutex) 158 # define G4MUTEXUNLOCK(mutex) \
159 { 159 { \
160 (mutex)->unlock(); 160 (mutex)->unlock(); \
161 } 161 }
162 162
163 // Macro to join thread 163 // Macro to join thread
164 # define G4THREADJOIN(worker) (worker).join() 164 # define G4THREADJOIN(worker) (worker).join()
165 165
166 // std::thread::id does not cast to integer 166 // std::thread::id does not cast to integer
167 using G4Pid_t = std::thread::id; 167 using G4Pid_t = std::thread::id;
168 168
169 // Instead of previous macro taking one argume 169 // Instead of previous macro taking one argument, define function taking
170 // unlimited arguments 170 // unlimited arguments
171 template <typename _Worker, typename _Func, ty 171 template <typename _Worker, typename _Func, typename... _Args>
172 void G4THREADCREATE(_Worker*& worker, _Func fu 172 void G4THREADCREATE(_Worker*& worker, _Func func, _Args... args)
173 { 173 {
174 *worker = G4Thread(func, std::forward<_Args> 174 *worker = G4Thread(func, std::forward<_Args>(args)...);
175 } 175 }
176 176
177 // Conditions 177 // Conditions
178 // 178 //
179 // See G4MTRunManager for example on how to us 179 // See G4MTRunManager for example on how to use these
180 // 180 //
181 using G4Condition = std::condition_variable; 181 using G4Condition = std::condition_variable;
182 # define G4CONDITION_INITIALIZER 182 # define G4CONDITION_INITIALIZER \
183 {} 183 {}
184 # define G4CONDITIONWAIT(cond, lock) (cond)-> 184 # define G4CONDITIONWAIT(cond, lock) (cond)->wait(*lock);
185 # define G4CONDITIONWAITLAMBDA(cond, lock, la 185 # define G4CONDITIONWAITLAMBDA(cond, lock, lambda) (cond)->wait(*lock, lambda);
186 # define G4CONDITIONNOTIFY(cond) (cond)->noti 186 # define G4CONDITIONNOTIFY(cond) (cond)->notify_one();
187 # define G4CONDITIONBROADCAST(cond) (cond)->n 187 # define G4CONDITIONBROADCAST(cond) (cond)->notify_all();
188 // 188 //
189 // we don't define above globally so single-th 189 // we don't define above globally so single-threaded code does not get
190 // caught in condition with no other thread to 190 // caught in condition with no other thread to wake it up
191 // 191 //
192 192
193 #else 193 #else
194 //========================================== 194 //==========================================
195 // G4MULTITHREADED is OFF - Sequential build 195 // G4MULTITHREADED is OFF - Sequential build
196 //========================================== 196 //==========================================
197 197
198 // implement a dummy thread class that acts li 198 // implement a dummy thread class that acts like a thread
199 class G4DummyThread 199 class G4DummyThread
200 { 200 {
201 public: 201 public:
202 using native_handle_type = G4int; 202 using native_handle_type = G4int;
203 using id = std::thread::id; 203 using id = std::thread::id;
204 204
205 public: 205 public:
206 // does nothing 206 // does nothing
207 G4DummyThread() {} 207 G4DummyThread() {}
208 // a std::thread-like constructor that execu 208 // a std::thread-like constructor that execute upon construction
209 template <typename _Func, typename... _Args> 209 template <typename _Func, typename... _Args>
210 G4DummyThread(_Func func, _Args&&... _args) 210 G4DummyThread(_Func func, _Args&&... _args)
211 { 211 {
212 func(std::forward<_Args>(_args)...); 212 func(std::forward<_Args>(_args)...);
213 } 213 }
214 214
215 public: 215 public:
216 native_handle_type native_handle() const { r 216 native_handle_type native_handle() const { return native_handle_type(); }
217 G4bool joinable() const { return true; } 217 G4bool joinable() const { return true; }
218 id get_id() const noexcept { return std::thi 218 id get_id() const noexcept { return std::this_thread::get_id(); }
219 void swap(G4DummyThread&) {} 219 void swap(G4DummyThread&) {}
220 void join() {} 220 void join() {}
221 void detach() {} 221 void detach() {}
222 222
223 public: 223 public:
224 static unsigned int hardware_concurrency() n 224 static unsigned int hardware_concurrency() noexcept
225 { 225 {
226 return std::thread::hardware_concurrency() 226 return std::thread::hardware_concurrency();
227 } 227 }
228 }; 228 };
229 229
230 // global thread types 230 // global thread types
231 using G4Thread = G4DummyThread; 231 using G4Thread = G4DummyThread;
232 using G4NativeThread = G4DummyThread::native_h 232 using G4NativeThread = G4DummyThread::native_handle_type;
233 233
234 // mutex macros 234 // mutex macros
235 # define G4MUTEXLOCK(mutex) 235 # define G4MUTEXLOCK(mutex) \
236 ; 236 ; \
237 ; 237 ;
238 # define G4MUTEXUNLOCK(mutex) 238 # define G4MUTEXUNLOCK(mutex) \
239 ; 239 ; \
240 ; 240 ;
241 241
242 // Macro to join thread 242 // Macro to join thread
243 # define G4THREADJOIN(worker) 243 # define G4THREADJOIN(worker) \
244 ; 244 ; \
245 ; 245 ;
246 246
247 using G4Pid_t = G4int; 247 using G4Pid_t = G4int;
248 248
249 // Instead of previous macro taking one argume 249 // Instead of previous macro taking one argument, define function taking
250 // unlimited arguments 250 // unlimited arguments
251 template <typename _Worker, typename _Func, ty 251 template <typename _Worker, typename _Func, typename... _Args>
252 void G4THREADCREATE(_Worker*& worker, _Func fu 252 void G4THREADCREATE(_Worker*& worker, _Func func, _Args... args)
253 { 253 {
254 *worker = G4Thread(func, std::forward<_Args> 254 *worker = G4Thread(func, std::forward<_Args>(args)...);
255 } 255 }
256 256
257 using G4Condition = G4int; 257 using G4Condition = G4int;
258 # define G4CONDITION_INITIALIZER 1 258 # define G4CONDITION_INITIALIZER 1
259 # define G4CONDITIONWAIT(cond, mutex) G4Consu 259 # define G4CONDITIONWAIT(cond, mutex) G4ConsumeParameters(cond, mutex);
260 # define G4CONDITIONWAITLAMBDA(cond, mutex, l 260 # define G4CONDITIONWAITLAMBDA(cond, mutex, lambda) \
261 G4ConsumeParameters(cond, mutex, lambda); 261 G4ConsumeParameters(cond, mutex, lambda);
262 # define G4CONDITIONNOTIFY(cond) G4ConsumePar 262 # define G4CONDITIONNOTIFY(cond) G4ConsumeParameters(cond);
263 # define G4CONDITIONBROADCAST(cond) G4Consume 263 # define G4CONDITIONBROADCAST(cond) G4ConsumeParameters(cond);
264 264
265 #endif // G4MULTITHREADING 265 #endif // G4MULTITHREADING
266 266
267 //============================================ 267 //============================================================================//
268 268
269 // Define here after G4Thread has been typedef 269 // Define here after G4Thread has been typedef
270 using G4ThreadId = G4Thread::id; 270 using G4ThreadId = G4Thread::id;
271 271
272 //============================================ 272 //============================================================================//
273 273
274 namespace G4Threading 274 namespace G4Threading
275 { 275 {
276 enum 276 enum
277 { 277 {
278 SEQUENTIAL_ID = -2, 278 SEQUENTIAL_ID = -2,
279 MASTER_ID = -1, 279 MASTER_ID = -1,
280 WORKER_ID = 0, 280 WORKER_ID = 0,
281 GENERICTHREAD_ID = -1000 281 GENERICTHREAD_ID = -1000
282 }; 282 };
283 283
284 G4Pid_t G4GetPidId(); 284 G4Pid_t G4GetPidId();
285 G4int G4GetNumberOfCores(); 285 G4int G4GetNumberOfCores();
286 G4int G4GetThreadId(); 286 G4int G4GetThreadId();
287 G4bool IsWorkerThread(); 287 G4bool IsWorkerThread();
288 G4bool IsMasterThread(); 288 G4bool IsMasterThread();
289 void G4SetThreadId(G4int aNewValue); 289 void G4SetThreadId(G4int aNewValue);
290 G4bool G4SetPinAffinity(G4int idx, G4NativeT 290 G4bool G4SetPinAffinity(G4int idx, G4NativeThread& at);
291 void SetMultithreadedApplication(G4bool valu 291 void SetMultithreadedApplication(G4bool value);
292 G4bool IsMultithreadedApplication(); 292 G4bool IsMultithreadedApplication();
293 G4int WorkerThreadLeavesPool(); 293 G4int WorkerThreadLeavesPool();
294 G4int WorkerThreadJoinsPool(); 294 G4int WorkerThreadJoinsPool();
295 G4int GetNumberOfRunningWorkerThreads(); 295 G4int GetNumberOfRunningWorkerThreads();
296 } // namespace G4Threading 296 } // namespace G4Threading
297 297
298 #endif // G4Threading_hh 298 #endif // G4Threading_hh
299 299