#include <OscarMTMasterThread.h>

Public Member Functions
void	beginRun (const edm::EventSetup &iSetup) 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 Member Functions
void	readES (const edm::EventSetup &iSetup) const

Private Attributes
edm::ESWatcher< IdealGeometryRecord >	idealGeomRcdWatcher_

edm::ESWatcher< IdealMagneticFieldRecord >	idealMagRcdWatcher_

bool	m_firstRun

bool	m_mainCanProceed

bool	m_masterCanProceed

std::thread	m_masterThread

ThreadState	m_masterThreadState

std::condition_variable	m_notifyMainCv

std::condition_variable	m_notifyMasterCv

const DDCompactView *	m_pDD

const cms::DDCompactView *	m_pDD4hep

const bool	m_pGeoFromDD4hep

std::mutex	m_protectMutex

const HepPDT::ParticleDataTable *	m_pTable

std::shared_ptr< RunManagerMT >	m_runManagerMaster

bool	m_stopped

std::mutex	m_threadMutex

Detailed Description

Definition at line 32 of file OscarMTMasterThread.h.

Member Enumeration Documentation

enum OscarMTMasterThread::ThreadState

strongprivate

Enumerator
NotExist
BeginRun
EndRun
Destruct

Definition at line 47 of file OscarMTMasterThread.h.

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

edm::Transition::EndRun

edm::Transition::BeginRun

Constructor & Destructor Documentation

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

explicit

Definition at line 20 of file OscarMTMasterThread.cc.

