G4TaskRunManager Class Reference

#include <G4TaskRunManager.hh>

Inheritance diagram for G4TaskRunManager:

Public Types
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	masterWorlds_t = std::map<G4int, G4VPhysicalVolume*>
Public Types inherited from G4RunManager
enum	RMType {   sequentialRM , masterRM , workerRM , subEventMasterRM ,   subEventWorkerRM }
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) override
void	MergeRun (const G4Run *localRun) override
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	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)
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)
void	SetDefaultClassification (G4TrackStatus ts, G4ClassificationOfNewTrack val, G4ExceptionSeverity es=G4ExceptionSeverity::IgnoreTheIssue)
void	SetDefaultClassification (const G4ParticleDefinition *pd, G4ClassificationOfNewTrack val, G4ExceptionSeverity es=G4ExceptionSeverity::IgnoreTheIssue)
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
virtual void	RegisterSubEventType (G4int, G4int)
virtual void	MergeTrajectories (const G4SubEvent *, const G4Event *)
virtual void	UpdateScoringForSubEvent (const G4SubEvent *, const G4Event *)
virtual const G4SubEvent *	GetSubEvent (G4int, G4bool &, G4long &, G4long &, G4long &, G4bool)
virtual void	SubEventFinished (const G4SubEvent *, const G4Event *)
virtual G4int	GetSubEventType () const
virtual void	SetSubEventType (G4int)
virtual std::size_t	GetMaxNTrack () const
virtual void	TrajectoriesToBeMerged (G4bool)
virtual void	ReportEventDeletion (const G4Event *evt)
void	ResetNavigatorAtInitialization (G4bool val=true)
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

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)
virtual void	StackPreviousEvent (G4Event *anEvent)
virtual void	CleanUpPreviousEvents ()
virtual void	CleanUpUnnecessaryEvents (G4int keepNEvents)
void	UpdateScoring (const G4Event *evt=nullptr)
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
G4bool	workersStarted = false
G4int	eventGrainsize = 0
G4int	numberOfEventsPerTask = -1
G4int	numberOfTasks = -1
CLHEP::HepRandomEngine *	masterRNGEngine = nullptr
G4TaskRunManagerKernel *	MTkernel = nullptr
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
G4int	pinAffinity = 0
G4ThreadsList	threads
std::vector< G4String >	uiCmdsForWorkers
CLHEP::HepRandomEngine *	masterRNGEngine = nullptr
G4MTRunManagerKernel *	MTkernel = nullptr
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
uint64_t	m_workers = 0
bool	m_use_tbb = false
VUserTaskQueue *	m_task_queue = nullptr
ThreadPool *	m_thread_pool = nullptr
TaskManager *	m_task_manager = nullptr

Friends
class	G4RunManagerFactory

Additional Inherited Members
Protected Types inherited from G4MTRunManager
using	G4ThreadsList = std::list<G4Thread*>
Static Protected Attributes inherited from G4MTRunManager
static G4MTRUN_DLL G4ScoringManager *	masterScM = nullptr
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 65 of file G4TaskRunManager.hh.

Member Typedef Documentation

InitializeSeedsCallback

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

Definition at line 70 of file G4TaskRunManager.hh.

RunTaskGroup

using G4TaskRunManager::RunTaskGroup = G4TaskGroup<void>

Definition at line 71 of file G4TaskRunManager.hh.

Constructor & Destructor Documentation

G4TaskRunManager() [1/2]

G4TaskRunManager::G4TaskRunManager

(

G4bool

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

)

Definition at line 141 of file G4TaskRunManager.cc.

: G4TaskRunManager(nullptr, useTBB, 0) {}

Referenced by G4SubEvtRunManager::G4SubEvtRunManager(), G4TaskRunManager(), and GetMasterRunManager().

G4TaskRunManager() [2/2]

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

Definition at line 76 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
}

~G4TaskRunManager()

G4TaskRunManager::~G4TaskRunManager ( )

override

Definition at line 145 of file G4TaskRunManager.cc.

