HLT::HLTResultMTByteStreamCnv Class Reference

ByteStream converter for HLTResultMT. More...

#include <HLTResultMTByteStreamCnv.h>

Inheritance diagram for HLT::HLTResultMTByteStreamCnv:

Collaboration diagram for HLT::HLTResultMTByteStreamCnv:

Classes
struct	Cache
	Cache tracking memory allocation for serialised stream tag data and ROBFragment objects. More...

Public Member Functions
	HLTResultMTByteStreamCnv (ISvcLocator *svcLoc)
	Standard constructor.
virtual	~HLTResultMTByteStreamCnv ()
	Standard destructor.
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	createObj (IOpaqueAddress *pAddr, DataObject *&pObj) override
	Create RDO (HLTResultMT) from ByteStream.
virtual StatusCode	createRep (DataObject *pObj, IOpaqueAddress *&pAddr) override
	Create ByteStream from RDO (HLTResultMT).
long	repSvcType () const override
	return repSvcType
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Static Public Member Functions
static long	storageType ()
	Storage type used by this converter.
static CLID	classID ()
	CLID of the class HLTResultMT converted by this converter.

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
ServiceHandle< IByteStreamEventAccess >	m_ByteStreamEventAccess
	Helper to obtain the RawEvent pointer.
SG::SlotSpecificObj< Cache >	m_cache
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

ByteStream converter for HLTResultMT.

Definition at line 21 of file HLTResultMTByteStreamCnv.h.

Constructor & Destructor Documentation

HLTResultMTByteStreamCnv()

HLT::HLTResultMTByteStreamCnv::HLTResultMTByteStreamCnv

(

ISvcLocator *

svcLoc

)

Standard constructor.

Definition at line 51 of file HLTResultMTByteStreamCnv.cxx.

                                                                         :
  Converter(storageType(), classID(), svcLoc),
  AthMessaging(msgSvc(), "HLTResultMTByteStreamCnv"),
  m_ByteStreamEventAccess("ByteStreamCnvSvc", "HLTResultMTByteStreamCnv") {}

~HLTResultMTByteStreamCnv()

HLT::HLTResultMTByteStreamCnv::~HLTResultMTByteStreamCnv ( )

virtual

Standard destructor.

Definition at line 59 of file HLTResultMTByteStreamCnv.cxx.

{}

Member Function Documentation

classID()

CLID HLT::HLTResultMTByteStreamCnv::classID ( )

static

CLID of the class HLTResultMT converted by this converter.

Definition at line 253 of file HLTResultMTByteStreamCnv.cxx.

                                          {
  return ClassID_traits<HLT::HLTResultMT>::ID();
}

createObj()

StatusCode HLT::HLTResultMTByteStreamCnv::createObj ( IOpaqueAddress * pAddr, DataObject *& pObj )

overridevirtual

Create RDO (HLTResultMT) from ByteStream.

Definition at line 85 of file HLTResultMTByteStreamCnv.cxx.

                                                                                   {
  ATH_MSG_ERROR("Using BS converter to decode HLTResultMT is not supported!"
                << " Use HLTResultMTByteStreamDecoderAlg instead");
  return StatusCode::FAILURE;
}

createRep()

StatusCode HLT::HLTResultMTByteStreamCnv::createRep ( DataObject * pObj, IOpaqueAddress *& pAddr )

overridevirtual

Create ByteStream from RDO (HLTResultMT).

