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

using	RunTaskGroupTBB = G4TBBTaskGroup< void >

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

using	ProfilerConfig = G4ProfilerConfig< G4ProfileType::Run >

typedef std::map< G4int, G4VPhysicalVolume * >	masterWorlds_t

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

using	ProfilerConfig = G4ProfilerConfig< G4ProfileType::Run >

Public Types inherited from PTL::TaskRunManager
typedef TaskRunManager *	pointer

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

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

virtual	~G4TaskRunManager ()

void	SetGrainsize (G4int n)

G4int	GetGrainsize () const

G4int	GetNumberOfTasks () const

G4int	GetNumberOfEventsPerTask () const

virtual void	SetNumberOfThreads (G4int n) override

virtual G4int	GetNumberOfThreads () const override

virtual size_t	GetNumberActiveThreads () const override

virtual void	Initialize () override

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

virtual void	InitializeThreadPool () override

G4bool	ThreadPoolIsInitialized () const

virtual void	Initialize (uint64_t nthreads) override

virtual void	TerminateOneEvent () override

virtual void	ProcessOneEvent (G4int i_event) override

virtual void	ConstructScoringWorlds () override

virtual void	RunTermination () override

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

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

void	MergeScores (const G4ScoringManager *localScoringManager)

void	MergeRun (const G4Run *localRun)

virtual void	RequestWorkersProcessCommandsStack () override

virtual void	ThisWorkerProcessCommandsStackDone () override

virtual void	WaitForReadyWorkers () override

virtual void	WaitForEndEventLoopWorkers () override

virtual void	ThisWorkerReady () override

virtual void	ThisWorkerEndEventLoop () override

virtual WorkerActionRequest	ThisWorkerWaitForNextAction () override

void	SetInitializeSeedsCallback (InitializeSeedsCallback f)

virtual void	AbortRun (G4bool softAbort=false) override

virtual void	AbortEvent () override

Public Member Functions inherited from G4MTRunManager
	G4MTRunManager ()

virtual	~G4MTRunManager ()

virtual void	SetNumberOfThreads (G4int n)

virtual G4int	GetNumberOfThreads () const

void	SetPinAffinity (G4int n=1)

G4int	GetPinAffinity () const

virtual void	Initialize ()

virtual void	InitializeEventLoop (G4int n_event, const char *macroFile=0, G4int n_select=-1)

virtual void	InitializeThreadPool ()

virtual void	TerminateOneEvent ()

virtual void	ProcessOneEvent (G4int i_event)

virtual void	ConstructScoringWorlds ()

virtual void	RunTermination ()

virtual G4bool	SetUpAnEvent (G4Event *, long &s1, long &s2, long &s3, G4bool reseedRequired=true)

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

std::vector< G4String >	GetCommandStack ()

virtual size_t	GetNumberActiveThreads () const

virtual void	ThisWorkerReady ()

virtual void	ThisWorkerEndEventLoop ()

const CLHEP::HepRandomEngine *	getMasterRandomEngine () const

virtual void	SetUserInitialization (G4VUserPhysicsList *userPL)

virtual void	SetUserInitialization (G4VUserDetectorConstruction *userDC)

virtual void	SetUserInitialization (G4UserWorkerInitialization *userInit)

virtual void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit)

virtual void	SetUserInitialization (G4VUserActionInitialization *userInit)

virtual void	SetUserAction (G4UserRunAction *userAction)

virtual void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction)

virtual void	SetUserAction (G4UserEventAction *userAction)

virtual void	SetUserAction (G4UserStackingAction *userAction)

virtual void	SetUserAction (G4UserTrackingAction *userAction)

virtual void	SetUserAction (G4UserSteppingAction *userAction)

void	MergeScores (const G4ScoringManager *localScoringManager)

void	MergeRun (const G4Run *localRun)

virtual void	RequestWorkersProcessCommandsStack ()

virtual void	ThisWorkerProcessCommandsStackDone ()

