| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // G4Threading
27 //
28 // Description:
29 //
30 // This unit defines types and macros used to
31
32 // Author: Andrea Dotti, 15 February 2013 - Fi
33 // Revision: Jonathan R. Madsen, 21 February 2
34 // -------------------------------------------
35 #ifndef G4Threading_hh
36 #define G4Threading_hh 1
37
38 #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
144 #if defined(G4MULTITHREADED)
145 //==========================================
146 // G4MULTITHREADED is ON - threading enabled
147 //==========================================
148
149 // global thread types
150 using G4Thread = std::thread;
151 using G4NativeThread = std::thread::native_han
152
153 // mutex macros
154 # define G4MUTEXLOCK(mutex)
155 {
156 (mutex)->lock();
157 }
158 # define G4MUTEXUNLOCK(mutex)
159 {
160 (mutex)->unlock();
161 }
162
163 // Macro to join thread
164 # define G4THREADJOIN(worker) (worker).join()
165
166 // std::thread::id does not cast to integer
167 using G4Pid_t = std::thread::id;
168
169 // Instead of previous macro taking one argume
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
284 G4Pid_t G4GetPidId();
285 G4int G4GetNumberOfCores();
286 G4int G4GetThreadId();
287 G4bool IsWorkerThread();
288 G4bool IsMasterThread();
289 void G4SetThreadId(G4int aNewValue);
290 G4bool G4SetPinAffinity(G4int idx, G4NativeT
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