#include <OscarMTMasterThread.h>

Public Member Functions
void	beginRun (const edm::EventSetup &iSetup) const

void	callConsumes (edm::ConsumesCollector &&iC) const

void	endRun () const

	OscarMTMasterThread (const edm::ParameterSet &iConfig)

RunManagerMT &	runManagerMaster () const

RunManagerMT *	runManagerMasterPtr () const

void	stopThread ()

	~OscarMTMasterThread ()

Private Types
enum	ThreadState { ThreadState::NotExist = 0, ThreadState::BeginRun = 1, ThreadState::EndRun = 2, ThreadState::Destruct = 3 }

Private Attributes
edm::ESGetToken< cms::DDCompactView, IdealGeometryRecord >	m_DD4hep

edm::ESGetToken< DDCompactView, IdealGeometryRecord >	m_DDD

bool	m_firstRun = true

bool	m_hasToken = false

bool	m_mainCanProceed = false

bool	m_masterCanProceed = false

std::thread	m_masterThread

ThreadState	m_masterThreadState

std::condition_variable	m_notifyMainCv

std::condition_variable	m_notifyMasterCv

const cms::DDCompactView *	m_pDD4hep = nullptr

const DDCompactView *	m_pDDD = nullptr

edm::ESGetToken< HepPDT::ParticleDataTable, PDTRecord >	m_PDT

const bool	m_pGeoFromDD4hep

std::mutex	m_protectMutex

const HepPDT::ParticleDataTable *	m_pTable = nullptr

std::shared_ptr< RunManagerMT >	m_runManagerMaster

bool	m_stopped = false

std::mutex	m_threadMutex

Detailed Description

Definition at line 37 of file OscarMTMasterThread.h.

Member Enumeration Documentation

◆ ThreadState

enum OscarMTMasterThread::ThreadState

strongprivate

Enumerator
NotExist
BeginRun
EndRun
Destruct

Definition at line 52 of file OscarMTMasterThread.h.

52 { NotExist = 0, BeginRun = 1, EndRun = 2, Destruct = 3 };

edm::Transition::EndRun

edm::Transition::BeginRun

Constructor & Destructor Documentation

◆ OscarMTMasterThread()

OscarMTMasterThread::OscarMTMasterThread ( const edm::ParameterSet & iConfig )

explicit

Definition at line 12 of file OscarMTMasterThread.cc.