virtual WorkerActionRequest	ThisWorkerWaitForNextAction ()

void	SetEventModulo (G4int i=1)

G4int	GetEventModulo () const

virtual void	AbortRun (G4bool softAbort=false)

virtual void	AbortEvent ()

Public Member Functions inherited from G4RunManager
	G4RunManager ()

virtual	~G4RunManager ()

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

virtual void	Initialize ()

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

virtual void	AbortRun (G4bool softAbort=false)

virtual void	AbortEvent ()

virtual void	InitializeGeometry ()

virtual void	InitializePhysics ()

virtual G4bool	ConfirmBeamOnCondition ()

virtual void	RunInitialization ()

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

virtual void	RunTermination ()

virtual void	InitializeEventLoop (G4int n_event, const char *macroFile=0, G4int n_select=-1)

virtual void	ProcessOneEvent (G4int i_event)

virtual void	TerminateOneEvent ()

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 (int argc, char **argv)

virtual void	SetNumberOfThreads (G4int)

virtual G4int	GetNumberOfThreads () const

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=0) const

virtual void	rndmSaveThisRun ()

virtual void	rndmSaveThisEvent ()

virtual void	RestoreRandomNumberStatus (const G4String &fileN)

virtual void	SetUserInitialization (G4VUserDetectorConstruction *userInit)

virtual void	SetUserInitialization (G4VUserPhysicsList *userInit)

virtual void	SetUserInitialization (G4VUserActionInitialization *userInit)

virtual void	SetUserInitialization (G4UserWorkerInitialization *userInit)

virtual void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit)

virtual void	SetUserAction (G4UserRunAction *userAction)

virtual void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction)

virtual void	SetUserAction (G4UserEventAction *userAction)

virtual void	SetUserAction (G4UserStackingAction *userAction)

virtual void	SetUserAction (G4UserTrackingAction *userAction)

virtual void	SetUserAction (G4UserSteppingAction *userAction)

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	GeometryHasBeenModified (G4bool prop=true)

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

void	PhysicsHasBeenModified ()

void	CutOffHasBeenModified ()

void	ReOptimizeMotherOf (G4VPhysicalVolume *)

void	ReOptimize (G4LogicalVolume *)

void	SetVerboseLevel (G4int vl)

G4int	GetVerboseLevel () const

G4int	GetPrintProgress ()

void	SetPrintProgress (G4int i)

void	SetGeometryToBeOptimized (G4bool vl)

G4bool	GetGeometryToBeOptimized ()

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

G4String	GetSelectMacro () const

void	SetDCtable (G4DCtable *DCtbl)

RMType	GetRunManagerType () const

virtual void	ConstructScoringWorlds ()

virtual void	RestoreRndmEachEvent (G4bool)

void	GeometryDirectlyUpdated (G4bool val=true)

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

virtual	~TaskRunManager ()

virtual int	GetNumberOfThreads () const

virtual size_t	GetNumberActiveThreads () const

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

virtual void	Terminate ()

ThreadPool *	GetThreadPool () const

TaskManager *	GetTaskManager () const

bool	IsInitialized () const

int	GetVerbose () const

void	SetVerbose (int val)

Static Public Member Functions
static G4ThreadId	GetMasterThreadId ()

static G4TaskRunManager *	GetMasterRunManager ()

static G4TaskRunManagerKernel *	GetMTMasterRunManagerKernel ()

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 G4ThreadId	GetMasterTheadId ()

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 ()

virtual G4bool	InitializeSeeds (G4int) override

virtual void	RefillSeeds () override

virtual void	StoreRNGStatus (const G4String &filenamePrefix) override

virtual void	CreateAndStartWorkers () override

virtual void	TerminateWorkers () override

virtual void	NewActionRequest (WorkerActionRequest) override

virtual void	AddEventTask (G4int)

Protected Member Functions inherited from G4MTRunManager
virtual G4bool	InitializeSeeds (G4int)

virtual void	PrepareCommandsStack ()

