#include <G4TaskRunManager.hh>

Inheritance diagram for G4TaskRunManager:

Public Types
using	ProfilerConfig = G4ProfilerConfig<G4ProfileType::Run>

using	InitializeSeedsCallback = std::function<G4bool(G4int, G4int&, G4int&)>

using	RunTaskGroup = G4TaskGroup<void>

Public Types inherited from G4MTRunManager
enum class	WorkerActionRequest { UNDEFINED , NEXTITERATION , PROCESSUI , ENDWORKER }

using	ProfilerConfig = G4ProfilerConfig<G4ProfileType::Run>

using	masterWorlds_t = std::map<G4int, G4VPhysicalVolume*>

Public Types inherited from G4RunManager
enum	RMType { sequentialRM , masterRM , workerRM }

using	ProfilerConfig = G4ProfilerConfig<G4ProfileType::Run>

Public Types inherited from PTL::TaskRunManager
using	pointer = TaskRunManager*

Public Member Functions
	G4TaskRunManager (G4bool useTBB=G4GetEnv< G4bool >("G4USE_TBB", false))

	G4TaskRunManager (G4VUserTaskQueue *taskQueue, G4bool useTBB=G4GetEnv< G4bool >("G4USE_TBB", false), G4int evtGrainsize=0)

	~G4TaskRunManager () override

void	SetGrainsize (G4int n)

G4int	GetGrainsize () const

G4int	GetNumberOfTasks () const

G4int	GetNumberOfEventsPerTask () const

void	SetNumberOfThreads (G4int n) override

G4int	GetNumberOfThreads () const override

size_t	GetNumberActiveThreads () const override

void	Initialize () override

void	InitializeEventLoop (G4int n_event, const char *macroFile=nullptr, G4int n_select=-1) override

void	InitializeThreadPool () override

G4bool	ThreadPoolIsInitialized () const

void	Initialize (uint64_t nthreads) override

void	TerminateOneEvent () override

void	ProcessOneEvent (G4int i_event) override

void	ConstructScoringWorlds () override

void	RunTermination () override

G4bool	SetUpAnEvent (G4Event *, G4long &s1, G4long &s2, G4long &s3, G4bool reseedRequired=true) override

G4int	SetUpNEvents (G4Event , G4SeedsQueue seedsQueue, G4bool reseedRequired=true) override

void	MergeScores (const G4ScoringManager *localScoringManager)

void	MergeRun (const G4Run *localRun)

void	RequestWorkersProcessCommandsStack () override

void	ThisWorkerProcessCommandsStackDone () override

void	WaitForReadyWorkers () override

void	WaitForEndEventLoopWorkers () override

void	ThisWorkerReady () override

void	ThisWorkerEndEventLoop () override

WorkerActionRequest	ThisWorkerWaitForNextAction () override

void	SetInitializeSeedsCallback (InitializeSeedsCallback f)

void	AbortRun (G4bool softAbort=false) override

void	AbortEvent () override

Public Member Functions inherited from G4MTRunManager
	G4MTRunManager ()

	~G4MTRunManager () override

void	SetPinAffinity (G4int n=1)

G4int	GetPinAffinity () const

std::vector< G4String >	GetCommandStack ()

const CLHEP::HepRandomEngine *	getMasterRandomEngine () const

void	SetUserInitialization (G4VUserPhysicsList *userPL) override

void	SetUserInitialization (G4VUserDetectorConstruction *userDC) override

void	SetUserInitialization (G4UserWorkerInitialization *userInit) override

void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit) override

void	SetUserInitialization (G4VUserActionInitialization *userInit) override

void	SetUserAction (G4UserRunAction *userAction) override

void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction) override

void	SetUserAction (G4UserEventAction *userAction) override

void	SetUserAction (G4UserStackingAction *userAction) override

void	SetUserAction (G4UserTrackingAction *userAction) override

void	SetUserAction (G4UserSteppingAction *userAction) override

void	MergeScores (const G4ScoringManager *localScoringManager)

void	MergeRun (const G4Run *localRun)

void	SetEventModulo (G4int i=1)

G4int	GetEventModulo () const

Public Member Functions inherited from G4RunManager
	G4RunManager ()

virtual	~G4RunManager ()

	G4RunManager (const G4RunManager &)=delete

G4RunManager &	operator= (const G4RunManager &)=delete

virtual void	BeamOn (G4int n_event, const char *macroFile=nullptr, G4int n_select=-1)

virtual void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)

virtual void	InitializeGeometry ()

virtual void	InitializePhysics ()

virtual G4bool	ConfirmBeamOnCondition ()

virtual void	RunInitialization ()

virtual void	DoEventLoop (G4int n_event, const char *macroFile=nullptr, G4int n_select=-1)

virtual void	TerminateEventLoop ()

virtual G4Event *	GenerateEvent (G4int i_event)

virtual void	AnalyzeEvent (G4Event *anEvent)

virtual void	ConfigureProfilers (const std::vector< std::string > &args={})

void	ConfigureProfilers (G4int argc, char **argv)

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=nullptr) const

void	GeometryHasBeenModified (G4bool prop=true)

void	ReinitializeGeometry (G4bool destroyFirst=false, G4bool prop=true)

void	PhysicsHasBeenModified ()

void	CutOffHasBeenModified ()

void	ReOptimizeMotherOf (G4VPhysicalVolume *)

void	ReOptimize (G4LogicalVolume *)

void	SetGeometryToBeOptimized (G4bool vl)

G4bool	GetGeometryToBeOptimized ()

void	GeometryDirectlyUpdated (G4bool val=true)

virtual void	RestoreRandomNumberStatus (const G4String &fileN)

virtual void	RestoreRndmEachEvent (G4bool)

const G4VUserDetectorConstruction *	GetUserDetectorConstruction () const

const G4VUserPhysicsList *	GetUserPhysicsList () const

const G4VUserActionInitialization *	GetUserActionInitialization () const

G4VUserActionInitialization *	GetNonConstUserActionInitialization () const

const G4UserWorkerInitialization *	GetUserWorkerInitialization () const

const G4UserWorkerThreadInitialization *	GetUserWorkerThreadInitialization () const

