OscarMTMasterThread Class Reference

#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

ThreadState

enum OscarMTMasterThread::ThreadState

strongprivate

Enumerator
NotExist
BeginRun
EndRun
Destruct

Definition at line 47 of file OscarMTMasterThread.h.

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

Constructor & Destructor Documentation

OscarMTMasterThread()

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

explicit

Definition at line 22 of file OscarMTMasterThread.cc.

    : 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::LogVerbatim("SimG4CoreApplication") << "OscarMTMasterThread: creating master thread";
 
  // Create Genat4 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; });
 
      // 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_pDD, 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 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";
 
    // must be done in this thread, segfault otherwise
    m_runManagerMaster.reset();
    G4PhysicalVolumeStore::Clean();
 
    edm::LogVerbatim("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";
}

References BeginRun, 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, and m_threadMutex.

~OscarMTMasterThread()

OscarMTMasterThread::~OscarMTMasterThread

(

)

Definition at line 116 of file OscarMTMasterThread.cc.

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

References m_stopped, and stopThread().

Member Function Documentation

beginRun()

void OscarMTMasterThread::beginRun

(

const edm::EventSetup &

iSetup

)

const

Definition at line 122 of file OscarMTMasterThread.cc.

                                                                    {
  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";
}

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

Referenced by OscarMTProducer::globalBeginRun().

endRun()

void OscarMTMasterThread::endRun

(

)

const

Definition at line 141 of file OscarMTMasterThread.cc.

                                       {
  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";
}

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

readES()

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

private

Definition at line 180 of file OscarMTMasterThread.cc.

                                                                  {
  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;
}

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

Referenced by beginRun().

runManagerMaster()

RunManagerMT& OscarMTMasterThread::runManagerMaster ( ) const

inline

Definition at line 41 of file OscarMTMasterThread.h.

{ return *m_runManagerMaster; }

References m_runManagerMaster.

runManagerMasterPtr()

RunManagerMT* OscarMTMasterThread::runManagerMasterPtr ( ) const

inline

Definition at line 42 of file OscarMTMasterThread.h.

{ return m_runManagerMaster.get(); }

References m_runManagerMaster.

Referenced by OscarMTProducer::beginRun().

stopThread()

void OscarMTMasterThread::stopThread

(

)

Definition at line 155 of file OscarMTMasterThread.cc.

                                     {
  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;
}

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

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

Member Data Documentation

idealGeomRcdWatcher_

edm::ESWatcher<IdealGeometryRecord> OscarMTMasterThread::idealGeomRcdWatcher_

mutableprivate

Definition at line 55 of file OscarMTMasterThread.h.

Referenced by readES().

idealMagRcdWatcher_

edm::ESWatcher<IdealMagneticFieldRecord> OscarMTMasterThread::idealMagRcdWatcher_

mutableprivate

Definition at line 56 of file OscarMTMasterThread.h.

m_firstRun

bool OscarMTMasterThread::m_firstRun

mutableprivate

Definition at line 70 of file OscarMTMasterThread.h.

Referenced by readES().

m_mainCanProceed

bool OscarMTMasterThread::m_mainCanProceed

mutableprivate

Definition at line 69 of file OscarMTMasterThread.h.

Referenced by beginRun(), endRun(), and OscarMTMasterThread().

m_masterCanProceed

bool OscarMTMasterThread::m_masterCanProceed

mutableprivate

Definition at line 68 of file OscarMTMasterThread.h.

Referenced by beginRun(), endRun(), OscarMTMasterThread(), and stopThread().

m_masterThread

std::thread OscarMTMasterThread::m_masterThread

private

Definition at line 52 of file OscarMTMasterThread.h.

Referenced by OscarMTMasterThread(), and stopThread().

m_masterThreadState

ThreadState OscarMTMasterThread::m_masterThreadState

mutableprivate

Definition at line 66 of file OscarMTMasterThread.h.

Referenced by beginRun(), endRun(), OscarMTMasterThread(), and stopThread().

m_notifyMainCv

std::condition_variable OscarMTMasterThread::m_notifyMainCv

mutableprivate

Definition at line 64 of file OscarMTMasterThread.h.

Referenced by beginRun(), endRun(), and OscarMTMasterThread().

m_notifyMasterCv

std::condition_variable OscarMTMasterThread::m_notifyMasterCv

mutableprivate

Definition at line 63 of file OscarMTMasterThread.h.

Referenced by beginRun(), endRun(), OscarMTMasterThread(), and stopThread().

m_pDD

const DDCompactView* OscarMTMasterThread::m_pDD

mutableprivate

Definition at line 57 of file OscarMTMasterThread.h.

Referenced by OscarMTMasterThread(), and readES().

m_pDD4hep

const cms::DDCompactView* OscarMTMasterThread::m_pDD4hep

mutableprivate

Definition at line 58 of file OscarMTMasterThread.h.

Referenced by OscarMTMasterThread(), and readES().

m_pGeoFromDD4hep

const bool OscarMTMasterThread::m_pGeoFromDD4hep

private

Definition at line 49 of file OscarMTMasterThread.h.

Referenced by readES().

m_protectMutex

std::mutex OscarMTMasterThread::m_protectMutex

mutableprivate

Definition at line 61 of file OscarMTMasterThread.h.

Referenced by beginRun(), and endRun().

m_pTable

const HepPDT::ParticleDataTable* OscarMTMasterThread::m_pTable

mutableprivate

Definition at line 59 of file OscarMTMasterThread.h.

Referenced by OscarMTMasterThread(), and readES().

m_runManagerMaster

std::shared_ptr<RunManagerMT> OscarMTMasterThread::m_runManagerMaster

private

Definition at line 51 of file OscarMTMasterThread.h.

Referenced by OscarMTMasterThread(), runManagerMaster(), runManagerMasterPtr(), and stopThread().

m_stopped

bool OscarMTMasterThread::m_stopped

mutableprivate

Definition at line 71 of file OscarMTMasterThread.h.

Referenced by stopThread(), and ~OscarMTMasterThread().

m_threadMutex

std::mutex OscarMTMasterThread::m_threadMutex

mutableprivate

Definition at line 62 of file OscarMTMasterThread.h.

Referenced by beginRun(), endRun(), OscarMTMasterThread(), and stopThread().