G4TaskRunManagerKernel Class Reference

#include <G4TaskRunManagerKernel.hh>

Inheritance diagram for G4TaskRunManagerKernel:

Public Member Functions
	G4TaskRunManagerKernel ()
	~G4TaskRunManagerKernel () override=default
void	SetUpDecayChannels ()
void	BroadcastAbortRun (G4bool softAbort)
Public Member Functions inherited from G4RunManagerKernel
	G4RunManagerKernel ()
virtual	~G4RunManagerKernel ()
void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	WorkerDefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	SetPhysics (G4VUserPhysicsList *uPhys)
void	InitializePhysics ()
G4bool	RunInitialization (G4bool fakeRun=false)
void	RunTermination ()
void	UpdateRegion ()
void	DumpRegion (const G4String &rname) const
void	DumpRegion (G4Region *region=nullptr) const
void	WorkerUpdateWorldVolume ()
void	GeometryHasBeenModified ()
void	PhysicsHasBeenModified ()
G4EventManager *	GetEventManager () const
G4StackManager *	GetStackManager () const
G4TrackingManager *	GetTrackingManager () const
void	SetPrimaryTransformer (G4PrimaryTransformer *pt)
G4PrimaryTransformer *	GetPrimaryTransformer () const
const G4String &	GetVersionString () const
void	SetVerboseLevel (G4int vl)
void	SetGeometryToBeOptimized (G4bool vl)
G4int	GetNumberOfParallelWorld () const
void	SetNumberOfParallelWorld (G4int i)
G4VUserPhysicsList *	GetPhysicsList () const
G4VPhysicalVolume *	GetCurrentWorld () const
G4int	GetNumberOfStaticAllocators () const

Static Public Member Functions
static G4WorkerThread *	GetWorkerThread ()
static void	InitializeWorker ()
static void	ExecuteWorkerInit ()
static void	ExecuteWorkerTask ()
static void	TerminateWorkerRunEventLoop ()
static void	TerminateWorker ()
static void	TerminateWorkerRunEventLoop (G4WorkerTaskRunManager *)
static void	TerminateWorker (G4WorkerTaskRunManager *)
static std::vector< G4String > &	InitCommandStack ()
Static Public Member Functions inherited from G4RunManagerKernel
static G4RunManagerKernel *	GetRunManagerKernel ()

Protected Member Functions
void	SetupShadowProcess () const override
Protected Member Functions inherited from G4RunManagerKernel
	G4RunManagerKernel (RMKType rmkType)
void	SetupDefaultRegion ()
void	SetupPhysics ()
void	ResetNavigator ()
void	BuildPhysicsTables (G4bool fakeRun)
void	CheckRegions ()
void	PropagateGenericIonID ()

Static Protected Attributes
static G4RUN_DLL std::vector< G4String >	initCmdStack = {}

Additional Inherited Members
Public Types inherited from G4RunManagerKernel
enum	RMKType { sequentialRMK , masterRMK , workerRMK }
Protected Attributes inherited from G4RunManagerKernel
RMKType	runManagerKernelType
G4Region *	defaultRegion = nullptr
G4Region *	defaultRegionForParallelWorld = nullptr
G4bool	geometryNeedsToBeClosed = true

Detailed Description

Definition at line 67 of file G4TaskRunManagerKernel.hh.

Constructor & Destructor Documentation

G4TaskRunManagerKernel()

G4TaskRunManagerKernel::G4TaskRunManagerKernel

(

)

Definition at line 70 of file G4TaskRunManagerKernel.cc.

                                               : G4RunManagerKernel(masterRMK)
{
  // This version of the constructor should never be called in sequential mode!
#ifndef G4MULTITHREADED
  G4ExceptionDescription msg;
  msg << "Geant4 code is compiled without multi-threading support "
         "(-DG4MULTITHREADED "
         "is set to off).";
  msg << " This type of RunManager can only be used in mult-threaded "
         "applications.";
  G4Exception("G4RunManagerKernel::G4RunManagerKernel()", "Run0109", FatalException, msg);
#endif
  // Set flag that a MT-type kernel has been instantiated
  G4Threading::SetMultithreadedApplication(true);
}

