G4RunToolEventQueue Class Reference

Thread-safe event handoff between Athena and the Geant4 worker threads. More...

#include <G4RunToolEventQueue.h>

Collaboration diagram for G4RunToolEventQueue:

Public Types
using	UPEvent = std::unique_ptr<AtlasG4SyncEventUserInfo>

Public Member Functions
std::size_t	Size () const
void	PushEvent (UPEvent event)
	Submit a non-null event. Throws std::invalid_argument for null events.
UPEvent	GetEvent ()
void	Close () noexcept
	Stop accepting events and wake all Geant4 workers. Idempotent.
void	CompleteOutstandingEvents () noexcept
	Release abandoned events and report run termination to their waiters.

Private Types
using	WeakSyncInterface

Private Attributes
std::queue< UPEvent >	m_events
std::vector< WeakSyncInterface >	m_outstandingEvents
bool	m_closed {false}
std::mutex	m_mutex
std::condition_variable	m_cv

Detailed Description

Thread-safe event handoff between Athena and the Geant4 worker threads.

Events submitted while the queue is open are tracked until their Athena waiters have been notified. Closing the queue wakes every blocked Geant4 worker; subsequent GetEvent() calls return nullptr so that SyncEventAction aborts the run. Once the workers have stopped, CompleteOutstandingEvents() releases any abandoned events and wakes their Athena waiters.

Definition at line 24 of file G4RunToolEventQueue.h.

Member Typedef Documentation

UPEvent

using G4RunToolEventQueue::UPEvent = std::unique_ptr<AtlasG4SyncEventUserInfo>

Definition at line 27 of file G4RunToolEventQueue.h.

WeakSyncInterface

using G4RunToolEventQueue::WeakSyncInterface

private

Initial value:

 
std::weak_ptr<G4EventSynchronizationInterface>

Definition at line 42 of file G4RunToolEventQueue.h.

Member Function Documentation

Close()

void G4RunToolEventQueue::Close ( )

noexcept

Stop accepting events and wake all Geant4 workers. Idempotent.

Definition at line 69 of file G4RunToolEventQueue.cxx.

{
  {
    std::scoped_lock lock(m_mutex);
    m_closed = true;
  }
  m_cv.notify_all();
}

CompleteOutstandingEvents()

void G4RunToolEventQueue::CompleteOutstandingEvents ( )

noexcept

Release abandoned events and report run termination to their waiters.

Must be called only after all Geant4 workers have stopped. Idempotent.

Definition at line 78 of file G4RunToolEventQueue.cxx.

{
  std::vector<WeakSyncInterface> outstandingEvents;
  std::queue<UPEvent> abandonedEvents;
  {
    std::scoped_lock lock(m_mutex);
    outstandingEvents.swap(m_outstandingEvents);
    abandonedEvents.swap(m_events);
  }
 
  // Destroy queued event information before waking Athena. In-flight event
  // information has already been destroyed as part of worker termination.
  while (!abandonedEvents.empty()) {
    abandonedEvents.pop();
  }
 
  for (const WeakSyncInterface& weakInterface : outstandingEvents) {
    if (auto syncInterface = weakInterface.lock()) {
      syncInterface->Complete(
        G4EventSynchronizationInterface::EventOutcome::RunTerminated);
    }
  }
}

GetEvent()

auto G4RunToolEventQueue::GetEvent

(

)

Definition at line 56 of file G4RunToolEventQueue.cxx.

{
  std::unique_lock lock(m_mutex);
  m_cv.wait(lock, [this] { return m_closed || !m_events.empty(); });
  if (m_closed) {
    return nullptr;
  }
 
  UPEvent event = std::move(m_events.front());
  m_events.pop();
  return event;
}

PushEvent()

void G4RunToolEventQueue::PushEvent

(

UPEvent

event

)

Submit a non-null event. Throws std::invalid_argument for null events.

Definition at line 17 of file G4RunToolEventQueue.cxx.

{
  if (!event) {
    throw std::invalid_argument(
      "G4RunToolEventQueue::PushEvent requires a non-null event");
  }
 
  auto syncInterface = event->SyncInterface();
  bool eventQueued = false;
  {
    std::scoped_lock lock(m_mutex);
    if (!m_closed) {
      m_outstandingEvents.erase(
        std::remove_if(m_outstandingEvents.begin(),
                       m_outstandingEvents.end(),
                       [](const WeakSyncInterface& interface) {
                         return interface.expired();
                       }),
        m_outstandingEvents.end());
      if (syncInterface) {
        m_outstandingEvents.emplace_back(syncInterface);
      }
      m_events.push(std::move(event));
      eventQueued = true;
    }
  }
 
  if (eventQueued) {
    m_cv.notify_one();
  }
  else if (syncInterface) {
    // The event was never exposed to Geant4, so its owned state can be safely
    // released before the Athena thread is notified.
    event.reset();
    syncInterface->Complete(
      G4EventSynchronizationInterface::EventOutcome::RunTerminated);
  }
}

Size()

std::size_t G4RunToolEventQueue::Size

(

)

const

Definition at line 11 of file G4RunToolEventQueue.cxx.

{
  std::scoped_lock lock(m_mutex);
  return m_events.size();
}

Member Data Documentation

m_closed

bool G4RunToolEventQueue::m_closed {false}

private

Definition at line 47 of file G4RunToolEventQueue.h.

{false};

m_cv

std::condition_variable G4RunToolEventQueue::m_cv

private

Definition at line 49 of file G4RunToolEventQueue.h.

m_events

std::queue<UPEvent> G4RunToolEventQueue::m_events

private

Definition at line 45 of file G4RunToolEventQueue.h.

m_mutex

std::mutex G4RunToolEventQueue::m_mutex

mutableprivate

Definition at line 48 of file G4RunToolEventQueue.h.

m_outstandingEvents

std::vector<WeakSyncInterface> G4RunToolEventQueue::m_outstandingEvents

private

Definition at line 46 of file G4RunToolEventQueue.h.

---

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

• G4RunToolEventQueue.h
• G4RunToolEventQueue.cxx