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

void G4WorkerThread::BuildGeometryAndPhysicsVector ( )

static

Definition at line 57 of file G4WorkerThread.cc.

{
    // Initialise all split classes in the geometry with copy of data from master thread
    G4GeometryWorkspacePool::GetInstance()->CreateAndUseWorkspace();
    G4SolidsWorkspacePool::GetInstance()->CreateAndUseWorkspace();

    G4ParticlesWorkspace::GetPool()->CreateAndUseWorkspace();
    G4PhysicsListWorkspace::GetPool()->CreateAndUseWorkspace();
//    const_cast<G4VUPLManager&>(G4VUserPhysicsList::GetSubInstanceManager()).NewSubInstances();
//    const_cast<G4VPCManager&>(G4VPhysicsConstructor::GetSubInstanceManager()).NewSubInstances();
//    const_cast<G4VMPLManager&>(G4VModularPhysicsList::GetSubInstanceManager()).WorkerCopySubInstanceArray();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4WorkerThread::DestroyGeometryAndPhysicsVector ( )

static

Definition at line 70 of file G4WorkerThread.cc.

{
#if 0
    // Manage Geometry Workspace explicitly
    fGeometryWrk->ReleaseAndDestroyWorkspace();
    delete fGeometryWrk;
    fGeometryWrk=0;
#else
    // Alternative:
    // Initialise all split classes in the geometry with copy of data from master thread
    // G4GeometryWorkspacePool::GetInstance()->ReleaseAndDestroyMyWorkspace();
    G4GeometryWorkspacePool::GetInstance()->GetWorkspace()->DestroyWorkspace();
    G4SolidsWorkspacePool::GetInstance()->GetWorkspace()->DestroyWorkspace();
    G4ParticlesWorkspace::GetPool()->GetWorkspace()->DestroyWorkspace();
    
    G4PhysicsListWorkspace::GetPool()->GetWorkspace()->DestroyWorkspace();
#endif

//    const_cast<G4VUPLManager&>(G4VUserPhysicsList::GetSubInstanceManager()).FreeWorker();
//    const_cast<G4VPCManager&>(G4VPhysicsConstructor::GetSubInstanceManager()).FreeWorker();
//    const_cast<G4VMPLManager&>(G4VModularPhysicsList::GetSubInstanceManager()).FreeWorker();
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4WorkerThread::GetNumberThreads

(

)

const

Definition at line 52 of file G4WorkerThread.cc.

{
    return numThreads;
}

G4int G4WorkerThread::GetThreadId

(

)

const

Definition at line 42 of file G4WorkerThread.cc.

{
    return threadId;
}

Here is the caller graph for this function:

void G4WorkerThread::SetNumberThreads

(

G4int

numnberThreads

)

Definition at line 47 of file G4WorkerThread.cc.

{
    numThreads = nw;
}

Here is the caller graph for this function:

void G4WorkerThread::SetPinAffinity

(

G4int

aff

)

const

Definition at line 206 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 + (myidx>=offset);
  }
  G4cout<<"Setting affinity to:"<<cpuindex<<G4endl;
  //Avoid compilation warning in C90 standard w/o MT
#if defined(G4MULTITHREADED)
  G4Thread t = G4THREADSELF();
#else
  G4Thread t;
#endif
  G4bool success = G4Threading::G4SetPinAffinity(cpuindex,t);
  if ( ! success ) {
      G4Exception("G4MTRunManagerKernel::StarThread","Run0101",JustWarning,"Cannot set thread affinity.");
  }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4WorkerThread::SetThreadId

(

G4int

threadId

)

Definition at line 37 of file G4WorkerThread.cc.

{
    threadId = tid;
}

Here is the caller graph for this function:

void G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster ( )

static

Definition at line 101 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
    typedef std::map<G4LogicalVolume*,std::pair<G4VSensitiveDetector*,G4FieldManager*> > LV2SDFM;
    LV2SDFM lvmap;
//    typedef std::map<G4LogicalVolume*,std::pair<G4Region*,G4bool> > LV2Region;
//    LV2Region lv2rmap;
    typedef std::map<G4Region*,std::pair<G4FastSimulationManager*,G4UserSteppingAction*> > R2FSM;
    R2FSM rgnmap;
    G4LogicalVolumeStore* mLogVolStore = G4LogicalVolumeStore::GetInstance();
    for(size_t ip=0; ip<mLogVolStore->size(); ip++)
    {
        G4LogicalVolume *lv = (*mLogVolStore)[ip];
        //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 is 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 = 0;
        G4FieldManager* fmgr = 0;
        if ( lv->GetMasterSensitiveDetector() != 0 ) sd = lv->GetSensitiveDetector();
        if ( lv->GetMasterFieldManager() != 0 ) fmgr = lv->GetFieldManager();
        if ( sd || fmgr ) lvmap[lv] = std::make_pair(sd,fmgr);
//        G4Region* rgn = lv->GetRegion();
//        G4bool isRoot = lv->IsRootRegion();
//        if ( rgn || isRoot ) lv2rmap[lv] = std::make_pair(rgn,isRoot);
    }
    G4RegionStore* mRegStore = G4RegionStore::GetInstance();
    for(size_t ir=0; ir<mRegStore->size(); ir++)
    {
        G4Region* reg = (*mRegStore)[ir];
        G4FastSimulationManager* fsm = reg->GetFastSimulationManager();
        G4UserSteppingAction* usa = reg->GetRegionalSteppingAction();
        if ( reg || usa ) rgnmap[reg] = std::make_pair(fsm,usa);
    }

    //===========================
    //Step-1: Clean the workspace
    //===========================
    G4GeometryWorkspace* geomWorkspace= G4GeometryWorkspacePool::GetInstance()->GetWorkspace();
    geomWorkspace->DestroyWorkspace();
    G4SolidsWorkspace* solidWorkspace = G4SolidsWorkspacePool::GetInstance()->GetWorkspace();
    solidWorkspace->DestroyWorkspace();
    
    //===========================
    //Step-2: Re-create and initialize workspace
    //===========================
    geomWorkspace->InitialiseWorkspace();
    solidWorkspace->InitialiseWorkspace();

    // Alternative
    //
    // To wipe, release and get a new one ...
    // G4GeometryWorkspacePool *fWorkspaceMgr=  G4GeometryWorkspaceOutlet::GetInstance();
    // fWorkspaceMgr->ReleaseAndDestroyMyWorkspace();
    // Now re-create
    // fWorkspaceMgr->CreateAndUseWorkspace();
    
    
    //===================================================
    //Step-4: Restore sensitive detector and field manaer
    //===================================================
    for ( LV2SDFM::const_iterator it = lvmap.begin() ; it != lvmap.end() ; ++it )
    {
        G4LogicalVolume* lv      = it->first;
        G4VSensitiveDetector* sd = (it->second).first;
        G4FieldManager* fmgr       = (it->second).second;
        if(fmgr) lv->SetFieldManager(fmgr, false); //What should be the second parameter? We use always false for MT mode
        if(sd) lv->SetSensitiveDetector(sd);
    }
    
//    for ( LV2Region::const_iterator it2 = lv2rmap.begin() ; it2 != lv2rmap.end() ; it2++ )
//    {
//        G4LogicalVolume* lv2 = it2->first;
//        G4Region* rgn = (it2->second).first;
//        if(rgn) lv2->SetRegion(rgn);
//        G4bool isRoot = (it2->second).second;
//        lv2->SetRegionRootFlag(isRoot);
//    }

    
    for ( R2FSM::const_iterator it3 = rgnmap.begin() ; it3 != rgnmap.end() ; it3++ )
    {
        G4Region* reg = it3->first;
        G4FastSimulationManager* fsm = (it3->second).first;
        if(fsm) reg->SetFastSimulationManager(fsm);
        G4UserSteppingAction* usa = (it3->second).second;
        if(usa) reg->SetRegionalSteppingAction(usa);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• geant4.10.03.p01/source/run/include/G4WorkerThread.hh
• geant4.10.03.p01/source/run/src/G4WorkerThread.cc