G4WorkerThread Class Reference

#include <G4WorkerThread.hh>

Public Member Functions
void	SetThreadId (G4int threadId)
G4int	GetThreadId () const
void	SetNumberThreads (G4int numnberThreads)
G4int	GetNumberThreads () const
void	SetPinAffinity (G4int aff) const

Static Public Member Functions
static void	BuildGeometryAndPhysicsVector ()
static void	DestroyGeometryAndPhysicsVector ()
static void	UpdateGeometryAndPhysicsVectorFromMaster ()

Detailed Description

Definition at line 42 of file G4WorkerThread.hh.

Member Function Documentation

BuildGeometryAndPhysicsVector()

void G4WorkerThread::BuildGeometryAndPhysicsVector ( )

static

Definition at line 70 of file G4WorkerThread.cc.

{
  // Initialise all split classes
  // with copy of data from master thread
 
  G4GeometryWorkspace::GetPool()->CreateAndUseWorkspace();
  G4SolidsWorkspace::GetPool()->CreateAndUseWorkspace();
  G4ParticlesWorkspace::GetPool()->CreateAndUseWorkspace();
  G4PhysicsListWorkspace::GetPool()->CreateAndUseWorkspace();
}

Referenced by G4MTRunManagerKernel::StartThread().

DestroyGeometryAndPhysicsVector()

void G4WorkerThread::DestroyGeometryAndPhysicsVector ( )

static

Definition at line 82 of file G4WorkerThread.cc.

{
  // Clear all split classes
 
  G4GeometryWorkspace::GetPool()->CleanUpAndDestroyAllWorkspaces();
  G4SolidsWorkspace::GetPool()->CleanUpAndDestroyAllWorkspaces();
  G4ParticlesWorkspace::GetPool()->CleanUpAndDestroyAllWorkspaces();
  G4PhysicsListWorkspace::GetPool()->CleanUpAndDestroyAllWorkspaces();
}

Referenced by G4MTRunManagerKernel::StartThread(), and G4TaskRunManagerKernel::TerminateWorker().

GetNumberThreads()

G4int G4WorkerThread::GetNumberThreads

(

)

const

Definition at line 64 of file G4WorkerThread.cc.

{
  return numThreads;
}

GetThreadId()

G4int G4WorkerThread::GetThreadId

(

)

const

Definition at line 52 of file G4WorkerThread.cc.

{
  return threadId;
}

Referenced by G4WorkerRunManager::rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisRun(), SetPinAffinity(), G4MTRunManagerKernel::StartThread(), G4WorkerRunManager::StoreRNGStatus(), G4WorkerTaskRunManager::StoreRNGStatus(), and G4WorkerTaskRunManager::TerminateEventLoop().

SetNumberThreads()

void G4WorkerThread::SetNumberThreads

(

G4int

numnberThreads

)

Definition at line 58 of file G4WorkerThread.cc.

{
  numThreads = nw;
}

Referenced by G4MTRunManager::CreateAndStartWorkers().

SetPinAffinity()

void G4WorkerThread::SetPinAffinity

(

G4int

aff

)

const

Definition at line 192 of file G4WorkerThread.cc.

{
  if (affinity == 0) return;
 
#if !defined(WIN32)
  G4cout << "AFFINITY SET" << G4endl;
  // Assign this thread to cpus in a round robin way
  G4int offset = affinity;
  G4int cpuindex = 0;
  if (std::abs(offset) > G4Threading::G4GetNumberOfCores()) {
    G4Exception("G4WorkerThread::SetPinAffinity()", "Run0100", JustWarning,
                "Cannot set thread affinity, affinity parameter larger than "
                "number of cores");
    return;
  }
  if (offset > 0)  // Start assigning affinity to given CPU
  {
    --offset;
    cpuindex = (GetThreadId() + offset) % G4Threading::G4GetNumberOfCores();
    // Round robin
  }
  else  // Exclude the given CPU
  {
    offset *= -1;
    --offset;
    G4int myidx = GetThreadId() % (G4Threading::G4GetNumberOfCores() - 1);
    cpuindex = myidx + static_cast<G4int>(myidx >= offset);
  }
  G4cout << "Setting affinity to:" << cpuindex << G4endl;
 
#  if defined(G4MULTITHREADED)
  // Avoid compilation warning in C90 standard w/o MT
  G4NativeThread t = pthread_self();
#  else
  G4NativeThread t;
#  endif
  G4bool success = G4Threading::G4SetPinAffinity(cpuindex, t);
  if (!success) {
    G4Exception("G4MTRunManagerKernel::StarThread()", "Run0101", JustWarning,
                "Cannot set thread affinity.");
  }
#endif
}

Referenced by G4MTRunManagerKernel::StartThread().

SetThreadId()

void G4WorkerThread::SetThreadId