const G4UserRunAction *	GetUserRunAction () const

const G4VUserPrimaryGeneratorAction *	GetUserPrimaryGeneratorAction () const

const G4UserEventAction *	GetUserEventAction () const

const G4UserStackingAction *	GetUserStackingAction () const

const G4UserTrackingAction *	GetUserTrackingAction () const

const G4UserSteppingAction *	GetUserSteppingAction () const

void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)

const G4String &	GetVersionString () const

void	SetPrimaryTransformer (G4PrimaryTransformer *pt)

void	StoreRandomNumberStatusToG4Event (G4int vl)

G4int	GetFlagRandomNumberStatusToG4Event () const

void	SetRandomNumberStore (G4bool flag)

G4bool	GetRandomNumberStore () const

void	SetRandomNumberStoreDir (const G4String &dir)

const G4String &	GetRandomNumberStoreDir () const

const G4String &	GetRandomNumberStatusForThisRun () const

const G4String &	GetRandomNumberStatusForThisEvent () const

void	SetRandomNumberStorePerEvent (G4bool flag)

G4bool	GetRandomNumberStorePerEvent () const

void	SetVerboseLevel (G4int vl)

G4int	GetVerboseLevel () const

G4int	GetPrintProgress ()

void	SetPrintProgress (G4int i)

void	SetNumberOfEventsToBeStored (G4int val)

const G4Run *	GetCurrentRun () const

G4Run *	GetNonConstCurrentRun () const

const G4Event *	GetCurrentEvent () const

const G4Event *	GetPreviousEvent (G4int i) const

void	SetRunIDCounter (G4int i)

G4int	GetNumberOfParallelWorld () const

void	SetNumberOfEventsToBeProcessed (G4int val)

G4int	GetNumberOfEventsToBeProcessed () const

G4int	GetNumberOfSelectEvents () const

const G4String &	GetSelectMacro () const

void	SetDCtable (G4DCtable *DCtbl)

RMType	GetRunManagerType () const

Public Member Functions inherited from PTL::TaskRunManager
	TaskRunManager (bool useTBB=false)

virtual	~TaskRunManager ()

virtual void	Terminate ()

ThreadPool *	GetThreadPool () const

TaskManager *	GetTaskManager () const

bool	IsInitialized () const

int	GetVerbose () const

void	SetVerbose (int val)

Static Public Member Functions
static G4TaskRunManager *	GetMasterRunManager ()

static G4TaskRunManagerKernel *	GetMTMasterRunManagerKernel ()

static G4ThreadId	GetMasterThreadId ()

Static Public Member Functions inherited from G4MTRunManager
static G4ThreadId	GetMasterThreadId ()

static G4ScoringManager *	GetMasterScoringManager ()

static masterWorlds_t &	GetMasterWorlds ()

static void	addWorld (G4int counter, G4VPhysicalVolume *w)

static G4MTRunManager *	GetMasterRunManager ()

static G4RunManagerKernel *	GetMasterRunManagerKernel ()

static G4MTRunManagerKernel *	GetMTMasterRunManagerKernel ()

static G4int	SeedOncePerCommunication ()

static void	SetSeedOncePerCommunication (G4int val)

Static Public Member Functions inherited from G4RunManager
static G4RunManager *	GetRunManager ()

static G4bool	IfGeometryHasBeenDestroyed ()

Static Public Member Functions inherited from PTL::TaskRunManager
static TaskRunManager *	GetInstance (bool useTBB=false)

static TaskRunManager *	GetMasterRunManager (bool useTBB=false)

Protected Member Functions
virtual void	ComputeNumberOfTasks ()

G4bool	InitializeSeeds (G4int) override

void	RefillSeeds () override

void	StoreRNGStatus (const G4String &filenamePrefix) override

void	CreateAndStartWorkers () override

void	TerminateWorkers () override

void	NewActionRequest (WorkerActionRequest) override

virtual void	AddEventTask (G4int)

Protected Member Functions inherited from G4MTRunManager
virtual void	PrepareCommandsStack ()

void	rndmSaveThisRun () override

void	rndmSaveThisEvent () override

Protected Member Functions inherited from G4RunManager
	G4RunManager (RMType rmType)

void	CleanUpPreviousEvents ()

void	CleanUpUnnecessaryEvents (G4int keepNEvents)

void	StackPreviousEvent (G4Event *anEvent)

void	UpdateScoring ()

virtual void	DeleteUserInitializations ()

Protected Attributes
RunTaskGroup *	workTaskGroup = nullptr

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

Protected Attributes inherited from G4MTRunManager
G4int	nworkers = 2

G4int	forcedNwokers = -1

G4int	numberOfEventToBeProcessed = 0

WorkerActionRequest	nextActionRequest = WorkerActionRequest::UNDEFINED

G4int	eventModuloDef = 0

G4int	eventModulo = 1

G4int	nSeedsUsed = 0

G4int	nSeedsFilled = 0

G4int	nSeedsMax = 10000

G4int	nSeedsPerEvent = 2

G4double *	randDbl = nullptr

G4MTBarrier	beginOfEventLoopBarrier

G4MTBarrier	endOfEventLoopBarrier

G4MTBarrier	nextActionRequestBarrier

G4MTBarrier	processUIBarrier

Protected Attributes inherited from G4RunManager
G4RunManagerKernel *	kernel = nullptr

G4EventManager *	eventManager = nullptr

G4VUserDetectorConstruction *	userDetector = nullptr

G4VUserPhysicsList *	physicsList = nullptr

G4VUserActionInitialization *	userActionInitialization = nullptr

G4UserWorkerInitialization *	userWorkerInitialization = nullptr

G4UserWorkerThreadInitialization *	userWorkerThreadInitialization = nullptr

G4UserRunAction *	userRunAction = nullptr

G4VUserPrimaryGeneratorAction *	userPrimaryGeneratorAction = nullptr

G4UserEventAction *	userEventAction = nullptr

G4UserStackingAction *	userStackingAction = nullptr

G4UserTrackingAction *	userTrackingAction = nullptr

G4UserSteppingAction *	userSteppingAction = nullptr

G4bool	geometryInitialized = false

