OutputStreamSequencerSvc Class Reference

This class provides configuration properties to enable OutputStream file sequences. More...

#include <OutputStreamSequencerSvc.h>

Inheritance diagram for OutputStreamSequencerSvc:

Collaboration diagram for OutputStreamSequencerSvc:

Public Types
typedef std::pair< std::string, std::string >	RangeReport_t
typedef std::unique_ptr< RangeReport_t >	RangeReport_ptr

Public Member Functions
	OutputStreamSequencerSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor.
virtual	~OutputStreamSequencerSvc ()
	Destructor.
virtual StatusCode	initialize () override final
	Required of all Gaudi services:
virtual StatusCode	finalize () override final
	Required of all Gaudi services:
virtual void	handle (const Incident &) override final
	Incident service handle.
std::string	buildSequenceFileName (const EventContext &ctx, const std::string &)
	Returns sequenced file name for output stream.
void	publishRangeReport (const std::string &outputFile)
RangeReport_ptr	getRangeReport ()
std::string	incidentName () const
	The name of the incident that starts a new event sequence.
std::string	currentRangeID (const EventContext &ctx) const
	The current Event Range ID (only one range is returned).
std::string	setRangeID (const EventContext &ctx, const std::string &rangeID)
	set the RangeID (possibly temporarily) so the right Range Filename may be generated
bool	inUse () const
	Is the service in active use? (true after the first range incident is handled).
const std::string &	lastIncident ()
	Last incident type that was handled.

Static Public Member Functions
static bool	inConcurrentEventsMode ()
	Are there concurrent events? (threads>1).

Private Attributes
ServiceHandle< MetaDataSvc >	m_metaDataSvc
int	m_fileSequenceNumber {}
	The event sequence number.
std::string	m_currentRangeID
	Current EventRange ID constructed on the last NextRange incident.
std::string	m_lastFileName
	Recently constructed full file name (useful in single threaded processing).
std::string	m_lastIncident
	Last incident type that was handled.
SG::SlotSpecificObj< std::string, SG::InvalidSlot::Enabled >	m_rangeIDinSlot
	EventRange ID for all slots.
StringProperty	m_incidentName
	SequenceIncidentName, incident name for triggering file sequencing.
BooleanProperty	m_reportingOn
	Flag to switch on storage of reporting info in fnToRangeId.