~G4TaskRunManagerKernel()

G4TaskRunManagerKernel::~G4TaskRunManagerKernel ( )

overridedefault

Member Function Documentation

BroadcastAbortRun()

void G4TaskRunManagerKernel::BroadcastAbortRun

(

G4bool

softAbort

)

Definition at line 329 of file G4TaskRunManagerKernel.cc.

{
  G4ConsumeParameters(softAbort);
}

Referenced by G4TaskRunManager::AbortRun().

ExecuteWorkerInit()

void G4TaskRunManagerKernel::ExecuteWorkerInit ( )

static

Definition at line 220 of file G4TaskRunManagerKernel.cc.

{
  // because of TBB
  if (G4MTRunManager::GetMasterThreadId() == G4ThisThread::get_id()) {
    G4TaskManager* taskManager = G4TaskRunManager::GetMasterRunManager()->GetTaskManager();
    auto _fut = taskManager->async(ExecuteWorkerInit);
    return _fut->get();
  }
 
  // this check is for TBB as there is not a way to run an initialization
  // routine on each thread
  if (!workerRM()) InitializeWorker();
 
  auto& wrm = workerRM();
  assert(wrm.get() != nullptr);
  wrm->DoCleanup();
}

Referenced by G4TaskRunManager::CreateAndStartWorkers(), and ExecuteWorkerInit().

ExecuteWorkerTask()

void G4TaskRunManagerKernel::ExecuteWorkerTask ( )

static

Definition at line 240 of file G4TaskRunManagerKernel.cc.

{
  // because of TBB
  if (G4MTRunManager::GetMasterThreadId() == G4ThisThread::get_id()) {
    G4TaskManager* taskManager = G4TaskRunManager::GetMasterRunManager()->GetTaskManager();
    auto _fut = taskManager->async(ExecuteWorkerTask);
    return _fut->get();
  }
 
  // this check is for TBB as there is not a way to run an initialization
  // routine on each thread
  if (!workerRM()) InitializeWorker();
 
  auto& wrm = workerRM();
  assert(wrm.get() != nullptr);
  wrm->DoWork();
}

Referenced by G4TaskRunManager::AddEventTask(), and ExecuteWorkerTask().

GetWorkerThread()

G4WorkerThread * G4TaskRunManagerKernel::GetWorkerThread ( )

static

Definition at line 118 of file G4TaskRunManagerKernel.cc.

{
  return context().get();
}

InitCommandStack()

std::vector< G4String > & G4TaskRunManagerKernel::InitCommandStack ( )

static

Definition at line 305 of file G4TaskRunManagerKernel.cc.

{
  return initCmdStack;
}

Referenced by G4TaskRunManager::CreateAndStartWorkers().

InitializeWorker()

void G4TaskRunManagerKernel::InitializeWorker ( )

static

!!!!!!!!!!!!!!!!!!!!!!!!! !!!!! IMPORTANT !!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!

!!!!!!!!!!!!!!!!!!!!!!!!!

Definition at line 125 of file G4TaskRunManagerKernel.cc.

