G4MTRunManagerKernel Class Reference

#include <G4MTRunManagerKernel.hh>

Inheritance diagram for G4MTRunManagerKernel:

Public Member Functions
	G4MTRunManagerKernel ()
	~G4MTRunManagerKernel () override
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 void	StartThread (G4WorkerThread *context)
static G4WorkerThread *	GetWorkerThread ()
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 ()

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 66 of file G4MTRunManagerKernel.hh.

Constructor & Destructor Documentation

G4MTRunManagerKernel()

G4MTRunManagerKernel::G4MTRunManagerKernel

(

)

Definition at line 72 of file G4MTRunManagerKernel.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
  G4AutoLock l(&workerRMMutex);
  if (workerRMvector == nullptr) workerRMvector = new std::vector<G4WorkerRunManager*>;
  l.unlock();
  // Set flag that a MT-type kernel has been instantiated
  G4Threading::SetMultithreadedApplication(true);
}

~G4MTRunManagerKernel()

G4MTRunManagerKernel::~G4MTRunManagerKernel ( )

override

Definition at line 92 of file G4MTRunManagerKernel.cc.

{
  G4AutoLock l(&workerRMMutex);
  if (workerRMvector != nullptr) {
    if (!workerRMvector->empty()) {
      G4ExceptionDescription msg;
      msg << "G4MTRunManagerKernel is to be deleted while " << workerRMvector->size()
          << " G4WorkerRunManager are still alive.";
      G4Exception("G4RunManagerKernel::~G4RunManagerKernel()", "Run10035", FatalException, msg);
    }
    delete workerRMvector;
    workerRMvector = nullptr;
  }
}

Member Function Documentation

BroadcastAbortRun()

void G4MTRunManagerKernel::BroadcastAbortRun

(

G4bool

softAbort

)

Definition at line 255 of file G4MTRunManagerKernel.cc.

{
  G4AutoLock wrmm(&workerRMMutex);
 
  for (const auto& itr : *workerRMvector) {
    itr->AbortRun(softAbort);
  }
}

Referenced by G4MTRunManager::AbortRun().

GetWorkerThread()

G4WorkerThread * G4MTRunManagerKernel::GetWorkerThread ( )

static

Definition at line 116 of file G4MTRunManagerKernel.cc.

{
  return wThreadContext;
}

SetUpDecayChannels()

void G4MTRunManagerKernel::SetUpDecayChannels

(

)

Definition at line 239 of file G4MTRunManagerKernel.cc.