{
  // 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 653 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 638 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

Reimplemented in G4SubEvtRunManager.

Definition at line 408 of file G4TaskRunManager.cc.

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

Referenced by CreateAndStartWorkers().

ComputeNumberOfTasks()

void G4TaskRunManager::ComputeNumberOfTasks ( )

protectedvirtual

Reimplemented in G4SubEvtRunManager.

Definition at line 280 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 > 2) {
    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 536 of file G4TaskRunManager.cc.

{
  masterScM = G4ScoringManager::GetScoringManagerIfExist();
  // Call base class stuff...
  G4RunManager::ConstructScoringWorlds();
 
  GetMasterWorlds().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 333 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([cmds = std::move(initCmdStack)]() {
          for (auto& itr : cmds)
            G4UImanager::GetUIpointer()->ApplyCommand(itr);
          G4WorkerTaskRunManager::GetWorkerRunManager()->DoWork();
        });
      }
    }
    else {
      if (verboseLevel > 0) {
        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([cmds = std::move(initCmdStack)]() {
        for (auto& itr : cmds)
          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(); });
 
    if (verboseLevel > 0) {
      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 96 of file G4TaskRunManager.hh.

{ return eventGrainsize; }

GetMasterRunManager()

G4TaskRunManager * G4TaskRunManager::GetMasterRunManager ( )

inlinestatic

Definition at line 76 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(), G4WorkerSubEvtRunManager::ProcessUI(), G4WorkerTaskRunManager::ProcessUI(), G4WorkerSubEvtRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and G4TaskRunManagerKernel::TerminateWorker().

GetMasterThreadId()

G4ThreadId G4TaskRunManager::GetMasterThreadId ( )

static

Definition at line 165 of file G4TaskRunManager.cc.

{
  return G4MTRunManager::GetMasterThreadId();
}

GetMTMasterRunManagerKernel()

G4TaskRunManagerKernel * G4TaskRunManager::GetMTMasterRunManagerKernel ( )

static

Definition at line 69 of file G4TaskRunManager.cc.

{
  return GetMasterRunManager()->MTkernel;
}

GetNumberActiveThreads()

size_t G4TaskRunManager::GetNumberActiveThreads ( ) const

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 102 of file G4TaskRunManager.hh.

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

GetNumberOfEventsPerTask()

G4int G4TaskRunManager::GetNumberOfEventsPerTask ( ) const

inline

Definition at line 98 of file G4TaskRunManager.hh.

{ return numberOfEventsPerTask; }

Referenced by G4WorkerTaskRunManager::DoWork().

GetNumberOfTasks()

G4int G4TaskRunManager::GetNumberOfTasks ( ) const

inline

Definition at line 97 of file G4TaskRunManager.hh.

{ return numberOfTasks; }

GetNumberOfThreads()

G4int G4TaskRunManager::GetNumberOfThreads ( ) const

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 208 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 217 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 115 of file G4TaskRunManager.hh.

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

InitializeEventLoop()

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

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 443 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 179 of file G4TaskRunManager.hh.

{ return false; }

Referenced by InitializeEventLoop().

InitializeThreadPool()

void G4TaskRunManager::InitializeThreadPool ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 232 of file G4TaskRunManager.cc.

{
  if (poolInitialized && (threadPool != nullptr) && (workTaskGroup != nullptr)) {
    G4Exception("G4TaskRunManager::InitializeThreadPool", "Run1040", JustWarning,
                "Threadpool already initialized. Ignoring...");
    return;
  }
 
  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 G4SubEvtRunManager::Initialize(), and Initialize().

MergeRun()

void G4TaskRunManager::MergeRun ( const G4Run * localRun )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 561 of file G4TaskRunManager.cc.

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

MergeScores()

void G4TaskRunManager::MergeScores ( const G4ScoringManager * localScoringManager )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 553 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 189 of file G4TaskRunManager.hh.

{}

ProcessOneEvent()

void G4TaskRunManager::ProcessOneEvent ( G4int i_event )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 266 of file G4TaskRunManager.cc.

{
  // Nothing to do
}

RefillSeeds()

void G4TaskRunManager::RefillSeeds ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 419 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 672 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 521 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 95 of file G4TaskRunManager.hh.

{ eventGrainsize = n; }

SetInitializeSeedsCallback()

void G4TaskRunManager::SetInitializeSeedsCallback ( InitializeSeedsCallback f )

inline

Definition at line 168 of file G4TaskRunManager.hh.

{ initSeedsCallback = f; }

SetNumberOfThreads()

void G4TaskRunManager::SetNumberOfThreads ( G4int n )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 181 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 569 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 592 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 172 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 273 of file G4TaskRunManager.cc.

{
  // Nothing to do
}

TerminateWorkers()

void G4TaskRunManager::TerminateWorkers ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 624 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 161 of file G4TaskRunManager.hh.

{}

ThisWorkerProcessCommandsStackDone()

void G4TaskRunManager::ThisWorkerProcessCommandsStackDone ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 691 of file G4TaskRunManager.cc.

{}

ThisWorkerReady()

void G4TaskRunManager::ThisWorkerReady ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 160 of file G4TaskRunManager.hh.

{}

ThisWorkerWaitForNextAction()

WorkerActionRequest G4TaskRunManager::ThisWorkerWaitForNextAction ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 163 of file G4TaskRunManager.hh.

    {
      return WorkerActionRequest::UNDEFINED;
    }

ThreadPoolIsInitialized()

G4bool G4TaskRunManager::ThreadPoolIsInitialized ( ) const

inline

Definition at line 113 of file G4TaskRunManager.hh.

{ return poolInitialized; }

WaitForEndEventLoopWorkers()

void G4TaskRunManager::WaitForEndEventLoopWorkers ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 660 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 158 of file G4TaskRunManager.hh.

{}

Friends And Related Symbol Documentation

G4RunManagerFactory

friend class G4RunManagerFactory

friend

Definition at line 67 of file G4TaskRunManager.hh.

Referenced by G4RunManagerFactory.

Member Data Documentation

eventGrainsize

G4int G4TaskRunManager::eventGrainsize = 0

protected

Definition at line 209 of file G4TaskRunManager.hh.

Referenced by ComputeNumberOfTasks(), G4TaskRunManager(), GetGrainsize(), and SetGrainsize().

initSeedsCallback

InitializeSeedsCallback G4TaskRunManager::initSeedsCallback

protected

Initial value:

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

Definition at line 202 of file G4TaskRunManager.hh.

                                                                        {
      return false;
    };

Referenced by G4SubEvtRunManager::InitializeEventLoop(), InitializeEventLoop(), and SetInitializeSeedsCallback().

masterRNGEngine

CLHEP::HepRandomEngine* G4TaskRunManager::masterRNGEngine = nullptr

protected

Definition at line 212 of file G4TaskRunManager.hh.

Referenced by G4TaskRunManager(), G4SubEvtRunManager::InitializeEventLoop(), InitializeEventLoop(), G4SubEvtRunManager::RefillSeeds(), and RefillSeeds().

MTkernel

G4TaskRunManagerKernel* G4TaskRunManager::MTkernel = nullptr

protected

Definition at line 214 of file G4TaskRunManager.hh.

Referenced by G4SubEvtRunManager::AbortRun(), AbortRun(), G4TaskRunManager(), GetMTMasterRunManagerKernel(), G4SubEvtRunManager::InitializeEventLoop(), and InitializeEventLoop().

numberOfEventsPerTask

G4int G4TaskRunManager::numberOfEventsPerTask = -1

protected

Definition at line 210 of file G4TaskRunManager.hh.

Referenced by G4SubEvtRunManager::ComputeNumberOfTasks(), ComputeNumberOfTasks(), G4SubEvtRunManager::CreateAndStartWorkers(), CreateAndStartWorkers(), GetNumberOfEventsPerTask(), and SetUpNEvents().

numberOfTasks

G4int G4TaskRunManager::numberOfTasks = -1

protected

Definition at line 211 of file G4TaskRunManager.hh.

Referenced by G4SubEvtRunManager::ComputeNumberOfTasks(), ComputeNumberOfTasks(), G4SubEvtRunManager::CreateAndStartWorkers(), CreateAndStartWorkers(), GetNumberOfTasks(), InitializeEventLoop(), G4SubEvtRunManager::RefillSeeds(), and RefillSeeds().

poolInitialized

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

protected

Definition at line 197 of file G4TaskRunManager.hh.

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

taskManager

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

protected

Definition at line 200 of file G4TaskRunManager.hh.

taskQueue

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

protected

Definition at line 199 of file G4TaskRunManager.hh.

Referenced by G4TaskRunManager().

threadPool

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

protected

Definition at line 198 of file G4TaskRunManager.hh.

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

workersStarted

G4bool G4TaskRunManager::workersStarted = false

protected

Definition at line 208 of file G4TaskRunManager.hh.

workTaskGroup

RunTaskGroup* G4TaskRunManager::workTaskGroup = nullptr

protected

Definition at line 194 of file G4TaskRunManager.hh.

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

---

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

• G4TaskRunManager.hh
• G4TaskRunManager.cc