References BeginRun, Destruct, EndRun, Exception, LogDebug, m_mainCanProceed, m_masterCanProceed, m_masterThread, m_masterThreadState, m_notifyMainCv, m_notifyMasterCv, m_pDD4hep, m_pDDD, m_pGeoFromDD4hep, m_pTable, m_runManagerMaster, and m_threadMutex.

     : m_pGeoFromDD4hep(iConfig.getParameter<bool>("g4GeometryDD4hepSource")),
       m_masterThreadState(ThreadState::NotExist) {
   // Lock the mutex
   std::unique_lock<std::mutex> lk(m_threadMutex);
 
   edm::LogVerbatim("SimG4CoreApplication")
       << "OscarMTMasterThread: creating master thread DD4hep: " << m_pGeoFromDD4hep;
 
   // Create Geant4 master thread
   m_masterThread = std::thread([&]() {
     // Initialization
     std::unique_ptr<CustomUIsession> uiSession;
 
     // Lock the mutex (i.e. wait until the creating thread has called cv.wait()
     std::unique_lock<std::mutex> lk2(m_threadMutex);
 
     edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: initializing RunManagerMT";
 
     //UIsession manager for message handling
     uiSession = std::make_unique<CustomUIsession>();
 
     // Create the master run manager, and share it to the CMSSW thread
     m_runManagerMaster = std::make_shared<RunManagerMT>(iConfig);
 
     // State loop
     bool isG4Alive = false;
     while (true) {
       // Signal main thread that it can proceed
       m_mainCanProceed = true;
       edm::LogVerbatim("OscarMTMasterThread") << "Master thread: State loop, notify main thread";
       m_notifyMainCv.notify_one();
 
       // Wait until the main thread sends signal
       m_masterCanProceed = false;
       edm::LogVerbatim("OscarMTMasterThread") << "Master thread: State loop, starting wait";
       m_notifyMasterCv.wait(lk2, [&] { return m_masterCanProceed; });
       //m_notifyMasterCv.wait(lk2, [&] { return false; });
 
       // Act according to the state
       edm::LogVerbatim("OscarMTMasterThread")
           << "Master thread: Woke up, state is " << static_cast<int>(m_masterThreadState);
       if (m_masterThreadState == ThreadState::BeginRun) {
         // Initialize Geant4
         edm::LogVerbatim("OscarMTMasterThread") << "Master thread: Initializing Geant4";
         m_runManagerMaster->initG4(m_pDDD, m_pDD4hep, m_pTable);
         isG4Alive = true;
       } else if (m_masterThreadState == ThreadState::EndRun) {
         // Stop Geant4
         edm::LogVerbatim("OscarMTMasterThread") << "Master thread: Stopping Geant4";
         m_runManagerMaster->stopG4();
         isG4Alive = false;
       } else if (m_masterThreadState == ThreadState::Destruct) {
         edm::LogVerbatim("OscarMTMasterThread") << "Master thread: Breaking out of state loop";
         if (isG4Alive)
           throw cms::Exception("LogicError") << "OscarMTMasterThread: Geant4 is still alive, master thread "
                                              << "state must be set to EndRun before Destruct";
         break;
       } else {
         throw cms::Exception("LogicError")
             << "OscarMTMasterThread: Illegal master thread state " << static_cast<int>(m_masterThreadState);
       }
     }
 
     // Cleanup
     edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: start RunManagerMT destruction";
 
     // must be done in this thread, segfault otherwise
     m_runManagerMaster.reset();
     G4PhysicalVolumeStore::Clean();
 
     edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: physics and geometry are cleaned";
     lk2.unlock();
     edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: Master thread is finished";
   });
 
   // Start waiting a signal from the condition variable (releases the lock temporarily)
   // First for initialization
   m_mainCanProceed = false;
   LogDebug("OscarMTMasterThread") << "Main thread: Signal master for initialization";
   m_notifyMainCv.wait(lk, [&]() { return m_mainCanProceed; });
 
   lk.unlock();
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: Master thread is constructed";
 }

◆ ~OscarMTMasterThread()

OscarMTMasterThread::~OscarMTMasterThread ( )

Definition at line 101 of file OscarMTMasterThread.cc.

References m_stopped, and stopThread().

                                           {
   if (!m_stopped) {
     stopThread();
   }
 }

Member Function Documentation

◆ beginRun()

void OscarMTMasterThread::beginRun ( const edm::EventSetup & iSetup ) const

Definition at line 120 of file OscarMTMasterThread.cc.

References BeginRun, edm::EventSetup::getData(), edm::EventSetup::getTransientHandle(), m_DD4hep, m_DDD, m_firstRun, m_mainCanProceed, m_masterCanProceed, m_masterThreadState, m_notifyMainCv, m_notifyMasterCv, m_pDD4hep, m_pDDD, m_PDT, m_pGeoFromDD4hep, m_protectMutex, m_pTable, and m_threadMutex.

Referenced by OscarMTProducer::globalBeginRun().

                                                                     {
   std::lock_guard<std::mutex> lk(m_protectMutex);
   std::unique_lock<std::mutex> lk2(m_threadMutex);
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread::beginRun";
 
   if (m_firstRun) {
     if (m_pGeoFromDD4hep) {
       m_pDD4hep = &(*iSetup.getTransientHandle(m_DD4hep));
     } else {
       m_pDDD = &(*iSetup.getTransientHandle(m_DDD));
     }
     m_pTable = &iSetup.getData(m_PDT);
     m_firstRun = false;
   }
   m_masterThreadState = ThreadState::BeginRun;
   m_masterCanProceed = true;
   m_mainCanProceed = false;
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: Signal master for BeginRun";
   m_notifyMasterCv.notify_one();
   m_notifyMainCv.wait(lk2, [&]() { return m_mainCanProceed; });
 
   lk2.unlock();
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: finish BeginRun";
 }

