G4ThreadInitTool Class Reference

A tool which sets up the worker-thread-local workspace for Geant4. More...

#include <G4ThreadInitTool.h>

Inheritance diagram for G4ThreadInitTool:

Collaboration diagram for G4ThreadInitTool:

Public Member Functions
	G4ThreadInitTool (const std::string &, const std::string &, const IInterface *)
	Standard tool constructor.
virtual void	initThread () override final
	Set up the Geant4 workspace for this worker thread.
virtual void	terminateThread () override final
	Tear down the Geant4 workspace for this worker thread.
virtual unsigned int	nInit () const override final
	Counter used for barrier mechanism in thread initialization.

Private Attributes
std::atomic_uint	m_nInitThreads
	Counter of threads that have been initialized.

Detailed Description

A tool which sets up the worker-thread-local workspace for Geant4.

Author

Steve Farrell Steve.nosp@m.n.Fa.nosp@m.rrell.nosp@m.@cer.nosp@m.n.ch

Definition at line 19 of file G4ThreadInitTool.h.

Constructor & Destructor Documentation

G4ThreadInitTool()

G4ThreadInitTool::G4ThreadInitTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Standard tool constructor.

Definition at line 30 of file G4ThreadInitTool.cxx.

  : base_class(type, name, parent),
    m_nInitThreads(0)
{}

Member Function Documentation

initThread()

void G4ThreadInitTool::initThread ( )

finaloverridevirtual

Set up the Geant4 workspace for this worker thread.

Definition at line 41 of file G4ThreadInitTool.cxx.

{
  ATH_MSG_INFO("==> tbb thread started with id: 0x" <<
               std::hex << pthread_self() << std::dec);
 
  // Define the G4 worker thread context and setup its cleanup mechanism.
  auto wThreadContext = new G4WorkerThread;
  G4AutoDelete::Register(wThreadContext);
 
  // Assign the thread ID
  static std::atomic_uint tid(0);
  wThreadContext->SetThreadId( tid++ );
  G4Threading::G4SetThreadId( wThreadContext->GetThreadId() );
 
  // Setup thread-local geometry and physics
  wThreadContext->BuildGeometryAndPhysicsVector();
 
  // Retrieve the master thread run manager
  G4MTRunManager* masterRM = G4MTRunManager::GetMasterRunManager();
 
  // For offloading EM showers to GPUs via AdePT, the G4 worker threads must know the number of G4 workers
  // Since this is so far known by Gaudi and not the G4MTRunManager, we need to pass
  // back the number of G4 worker threads to the G4MTRunManager, so that they are available in AdePT.
  masterRM->SetNumberOfThreads(Gaudi::Concurrency::ConcurrencyFlags::numThreads());
 
  // Worker thread initialization object
  const G4UserWorkerThreadInitialization* workerInitializer =
    masterRM->GetUserWorkerThreadInitialization();
 
  // Random number setup.
  // TODO: revisit this once MT AthRNGSvc is available.
  const CLHEP::HepRandomEngine* masterEngine = masterRM->getMasterRandomEngine();
  workerInitializer->SetupRNGEngine(masterEngine);
 
  // Create the thread-local worker run manager (G4AtlasWorkerRunManager)
  ATH_MSG_INFO("Creating worker RM");
  G4WorkerRunManager* wrm = workerInitializer->CreateWorkerRunManager();
  wrm->SetWorkerThread(wThreadContext);
 
  // Share detector from master with worker.
  ATH_MSG_INFO("Assigning detector construction");
  // I don't want to const-cast here, but this is what they do in G4's
  // StartThread function, so there is likely no alternative.
  // Should not be a problem for threading.
  G4VUserDetectorConstruction* detector ATLAS_THREAD_SAFE =
    const_cast<G4VUserDetectorConstruction*> (masterRM->GetUserDetectorConstruction());
  wrm->G4RunManager::SetUserInitialization (detector);
  // Share physics list from master with worker.
  // Should not be a problem for threading.
  G4VUserPhysicsList* physicslist ATLAS_THREAD_SAFE =
    const_cast<G4VUserPhysicsList*>(masterRM->GetUserPhysicsList());
  wrm->SetUserInitialization(physicslist);
 
  // Build thread-local user actions - NOT CURRENTLY USED.
  if(masterRM->GetUserActionInitialization()) {
    masterRM->GetNonConstUserActionInitialization()->Build();
  }
 
  // Start user worker initialization
  if(masterRM->GetUserWorkerInitialization()) {
    masterRM->GetUserWorkerInitialization()->WorkerStart();
  }
 
  // Initialize the worker run manager
  ATH_MSG_INFO("Initializing worker RM");
  wrm->Initialize();
 
  // Start user worker run
  if(masterRM->GetUserWorkerInitialization()) {
    masterRM->GetUserWorkerInitialization()->WorkerRunStart();
  }
 
  // Copy the UI commands to the worker
  std::vector<G4String> cmds = masterRM->GetCommandStack();
  ATH_MSG_INFO (cmds.size() << " commands in UI stack");
  G4UImanager* uimgr = G4UImanager::GetUIpointer();
  for(const auto& it : cmds) {
    ATH_MSG_INFO ("Adding command to worker: " << it);
    uimgr->ApplyCommand(it);
  }
 
  // Atomic increment number of initialized threads
  m_nInitThreads++;
 
  ATH_MSG_INFO("==> tbb thread end of initThread with id: 0x" <<
               std::hex << pthread_self() << std::dec);
}

nInit()

virtual unsigned int G4ThreadInitTool::nInit ( ) const

inlinefinaloverridevirtual

Counter used for barrier mechanism in thread initialization.

This number needs to be correctly reported to properly ensure scheduling of thread-initialization tasks on every thread.

Definition at line 36 of file G4ThreadInitTool.h.

                                                      {
      return m_nInitThreads;
    }

terminateThread()

void G4ThreadInitTool::terminateThread ( )

finaloverridevirtual

Tear down the Geant4 workspace for this worker thread.

Definition at line 132 of file G4ThreadInitTool.cxx.

{
  ATH_MSG_DEBUG("terminateThread ==> tbb thread 0x" <<
               std::hex << pthread_self() << std::dec);
 
  // Geant4 worker finalization
  auto runMgr = G4RunManager::GetRunManager();
  ATH_MSG_DEBUG("G4RunManager ptr" << runMgr);
  if(runMgr) {
    runMgr->RunTermination();
    ATH_MSG_INFO("terminateThread ==> safely called G4AtlasWorkerRunManager::RunTermination for tbb thread 0x" <<
               std::hex << pthread_self() << std::dec);
    // Atomic decrement number of initialized threads
    m_nInitThreads--;
  }
  else {
    ATH_MSG_WARNING("skipping attempt to call terminateThread for tbb thread 0x" <<
                    std::hex << pthread_self() << std::dec <<
                    " without having first called initThread.");
    // Not decrementing m_nInitThreads as initThread was not called in this case.
  }
}

Member Data Documentation

m_nInitThreads

std::atomic_uint G4ThreadInitTool::m_nInitThreads

private

Counter of threads that have been initialized.

Definition at line 43 of file G4ThreadInitTool.h.

---

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

• G4ThreadInitTool.h
• G4ThreadInitTool.cxx