virtual void	StoreRNGStatus (const G4String &filenamePrefix)

virtual void	rndmSaveThisRun ()

virtual void	rndmSaveThisEvent ()

virtual void	CreateAndStartWorkers ()

virtual void	WaitForReadyWorkers ()

virtual void	WaitForEndEventLoopWorkers ()

virtual void	TerminateWorkers ()

virtual void	NewActionRequest (WorkerActionRequest newRequest)

virtual void	RefillSeeds ()

Protected Member Functions inherited from G4RunManager
void	CleanUpPreviousEvents ()

void	CleanUpUnnecessaryEvents (G4int keepNEvents)

void	StackPreviousEvent (G4Event *anEvent)

	G4RunManager (RMType rmType)

virtual void	StoreRNGStatus (const G4String &filenamePrefix)

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

G4int	forcedNwokers

G4int	numberOfEventToBeProcessed

WorkerActionRequest	nextActionRequest

G4int	eventModuloDef

G4int	eventModulo

G4int	nSeedsUsed

G4int	nSeedsFilled

G4int	nSeedsMax

G4int	nSeedsPerEvent

double *	randDbl

G4MTBarrier	beginOfEventLoopBarrier

G4MTBarrier	endOfEventLoopBarrier

G4MTBarrier	nextActionRequestBarrier

G4MTBarrier	processUIBarrier

Protected Attributes inherited from G4RunManager
G4RunManagerKernel *	kernel

G4EventManager *	eventManager

G4VUserDetectorConstruction *	userDetector

G4VUserPhysicsList *	physicsList

G4VUserActionInitialization *	userActionInitialization

G4UserWorkerInitialization *	userWorkerInitialization

G4UserWorkerThreadInitialization *	userWorkerThreadInitialization

G4UserRunAction *	userRunAction

G4VUserPrimaryGeneratorAction *	userPrimaryGeneratorAction

G4UserEventAction *	userEventAction

G4UserStackingAction *	userStackingAction

G4UserTrackingAction *	userTrackingAction

G4UserSteppingAction *	userSteppingAction

G4bool	geometryInitialized

G4bool	physicsInitialized

G4bool	runAborted

G4bool	initializedAtLeastOnce

G4bool	geometryToBeOptimized

G4int	runIDCounter

G4int	verboseLevel

G4int	printModulo

G4Timer *	timer

G4DCtable *	DCtable

G4Run *	currentRun

G4Event *	currentEvent

std::list< G4Event * > *	previousEvents

G4int	n_perviousEventsToBeStored

G4int	numberOfEventToBeProcessed

G4bool	storeRandomNumberStatus

G4int	storeRandomNumberStatusToG4Event

G4String	randomNumberStatusDir

G4String	randomNumberStatusForThisRun

G4String	randomNumberStatusForThisEvent

G4bool	rngStatusEventsFlag

G4VPhysicalVolume *	currentWorld

G4int	nParallelWorlds

G4String	msgText

G4int	n_select_msg

G4int	numberOfEventProcessed

G4String	selectMacro

G4bool	fakeRun

G4bool	isScoreNtupleWriter

RMType	runManagerType

G4bool	geometryDirectlyUpdated

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 = 0

static G4MTRUN_DLL masterWorlds_t	masterWorlds

static G4MTRUN_DLL G4MTRunManager *	fMasterRM = 0

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 76 of file G4TaskRunManager.hh.

◆ ProfilerConfig

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

Definition at line 73 of file G4TaskRunManager.hh.

◆ RunTaskGroup

using G4TaskRunManager::RunTaskGroup = G4TaskGroup<void>

Definition at line 77 of file G4TaskRunManager.hh.

◆ RunTaskGroupTBB

using G4TaskRunManager::RunTaskGroupTBB = G4TBBTaskGroup<void>

Definition at line 78 of file G4TaskRunManager.hh.

Constructor & Destructor Documentation

◆ G4TaskRunManager() [1/2]

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

Definition at line 161 of file G4TaskRunManager.cc.