◆ callConsumes()

void OscarMTMasterThread::callConsumes ( edm::ConsumesCollector && iC ) const

Definition at line 107 of file OscarMTMasterThread.cc.

References edm::BeginRun, m_DD4hep, m_DDD, m_hasToken, m_PDT, and m_pGeoFromDD4hep.

                                                                       {
   if (m_hasToken) {
     return;
   }
   if (m_pGeoFromDD4hep) {
     m_DD4hep = iC.esConsumes<cms::DDCompactView, IdealGeometryRecord, edm::Transition::BeginRun>();
   } else {
     m_DDD = iC.esConsumes<DDCompactView, IdealGeometryRecord, edm::Transition::BeginRun>();
   }
   m_PDT = iC.esConsumes<HepPDT::ParticleDataTable, PDTRecord, edm::Transition::BeginRun>();
   m_hasToken = true;
 }

◆ endRun()

void OscarMTMasterThread::endRun ( ) const

Definition at line 145 of file OscarMTMasterThread.cc.

References EndRun, m_mainCanProceed, m_masterCanProceed, m_masterThreadState, m_notifyMainCv, m_notifyMasterCv, m_protectMutex, and m_threadMutex.

                                        {
   std::lock_guard<std::mutex> lk(m_protectMutex);
   std::unique_lock<std::mutex> lk2(m_threadMutex);
 
   m_masterThreadState = ThreadState::EndRun;
   m_mainCanProceed = false;
   m_masterCanProceed = true;
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: Signal master for EndRun";
   m_notifyMasterCv.notify_one();
   m_notifyMainCv.wait(lk2, [&]() { return m_mainCanProceed; });
   lk2.unlock();
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: finish EndRun";
 }

◆ runManagerMaster()

RunManagerMT& OscarMTMasterThread::runManagerMaster ( ) const

inline

Definition at line 48 of file OscarMTMasterThread.h.

References m_runManagerMaster.

48 { return *m_runManagerMaster; }

OscarMTMasterThread::m_runManagerMaster

std::shared_ptr< RunManagerMT > m_runManagerMaster

Definition: OscarMTMasterThread.h:56

◆ runManagerMasterPtr()

RunManagerMT* OscarMTMasterThread::runManagerMasterPtr ( ) const

inline

Definition at line 49 of file OscarMTMasterThread.h.

References m_runManagerMaster.

Referenced by OscarMTProducer::beginRun().

49 { return m_runManagerMaster.get(); }

OscarMTMasterThread::m_runManagerMaster

std::shared_ptr< RunManagerMT > m_runManagerMaster

Definition: OscarMTMasterThread.h:56

◆ stopThread()

void OscarMTMasterThread::stopThread ( )

Definition at line 159 of file OscarMTMasterThread.cc.

References Destruct, m_masterCanProceed, m_masterThread, m_masterThreadState, m_notifyMasterCv, m_stopped, and m_threadMutex.

Referenced by OscarMTProducer::globalEndJob(), and ~OscarMTMasterThread().

                                      {
   if (m_stopped) {
     return;
   }
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread::stopTread: stop main thread";
   std::unique_lock<std::mutex> lk2(m_threadMutex);
   m_masterThreadState = ThreadState::Destruct;
   m_masterCanProceed = true;
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread::stopTread: notify";
   m_notifyMasterCv.notify_one();
   lk2.unlock();
   m_masterThread.join();
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread::stopTread: is done";
   m_stopped = true;
 }