(

G4int

threadId

)

Definition at line 46 of file G4WorkerThread.cc.

{
  threadId = tid;
}

UpdateGeometryAndPhysicsVectorFromMaster()

void G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster ( )

static

Definition at line 93 of file G4WorkerThread.cc.

{
  // =================================================
  // Step-0: keep sensitive detector and field manager
  // =================================================
  // First remember SD and Filed Associated with worker
  // in order to re-use it
  // (note that all the stuff after this will reset SD and Field)
  using LV2SDFM = std::map<G4LogicalVolume*, std::pair<G4VSensitiveDetector*, G4FieldManager*>>;
  LV2SDFM lvmap;
 
  using R2FSM = std::map<G4Region*, std::pair<G4FastSimulationManager*, G4UserSteppingAction*>>;
  R2FSM rgnmap;
 
  G4LogicalVolumeStore* mLogVolStore = G4LogicalVolumeStore::GetInstance();
  for (auto lv : *mLogVolStore) {
    // The following needs an explanation.
    // Consider the case in which the user adds one LogVolume between
    // the runs. The problem is that the thread-local part (split class)
    // of the G4LogicalVolume object is not initialized for workers
    // because the initialization is done once when the thread starts
    // (see G4MTRunManagerKernel::StartThread Step-2 that calls
    // G4WorkerThread::BuildGeometryAndPhysicsVector in this class).
    // The problem is that pointers of SD and FM for these newly added LV
    // may be invalid pointers (because never initialized, we have seen
    // this behavior in our testing). If now we remember them and re-use
    // them in Step-4 below we set invalid pointers to LV for this thread.
    // Thus we need a way to know if for a given LV we need to remember
    // or not the SD and FM pointers.
    // To solve this problem: We assume that the ConstructSDandField() is
    // called also by Master thread, thus for newly added LV the shadow
    // pointers of SD and Fields are correct.
    // (LIMITATION: this assumption may be too stringent, a user to save
    // memory could instantiate SD only for workers, but we require this
    // not to happen!).
    // Thus if a SD and FieldMgr are needed for this particular LV, and
    // shadow are !=0 it means that user wants an SD and FM to be
    // associated with LV, we get the values and we remember them.
    //
    G4VSensitiveDetector* sd = nullptr;
    G4FieldManager* fmgr = nullptr;
    if (lv->GetMasterSensitiveDetector() != nullptr) {
      sd = lv->GetSensitiveDetector();
    }
    if (lv->GetMasterFieldManager() != nullptr) {
      fmgr = lv->GetFieldManager();
    }
    if (sd != nullptr || fmgr != nullptr) {
      lvmap[lv] = std::make_pair(sd, fmgr);
    }
  }
  G4RegionStore* mRegStore = G4RegionStore::GetInstance();
  for (auto reg : *mRegStore) {
    G4FastSimulationManager* fsm = reg->GetFastSimulationManager();
    G4UserSteppingAction* usa = reg->GetRegionalSteppingAction();
    if (reg != nullptr || usa != nullptr) {
      rgnmap[reg] = std::make_pair(fsm, usa);
    }
  }
 
  //===========================
  // Step-1: Clean the workspace
  //===========================
  G4GeometryWorkspace* geomWorkspace = G4GeometryWorkspace::GetPool()->GetWorkspace();
  geomWorkspace->DestroyWorkspace();
  G4SolidsWorkspace* solidWorkspace = G4SolidsWorkspace::GetPool()->GetWorkspace();
  solidWorkspace->DestroyWorkspace();
 
  //===========================
  // Step-2: Re-create and initialize workspace
  //===========================
  geomWorkspace->InitialiseWorkspace();
  solidWorkspace->InitialiseWorkspace();
 
  //===================================================
  // Step-4: Restore sensitive detector and field manaer
  //===================================================
  for (const auto& it : lvmap) {
    G4LogicalVolume* lv = it.first;
    G4VSensitiveDetector* sd = (it.second).first;
    G4FieldManager* fmgr = (it.second).second;
    if (fmgr != nullptr)  // What should be the second parameter?
    {  // We use always false for MT mode
      lv->SetFieldManager(fmgr, false);
    }
    if (sd != nullptr) {
      lv->SetSensitiveDetector(sd);
    }
  }
  for (const auto& it3 : rgnmap) {
    G4Region* reg = it3.first;
    G4FastSimulationManager* fsm = (it3.second).first;
    if (fsm != nullptr) reg->SetFastSimulationManager(fsm);
    G4UserSteppingAction* usa = (it3.second).second;
    if (usa != nullptr) reg->SetRegionalSteppingAction(usa);
  }
}

Referenced by G4WorkerRunManager::DoWork(), and G4WorkerTaskRunManager::DoWork().

---

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

• G4WorkerThread.hh
• G4WorkerThread.cc