{
  if (context() && workerRM()) return;
 
  G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
  if (G4MTRunManager::GetMasterThreadId() == G4ThisThread::get_id()) {
    G4TaskManager* taskManager = mrm->GetTaskManager();
    auto _fut = taskManager->async(InitializeWorker);
    _fut->wait();
    return;
  }
 
  //!!!!!!!!!!!!!!!!!!!!!!!!!!
  //!!!!!! IMPORTANT !!!!!!!!!
  //!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Here is not sequential anymore and G4UserWorkerThreadInitialization is
  // a shared user initialization class
  // This means this method cannot use data memebers of G4RunManagerKernel
  // unless they are invariant ("read-only") and can be safely shared.
  //  All the rest that is not invariant should be incapsualted into
  //  the context (or, as for wThreadContext be G4ThreadLocal)
  //!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  G4Threading::WorkerThreadJoinsPool();
  context() = std::make_unique<G4WorkerThread>();
 
  //============================
  // Step-0: Thread ID
  //============================
  // Initliazie per-thread stream-output
  // The following line is needed before we actually do IO initialization
  // becasue the constructor of UI manager resets the IO destination.
  context()->SetNumberThreads((G4int)mrm->GetThreadPool()->size());
  context()->SetThreadId(G4int(G4ThreadPool::get_this_thread_id() - 1));
  G4int thisID = context()->GetThreadId();
  G4Threading::G4SetThreadId(thisID);
  G4UImanager::GetUIpointer()->SetUpForAThread(thisID);
 
  //============================
  // Optimization: optional
  //============================
  // Enforce thread affinity if requested
  context()->SetPinAffinity(mrm->GetPinAffinity());
 
  //============================
  // Step-1: Random number engine
  //============================
  // RNG Engine needs to be initialized by "cloning" the master one.
  const CLHEP::HepRandomEngine* masterEngine = mrm->getMasterRandomEngine();
  mrm->GetUserWorkerThreadInitialization()->SetupRNGEngine(masterEngine);
 
  //============================
  // Step-2: Initialize worker thread
  //============================
  if (mrm->GetUserWorkerInitialization() != nullptr)
    mrm->GetUserWorkerInitialization()->WorkerInitialize();
 
  if (mrm->GetUserActionInitialization() != nullptr) {
    G4VSteppingVerbose* sv = mrm->GetUserActionInitialization()->InitializeSteppingVerbose();
    if (sv != nullptr) G4VSteppingVerbose::SetInstance(sv);
  }
  // Now initialize worker part of shared objects (geometry/physics)
  context()->BuildGeometryAndPhysicsVector();
  workerRM().reset(static_cast<G4WorkerTaskRunManager*>(
    mrm->GetUserWorkerThreadInitialization()->CreateWorkerRunManager()));
  auto& wrm = workerRM();
  wrm->SetWorkerThread(context().get());
 
  //================================
  // Step-3: Setup worker run manager
  //================================
  // Set the detector and physics list to the worker thread. Share with master
  const G4VUserDetectorConstruction* detector = mrm->GetUserDetectorConstruction();
  wrm->G4RunManager::SetUserInitialization(const_cast<G4VUserDetectorConstruction*>(detector));
  const G4VUserPhysicsList* physicslist = mrm->GetUserPhysicsList();
  wrm->SetUserInitialization(const_cast<G4VUserPhysicsList*>(physicslist));
 
  //================================
  // Step-4: Initialize worker run manager
  //================================
  if (mrm->GetUserActionInitialization() != nullptr)
    mrm->GetNonConstUserActionInitialization()->Build();
  if (mrm->GetUserWorkerInitialization() != nullptr)
    mrm->GetUserWorkerInitialization()->WorkerStart();
 
  workerRM()->Initialize();
 
  for (auto& itr : initCmdStack)
    G4UImanager::GetUIpointer()->ApplyCommand(itr);
 
  wrm->ProcessUI();
}

Referenced by G4TaskRunManager::CreateAndStartWorkers(), ExecuteWorkerInit(), ExecuteWorkerTask(), and InitializeWorker().

SetUpDecayChannels()

void G4TaskRunManagerKernel::SetUpDecayChannels

(

)

Definition at line 312 of file G4TaskRunManagerKernel.cc.

{
  G4ParticleTable::G4PTblDicIterator* pItr = G4ParticleTable::GetParticleTable()->GetIterator();
  pItr->reset();
  while ((*pItr)()) {
    G4DecayTable* dt = pItr->value()->GetDecayTable();
    if (dt != nullptr) {
      G4int nCh = dt->entries();
      for (G4int i = 0; i < nCh; i++) {
        dt->GetDecayChannel(i)->GetDaughter(0);
      }
    }
  }
}