G4bool	physicsInitialized = false

G4bool	runAborted = false

G4bool	initializedAtLeastOnce = false

G4bool	geometryToBeOptimized = true

G4int	runIDCounter = 0

G4int	verboseLevel = 0

G4int	printModulo = -1

G4Timer *	timer = nullptr

G4DCtable *	DCtable = nullptr

G4Run *	currentRun = nullptr

G4Event *	currentEvent = nullptr

std::list< G4Event * > *	previousEvents = nullptr

G4int	n_perviousEventsToBeStored = 0

G4int	numberOfEventToBeProcessed = 0

G4bool	storeRandomNumberStatus = false

G4int	storeRandomNumberStatusToG4Event = 0

G4String	randomNumberStatusDir = "./"

G4String	randomNumberStatusForThisRun = ""

G4String	randomNumberStatusForThisEvent = ""

G4bool	rngStatusEventsFlag = false

G4VPhysicalVolume *	currentWorld = nullptr

G4int	nParallelWorlds = 0

G4String	msgText = " "

G4int	n_select_msg = -1

G4int	numberOfEventProcessed = 0

G4String	selectMacro = ""

G4bool	fakeRun = false

G4bool	isScoreNtupleWriter = false

G4bool	geometryDirectlyUpdated = false

RMType	runManagerType

Protected Attributes inherited from PTL::TaskRunManager
bool	m_is_initialized = false

int	m_verbose = 0

uint64_t	m_workers = 0

VUserTaskQueue *	m_task_queue = nullptr

ThreadPool *	m_thread_pool = nullptr

TaskManager *	m_task_manager = nullptr

Friends
class	G4RunManagerFactory

Additional Inherited Members
Static Protected Attributes inherited from G4MTRunManager
static G4MTRUN_DLL G4ScoringManager *	masterScM = nullptr

static G4MTRUN_DLL masterWorlds_t	masterWorlds = G4MTRunManager::masterWorlds_t()

static G4MTRUN_DLL G4MTRunManager *	fMasterRM = nullptr

static G4ThreadId	masterThreadId = G4ThisThread::get_id()

static G4int	seedOncePerCommunication = 0

Static Protected Attributes inherited from G4RunManager
static G4RUN_DLL G4bool	fGeometryHasBeenDestroyed = false

Detailed Description

Definition at line 66 of file G4TaskRunManager.hh.

Member Typedef Documentation

◆ InitializeSeedsCallback

using G4TaskRunManager::InitializeSeedsCallback = std::function<G4bool(G4int, G4int&, G4int&)>

Definition at line 73 of file G4TaskRunManager.hh.

◆ ProfilerConfig

using G4TaskRunManager::ProfilerConfig = G4ProfilerConfig<G4ProfileType::Run>

Definition at line 72 of file G4TaskRunManager.hh.

◆ RunTaskGroup

using G4TaskRunManager::RunTaskGroup = G4TaskGroup<void>

Definition at line 74 of file G4TaskRunManager.hh.

Constructor & Destructor Documentation

◆ G4TaskRunManager() [1/2]

G4TaskRunManager::G4TaskRunManager ( G4bool useTBB = G4GetEnv<G4bool>("G4USE_TBB", false) )

Definition at line 145 of file G4TaskRunManager.cc.

145: G4TaskRunManager(nullptr, useTBB, 0) {}

G4TaskRunManager::G4TaskRunManager

G4TaskRunManager(G4bool useTBB=G4GetEnv< G4bool >("G4USE_TBB", false))

Definition G4TaskRunManager.cc:145

◆ G4TaskRunManager() [2/2]

G4TaskRunManager::G4TaskRunManager	(	G4VUserTaskQueue *	taskQueue,
		G4bool	useTBB = G4GetEnv<G4bool>("G4USE_TBB", false),
		G4int	evtGrainsize = 0 )

Definition at line 77 of file G4TaskRunManager.cc.

  : PTL::TaskRunManager(useTBB), eventGrainsize(grainsize)
{
  if (task_queue != nullptr) taskQueue = task_queue;
 
  // override default of 2 from G4MTRunManager
  nworkers = G4Threading::G4GetNumberOfCores();
  fMasterRM = this;
  MTkernel = static_cast<G4TaskRunManagerKernel*>(kernel);
 
  G4int numberOfStaticAllocators = kernel->GetNumberOfStaticAllocators();
  if (numberOfStaticAllocators > 0) {
    G4ExceptionDescription msg1;
    msg1 << "There are " << numberOfStaticAllocators << " static G4Allocator objects detected.\n"
         << "In multi-threaded mode, all G4Allocator objects must "
         << "be dynamicly instantiated.";
    G4Exception("G4TaskRunManager::G4TaskRunManager", "Run1035", FatalException, msg1);
  }
 
  G4UImanager::GetUIpointer()->SetMasterUIManager(true);
  masterScM = G4ScoringManager::GetScoringManagerIfExist();
 
  // use default RandomNumberGenerator if created by user, or create default
  masterRNGEngine = G4Random::getTheEngine();
 
  numberOfEventToBeProcessed = 0;
  randDbl = new G4double[nSeedsPerEvent * nSeedsMax];
 
  //------------------------------------------------------------------------//
  //      handle threading
  //------------------------------------------------------------------------//
  auto _nthread_env = G4GetEnv<G4String>("G4FORCENUMBEROFTHREADS", "");
  for (auto& itr : _nthread_env)
    itr = (char)std::tolower(itr);
 
  if (_nthread_env == "max")
    forcedNwokers = G4Threading::G4GetNumberOfCores();
  else if (!_nthread_env.empty()) {
    std::stringstream ss;
    G4int _nthread_val = -1;
    ss << _nthread_env;
    ss >> _nthread_val;
    if (_nthread_val > 0) forcedNwokers = _nthread_val;
 
    if (forcedNwokers > 0) nworkers = forcedNwokers;
  }
 
  //------------------------------------------------------------------------//
  //      option for forcing TBB
  //------------------------------------------------------------------------//
#ifdef GEANT4_USE_TBB
  G4int _useTBB = G4GetEnv<G4int>("G4FORCE_TBB", (G4int)useTBB);
  if (_useTBB > 0) useTBB = true;
#else
  if (useTBB) {
    G4ExceptionDescription msg;
    msg << "TBB was requested but Geant4 was not built with TBB support";
    G4Exception("G4TaskRunManager::G4TaskRunManager(...)", "Run0131", JustWarning, msg);
  }
  useTBB = false;
#endif
 
  // handle TBB
  G4ThreadPool::set_use_tbb(useTBB);
}