162 : G4TaskRunManager(nullptr, useTBB, 0)

163{}

G4TaskRunManager

Definition: G4TaskRunManager.hh:69

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

  : G4MTRunManager()
  , PTL::TaskRunManager(useTBB)
  , eventGrainsize(grainsize)
  , numberOfEventsPerTask(-1)
  , numberOfTasks(-1)
  , masterRNGEngine(nullptr)
  , workTaskGroup(nullptr)
{
  if(task_queue)
    taskQueue = task_queue;
 
  // override default of 2 from G4MTRunManager
  nworkers  = std::thread::hardware_concurrency();
  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
  //------------------------------------------------------------------------//
  G4String _nthread_env = G4GetEnv<G4String>("G4FORCENUMBEROFTHREADS", "max");
  for(auto& itr : _nthread_env)
    itr = tolower(itr);
 
  if(_nthread_env == "max")
    forcedNwokers = G4Threading::G4GetNumberOfCores();
  else
  {
    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 ( )

virtual

Definition at line 167 of file G4TaskRunManager.cc.

{
  if(workTaskGroup)
  {
    workTaskGroup->join();
    delete workTaskGroup;
  }
  // finalize profiler before shutting down the threads
  G4Profiler::Finalize();
  if(threadPool)
    threadPool->destroy_threadpool();
  PTL::TaskRunManager::Terminate();
}

Member Function Documentation

◆ AbortEvent()

void G4TaskRunManager::AbortEvent ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 744 of file G4TaskRunManager.cc.

{
  // nothing to do in the master thread
}

◆ AbortRun()

void G4TaskRunManager::AbortRun ( G4bool softAbort = false )

overridevirtual

virtual void ResetNavigator() const;

Reimplemented from G4MTRunManager.

Definition at line 726 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 440 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 304 of file G4TaskRunManager.cc.

{
  G4int grainSize = (eventGrainsize == 0) ? threadPool->size() : eventGrainsize;
  grainSize =
    G4GetEnv<G4int>("G4FORCE_GRAINSIZE", grainSize, "Forcing grainsize...");
  if(grainSize == 0)
    grainSize = 1;
 
  G4int nEvtsPerTask = (numberOfEventToBeProcessed > grainSize)
                         ? (numberOfEventToBeProcessed / grainSize)
                         : 1;
 
  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(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 606 of file G4TaskRunManager.cc.

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

◆ CreateAndStartWorkers()

void G4TaskRunManager::CreateAndStartWorkers ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 349 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(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(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 93 of file G4TaskRunManager.hh.

93{ return eventGrainsize; }

◆ GetMasterRunManager()

static G4TaskRunManager * G4TaskRunManager::GetMasterRunManager ( )

inlinestatic

Definition at line 166 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 183 of file G4TaskRunManager.cc.

{
  return G4MTRunManager::GetMasterThreadId();
}

◆ GetMTMasterRunManagerKernel()

G4TaskRunManagerKernel * G4TaskRunManager::GetMTMasterRunManagerKernel ( )

static

Definition at line 69 of file G4TaskRunManager.cc.

{
  return GetMasterRunManager()->MTkernel;
}

◆ GetNumberActiveThreads()

virtual size_t G4TaskRunManager::GetNumberActiveThreads ( ) const

inlineoverridevirtual

Reimplemented from PTL::TaskRunManager.

Definition at line 105 of file G4TaskRunManager.hh.

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

◆ GetNumberOfEventsPerTask()

G4int G4TaskRunManager::GetNumberOfEventsPerTask ( ) const

inline

Definition at line 95 of file G4TaskRunManager.hh.

  {
    return numberOfEventsPerTask;
  }

◆ GetNumberOfTasks()

G4int G4TaskRunManager::GetNumberOfTasks ( ) const

inline

Definition at line 94 of file G4TaskRunManager.hh.

94{ return numberOfTasks; }

◆ GetNumberOfThreads()

virtual G4int G4TaskRunManager::GetNumberOfThreads ( ) const

inlineoverridevirtual

Reimplemented from PTL::TaskRunManager.

Definition at line 101 of file G4TaskRunManager.hh.

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

◆ Initialize() [1/2]

void G4TaskRunManager::Initialize ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 237 of file G4TaskRunManager.cc.

{
  G4bool firstTime = (!threadPool);
  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]

virtual void G4TaskRunManager::Initialize ( uint64_t nthreads )

inlineoverridevirtual

Reimplemented from PTL::TaskRunManager.

Definition at line 120 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 477 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(eventModuloDef > 0)
    {
      eventModulo = eventModuloDef;
      if(eventModulo > numberOfEventsPerTask)
      {
        G4int oldMod = eventModulo;
        eventModulo  = numberOfEventsPerTask;
        if(eventModulo < 1)
          eventModulo = 1;
 
        G4ExceptionDescription msgd;
        msgd << "Event modulo is reduced to " << eventModulo << " (was "
             << oldMod << ")"
             << " to distribute events to all threads.";
        G4Exception("G4TaskRunManager::InitializeEventLoop()", "Run10035",
                    JustWarning, msgd);
      }
    }
    else
    {
      eventModulo = G4int(std::sqrt(G4double(numberOfEventsPerTask)));
      if(eventModulo < 1)
        eventModulo = 1;
    }
 
    if(n_event > 0)
    {
      G4bool _overload = InitializeSeeds(n_event);
      G4bool _functor  = false;
      if(!_overload)
        _functor = initSeedsCallback(n_event, nSeedsPerEvent, nSeedsFilled);
      if(_overload == false && _functor == false)
      {
        G4RNGHelper* helper = G4RNGHelper::GetInstance();
        switch(SeedOncePerCommunication())
        {
          case 0:
            nSeedsFilled = n_event;
            break;
          case 1:
            nSeedsFilled = numberOfEventsPerTask;
            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()

virtual G4bool G4TaskRunManager::InitializeSeeds ( G4int )

inlineoverrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 155 of file G4TaskRunManager.hh.

155{ return false; }

Referenced by InitializeEventLoop().

◆ InitializeThreadPool()

void G4TaskRunManager::InitializeThreadPool ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 254 of file G4TaskRunManager.cc.

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

Referenced by Initialize().

◆ MergeRun()

void G4TaskRunManager::MergeRun ( const G4Run * localRun )

Definition at line 635 of file G4TaskRunManager.cc.

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

◆ MergeScores()

void G4TaskRunManager::MergeScores ( const G4ScoringManager * localScoringManager )

Definition at line 626 of file G4TaskRunManager.cc.

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

◆ NewActionRequest()

virtual void G4TaskRunManager::NewActionRequest ( WorkerActionRequest )

inlineoverrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 205 of file G4TaskRunManager.hh.

205{}

◆ ProcessOneEvent()

void G4TaskRunManager::ProcessOneEvent ( G4int i_event )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 290 of file G4TaskRunManager.cc.

{
  // Nothing to do
}

◆ RefillSeeds()

void G4TaskRunManager::RefillSeeds ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 449 of file G4TaskRunManager.cc.

{
  G4RNGHelper* helper = G4RNGHelper::GetInstance();
  G4int nFill         = 0;
  switch(SeedOncePerCommunication())
  {
    case 0:
      nFill = numberOfEventToBeProcessed - nSeedsFilled;
      break;
    case 1:
      nFill = numberOfEventsPerTask - 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 764 of file G4TaskRunManager.cc.

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

Referenced by TerminateWorkers().

◆ RunTermination()

void G4TaskRunManager::RunTermination ( )

overridevirtual

Reimplemented from G4MTRunManager.

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

92{ eventGrainsize = n; }

CLHEP::detail::n

n

Definition: Ranlux64Engine.cc:90

◆ SetInitializeSeedsCallback()

void G4TaskRunManager::SetInitializeSeedsCallback ( InitializeSeedsCallback f )

inline

Definition at line 209 of file G4TaskRunManager.hh.

  {
    initSeedsCallback = f;
  }

◆ SetNumberOfThreads()

void G4TaskRunManager::SetNumberOfThreads ( G4int n )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 199 of file G4TaskRunManager.cc.

{
  if(forcedNwokers > 0)
  {
    std::stringstream ss;
    ss << "\n### Number of threads is forced to " << forcedNwokers
       << " by G4FORCENUMBEROFTHREADS environment variable. G4TaskRunManager::"
       << __FUNCTION__ << "(" << n << ") ignored ###";
 
    if(verboseLevel > 1)
    {
      G4ExceptionDescription msg;
      msg << ss.str();
      G4Exception("G4TaskRunManager::SetNumberOfThreads(G4int)", "Run0132",
                  JustWarning, msg);
    }
    else
    {
      G4cout << ss.str() << "\n" << G4endl;
    }
    nworkers = forcedNwokers;
  }
  else
  {
    nworkers = n;
    if(poolInitialized)
    {
      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 644 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 671 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 190 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 297 of file G4TaskRunManager.cc.

{
  // Nothing to do
}

◆ TerminateWorkers()

void G4TaskRunManager::TerminateWorkers ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 710 of file G4TaskRunManager.cc.

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

◆ ThisWorkerEndEventLoop()

virtual void G4TaskRunManager::ThisWorkerEndEventLoop ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 198 of file G4TaskRunManager.hh.

198{}

◆ ThisWorkerProcessCommandsStackDone()

void G4TaskRunManager::ThisWorkerProcessCommandsStackDone ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 784 of file G4TaskRunManager.cc.

784{}

◆ ThisWorkerReady()

virtual void G4TaskRunManager::ThisWorkerReady ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 197 of file G4TaskRunManager.hh.

197{}

◆ ThisWorkerWaitForNextAction()

virtual WorkerActionRequest G4TaskRunManager::ThisWorkerWaitForNextAction ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 199 of file G4TaskRunManager.hh.

  {
    return WorkerActionRequest::UNDEFINED;
  }

◆ ThreadPoolIsInitialized()

G4bool G4TaskRunManager::ThreadPoolIsInitialized ( ) const

inline

Definition at line 118 of file G4TaskRunManager.hh.

118{ return poolInitialized; }

◆ WaitForEndEventLoopWorkers()

void G4TaskRunManager::WaitForEndEventLoopWorkers ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 751 of file G4TaskRunManager.cc.

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

Referenced by RunTermination().

◆ WaitForReadyWorkers()

virtual void G4TaskRunManager::WaitForReadyWorkers ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 195 of file G4TaskRunManager.hh.

195{}

Friends And Related Function Documentation

◆ G4RunManagerFactory

friend class G4RunManagerFactory

friend

Definition at line 70 of file G4TaskRunManager.hh.

Member Data Documentation

◆ initSeedsCallback

InitializeSeedsCallback G4TaskRunManager::initSeedsCallback

protected

Initial value:

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

Definition at line 238 of file G4TaskRunManager.hh.

Referenced by InitializeEventLoop(), and SetInitializeSeedsCallback().

◆ poolInitialized

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

protected

Definition at line 233 of file G4TaskRunManager.hh.

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

◆ taskManager

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

protected

Definition at line 236 of file G4TaskRunManager.hh.

◆ taskQueue

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

protected

Definition at line 235 of file G4TaskRunManager.hh.

Referenced by G4TaskRunManager().

◆ threadPool

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

protected

Definition at line 234 of file G4TaskRunManager.hh.

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

◆ workTaskGroup

RunTaskGroup* G4TaskRunManager::workTaskGroup = nullptr

protected

Definition at line 230 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

◆ RunTaskGroupTBB

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 Function Documentation

◆ G4RunManagerFactory

Member Data Documentation

◆ initSeedsCallback

◆ poolInitialized

◆ taskManager

◆ taskQueue

◆ threadPool

◆ workTaskGroup