Import Geant4 10.7.0.beta source tree
This commit is contained in:
Gabriele Cosmo
@@ -0,0 +1,247 @@
|
||||
//
|
||||
// ********************************************************************
|
||||
// * License and Disclaimer *
|
||||
// * *
|
||||
// * The Geant4 software is copyright of the Copyright Holders of *
|
||||
// * the Geant4 Collaboration. It is provided under the terms and *
|
||||
// * conditions of the Geant4 Software License, included in the file *
|
||||
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
||||
// * include a list of copyright holders. *
|
||||
// * *
|
||||
// * Neither the authors of this software system, nor their employing *
|
||||
// * institutes,nor the agencies providing financial support for this *
|
||||
// * work make any representation or warranty, express or implied, *
|
||||
// * regarding this software system or assume any liability for its *
|
||||
// * use. Please see the license in the file LICENSE and URL above *
|
||||
// * for the full disclaimer and the limitation of liability. *
|
||||
// * *
|
||||
// * This code implementation is the result of the scientific and *
|
||||
// * technical work of the GEANT4 collaboration. *
|
||||
// * By using, copying, modifying or distributing the software (or *
|
||||
// * any work based on the software) you agree to acknowledge its *
|
||||
// * use in resulting scientific publications, and indicate your *
|
||||
// * acceptance of all terms of the Geant4 Software license. *
|
||||
// ********************************************************************
|
||||
//
|
||||
// Author: Jonathan Madsen (May 28st 2020)
|
||||
//
|
||||
// class description:
|
||||
// This is a class for run control in GEANT4 for multi-threaded runs
|
||||
// It extends G4RunManager re-implementing multi-threaded behavior in
|
||||
// key methods. See documentation for G4RunManager
|
||||
// Users initializes an instance of this class instead of G4RunManager
|
||||
// to start a multi-threaded simulation.
|
||||
|
||||
#ifndef G4TaskRunManager_hh
|
||||
#define G4TaskRunManager_hh 1
|
||||
|
||||
#include "taskdefs.hh"
|
||||
#include "G4MTBarrier.hh"
|
||||
#include "G4MTRunManager.hh"
|
||||
#include "G4RNGHelper.hh"
|
||||
#include "G4RunManager.hh"
|
||||
#include "G4TBBTaskGroup.hh"
|
||||
#include "G4TaskGroup.hh"
|
||||
#include "G4TaskManager.hh"
|
||||
#include "G4ThreadPool.hh"
|
||||
#include "G4Threading.hh"
|
||||
#include "G4VUserTaskQueue.hh"
|
||||
#include "G4EnvironmentUtils.hh"
|
||||
|
||||
#include "PTL/TaskRunManager.hh"
|
||||
|
||||
#include <list>
|
||||
#include <map>
|
||||
|
||||
class G4TaskRunManagerKernel;
|
||||
class G4ScoringManager;
|
||||
class G4UserTaskInitialization;
|
||||
class G4UserTaskThreadInitialization;
|
||||
class G4WorkerTaskRunManager;
|
||||
|
||||
//============================================================================//
|
||||
|
||||
class G4TaskRunManager
|
||||
: public G4MTRunManager
|
||||
, public PTL::TaskRunManager
|
||||
{
|
||||
public:
|
||||
|
||||
using InitializeSeedsCallback = std::function<G4bool(G4int, G4int&, G4int&)>;
|
||||
using WorkerRunSet = std::set<G4WorkerTaskRunManager**>;
|
||||
using RunTaskGroup = G4TaskGroup<void>;
|
||||
using RunTaskGroupTBB = G4TBBTaskGroup<WorkerRunSet, G4WorkerTaskRunManager**>;
|
||||
|
||||
public:
|
||||
// Parameters:
|
||||
// taskQueue : provide a custom task queue
|
||||
// useTBB : only relevant if GEANT4_USE_TBB defined
|
||||
// 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),
|
||||
G4int evtGrainsize = 0);
|
||||
virtual ~G4TaskRunManager();
|
||||
|
||||
public:
|
||||
void SetGrainsize(G4int n) { eventGrainsize = n; }
|
||||
G4int GetGrainsize() const { return eventGrainsize; }
|
||||
inline G4int GetNumberOfTasks() const { return numberOfTasks; }
|
||||
inline G4int GetNumberOfEventsPerTask() const
|
||||
{
|
||||
return numberOfEventsPerTask;
|
||||
}
|
||||
|
||||
virtual void SetNumberOfThreads(G4int n) override;
|
||||
virtual G4int GetNumberOfThreads() const override
|
||||
{
|
||||
return PTL::TaskRunManager::GetNumberOfThreads();
|
||||
}
|
||||
virtual size_t GetNumberActiveThreads() const override
|
||||
{
|
||||
return PTL::TaskRunManager::GetNumberActiveThreads();
|
||||
}
|
||||
static G4ThreadId GetMasterThreadId();
|
||||
|
||||
public:
|
||||
// Inherited methods to re-implement for MT case
|
||||
virtual void Initialize() override;
|
||||
virtual void InitializeEventLoop(G4int n_event,
|
||||
const char* macroFile = nullptr,
|
||||
G4int n_select = -1) override;
|
||||
virtual void InitializeThreadPool() override;
|
||||
G4bool ThreadPoolIsInitialized() const { return poolInitialized; }
|
||||
|
||||
virtual void Initialize(uint64_t nthreads) override
|
||||
{
|
||||
PTL::TaskRunManager::Initialize(nthreads);
|
||||
}
|
||||
|
||||
virtual void TerminateOneEvent() override;
|
||||
virtual void ProcessOneEvent(G4int i_event) override;
|
||||
virtual void ConstructScoringWorlds() override;
|
||||
virtual void RunTermination() override;
|
||||
|
||||
// The following method should be invoked by G4WorkerTaskRunManager for each
|
||||
// event. False is returned if no more event to be processed. Note: G4Event
|
||||
// object must be instantiated by a worker thread. In case no more
|
||||
// event remains to be processed, that worker thread must delete that G4Event
|
||||
// object. If a worker runs with its own random number sequence, the Boolean
|
||||
// flag reseedRequired should be set to false. This is *NOT* allowed for the
|
||||
// first event.
|
||||
virtual G4bool SetUpAnEvent(G4Event*, G4long& s1, G4long& s2, G4long& s3,
|
||||
G4bool reseedRequired = true) override;
|
||||
// Same as above method, but the seeds are set only once over "eventModulo"
|
||||
// events. The return value shows the number of events the caller Worker has
|
||||
// to process (between 1 and eventModulo depending on number of events yet to
|
||||
// be processed). G4Event object has the event ID of the first event of this
|
||||
// bunch. If zero is returned no more event needs to be processed, and worker
|
||||
// thread must delete that G4Event.
|
||||
virtual G4int SetUpNEvents(G4Event*, G4SeedsQueue* seedsQueue,
|
||||
G4bool reseedRequired = true) override;
|
||||
|
||||
// Method called by Initialize() method
|
||||
|
||||
protected:
|
||||
virtual void ComputeNumberOfTasks();
|
||||
// Initialize the seeds list, if derived class does not implement this method
|
||||
// A default generation will be used (nevents*2 random seeds)
|
||||
// Return true if initialization is done.
|
||||
virtual G4bool InitializeSeeds(G4int /*nevts*/) override { return false; }
|
||||
virtual void RefillSeeds() override;
|
||||
// Adds one seed to the list of seeds
|
||||
virtual void StoreRNGStatus(const G4String& filenamePrefix) override;
|
||||
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();
|
||||
// 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
|
||||
|
||||
public:
|
||||
// To be invoked solely from G4WorkerTaskRunManager to merge the results
|
||||
void MergeScores(const G4ScoringManager* localScoringManager);
|
||||
void MergeRun(const G4Run* localRun);
|
||||
|
||||
public:
|
||||
virtual void RequestWorkersProcessCommandsStack() override;
|
||||
// Called to force workers to request and process the UI commands stack
|
||||
// This will block untill all workers have processed UI commands
|
||||
virtual void ThisWorkerProcessCommandsStackDone() override;
|
||||
// Called by workers to signal to master it has completed processing of
|
||||
// UI commands
|
||||
// virtual WorkerActionRequest ThisWorkerWaitForNextAction();
|
||||
// Worker thread barrier
|
||||
// This method should be used by workers' run manager to wait,
|
||||
// after an event loop for the next action to be performed
|
||||
// (for example execute a new run)
|
||||
// This returns the action to be performed
|
||||
virtual void WaitForReadyWorkers() override {}
|
||||
virtual void WaitForEndEventLoopWorkers() override;
|
||||
virtual void ThisWorkerReady() override {}
|
||||
virtual void ThisWorkerEndEventLoop() override {}
|
||||
virtual WorkerActionRequest ThisWorkerWaitForNextAction() override
|
||||
{
|
||||
return WorkerActionRequest::UNDEFINED;
|
||||
}
|
||||
virtual void NewActionRequest(WorkerActionRequest) override {}
|
||||
|
||||
protected:
|
||||
// WorkerActionRequest nextActionRequest;
|
||||
// virtual void NewActionRequest( WorkerActionRequest newRequest );
|
||||
virtual void AddEventTask(G4int, G4int);
|
||||
|
||||
public:
|
||||
inline void SetInitializeSeedsCallback(InitializeSeedsCallback f)
|
||||
{
|
||||
initSeedsCallback = f;
|
||||
}
|
||||
|
||||
public:
|
||||
virtual void AbortRun(G4bool softAbort = false) override;
|
||||
virtual void AbortEvent() override;
|
||||
|
||||
protected:
|
||||
// Barriers: synch points between master and workers
|
||||
RunTaskGroup* workTaskGroup = nullptr;
|
||||
RunTaskGroupTBB* workTaskGroupTBB = nullptr;
|
||||
|
||||
// aliases to inherited member values
|
||||
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;
|
||||
|
||||
InitializeSeedsCallback initSeedsCallback = [](G4int, G4int&, G4int&) {
|
||||
return false;
|
||||
};
|
||||
};
|
||||
|
||||
#endif // G4TaskRunManager_hh
|
||||
Reference in New Issue
Block a user