◆ ~G4TaskRunManager()

G4TaskRunManager::~G4TaskRunManager ( )

override

Definition at line 149 of file G4TaskRunManager.cc.

{
  // finalize profiler before shutting down the threads
  G4Profiler::Finalize();
 
  // terminate all the workers
  G4TaskRunManager::TerminateWorkers();
 
  // trigger all G4AutoDelete instances
  G4ThreadLocalSingleton<void>::Clear();
 
  // delete the task-group
  delete workTaskGroup;
  workTaskGroup = nullptr;
 
  // destroy the thread-pool
  if (threadPool != nullptr) threadPool->destroy_threadpool();
 
  PTL::TaskRunManager::Terminate();
}

Member Function Documentation

◆ AbortEvent()

void G4TaskRunManager::AbortEvent ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 656 of file G4TaskRunManager.cc.

{
  // nothing to do in the master thread
}

◆ AbortRun()

void G4TaskRunManager::AbortRun ( G4bool softAbort = false )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 641 of file G4TaskRunManager.cc.

{
  // This method is valid only for GeomClosed or EventProc state
  G4ApplicationState currentState = G4StateManager::GetStateManager()->GetCurrentState();
  if (currentState == G4State_GeomClosed || currentState == G4State_EventProc) {
    runAborted = true;
    MTkernel->BroadcastAbortRun(softAbort);
  }
  else {
    G4cerr << "Run is not in progress. AbortRun() ignored." << G4endl;
  }
}

◆ AddEventTask()

void G4TaskRunManager::AddEventTask ( G4int nt )

protectedvirtual

Definition at line 414 of file G4TaskRunManager.cc.

{
  if (verboseLevel > 1) G4cout << "Adding task " << nt << " to task-group..." << G4endl;
  workTaskGroup->exec([]() { G4TaskRunManagerKernel::ExecuteWorkerTask(); });
}

Referenced by CreateAndStartWorkers().

◆ ComputeNumberOfTasks()

void G4TaskRunManager::ComputeNumberOfTasks ( )

protectedvirtual

Definition at line 288 of file G4TaskRunManager.cc.

{
  G4int grainSize = (eventGrainsize == 0) ? (G4int)threadPool->size() : eventGrainsize;
  grainSize = G4GetEnv<G4int>("G4FORCE_GRAINSIZE", grainSize, "Forcing grainsize...");
  if (grainSize == 0) grainSize = 1;
 
  G4int nEvtsPerTask =
    (numberOfEventToBeProcessed > grainSize) ? (numberOfEventToBeProcessed / grainSize) : 1;
 
  if (eventModuloDef > 0) {
    eventModulo = eventModuloDef;
  }
  else {
    eventModulo = G4int(std::sqrt(G4double(numberOfEventToBeProcessed)));
    if (eventModulo < 1) eventModulo = 1;
  }
  if (eventModulo > nEvtsPerTask) {
    G4int oldMod = eventModulo;
    eventModulo = nEvtsPerTask;
 
    G4ExceptionDescription msgd;
    msgd << "Event modulo is reduced to " << eventModulo << " (was " << oldMod << ")"
         << " to distribute events to all threads.";
    G4Exception("G4TaskRunManager::InitializeEventLoop()", "Run10035", JustWarning, msgd);
  }
  nEvtsPerTask = eventModulo;
 
  if (fakeRun)
    nEvtsPerTask = G4GetEnv<G4int>("G4FORCE_EVENTS_PER_TASK", nEvtsPerTask,
                                   "Forcing number of events per task (overrides grainsize)...");
  else
    nEvtsPerTask = G4GetEnv<G4int>("G4FORCE_EVENTS_PER_TASK", nEvtsPerTask);
 
  if (nEvtsPerTask < 1) nEvtsPerTask = 1;
 
  numberOfTasks = numberOfEventToBeProcessed / nEvtsPerTask;
  numberOfEventsPerTask = nEvtsPerTask;
  eventModulo = numberOfEventsPerTask;
 
  if (fakeRun && verboseLevel > 1) {
    std::stringstream msg;
    msg << "--> G4TaskRunManager::ComputeNumberOfTasks() --> " << numberOfTasks << " tasks with "
        << numberOfEventsPerTask << " events/task...";
 
    std::stringstream ss;
    ss.fill('=');
    ss << std::setw((G4int)msg.str().length()) << "";
    G4cout << "\n" << ss.str() << "\n" << msg.str() << "\n" << ss.str() << "\n" << G4endl;
  }
}

Referenced by CreateAndStartWorkers(), and InitializeEventLoop().

◆ ConstructScoringWorlds()

void G4TaskRunManager::ConstructScoringWorlds ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 539 of file G4TaskRunManager.cc.

{
  masterScM = G4ScoringManager::GetScoringManagerIfExist();
  // Call base class stuff...
  G4RunManager::ConstructScoringWorlds();
 
  masterWorlds.clear();
  auto nWorlds = (G4int)G4TransportationManager::GetTransportationManager()->GetNoWorlds();
  auto itrW = G4TransportationManager::GetTransportationManager()->GetWorldsIterator();
  for (G4int iWorld = 0; iWorld < nWorlds; ++iWorld) {
    addWorld(iWorld, *itrW);
    ++itrW;
  }
}

◆ CreateAndStartWorkers()

void G4TaskRunManager::CreateAndStartWorkers ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 341 of file G4TaskRunManager.cc.

