#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.

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

G4TaskRunManager::G4TaskRunManager

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

Definition G4TaskRunManager.cc:141

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 651 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 636 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 406 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 534 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 {
      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(); });
 
    {
      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.

96{ return eventGrainsize; }

◆ GetMasterRunManager()

static 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.

98{ return numberOfEventsPerTask; }

Referenced by G4WorkerTaskRunManager::DoWork().

◆ GetNumberOfTasks()

G4int G4TaskRunManager::GetNumberOfTasks ( ) const

inline

Definition at line 97 of file G4TaskRunManager.hh.

97{ 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.

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

PTL::TaskRunManager::Initialize

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

Definition TaskRunManager.cc:88

◆ InitializeEventLoop()

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

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 441 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.

179{ 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 559 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 551 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.

189{}

◆ 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 417 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 670 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 519 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.

95{ eventGrainsize = n; }

CLHEP::detail::n

n

Definition Ranlux64Engine.cc:90

◆ SetInitializeSeedsCallback()

void G4TaskRunManager::SetInitializeSeedsCallback ( InitializeSeedsCallback f )

inline

Definition at line 168 of file G4TaskRunManager.hh.

168{ 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 567 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 590 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 622 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.

161{}

◆ ThisWorkerProcessCommandsStackDone()

void G4TaskRunManager::ThisWorkerProcessCommandsStackDone ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 689 of file G4TaskRunManager.cc.

689{}

◆ ThisWorkerReady()

void G4TaskRunManager::ThisWorkerReady ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 160 of file G4TaskRunManager.hh.

160{}

◆ 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.

113{ return poolInitialized; }

◆ WaitForEndEventLoopWorkers()

void G4TaskRunManager::WaitForEndEventLoopWorkers ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 658 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.

158{}

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:

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ InitializeSeedsCallback

◆ 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

◆ eventGrainsize

◆ initSeedsCallback

◆ masterRNGEngine

◆ MTkernel

◆ numberOfEventsPerTask

◆ numberOfTasks

◆ poolInitialized

◆ taskManager

◆ taskQueue

◆ threadPool

◆ workersStarted

◆ workTaskGroup