{
  auto 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 G4MTRunManager::InitializeEventLoop().

SetupShadowProcess()

void G4MTRunManagerKernel::SetupShadowProcess ( ) const

overrideprotectedvirtual

Reimplemented from G4RunManagerKernel.

Definition at line 108 of file G4MTRunManagerKernel.cc.

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

StartThread()

void G4MTRunManagerKernel::StartThread ( G4WorkerThread * context )

static

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

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

Definition at line 122 of file G4MTRunManagerKernel.cc.

{
  //!!!!!!!!!!!!!!!!!!!!!!!!!!
  //!!!!!! IMPORTANT !!!!!!!!!
  //!!!!!!!!!!!!!!!!!!!!!!!!!!
  // Here is not sequential anymore and G4UserWorkerThreadInitialization is
  // a shared user initialization class.
  // This means this method cannot use data members of G4RunManagerKernel
  // unless they are invariant ("read-only") and can be safely shared.
  // All the rest that is not invariant should be incapsulated into
  // the context (or, as for wThreadContext be G4ThreadLocal)
  //!!!!!!!!!!!!!!!!!!!!!!!!!!
  // #ifdef G4MULTITHREADED
  //     turnontpmalloc();
  // #endif
  G4Threading::WorkerThreadJoinsPool();
  wThreadContext = context;
  G4MTRunManager* masterRM = G4MTRunManager::GetMasterRunManager();
 
  //============================
  // Step-0: Thread ID
  //============================
  // Initialise per-thread stream-output
  // The following line is needed before we actually do IO initialisation
  // because the constructor of UI manager resets the IO destination.
  G4int thisID = wThreadContext->GetThreadId();
  G4Threading::G4SetThreadId(thisID);
  G4UImanager::GetUIpointer()->SetUpForAThread(thisID);
 
  //============================
  // Optimization: optional
  //============================
  // Enforce thread affinity if requested
  wThreadContext->SetPinAffinity(masterRM->GetPinAffinity());
 
  //============================
  // Step-1: Random number engine
  //============================
  // RNG Engine needs to be initialised by "cloning" the master one.
  const CLHEP::HepRandomEngine* masterEngine = masterRM->getMasterRandomEngine();
  masterRM->GetUserWorkerThreadInitialization()->SetupRNGEngine(masterEngine);
 
  //============================
  // Step-2: Initialise worker thread
  //============================
  if (masterRM->GetUserWorkerInitialization() != nullptr) {
    masterRM->GetUserWorkerInitialization()->WorkerInitialize();
  }
  if (masterRM->GetUserActionInitialization() != nullptr) {
    G4VSteppingVerbose* sv = masterRM->GetUserActionInitialization()->InitializeSteppingVerbose();
    if (sv != nullptr) {
      G4VSteppingVerbose::SetInstance(sv);
    }
  }
  // Now initialise worker part of shared objects (geometry/physics)
  wThreadContext->BuildGeometryAndPhysicsVector();
  G4WorkerRunManager* wrm = masterRM->GetUserWorkerThreadInitialization()->CreateWorkerRunManager();
  wrm->SetWorkerThread(wThreadContext);
  G4AutoLock wrmm(&workerRMMutex);
  workerRMvector->push_back(wrm);
  wrmm.unlock();
 
  //================================
  // Step-3: Setup worker run manager
  //================================
  // Set the detector and physics list to the worker thread. Share with master
  const G4VUserDetectorConstruction* detector = masterRM->GetUserDetectorConstruction();
  wrm->G4RunManager::SetUserInitialization(const_cast<G4VUserDetectorConstruction*>(detector));
  const G4VUserPhysicsList* physicslist = masterRM->GetUserPhysicsList();
  wrm->SetUserInitialization(const_cast<G4VUserPhysicsList*>(physicslist));
 
  //================================
  // Step-4: Initialise worker run manager
  //================================
  if (masterRM->GetUserActionInitialization() != nullptr) {
    masterRM->GetNonConstUserActionInitialization()->Build();
  }
  if (masterRM->GetUserWorkerInitialization() != nullptr) {
    masterRM->GetUserWorkerInitialization()->WorkerStart();
  }
  wrm->Initialize();
 
  //================================
  // Step5: Loop over requests from the master thread
  //================================
  // This function should enter a loop processing new runs and actions
  // requests from master. It should block until thread is ready
  // to terminate
  wrm->DoWork();
 
  //===============================
  // Step-6: Terminate worker thread
  //===============================
  if (masterRM->GetUserWorkerInitialization() != nullptr) {
    masterRM->GetUserWorkerInitialization()->WorkerStop();
  }
 
  wrmm.lock();
  for (auto itrWrm = workerRMvector->cbegin(); itrWrm != workerRMvector->cend(); ++itrWrm) {
    if ((*itrWrm) == wrm) {
      workerRMvector->erase(itrWrm);
      break;
    }
  }
  wrmm.unlock();
  delete wrm;
 
  //===============================
  // Step-7: Cleanup split classes
  //===============================
  wThreadContext->DestroyGeometryAndPhysicsVector();
  wThreadContext = nullptr;
 
  G4Threading::WorkerThreadLeavesPool();
}

---

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

• G4MTRunManagerKernel.hh
• G4MTRunManagerKernel.cc