{
  // Now loop on requested number of workers
  // This will also start the workers
  // Currently we do not allow to change the
  // number of threads: threads area created once
  // Instead of pthread based workers, create tbbTask
  static bool initializeStarted = false;
 
  ComputeNumberOfTasks();
 
  if (fakeRun) {
    if (initializeStarted) {
      auto initCmdStack = GetCommandStack();
      if (!initCmdStack.empty()) {
        threadPool->execute_on_all_threads([initCmdStack]() {
          for (auto& itr : initCmdStack)
            G4UImanager::GetUIpointer()->ApplyCommand(itr);
          G4WorkerTaskRunManager::GetWorkerRunManager()->DoWork();
        });
      }
    }
    else {
      std::stringstream msg;
      msg << "--> G4TaskRunManager::CreateAndStartWorkers() --> "
          << "Initializing workers...";
 
      std::stringstream ss;
      ss.fill('=');
      ss << std::setw((G4int)msg.str().length()) << "";
      G4cout << "\n" << ss.str() << "\n" << msg.str() << "\n" << ss.str() << "\n" << G4endl;
 
      G4TaskRunManagerKernel::InitCommandStack() = GetCommandStack();
      threadPool->execute_on_all_threads([]() { G4TaskRunManagerKernel::InitializeWorker(); });
    }
    initializeStarted = true;
  }
  else {
    auto initCmdStack = GetCommandStack();
    if (!initCmdStack.empty()) {
      threadPool->execute_on_all_threads([initCmdStack]() {
        for (auto& itr : initCmdStack)
          G4UImanager::GetUIpointer()->ApplyCommand(itr);
      });
    }
 
    // cleans up a previous run and events in case a thread
    // does not execute any tasks
    threadPool->execute_on_all_threads([]() { G4TaskRunManagerKernel::ExecuteWorkerInit(); });
 
    {
      std::stringstream msg;
      msg << "--> G4TaskRunManager::CreateAndStartWorkers() --> "
          << "Creating " << numberOfTasks << " tasks with " << numberOfEventsPerTask
          << " events/task...";
 
      std::stringstream ss;
      ss.fill('=');
      ss << std::setw((G4int)msg.str().length()) << "";
      G4cout << "\n" << ss.str() << "\n" << msg.str() << "\n" << ss.str() << "\n" << G4endl;
    }
 
    G4int remaining = numberOfEventToBeProcessed;
    for (G4int nt = 0; nt < numberOfTasks + 1; ++nt) {
      if (remaining > 0) AddEventTask(nt);
      remaining -= numberOfEventsPerTask;
    }
    workTaskGroup->wait();
  }
}

Referenced by InitializeEventLoop().

◆ GetGrainsize()

G4int G4TaskRunManager::GetGrainsize ( ) const

inline

Definition at line 99 of file G4TaskRunManager.hh.

99{ return eventGrainsize; }

◆ GetMasterRunManager()

static G4TaskRunManager * G4TaskRunManager::GetMasterRunManager ( )

inlinestatic

Definition at line 79 of file G4TaskRunManager.hh.

    {
      auto* _rm = G4MTRunManager::GetMasterRunManager();
      return dynamic_cast<G4TaskRunManager*>(_rm);
    }

Referenced by G4WorkerTaskRunManager::DoWork(), G4TaskRunManagerKernel::ExecuteWorkerInit(), G4TaskRunManagerKernel::ExecuteWorkerTask(), G4RunManagerFactory::GetMTMasterRunManager(), GetMTMasterRunManagerKernel(), G4TaskRunManagerKernel::InitializeWorker(), G4WorkerTaskRunManager::ProcessUI(), G4WorkerTaskRunManager::RunInitialization(), and G4TaskRunManagerKernel::TerminateWorker().

◆ GetMasterThreadId()

G4ThreadId G4TaskRunManager::GetMasterThreadId ( )

static

Definition at line 172 of file G4TaskRunManager.cc.

{
  return G4MTRunManager::GetMasterThreadId();
}

◆ GetMTMasterRunManagerKernel()

G4TaskRunManagerKernel * G4TaskRunManager::GetMTMasterRunManagerKernel ( )

static

Definition at line 70 of file G4TaskRunManager.cc.

{
  return GetMasterRunManager()->MTkernel;
}

◆ GetNumberActiveThreads()

size_t G4TaskRunManager::GetNumberActiveThreads ( ) const

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 105 of file G4TaskRunManager.hh.

    {
      return PTL::TaskRunManager::GetNumberActiveThreads();
    }

◆ GetNumberOfEventsPerTask()

G4int G4TaskRunManager::GetNumberOfEventsPerTask ( ) const

inline

Definition at line 101 of file G4TaskRunManager.hh.

101{ return numberOfEventsPerTask; }

◆ GetNumberOfTasks()

G4int G4TaskRunManager::GetNumberOfTasks ( ) const

inline

Definition at line 100 of file G4TaskRunManager.hh.

100{ return numberOfTasks; }

◆ GetNumberOfThreads()

G4int G4TaskRunManager::GetNumberOfThreads ( ) const

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 215 of file G4TaskRunManager.cc.

{
  // If the ThreadPool isn't initialized, it will return 0 even if we've already
  // set nworkers
  return poolInitialized ? PTL::TaskRunManager::GetNumberOfThreads() : nworkers;
}

◆ Initialize() [1/2]

void G4TaskRunManager::Initialize ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 224 of file G4TaskRunManager.cc.

{
  G4bool firstTime = (threadPool == nullptr);
  if (firstTime) InitializeThreadPool();
 
  G4RunManager::Initialize();
 
  // make sure all worker threads are set up.
  G4RunManager::BeamOn(0);
  if (firstTime) G4RunManager::SetRunIDCounter(0);
  // G4UImanager::GetUIpointer()->SetIgnoreCmdNotFound(true);
}

◆ Initialize() [2/2]

void G4TaskRunManager::Initialize ( uint64_t nthreads )

inlineoverridevirtual

Reimplemented from PTL::TaskRunManager.

Definition at line 118 of file G4TaskRunManager.hh.

118{ PTL::TaskRunManager::Initialize(nthreads); }

PTL::TaskRunManager::Initialize

virtual void Initialize(uint64_t n=std::thread::hardware_concurrency())

Definition TaskRunManager.cc:104

◆ InitializeEventLoop()

void G4TaskRunManager::InitializeEventLoop	(	G4int	n_event,
		const char *	macroFile = nullptr,
		G4int	n_select = -1 )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 446 of file G4TaskRunManager.cc.