BooleanProperty	m_replaceRangeMode
	Flag to put in ReplaceRangeMode (i.e.
std::map< std::string, std::string >	m_fnToRangeId
std::map< std::string, std::string >::iterator	m_finishedRange {}
std::mutex	m_mutex

Detailed Description

This class provides configuration properties to enable OutputStream file sequences.

Definition at line 30 of file OutputStreamSequencerSvc.h.

Member Typedef Documentation

RangeReport_ptr

typedef std::unique_ptr<RangeReport_t> OutputStreamSequencerSvc::RangeReport_ptr

Definition at line 36 of file OutputStreamSequencerSvc.h.

RangeReport_t

typedef std::pair<std::string,std::string> OutputStreamSequencerSvc::RangeReport_t

Definition at line 35 of file OutputStreamSequencerSvc.h.

Constructor & Destructor Documentation

OutputStreamSequencerSvc()

OutputStreamSequencerSvc::OutputStreamSequencerSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Service Constructor.

Definition at line 25 of file OutputStreamSequencerSvc.cxx.

  : base_class(name, pSvcLocator),
    m_metaDataSvc("MetaDataSvc", name),
    m_fileSequenceNumber(-1)
{
}

~OutputStreamSequencerSvc()

OutputStreamSequencerSvc::~OutputStreamSequencerSvc ( )

virtual

Destructor.

Definition at line 33 of file OutputStreamSequencerSvc.cxx.

                                                    {
}

Member Function Documentation

buildSequenceFileName()

std::string OutputStreamSequencerSvc::buildSequenceFileName	(	const EventContext &	ctx,
		const std::string &	orgFileName )

Returns sequenced file name for output stream.

Definition at line 163 of file OutputStreamSequencerSvc.cxx.

{
   if( !inUse() ) {
      // Event sequences not in use, just return the original filename
      return orgFileName;
   }
   std::string rangeID = currentRangeID(ctx);
   std::lock_guard lockg( m_mutex );
   if (!m_replaceRangeMode) {
     // build the full output file name for this event range
     std::string fileNameCore = orgFileName, fileNameExt;
     std::size_t sepPos = orgFileName.find('[');
     if (sepPos != std::string::npos) {
       fileNameCore = orgFileName.substr(0, sepPos);
       fileNameExt = orgFileName.substr(sepPos);
     }
     m_lastFileName = fileNameCore + "." + rangeID + fileNameExt;
   } else {
     std::string_view origFileNameView = orgFileName;
     std::size_t open = origFileNameView.find('[');
     std::size_t close = origFileNameView.find(']');
     // If we don't find a [  ] enclosed section, just append the rangeID to the
     // end
     if (open == std::string_view::npos || close == std::string_view::npos) {
       m_lastFileName = std::format("{}.{}", origFileNameView, rangeID);
     } else {
       // build list of elems to substitute from
       ATH_MSG_DEBUG("Building element list");
       std::vector<std::string_view> elems{};
       std::size_t pos = open + 1;
       for (std::size_t comma = origFileNameView.find(',', pos);
            comma < close;
            comma = origFileNameView.find(',', pos)) {
     std::string_view item = origFileNameView.substr(pos, comma - pos);
     ATH_MSG_DEBUG("(start) pos = {}, (end) comma = comma, item = {}",
                       pos, comma, item);
         elems.push_back(item);
         pos = comma + 1;
       }
       std::string_view last_item = origFileNameView.substr(pos, close - pos);
       ATH_MSG_DEBUG("(start) pos = {}, (end) close = {}, item = {}",
                     pos, close, last_item);
       elems.push_back(last_item);
       // substitute
       std::size_t rangeIdx{};
       auto rangeIdxParseRes = std::from_chars(
           rangeID.data(), rangeID.data() + rangeID.size(), rangeIdx);
       if (rangeIdxParseRes.ec != std::errc()) {
         ATH_MSG_ERROR(
             "Error parsing rangeID to integer. Replacing [] list with "
             "rangeID.");
         m_lastFileName =
             std::format("{}{}{}", origFileNameView.substr(0, open), rangeID,
                         origFileNameView.substr(close + 1));
       } else if (rangeIdx >= elems.size()) {
         ATH_MSG_WARNING(
             "Number of elements in [] list <= rangeID. Replacing [] list with "
             "rangeID.");
         m_lastFileName =
             std::format("{}{}{}", origFileNameView.substr(0, open), rangeID,
                         origFileNameView.substr(close + 1));
       } else {
         m_lastFileName = std::format(
             "{}{}{}", origFileNameView.substr(0, open), elems.at(rangeIdx),
             origFileNameView.substr(close + 1));
         ATH_MSG_DEBUG("Output file: {}", m_lastFileName);
       }
     }
   }
 
   if( m_reportingOn.value() ) {
      m_fnToRangeId.insert( std::pair(m_lastFileName, rangeID) );
   }
 
   return m_lastFileName;
}

currentRangeID()

std::string OutputStreamSequencerSvc::currentRangeID

(

const EventContext &

ctx

)

const

The current Event Range ID (only one range is returned).

Definition at line 241 of file OutputStreamSequencerSvc.cxx.

{
   if( !inUse() )  return "";
   return *m_rangeIDinSlot.get(ctx);
}

finalize()

StatusCode OutputStreamSequencerSvc::finalize ( )

finaloverridevirtual

Required of all Gaudi services:

Definition at line 68 of file OutputStreamSequencerSvc.cxx.

                                              {
   // Release MetaDataSvc
   if (!m_metaDataSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release MetaDataSvc.");
   }
   return(StatusCode::SUCCESS);
}

getRangeReport()

OutputStreamSequencerSvc::RangeReport_ptr OutputStreamSequencerSvc::getRangeReport

(

)

Definition at line 263 of file OutputStreamSequencerSvc.cxx.

{
  RangeReport_ptr report;
  if( !m_reportingOn.value() ) {
     ATH_MSG_WARNING("Reporting not turned on - set {} to True",
                     m_reportingOn.name());
  } else {
     std::lock_guard lockg( m_mutex );
     if(m_finishedRange!=m_fnToRangeId.end()) {
        report = std::make_unique<RangeReport_t>(m_finishedRange->second,m_finishedRange->first);
        m_fnToRangeId.erase(m_finishedRange);
        m_finishedRange=m_fnToRangeId.end();
     }
  }
  return report;
}

handle()

void OutputStreamSequencerSvc::handle ( const Incident & inc )

finaloverridevirtual

Incident service handle.

Definition at line 88 of file OutputStreamSequencerSvc.cxx.

{
   const EventContext& ctx = inc.context();
   m_lastIncident = inc.type();
   ATH_MSG_INFO("Handling incident of type " << m_lastIncident << " for " << ctx);
 
   if( inc.type() == incidentName() ) {  // NextEventRange
      std::string rangeID;
      const FileIncident* fileInc  = dynamic_cast<const FileIncident*>(&inc);
      if (fileInc != nullptr) {
        rangeID = fileInc->fileName();
        // Handle BeginInputFile
        if (inc.type() == IncidentType::BeginInputFile) {
          rangeID = "INFILE";
        }
        ATH_MSG_DEBUG(
                      "Requested (through incident) Next Event Range filename extension: {}",
                      rangeID);
      }
 
      if( rangeID == "dummy" ) {
         if( not inConcurrentEventsMode() ) {
            // finish the previous Range here only in SEQUENTIAL (threads<2) event processing
            // Write metadata on the incident finishing a Range (filename=="dummy") in ES MP
            ATH_MSG_DEBUG("MetaData transition");
            // immediate write and disconnect for ES, otherwise do it after Event write is done
            bool disconnect { true };
            std::lock_guard lockg( m_mutex );
            if( !m_metaDataSvc->transitionMetaDataFile( m_lastFileName, disconnect ).isSuccess() ) {
               throw GaudiException("Cannot transition MetaData", name(), StatusCode::FAILURE);
            }
         }
         // exit now, wait for the next (real) incident that will start the next range
         return;
      }
      {
         // start a new range
         std::lock_guard lockg( m_mutex );
         m_fileSequenceNumber++;
         if( rangeID.empty() ) {
            std::ostringstream n;
            std::print (n, "_{:04}", m_fileSequenceNumber);
            rangeID = n.str();
            ATH_MSG_DEBUG("Default next event range filename extension: {}", rangeID);
         }
         else if (rangeID == "INFILE") {
             rangeID = std::to_string(m_fileSequenceNumber);
         }
         // from now on new events will use the new rangeID
         m_currentRangeID = rangeID;
         // for ESMT these incidents are asynchronous, so wait for BeginProcessing to update the range map
         if( not inConcurrentEventsMode() or ctx.valid() ) {
           *m_rangeIDinSlot.get(ctx) = std::move(rangeID);
         }
      }
      if( not inConcurrentEventsMode() and not fileInc ) {
         // non-file incident case (filename=="") in regular SP LoopMgr
         ATH_MSG_DEBUG("MetaData transition");
         bool disconnect { false };
         // MN: may not know the full filename yet, but that is only needed for disconnect==true
         if( !m_metaDataSvc->transitionMetaDataFile( "" /*m_lastFileName*/, disconnect ).isSuccess() ) {
            throw GaudiException("Cannot transition MetaData", name(), StatusCode::FAILURE);
         }
      }
   }
   else if( inc.type() == IncidentType::BeginProcessing ) {
      // new event start - assing current rangeId to its slot
      std::lock_guard lockg( m_mutex );
      ATH_MSG_DEBUG("Assigning rangeID = {} to slot {}",
                    m_currentRangeID, ctx.slot());
      *m_rangeIDinSlot.get(ctx) = m_currentRangeID;
   }
}

incidentName()

std::string OutputStreamSequencerSvc::incidentName ( ) const

inline

The name of the incident that starts a new event sequence.

Definition at line 60 of file OutputStreamSequencerSvc.h.

{ return m_incidentName.value(); }

inConcurrentEventsMode()

bool OutputStreamSequencerSvc::inConcurrentEventsMode ( )

static

Are there concurrent events? (threads>1).

Definition at line 77 of file OutputStreamSequencerSvc.cxx.

                                                         {
   return Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1;
}

initialize()

StatusCode OutputStreamSequencerSvc::initialize ( )

finaloverridevirtual

Required of all Gaudi services:

Definition at line 36 of file OutputStreamSequencerSvc.cxx.

                                                {
   ATH_MSG_DEBUG("Initializing {}", name());
 
   // Set to be listener for end of event
   ServiceHandle<IIncidentSvc> incsvc("IncidentSvc", this->name());
   if (!incsvc.retrieve().isSuccess()) {
      ATH_MSG_FATAL("Cannot get IncidentSvc.");
      return(StatusCode::FAILURE);
   }
   if( !incidentName().empty() ) {
      incsvc->addListener(this, incidentName(), 100);
      incsvc->addListener(this, IncidentType::BeginProcessing, 100);
      ATH_MSG_DEBUG("Listening to {} incidents", incidentName() );
      ATH_MSG_DEBUG("Reporting is {}", (m_reportingOn.value()? "ON" : "OFF") );
      // Retrieve MetaDataSvc
      if( !m_metaDataSvc.isValid() and !m_metaDataSvc.retrieve().isSuccess() ) {
         ATH_MSG_ERROR("Cannot get MetaDataSvc");
         return StatusCode::FAILURE;
      }
   }
 
   if( inConcurrentEventsMode() ) {
      ATH_MSG_DEBUG("Concurrent events mode");
   } else {
      ATH_MSG_VERBOSE("Sequential events mode");
   }
 
   m_finishedRange = m_fnToRangeId.end();
 
   return(StatusCode::SUCCESS);
}

inUse()

bool OutputStreamSequencerSvc::inUse

(

)

const

Is the service in active use? (true after the first range incident is handled).

Definition at line 82 of file OutputStreamSequencerSvc.cxx.

                                              {
   std::lock_guard lockg( m_mutex );
   return m_fileSequenceNumber >= 0;
}

lastIncident()

const std::string & OutputStreamSequencerSvc::lastIncident ( )

inline

Last incident type that was handled.

Definition at line 75 of file OutputStreamSequencerSvc.h.

{ return m_lastIncident; }

publishRangeReport()

void OutputStreamSequencerSvc::publishRangeReport

(

const std::string &

outputFile

)

Definition at line 257 of file OutputStreamSequencerSvc.cxx.

{
   std::lock_guard lockg( m_mutex );
   m_finishedRange = m_fnToRangeId.find(outputFile);
}

setRangeID()

std::string OutputStreamSequencerSvc::setRangeID	(	const EventContext &	ctx,
		const std::string &	rangeID )

set the RangeID (possibly temporarily) so the right Range Filename may be generated

Definition at line 248 of file OutputStreamSequencerSvc.cxx.

{
   std::string* rangeid = m_rangeIDinSlot.get(ctx);
   const std::string oldrange = *rangeid;
   *rangeid = rangeID;
   return oldrange;
}

Member Data Documentation

m_currentRangeID

std::string OutputStreamSequencerSvc::m_currentRangeID

private

Current EventRange ID constructed on the last NextRange incident.

Definition at line 84 of file OutputStreamSequencerSvc.h.

m_fileSequenceNumber

int OutputStreamSequencerSvc::m_fileSequenceNumber {}

private

The event sequence number.

Definition at line 81 of file OutputStreamSequencerSvc.h.

{};

m_finishedRange

std::map<std::string,std::string>::iterator OutputStreamSequencerSvc::m_finishedRange {}

private

Definition at line 112 of file OutputStreamSequencerSvc.h.

{};

m_fnToRangeId

std::map<std::string,std::string> OutputStreamSequencerSvc::m_fnToRangeId

private

Definition at line 111 of file OutputStreamSequencerSvc.h.

m_incidentName

StringProperty OutputStreamSequencerSvc::m_incidentName

private

Initial value:

{this, "SequenceIncidentName", "",
         "Name of the incident that signals the next Event Range start" }

SequenceIncidentName, incident name for triggering file sequencing.

Definition at line 97 of file OutputStreamSequencerSvc.h.

                                             {this, "SequenceIncidentName", "",
         "Name of the incident that signals the next Event Range start" };

m_lastFileName

std::string OutputStreamSequencerSvc::m_lastFileName

private

Recently constructed full file name (useful in single threaded processing).

Definition at line 87 of file OutputStreamSequencerSvc.h.

m_lastIncident

std::string OutputStreamSequencerSvc::m_lastIncident

private

Last incident type that was handled.

Definition at line 90 of file OutputStreamSequencerSvc.h.

m_metaDataSvc

ServiceHandle<MetaDataSvc> OutputStreamSequencerSvc::m_metaDataSvc

private

Definition at line 78 of file OutputStreamSequencerSvc.h.

m_mutex

std::mutex OutputStreamSequencerSvc::m_mutex

mutableprivate

Definition at line 114 of file OutputStreamSequencerSvc.h.

m_rangeIDinSlot

SG::SlotSpecificObj<std::string, SG::InvalidSlot::Enabled> OutputStreamSequencerSvc::m_rangeIDinSlot

private

EventRange ID for all slots.

Definition at line 93 of file OutputStreamSequencerSvc.h.

m_replaceRangeMode

BooleanProperty OutputStreamSequencerSvc::m_replaceRangeMode

private

Initial value:

{
       this, "ReplaceRangeMode", false,
       "If True, everything between [ and ] in the output filename is treated "
       "as a comma-separated list, and the range_idth element of the list is "
       "selected"}

Flag to put in ReplaceRangeMode (i.e.

everything between [ and ] (inclusive) is replaced with the range_idth element of that list)

Definition at line 105 of file OutputStreamSequencerSvc.h.

                                     {
       this, "ReplaceRangeMode", false,
       "If True, everything between [ and ] in the output filename is treated "
       "as a comma-separated list, and the range_idth element of the list is "
       "selected"};

m_reportingOn

BooleanProperty OutputStreamSequencerSvc::m_reportingOn

private

Initial value:

{this, "ReportingOn", false,
         "If True, keep info about Ranges for getRangeReport() calls"}

Flag to switch on storage of reporting info in fnToRangeId.

Definition at line 100 of file OutputStreamSequencerSvc.h.

                                            {this, "ReportingOn", false,
         "If True, keep info about Ranges for getRangeReport() calls"};

---

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

• OutputStreamSequencerSvc.h
• OutputStreamSequencerSvc.cxx