lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.7.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2020-12-04 12:30:43 +01:00
parent 67ba86d073
commit dab42d2018
3770 changed files with 226369 additions and 286486 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/tasking/include/G4RunManagerFactory.hh
+14 -9
View File
@@ -49,10 +49,14 @@
enum class G4RunManagerType : G4int
{
Serial = 0,
MT = 1,
Tasking = 2,
TBB = 3,
Serial = 0,
SerialOnly = 1,
MT = 2,
MTOnly = 3,
Tasking = 4,
TaskingOnly = 5,
TBB = 6,
TBBOnly = 7,
Default
};
@@ -61,7 +65,6 @@ enum class G4RunManagerType : G4int
class G4RunManagerFactory
{
public:
static G4RunManager* CreateRunManager(
G4RunManagerType _type = G4RunManagerType::Default,
G4VUserTaskQueue* _queue = nullptr, G4bool fail_if_unavail = true,
@@ -70,15 +73,14 @@ class G4RunManagerFactory
// provide a version which specifies to fail if unavailable
static G4RunManager* CreateRunManager(G4RunManagerType _type,
G4bool fail_if_unavail,
G4int nthreads = 0,
G4int nthreads = 0,
G4VUserTaskQueue* _queue = nullptr)
{
return CreateRunManager(_type, _queue, fail_if_unavail, nthreads);
}
static G4RunManager* CreateRunManager(G4RunManagerType _type,
G4int nthreads,
G4bool fail_if_unavail = true,
static G4RunManager* CreateRunManager(G4RunManagerType _type, G4int nthreads,
G4bool fail_if_unavail = true,
G4VUserTaskQueue* _queue = nullptr)
{
return CreateRunManager(_type, _queue, fail_if_unavail, nthreads);
@@ -95,6 +97,9 @@ class G4RunManagerFactory
static std::string GetName(G4RunManagerType);
static G4RunManagerType GetType(const std::string&);
static std::set<std::string> GetOptions();
static G4RunManager* GetMasterRunManager();
static G4MTRunManager* GetMTMasterRunManager();
static G4RunManagerKernel* GetMasterRunManagerKernel();
};
#endif // G4TaskRunManagerCreator_h
source/tasking/include/G4TaskRunManager.hh
+28 -32
View File
@@ -47,6 +47,7 @@
#include "G4Threading.hh"
#include "G4VUserTaskQueue.hh"
#include "G4EnvironmentUtils.hh"
#include "G4Profiler.hh"
#include "PTL/TaskRunManager.hh"
@@ -58,6 +59,7 @@ class G4ScoringManager;
class G4UserTaskInitialization;
class G4UserTaskThreadInitialization;
class G4WorkerTaskRunManager;
class G4RunManagerFactory;
//============================================================================//
@@ -65,12 +67,15 @@ class G4TaskRunManager
: public G4MTRunManager
, public PTL::TaskRunManager
{
friend class G4RunManagerFactory;
public:
// the profiler aliases are only used when compiled with GEANT4_USE_TIMEMORY
using ProfilerConfig = G4ProfilerConfig<G4ProfileType::Run>;
public:
using InitializeSeedsCallback = std::function<G4bool(G4int, G4int&, G4int&)>;
using WorkerRunSet = std::set<G4WorkerTaskRunManager**>;
using RunTaskGroup = G4TaskGroup<void>;
using RunTaskGroupTBB = G4TBBTaskGroup<WorkerRunSet, G4WorkerTaskRunManager**>;
using RunTaskGroup = G4TaskGroup<void>;
using RunTaskGroupTBB = G4TBBTaskGroup<void>;
public:
// Parameters:
@@ -79,7 +84,7 @@ class G4TaskRunManager
// evtGrainsize : the number of events per task
G4TaskRunManager(G4bool useTBB = G4GetEnv<G4bool>("G4USE_TBB", false));
G4TaskRunManager(G4VUserTaskQueue* taskQueue,
G4bool useTBB = G4GetEnv<G4bool>("G4USE_TBB", false),
G4bool useTBB = G4GetEnv<G4bool>("G4USE_TBB", false),
G4int evtGrainsize = 0);
virtual ~G4TaskRunManager();
@@ -154,33 +159,17 @@ class G4TaskRunManager
virtual void CreateAndStartWorkers() override;
// Creates worker threads and signal to start
private:
// grainsize
G4int eventGrainsize;
G4int numberOfEventsPerTask;
G4int numberOfTasks;
// List of workers run managers
// List of all workers run managers
CLHEP::HepRandomEngine* masterRNGEngine;
// Pointer to the mastet thread random engine
protected:
virtual void TerminateWorkers() override;
private:
// Handling of master thread scoring worlds, access to it is needed by workers
G4TASK_DLL static G4ScoringManager* masterScM;
G4TASK_DLL static masterWorlds_t masterWorlds;
// Singleton implementing master thread behavior
static G4TaskRunManager* fMasterRM;
G4TaskRunManagerKernel* MTkernel;
public: // with description
static G4TaskRunManager* GetMasterRunManager();
static G4TaskRunManager* GetMasterRunManager()
{
auto* _rm = G4MTRunManager::GetMasterRunManager();
return dynamic_cast<G4TaskRunManager*>(_rm);
}
// Returns the singleton instance of the run manager common to all threads
// implementing the master behavior
static G4RunManagerKernel* GetMasterRunManagerKernel();
static G4TaskRunManagerKernel* GetMTMasterRunManagerKernel();
// Returns the singleton instance of the run manager kernel common to all
// threads
@@ -211,12 +200,10 @@ class G4TaskRunManager
{
return WorkerActionRequest::UNDEFINED;
}
virtual void NewActionRequest(WorkerActionRequest) override {}
protected:
// WorkerActionRequest nextActionRequest;
// virtual void NewActionRequest( WorkerActionRequest newRequest );
virtual void AddEventTask(G4int, G4int);
virtual void NewActionRequest(WorkerActionRequest) override {}
virtual void AddEventTask(G4int);
public:
inline void SetInitializeSeedsCallback(InitializeSeedsCallback f)
@@ -228,13 +215,22 @@ class G4TaskRunManager
virtual void AbortRun(G4bool softAbort = false) override;
virtual void AbortEvent() override;
private:
// grainsize
bool workersStarted = false;
G4int eventGrainsize = 0;
G4int numberOfEventsPerTask = -1;
G4int numberOfTasks = -1;
CLHEP::HepRandomEngine* masterRNGEngine = nullptr;
// Pointer to the master thread random engine
G4TaskRunManagerKernel* MTkernel = nullptr;
protected:
// Barriers: synch points between master and workers
RunTaskGroup* workTaskGroup = nullptr;
RunTaskGroupTBB* workTaskGroupTBB = nullptr;
RunTaskGroup* workTaskGroup = nullptr;
// aliases to inherited member values
G4bool& poolInitialized = PTL::TaskRunManager::m_is_initialized;
G4bool& poolInitialized = PTL::TaskRunManager::m_is_initialized;
G4ThreadPool*& threadPool = PTL::TaskRunManager::m_thread_pool;
G4VUserTaskQueue*& taskQueue = PTL::TaskRunManager::m_task_queue;
G4TaskManager*& taskManager = PTL::TaskRunManager::m_task_manager;
source/tasking/include/G4TaskRunManagerKernel.hh
+4 -3
View File
@@ -72,11 +72,12 @@ class G4TaskRunManagerKernel : public G4RunManagerKernel
static G4WorkerThread* GetWorkerThread();
// G4ThreadPool tasks
static void InitializeWorker();
static G4WorkerTaskRunManager** ExecuteWorkerTask(G4int nevts);
static void ExecuteWorkerInit();
static void ExecuteWorkerTask();
static void TerminateWorkerRunEventLoop();
static void TerminateWorker();
static void TerminateWorkerRunEventLoop(G4WorkerTaskRunManager**);
static void TerminateWorker(G4WorkerTaskRunManager**);
static void TerminateWorkerRunEventLoop(G4WorkerTaskRunManager*);
static void TerminateWorker(G4WorkerTaskRunManager*);
static std::vector<G4String>& InitCommandStack();
// Fill decay tables with particle definition pointers of
source/tasking/include/G4TaskSingletonDelegator.hh
+47 -46
View File
@@ -45,85 +45,86 @@
namespace G4Traits
{
template <typename T>
struct TaskSingletonKey
{
template <typename T>
struct TaskSingletonKey
{
using type = G4int;
using compare_type = std::less<type>;
};
}
};
} // namespace G4Traits
// ------------------------------------------------------------------------------------ //
//----------------------------------------------------------------------------//
/// \class G4TaskSingletonEvaluator
/// \brief This structure must be specialized and use overloads to the constructor
/// \brief This structure must be specialized and use overloads to the
/// constructor
///
template <typename T>
struct G4TaskSingletonEvaluator;
// ------------------------------------------------------------------------------------ //
//----------------------------------------------------------------------------//
template <typename T>
class G4TaskSingletonDelegator;
// ------------------------------------------------------------------------------------ //
//----------------------------------------------------------------------------//
template <typename T>
class G4TaskSingletonData
{
using key_type = typename G4Traits::TaskSingletonKey<T>::type;
using compare_type = typename G4Traits::TaskSingletonKey<T>::compare_type;
using key_type = typename G4Traits::TaskSingletonKey<T>::type;
using compare_type = typename G4Traits::TaskSingletonKey<T>::compare_type;
friend struct G4TaskSingletonEvaluator<T>;
friend class G4TaskSingletonDelegator<T>;
using this_type = G4TaskSingletonData<T>;
friend struct G4TaskSingletonEvaluator<T>;
friend class G4TaskSingletonDelegator<T>;
using this_type = G4TaskSingletonData<T>;
private:
static std::unique_ptr<this_type>& GetInstance()
{
static auto _instance = std::unique_ptr<this_type>(new this_type);
return _instance;
}
private:
static std::unique_ptr<this_type>& GetInstance()
{
static auto _instance = std::unique_ptr<this_type>(new this_type);
return _instance;
}
private:
std::map<key_type, T*, compare_type> m_data;
private:
std::map<key_type, T*, compare_type> m_data;
};
// ------------------------------------------------------------------------------------ //
//----------------------------------------------------------------------------//
template <typename T>
struct G4TaskSingletonEvaluator
{
using key_type = typename G4Traits::TaskSingletonKey<T>::type;
using data_type = G4TaskSingletonData<T>;
using key_type = typename G4Traits::TaskSingletonKey<T>::type;
using data_type = G4TaskSingletonData<T>;
template <typename... Args>
G4TaskSingletonEvaluator(key_type&, Args&&...)
{
throw std::runtime_error("Not specialized!");
}
template <typename... Args>
G4TaskSingletonEvaluator(key_type&, Args&&...)
{
throw std::runtime_error("Not specialized!");
}
};
// ------------------------------------------------------------------------------------ //
//----------------------------------------------------------------------------//
template <typename T>
class G4TaskSingletonDelegator
{
public:
using pointer = T*;
using evaluator_type = G4TaskSingletonEvaluator<T>;
using data_type = G4TaskSingletonData<T>;
using key_type = typename G4Traits::TaskSingletonKey<T>;
public:
using pointer = T*;
using evaluator_type = G4TaskSingletonEvaluator<T>;
using data_type = G4TaskSingletonData<T>;
using key_type = typename G4Traits::TaskSingletonKey<T>;
template <typename... Args>
static void Configure(Args&&... args)
{
auto& _data = data_type::GetInstance();
evaluator_type _eval(std::forward<Args>(args)...);
auto _ptr = _data->m_data.at(_eval.index);
_eval.modifier(_ptr);
T::SetInstance(_data->m_data.at(_key));
}
template <typename... Args>
static void Configure(Args&&... args)
{
auto& _data = data_type::GetInstance();
evaluator_type _eval(std::forward<Args>(args)...);
auto _ptr = _data->m_data.at(_eval.index);
_eval.modifier(_ptr);
T::SetInstance(_data->m_data.at(_key));
}
};
// ------------------------------------------------------------------------------------ //
//----------------------------------------------------------------------------//
source/tasking/include/G4WorkerTaskRunManager.hh
+8 -6
View File
@@ -47,6 +47,9 @@ class G4WorkerTaskRunManagerKernel;
class G4WorkerTaskRunManager : public G4WorkerRunManager
{
public:
using ProfilerConfig = G4ProfilerConfig<G4ProfileType::Run>;
public:
typedef std::vector<G4String> G4StrVector;
@@ -69,12 +72,9 @@ class G4WorkerTaskRunManager : public G4WorkerRunManager
readStatusFromFile = flag;
}
virtual void DoBeamOn(G4int evts);
virtual void DoWork(G4int nevts);
virtual void InitializeForNewRun();
void SetConfirmBeamOn(G4bool val) { fConfirmBeamOn = val; }
G4WorkerThread* GetWorkerThread() const { return workerContext; }
virtual void DoCleanup();
virtual void ProcessUI();
G4WorkerThread* GetWorkerThread() const { return workerContext; }
G4StrVector GetCommandStack() const { return processedCommandStack; }
protected:
@@ -84,8 +84,10 @@ class G4WorkerTaskRunManager : public G4WorkerRunManager
void SetupDefaultRNGEngine();
private:
G4bool fConfirmBeamOn;
G4StrVector processedCommandStack;
private:
std::unique_ptr<ProfilerConfig> workerRunProfiler;
};
#endif // G4WorkerTaskRunManager_h