Referenced by G4TaskRunManager::InitializeEventLoop().

SetupShadowProcess()

void G4TaskRunManagerKernel::SetupShadowProcess ( ) const

overrideprotectedvirtual

Reimplemented from G4RunManagerKernel.

Definition at line 88 of file G4TaskRunManagerKernel.cc.

{
  // Behavior is the same as base class (sequential mode)
  // ShadowProcess pointer == process poitner
  G4RunManagerKernel::SetupShadowProcess();
}

TerminateWorker() [1/2]

void G4TaskRunManagerKernel::TerminateWorker ( )

static

Definition at line 267 of file G4TaskRunManagerKernel.cc.

{
  if (workerRM()) TerminateWorker(workerRM().get());
  workerRM().reset();
  context().reset();
}

Referenced by TerminateWorker(), and G4TaskRunManager::TerminateWorkers().

TerminateWorker() [2/2]

void G4TaskRunManagerKernel::TerminateWorker ( G4WorkerTaskRunManager * wrm )

static

Definition at line 286 of file G4TaskRunManagerKernel.cc.

{
  if (wrm == nullptr) return;
 
  //===============================
  // Step-6: Terminate worker thread
  //===============================
  G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
  if ((mrm != nullptr) && (mrm->GetUserWorkerInitialization() != nullptr))
    mrm->GetUserWorkerInitialization()->WorkerStop();
 
  G4WorkerThread* _context = wrm->GetWorkerThread();
  _context->DestroyGeometryAndPhysicsVector();
 
  G4Threading::WorkerThreadLeavesPool();
}

TerminateWorkerRunEventLoop() [1/2]

void G4TaskRunManagerKernel::TerminateWorkerRunEventLoop ( )

static

Definition at line 260 of file G4TaskRunManagerKernel.cc.

{
  if (workerRM()) TerminateWorkerRunEventLoop(workerRM().get());
}

Referenced by TerminateWorkerRunEventLoop(), and G4TaskRunManager::WaitForEndEventLoopWorkers().

TerminateWorkerRunEventLoop() [2/2]

void G4TaskRunManagerKernel::TerminateWorkerRunEventLoop ( G4WorkerTaskRunManager * wrm )

static

Definition at line 276 of file G4TaskRunManagerKernel.cc.

{
  if (wrm == nullptr) return;
 
  wrm->TerminateEventLoop();
  wrm->RunTermination();
}

Member Data Documentation

initCmdStack

std::vector< G4String > G4TaskRunManagerKernel::initCmdStack = {}

staticprotected

Definition at line 66 of file G4TaskRunManagerKernel.hh.

: public G4RunManagerKernel
{
  public:
    G4TaskRunManagerKernel();
    ~G4TaskRunManagerKernel() override = default;
 
  public:  // with descroption
    static G4WorkerThread* GetWorkerThread();
    // G4ThreadPool tasks
    static void InitializeWorker();
    static void ExecuteWorkerInit();
    static void ExecuteWorkerTask();
    static void TerminateWorkerRunEventLoop();
    static void TerminateWorker();
    static void TerminateWorkerRunEventLoop(G4WorkerTaskRunManager*);
    static void TerminateWorker(G4WorkerTaskRunManager*);
 
    static std::vector<G4String>& InitCommandStack();
 
    // Fill decay tables with particle definition pointers of
    // decay products. This method has to be invoked by
    // MTRunManager before event loop starts on workers.
    void SetUpDecayChannels();
 
    // This method should be invoked by G4TaskRunManager
    void BroadcastAbortRun(G4bool softAbort);
 
  protected:
    void SetupShadowProcess() const override;
    G4RUN_DLL static std::vector<G4String> initCmdStack;
};
 
#endif  // G4TaskRunManagerKernel_hh

Referenced by InitCommandStack(), and InitializeWorker().

---

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

• G4TaskRunManagerKernel.hh
• G4TaskRunManagerKernel.cc