{
  MTkernel->SetUpDecayChannels();
  numberOfEventToBeProcessed = n_event;
  numberOfEventProcessed = 0;
 
  if (!fakeRun) {
    nSeedsUsed = 0;
    nSeedsFilled = 0;
 
    if (verboseLevel > 0) timer->Start();
 
    n_select_msg = n_select;
    if (macroFile != nullptr) {
      if (n_select_msg < 0) n_select_msg = n_event;
 
      msgText = "/control/execute ";
      msgText += macroFile;
      selectMacro = macroFile;
    }
    else {
      n_select_msg = -1;
      selectMacro = "";
    }
 
    ComputeNumberOfTasks();
 
    // initialize seeds
    // If user did not implement InitializeSeeds,
    // use default: nSeedsPerEvent seeds per event
 
    if (n_event > 0) {
      G4bool _overload = InitializeSeeds(n_event);
      G4bool _functor = false;
      if (!_overload) _functor = initSeedsCallback(n_event, nSeedsPerEvent, nSeedsFilled);
      if (!_overload && !_functor) {
        G4RNGHelper* helper = G4RNGHelper::GetInstance();
        switch (SeedOncePerCommunication()) {
          case 0:
            nSeedsFilled = n_event;
            break;
          case 1:
            nSeedsFilled = numberOfTasks;
            break;
          case 2:
            nSeedsFilled = n_event / eventModulo + 1;
            break;
          default:
            G4ExceptionDescription msgd;
            msgd << "Parameter value <" << SeedOncePerCommunication()
                 << "> of seedOncePerCommunication is invalid. It is reset "
                    "to 0.";
            G4Exception("G4TaskRunManager::InitializeEventLoop()", "Run10036", JustWarning, msgd);
            SetSeedOncePerCommunication(0);
            nSeedsFilled = n_event;
        }
 
        // Generates up to nSeedsMax seed pairs only.
        if (nSeedsFilled > nSeedsMax) nSeedsFilled = nSeedsMax;
        masterRNGEngine->flatArray(nSeedsPerEvent * nSeedsFilled, randDbl);
        helper->Fill(randDbl, nSeedsFilled, n_event, nSeedsPerEvent);
      }
    }
  }
 
  // Now initialize workers. Check if user defined a WorkerThreadInitialization
  if (userWorkerThreadInitialization == nullptr)
    userWorkerThreadInitialization = new G4UserTaskThreadInitialization();
 
  // Prepare UI commands for threads
  PrepareCommandsStack();
 
  // Start worker threads
  CreateAndStartWorkers();
}

◆ InitializeSeeds()

G4bool G4TaskRunManager::InitializeSeeds ( G4int )

inlineoverrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 182 of file G4TaskRunManager.hh.

182{ return false; }

Referenced by InitializeEventLoop().

◆ InitializeThreadPool()

void G4TaskRunManager::InitializeThreadPool ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 239 of file G4TaskRunManager.cc.

{
  if (poolInitialized && (threadPool != nullptr) && (workTaskGroup != nullptr)) {
    G4Exception("G4TaskRunManager::InitializeThreadPool", "Run1040", JustWarning,
                "Threadpool already initialized. Ignoring...");
    return;
  }
 
  PTL::TaskRunManager::SetVerbose(GetVerbose());
  PTL::TaskRunManager::Initialize(nworkers);
 
  // create the joiners
  if (workTaskGroup == nullptr) {
    workTaskGroup = new RunTaskGroup(threadPool);
  }
 
  if (verboseLevel > 0) {
    std::stringstream ss;
    ss.fill('=');
    ss << std::setw(90) << "";
    G4cout << "\n" << ss.str() << G4endl;
 
    if (threadPool->is_tbb_threadpool()) {
      G4cout << "G4TaskRunManager :: Using TBB..." << G4endl;
    }
    else {
      G4cout << "G4TaskRunManager :: Using G4ThreadPool..." << G4endl;
    }
 
    G4cout << ss.str() << "\n" << G4endl;
  }
}

Referenced by Initialize().

◆ MergeRun()

void G4TaskRunManager::MergeRun ( const G4Run * localRun )

Definition at line 564 of file G4TaskRunManager.cc.

{
  G4AutoLock l(&runMergerMutex);
  if (currentRun != nullptr) currentRun->Merge(localRun);
}

◆ MergeScores()

void G4TaskRunManager::MergeScores ( const G4ScoringManager * localScoringManager )

Definition at line 556 of file G4TaskRunManager.cc.

{
  G4AutoLock l(&scorerMergerMutex);
  if (masterScM != nullptr) masterScM->Merge(localScoringManager);
}

◆ NewActionRequest()

void G4TaskRunManager::NewActionRequest ( WorkerActionRequest )

inlineoverrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 192 of file G4TaskRunManager.hh.

192{}

◆ ProcessOneEvent()

void G4TaskRunManager::ProcessOneEvent ( G4int i_event )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 274 of file G4TaskRunManager.cc.

{
  // Nothing to do
}

◆ RefillSeeds()

void G4TaskRunManager::RefillSeeds ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 422 of file G4TaskRunManager.cc.

{
  G4RNGHelper* helper = G4RNGHelper::GetInstance();
  G4int nFill = 0;
  switch (SeedOncePerCommunication()) {
    case 0:
      nFill = numberOfEventToBeProcessed - nSeedsFilled;
      break;
    case 1:
      nFill = numberOfTasks - nSeedsFilled;
      break;
    case 2:
    default:
      nFill = (numberOfEventToBeProcessed - nSeedsFilled * eventModulo) / eventModulo + 1;
  }
  // Generates up to nSeedsMax seed pairs only.
  if (nFill > nSeedsMax) nFill = nSeedsMax;
  masterRNGEngine->flatArray(nSeedsPerEvent * nFill, randDbl);
  helper->Refill(randDbl, nFill);
  nSeedsFilled += nFill;
}

Referenced by SetUpAnEvent(), and SetUpNEvents().

◆ RequestWorkersProcessCommandsStack()