Definition at line 94 of file HLTResultMTByteStreamCnv.cxx.

                                                                                          {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
 
  // Find the cache corresponding to the current slot
  Cache* cache = m_cache.get(); // TODO: find a way to avoid using thread-local context here
 
  // Clear the cache which is required to remain valid between being filled here
  // and sending out the correspoding RawEventWrite in (Trig)ByteStreamCnvSvc::commitOutput
  cache->clear();
 
  // Cast the DataObject to HLTResultMT
  HLT::HLTResultMT* hltResult = nullptr;
  bool castSuccessful = SG::fromStorable(pObj, hltResult);
  if (!castSuccessful || !hltResult) {
    ATH_MSG_ERROR("Failed to convert DataObject to HLTResultMT");
    return StatusCode::FAILURE;
  }
 
  // Check ROD minor version
  const HLT::HLTResultMT::RODMinorVersion hltRodMinorVersion = hltResult->getVersion();
  if (hltRodMinorVersion == HLT::HLTResultMT::RODMinorVersion{0xff,0xff}) {
    ATH_MSG_ERROR("Invalid HLT ROD minor version {0xff, 0xff}");
    return StatusCode::FAILURE;
  }
  // Encode version X.Y (two 8-bit numbers) into a single 16-bit number
  const uint16_t hltRodMinorVersion16 = (hltRodMinorVersion.first << 8u) | hltRodMinorVersion.second;
  ATH_MSG_DEBUG("HLT ROD minor version is " << hltRodMinorVersion.first << "." << hltRodMinorVersion.second
                << " (0x" << MSG::hex << hltRodMinorVersion16 << MSG::dec << ")");
 
  // Obtain the RawEventWrite (aka eformat::write::FullEventFragment) pointer
  RawEventWrite* re = m_ByteStreamEventAccess->getRawEvent();
  if (!re) {
    ATH_MSG_ERROR("Failed to obtain a pointer to RawEventWrite");
    return StatusCode::FAILURE;
  }
  ATH_MSG_VERBOSE("Obtained RawEventWrite pointer = " << re);
 
  // Fill the status words (error code)
  re->status(hltResult->getStatus().size(), hltResult->getStatus().data());
 
  // Read the stream tags to check for debug stream tag and decide which HLT ROBFragments to write out
  std::set<eformat::helper::SourceIdentifier> resultIdsToWrite;
  bool debugEvent=false;
  std::string unknownTypeStreams;
  for (const eformat::helper::StreamTag& st : hltResult->getStreamTags()) {
    // Flag events with unknown stream type
    if (isUnknownStreamTag(st)) {
      unknownTypeStreams += st.type + "_" + st.name + " ";
    }
    // Flag debug stream events
    if (isDebugStreamTag(st)) debugEvent=true;
    // In case of full event building, add the full result ID
    if (st.robs.empty() && st.dets.empty()) {
      eformat::helper::SourceIdentifier sid(eformat::SubDetector::TDAQ_HLT, fullResultModuleId);
      resultIdsToWrite.insert(sid);
    }
    // In case of partial event building, add the results explicitly requested in the stream tag
    for (const uint32_t robid : st.robs) {
      eformat::helper::SourceIdentifier sid(robid);
      if (sid.subdetector_id() == eformat::SubDetector::TDAQ_HLT)
        resultIdsToWrite.insert(sid);
    }
  }
  // Fail if the event is not already failed (debug stream) and unknown stream type was found
  if (!debugEvent && !unknownTypeStreams.empty()) {
    ATH_MSG_ERROR("Found stream tag(s) with unknown type: " << unknownTypeStreams);
    return StatusCode::FAILURE;
  }
 
  // If the event goes to the debug stream, remove all non-debug stream tags
  // and force full event building in all debug streams
  if (debugEvent) {
    std::vector<eformat::helper::StreamTag>& writableStreamTags = hltResult->getStreamTagsNonConst();
    writableStreamTags.erase(
      std::remove_if(writableStreamTags.begin(),writableStreamTags.end(),std::not_fn(isDebugStreamTag)),
      writableStreamTags.end()
    );
    for (eformat::helper::StreamTag& st : writableStreamTags) {
      st.robs.clear();
      st.dets.clear();
    }
  }
 
  // Fill the stream tags
  uint32_t nStreamTagWords = eformat::helper::size_word(hltResult->getStreamTags());
  cache->streamTagData = std::make_unique<uint32_t[]>(nStreamTagWords);
  try {
    // encode can throw exceptions if the encoding fails
    eformat::helper::encode(hltResult->getStreamTags(),nStreamTagWords,cache->streamTagData.get());
  }
  catch (const std::exception& e) {
    ATH_MSG_ERROR("StreamTag encoding failed, caught an unexpected std::exception " << e.what());
    return StatusCode::FAILURE;
  }
  catch (...) {
    ATH_MSG_ERROR("StreamTag encoding failed, caught an unexpected exception");
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Encoded the stream tags successfully");
  re->stream_tag(nStreamTagWords, cache->streamTagData.get());
 
  // Fill the HLT bits
  const std::vector<uint32_t>& hltBits = hltResult->getHltBitsAsWords();
  re->hlt_info(hltBits.size(), hltBits.data());
 
  // Loop over the module IDs and fill the ROBFragments
  ATH_MSG_DEBUG("Iterating over " << resultIdsToWrite.size() << " HLT result IDs to assemble output data");
  const std::unordered_map<uint16_t, std::vector<uint32_t>>& serialisedData = hltResult->getSerialisedData();
  for (const eformat::helper::SourceIdentifier& resultId : resultIdsToWrite) {
    // Find the serialised data for this module ID
    const auto it = serialisedData.find(resultId.module_id());
    if (it==serialisedData.end()) {
      if (debugEvent) {
        ATH_MSG_DEBUG("HLT result with ID 0x" << MSG::hex << resultId.code() << MSG::dec
                    << " requested by a debug stream tag, but missing in the serialised data - skipping this result");
        continue;
      }
      ATH_MSG_ERROR("HLT result with ID 0x" << MSG::hex << resultId.code() << MSG::dec
                    << " requested by a stream tag, but missing in the serialised data");
      return StatusCode::FAILURE;
    }
    const std::vector<uint32_t>& data = it->second;
 
    // Create an HLT ROBFragment and append it to the full event
    auto hltROB = std::make_unique<OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment>(
      resultId.code(),
      re->run_no(),
      re->lvl1_id(),
      re->bc_id(),
      re->lvl1_trigger_type(),
      0, // detev_type not used by HLT
      data.size(),
      data.data(),
      eformat::STATUS_BACK
    );
    hltROB->rod_minor_version(hltRodMinorVersion16);
    // Fill the ROB status words
    const std::vector<uint32_t>& status = hltResult->getRobStatus(resultId.module_id());
    hltROB->status(status.size(), status.data());
 
    re->append(hltROB.get());
    cache->robFragments.push_back(std::move(hltROB));
    ATH_MSG_DEBUG("Appended data for HLT result ID 0x" << MSG::hex << resultId.code() << MSG::dec << " with "
                  << data.size() << " words of serialised payload to the output full event");
  }
 
  // Create a ByteStreamAddress for HLTResultMT
  if ( pAddr != nullptr ) pAddr->release();
  ByteStreamAddress* bsAddr = new ByteStreamAddress(classID(), pObj->registry()->name(), "");
  pAddr = static_cast<IOpaqueAddress*>(bsAddr);
  pAddr->addRef();
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}

finalize()

StatusCode HLT::HLTResultMTByteStreamCnv::finalize ( )

overridevirtual

Definition at line 74 of file HLTResultMTByteStreamCnv.cxx.

                                                 {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  if (m_ByteStreamEventAccess.release().isFailure())
    ATH_MSG_WARNING("Failed to release service " << m_ByteStreamEventAccess.typeAndName());
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}

initialize()

StatusCode HLT::HLTResultMTByteStreamCnv::initialize ( )

overridevirtual

Definition at line 64 of file HLTResultMTByteStreamCnv.cxx.

                                                   {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  ATH_CHECK(m_ByteStreamEventAccess.retrieve());
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

repSvcType()

long HLT::HLTResultMTByteStreamCnv::repSvcType ( ) const

inlineoverride

return repSvcType

Definition at line 43 of file HLTResultMTByteStreamCnv.h.

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

storageType()

long HLT::HLTResultMTByteStreamCnv::storageType ( )

static

Storage type used by this converter.

Definition at line 257 of file HLTResultMTByteStreamCnv.cxx.

{
  return ByteStreamAddress::storageType();
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_ByteStreamEventAccess

ServiceHandle<IByteStreamEventAccess> HLT::HLTResultMTByteStreamCnv::m_ByteStreamEventAccess

private

Helper to obtain the RawEvent pointer.

Definition at line 47 of file HLTResultMTByteStreamCnv.h.

m_cache

SG::SlotSpecificObj<Cache> HLT::HLTResultMTByteStreamCnv::m_cache

private

Definition at line 61 of file HLTResultMTByteStreamCnv.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

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

• HLTResultMTByteStreamCnv.h
• HLTResultMTByteStreamCnv.cxx