References BeginRun, g4SimHits_cfi::CustomUIsession, Destruct, EndRun, Exception, LogDebug, edm::errors::LogicError, m_mainCanProceed, m_masterCanProceed, m_masterThread, m_masterThreadState, m_notifyMainCv, m_notifyMasterCv, m_pDD, m_pDD4hep, m_pTable, m_runManagerMaster, m_threadMutex, and runManagerMaster().

     : m_pGeoFromDD4hep(iConfig.getParameter<bool>("g4GeometryDD4hepSource")),
       m_pDD(nullptr),
       m_pDD4hep(nullptr),
       m_pTable(nullptr),
       m_masterThreadState(ThreadState::NotExist),
       m_masterCanProceed(false),
       m_mainCanProceed(false),
       m_firstRun(true),
       m_stopped(false) {
   // Lock the mutex
   std::unique_lock<std::mutex> lk(m_threadMutex);
 
   edm::LogInfo("SimG4CoreApplication") << "OscarMTMasterThread: creating master thread";
 
   // Create Genat4 master thread
   m_masterThread = std::thread([&]() {
     // Initialization
 
     std::shared_ptr<RunManagerMT> runManagerMaster;
     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.reset(new CustomUIsession());
 
     // Create the master run manager, and share it to the CMSSW thread
     runManagerMaster = std::make_shared<RunManagerMT>(iConfig);
     m_runManagerMaster = runManagerMaster;
 
     LogDebug("SimG4CoreApplication") << "OscarMTMasterThread: initialization of RunManagerMT finished";
 
     // 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; });
 
       // Act according to the state
       edm::LogInfo("OscarMTMasterThread")
           << "Master thread: Woke up, state is " << static_cast<int>(m_masterThreadState);
       if (m_masterThreadState == ThreadState::BeginRun) {
         // Initialize Geant4
         edm::LogInfo("OscarMTMasterThread") << "Master thread: Initializing Geant4";
         runManagerMaster->initG4(m_pDD, m_pDD4hep, m_pTable);
         isG4Alive = true;
       } else if (m_masterThreadState == ThreadState::EndRun) {
         // Stop Geant4
         LogDebug("OscarMTMasterThread") << "Master thread: Stopping Geant4";
         runManagerMaster->stopG4();
         isG4Alive = false;
       } else if (m_masterThreadState == ThreadState::Destruct) {
         LogDebug("OscarMTMasterThread") << "Master thread: Breaking out of state loop";
         if (isG4Alive)
           throw edm::Exception(edm::errors::LogicError)
               << "Geant4 is still alive, master thread state must be set to EndRun before Destruct";
         break;
       } else {
         throw edm::Exception(edm::errors::LogicError)
             << "OscarMTMasterThread: Illegal master thread state " << static_cast<int>(m_masterThreadState);
       }
     }
 
     // Cleanup
     edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: start RunManagerMT destruction";
     LogDebug("OscarMTMasterThread") << "Master thread: Am I unique owner of runManagerMaster? "
                                     << runManagerMaster.unique();
 
     // must be done in this thread, segfault otherwise
     runManagerMaster.reset();
     G4PhysicalVolumeStore::Clean();
 
     LogDebug("OscarMTMasterThread") << "Master thread: Reseted shared_ptr";
     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 ( )

Definition at line 121 of file OscarMTMasterThread.cc.

References m_stopped, and stopThread().

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

Member Function Documentation

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

Definition at line 127 of file OscarMTMasterThread.cc.

References BeginRun, m_mainCanProceed, m_masterCanProceed, m_masterThreadState, m_notifyMainCv, m_notifyMasterCv, m_protectMutex, m_threadMutex, and readES().

Referenced by OscarMTProducer::globalBeginRun().

                                                                     {
   std::lock_guard<std::mutex> lk(m_protectMutex);
 
   std::unique_lock<std::mutex> lk2(m_threadMutex);
 
   // Reading from ES must be done in the main (CMSSW) thread
   readES(iSetup);
 
   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";
 }

void OscarMTMasterThread::endRun ( ) const

Definition at line 146 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";
 }

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

private

Definition at line 185 of file OscarMTMasterThread.cc.

References edm::ESWatcher< T >::check(), edm::errors::Configuration, Exception, edm::EventSetup::get(), idealGeomRcdWatcher_, m_firstRun, m_pDD, m_pDD4hep, m_pGeoFromDD4hep, m_pTable, edm::ESTransientHandle< T >::product(), and edm::ESHandle< T >::product().

Referenced by beginRun().

                                                                   {
   bool geomChanged = idealGeomRcdWatcher_.check(iSetup);
   if (geomChanged && (!m_firstRun)) {
     throw edm::Exception(edm::errors::Configuration)
         << "[SimG4Core OscarMTMasterThread]\n"
         << "The Geometry configuration is changed during the job execution\n"
         << "this is not allowed, the geometry must stay unchanged";
   }
   // Don't read from ES if not the first run, just as in
   if (!m_firstRun)
     return;
 
   // DDDWorld: get the DDCV from the ES and use it to build the World
   if (m_pGeoFromDD4hep) {
     edm::ESTransientHandle<cms::DDCompactView> pDD;
     iSetup.get<IdealGeometryRecord>().get(pDD);
     m_pDD4hep = pDD.product();
   } else {
     edm::ESTransientHandle<DDCompactView> pDD;
     iSetup.get<IdealGeometryRecord>().get(pDD);
     m_pDD = pDD.product();
   }
 
   edm::ESHandle<HepPDT::ParticleDataTable> fTable;
   iSetup.get<PDTRecord>().get(fTable);
   m_pTable = fTable.product();
 
   m_firstRun = false;
 }

RunManagerMT& OscarMTMasterThread::runManagerMaster ( ) const

inline

Definition at line 41 of file OscarMTMasterThread.h.

Referenced by OscarMTMasterThread().

41 { return *m_runManagerMaster; }

OscarMTMasterThread::m_runManagerMaster

std::shared_ptr< RunManagerMT > m_runManagerMaster

Definition: OscarMTMasterThread.h:51

RunManagerMT* OscarMTMasterThread::runManagerMasterPtr ( ) const

inline

Definition at line 42 of file OscarMTMasterThread.h.

42 { return m_runManagerMaster.get(); }

OscarMTMasterThread::m_runManagerMaster

std::shared_ptr< RunManagerMT > m_runManagerMaster

Definition: OscarMTMasterThread.h:51

void OscarMTMasterThread::stopThread ( )

Definition at line 160 of file OscarMTMasterThread.cc.

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

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

                                      {
   if (m_stopped) {
     return;
   }
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread::stopTread: stop main thread";
 
   // Release our instance of the shared master run manager, so that
   // the G4 master thread can do the cleanup. Then notify the master
   // thread, and join it.
   std::unique_lock<std::mutex> lk2(m_threadMutex);
   m_runManagerMaster.reset();
   LogDebug("OscarMTMasterThread") << "Main thread: reseted shared_ptr";
 
   m_masterThreadState = ThreadState::Destruct;
   m_masterCanProceed = true;
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread::stopTread: notify";
   m_notifyMasterCv.notify_one();
   lk2.unlock();
 
   LogDebug("OscarMTMasterThread") << "Main thread: joining master thread";
   m_masterThread.join();
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread::stopTread: main thread finished";
   m_stopped = true;
 }