void G4TaskRunManager::RequestWorkersProcessCommandsStack ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 675 of file G4TaskRunManager.cc.

{
  PrepareCommandsStack();
 
  auto process_commands_stack = []() {
    G4MTRunManager* mrm = G4MTRunManager::GetMasterRunManager();
    if (mrm != nullptr) {
      auto cmds = mrm->GetCommandStack();
      for (const auto& itr : cmds)
        G4UImanager::GetUIpointer()->ApplyCommand(itr);  // TLS instance
      mrm->ThisWorkerProcessCommandsStackDone();
    }
  };
 
  if (threadPool != nullptr) threadPool->execute_on_all_threads(process_commands_stack);
}

Referenced by TerminateWorkers().

◆ RunTermination()

void G4TaskRunManager::RunTermination ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 524 of file G4TaskRunManager.cc.

{
  // Wait for all worker threads to have finished the run
  // i.e. wait for them to return from RunTermination()
  // This guarantee that userrunaction for workers has been called
 
  // Wait now for all threads to finish event-loop
  WaitForEndEventLoopWorkers();
  // Now call base-class methof
  G4RunManager::TerminateEventLoop();
  G4RunManager::RunTermination();
}

◆ SetGrainsize()

void G4TaskRunManager::SetGrainsize ( G4int n )

inline

Definition at line 98 of file G4TaskRunManager.hh.

98{ eventGrainsize = n; }

CLHEP::detail::n

n

Definition Ranlux64Engine.cc:90

◆ SetInitializeSeedsCallback()

void G4TaskRunManager::SetInitializeSeedsCallback ( InitializeSeedsCallback f )

inline

Definition at line 171 of file G4TaskRunManager.hh.

171{ initSeedsCallback = f; }

◆ SetNumberOfThreads()

void G4TaskRunManager::SetNumberOfThreads ( G4int n )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 188 of file G4TaskRunManager.cc.

{
  if (forcedNwokers > 0) {
    if (verboseLevel > 0) {
      G4ExceptionDescription msg;
      msg << "\n### Number of threads is forced to " << forcedNwokers
          << " by G4FORCENUMBEROFTHREADS environment variable. G4TaskRunManager::" << __FUNCTION__
          << "(" << n << ") ignored ###";
      G4Exception("G4TaskRunManager::SetNumberOfThreads(G4int)", "Run0132", JustWarning, msg);
    }
    nworkers = forcedNwokers;
  }
  else {
    nworkers = n;
    if (poolInitialized) {
      if (verboseLevel > 0) {
        std::stringstream ss;
        ss << "\n### Thread-pool already initialized. Resizing  to " << nworkers << "threads ###";
        G4cout << ss.str() << "\n" << G4endl;
      }
      GetThreadPool()->resize(n);
    }
  }
}

◆ SetUpAnEvent()

G4bool G4TaskRunManager::SetUpAnEvent	(	G4Event *	evt,
		G4long &	s1,
		G4long &	s2,
		G4long &	s3,
		G4bool	reseedRequired = true )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 572 of file G4TaskRunManager.cc.

{
  G4AutoLock l(&setUpEventMutex);
  if (numberOfEventProcessed < numberOfEventToBeProcessed) {
    evt->SetEventID(numberOfEventProcessed);
    if (reseedRequired) {
      G4RNGHelper* helper = G4RNGHelper::GetInstance();
      G4int idx_rndm = nSeedsPerEvent * nSeedsUsed;
      s1 = helper->GetSeed(idx_rndm);
      s2 = helper->GetSeed(idx_rndm + 1);
      if (nSeedsPerEvent == 3) s3 = helper->GetSeed(idx_rndm + 2);
      ++nSeedsUsed;
      if (nSeedsUsed == nSeedsFilled) RefillSeeds();
    }
    numberOfEventProcessed++;
    return true;
  }
  return false;
}

◆ SetUpNEvents()

G4int G4TaskRunManager::SetUpNEvents	(	G4Event *	evt,
		G4SeedsQueue *	seedsQueue,
		G4bool	reseedRequired = true )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 595 of file G4TaskRunManager.cc.

{
  G4AutoLock l(&setUpEventMutex);
  if (numberOfEventProcessed < numberOfEventToBeProcessed && !runAborted) {
    G4int nevt = numberOfEventsPerTask;
    G4int nmod = eventModulo;
    if (numberOfEventProcessed + nevt > numberOfEventToBeProcessed) {
      nevt = numberOfEventToBeProcessed - numberOfEventProcessed;
      nmod = numberOfEventToBeProcessed - numberOfEventProcessed;
    }
    evt->SetEventID(numberOfEventProcessed);
 
    if (reseedRequired) {
      G4RNGHelper* helper = G4RNGHelper::GetInstance();
      G4int nevRnd = nmod;
      if (SeedOncePerCommunication() > 0) nevRnd = 1;
      for (G4int i = 0; i < nevRnd; ++i) {
        seedsQueue->push(helper->GetSeed(nSeedsPerEvent * nSeedsUsed));
        seedsQueue->push(helper->GetSeed(nSeedsPerEvent * nSeedsUsed + 1));
        if (nSeedsPerEvent == 3) seedsQueue->push(helper->GetSeed(nSeedsPerEvent * nSeedsUsed + 2));
        nSeedsUsed++;
        if (nSeedsUsed == nSeedsFilled) RefillSeeds();
      }
    }
    numberOfEventProcessed += nevt;
    return nevt;
  }
  return 0;
}

◆ StoreRNGStatus()

void G4TaskRunManager::StoreRNGStatus ( const G4String & filenamePrefix )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 179 of file G4TaskRunManager.cc.

{
  std::ostringstream os;
  os << randomNumberStatusDir << "G4Master_" << fn << ".rndm";
  G4Random::saveEngineStatus(os.str().c_str());
}

◆ TerminateOneEvent()

void G4TaskRunManager::TerminateOneEvent ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 281 of file G4TaskRunManager.cc.

{
  // Nothing to do
}

◆ TerminateWorkers()

void G4TaskRunManager::TerminateWorkers ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 627 of file G4TaskRunManager.cc.

