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