{
  // Force workers to execute (if any) all UI commands left in the stack
  RequestWorkersProcessCommandsStack();
 
  if (workTaskGroup != nullptr) {
    workTaskGroup->join();
    if (!fakeRun)
      threadPool->execute_on_all_threads([]() { G4TaskRunManagerKernel::TerminateWorker(); });
  }
}

Referenced by ~G4TaskRunManager().

◆ ThisWorkerEndEventLoop()

void G4TaskRunManager::ThisWorkerEndEventLoop ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 164 of file G4TaskRunManager.hh.

164{}

◆ ThisWorkerProcessCommandsStackDone()

void G4TaskRunManager::ThisWorkerProcessCommandsStackDone ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 694 of file G4TaskRunManager.cc.

694{}

◆ ThisWorkerReady()

void G4TaskRunManager::ThisWorkerReady ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 163 of file G4TaskRunManager.hh.

163{}

◆ ThisWorkerWaitForNextAction()

WorkerActionRequest G4TaskRunManager::ThisWorkerWaitForNextAction ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 166 of file G4TaskRunManager.hh.

    {
      return WorkerActionRequest::UNDEFINED;
    }

◆ ThreadPoolIsInitialized()

G4bool G4TaskRunManager::ThreadPoolIsInitialized ( ) const

inline

Definition at line 116 of file G4TaskRunManager.hh.

116{ return poolInitialized; }

◆ WaitForEndEventLoopWorkers()

void G4TaskRunManager::WaitForEndEventLoopWorkers ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 663 of file G4TaskRunManager.cc.

{
  if (workTaskGroup != nullptr) {
    workTaskGroup->join();
    if (!fakeRun)
      threadPool->execute_on_all_threads(
        []() { G4TaskRunManagerKernel::TerminateWorkerRunEventLoop(); });
  }
}

Referenced by RunTermination().

◆ WaitForReadyWorkers()

void G4TaskRunManager::WaitForReadyWorkers ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 161 of file G4TaskRunManager.hh.

161{}

Friends And Related Symbol Documentation

◆ G4RunManagerFactory

friend class G4RunManagerFactory

friend

Definition at line 68 of file G4TaskRunManager.hh.

Member Data Documentation

◆ initSeedsCallback

InitializeSeedsCallback G4TaskRunManager::initSeedsCallback

protected

Initial value:

= [](G4int, G4int&, G4int&) {
      return false;
    }

Definition at line 205 of file G4TaskRunManager.hh.

                                                                          {
      return false;
    };

Referenced by InitializeEventLoop(), and SetInitializeSeedsCallback().

◆ poolInitialized

G4bool& G4TaskRunManager::poolInitialized = PTL::TaskRunManager::m_is_initialized

protected

Definition at line 200 of file G4TaskRunManager.hh.

Referenced by GetNumberOfThreads(), InitializeThreadPool(), SetNumberOfThreads(), and ThreadPoolIsInitialized().

◆ taskManager

G4TaskManager*& G4TaskRunManager::taskManager = PTL::TaskRunManager::m_task_manager

protected

Definition at line 203 of file G4TaskRunManager.hh.

◆ taskQueue

G4VUserTaskQueue*& G4TaskRunManager::taskQueue = PTL::TaskRunManager::m_task_queue

protected

Definition at line 202 of file G4TaskRunManager.hh.

Referenced by G4TaskRunManager().

◆ threadPool

G4ThreadPool*& G4TaskRunManager::threadPool = PTL::TaskRunManager::m_thread_pool

protected

Definition at line 201 of file G4TaskRunManager.hh.

Referenced by ComputeNumberOfTasks(), CreateAndStartWorkers(), Initialize(), InitializeThreadPool(), RequestWorkersProcessCommandsStack(), TerminateWorkers(), WaitForEndEventLoopWorkers(), and ~G4TaskRunManager().

◆ workTaskGroup

RunTaskGroup* G4TaskRunManager::workTaskGroup = nullptr

protected

Definition at line 197 of file G4TaskRunManager.hh.

Referenced by AddEventTask(), CreateAndStartWorkers(), InitializeThreadPool(), TerminateWorkers(), WaitForEndEventLoopWorkers(), and ~G4TaskRunManager().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ InitializeSeedsCallback

◆ ProfilerConfig

◆ RunTaskGroup

Constructor & Destructor Documentation

◆ G4TaskRunManager() [1/2]

◆ G4TaskRunManager() [2/2]

◆ ~G4TaskRunManager()

Member Function Documentation

◆ AbortEvent()

◆ AbortRun()

◆ AddEventTask()

◆ ComputeNumberOfTasks()

◆ ConstructScoringWorlds()

◆ CreateAndStartWorkers()

◆ GetGrainsize()

◆ GetMasterRunManager()

◆ GetMasterThreadId()

◆ GetMTMasterRunManagerKernel()

◆ GetNumberActiveThreads()

◆ GetNumberOfEventsPerTask()

◆ GetNumberOfTasks()

◆ GetNumberOfThreads()

◆ Initialize() [1/2]

◆ Initialize() [2/2]

◆ InitializeEventLoop()

◆ InitializeSeeds()

◆ InitializeThreadPool()

◆ MergeRun()

◆ MergeScores()

◆ NewActionRequest()

◆ ProcessOneEvent()

◆ RefillSeeds()

◆ RequestWorkersProcessCommandsStack()

◆ RunTermination()

◆ SetGrainsize()

◆ SetInitializeSeedsCallback()

◆ SetNumberOfThreads()

◆ SetUpAnEvent()

◆ SetUpNEvents()

◆ StoreRNGStatus()

◆ TerminateOneEvent()

◆ TerminateWorkers()

◆ ThisWorkerEndEventLoop()

◆ ThisWorkerProcessCommandsStackDone()

◆ ThisWorkerReady()

◆ ThisWorkerWaitForNextAction()

◆ ThreadPoolIsInitialized()

◆ WaitForEndEventLoopWorkers()

◆ WaitForReadyWorkers()

Friends And Related Symbol Documentation

◆ G4RunManagerFactory

Member Data Documentation

◆ initSeedsCallback

◆ poolInitialized

◆ taskManager

◆ taskQueue

◆ threadPool

◆ workTaskGroup