A service managing all the communication with the df_ef interface, for online use. More...

#include <EFInterfaceSvc.h>

Inheritance diagram for EFInterfaceSvc:

Collaboration diagram for EFInterfaceSvc:

Public Types
enum class	Status { OK = 0 , NO_EVENT , STOP }

Public Member Functions
	EFInterfaceSvc (const std::string &name, ISvcLocator *svc)
virtual	~EFInterfaceSvc () noexcept override
virtual StatusCode initialize	ATLAS_NOT_THREAD_SAFE () override
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
virtual void	handle (const Incident &incident) override
virtual Status	getNext (std::unique_ptr< uint32_t[]> &rawEventPtr)
void	eventDone (std::unique_ptr< uint32_t[]> rawEventPtr)
boost::property_tree::ptree	prepInterfacePTree ()

Public Attributes
uint32_t	m_acceptedEvents {0}
uint32_t	m_rejectedEvents {0}
uint32_t	m_processedEvents {0}

Private Attributes
boost::dll::shared_library	m_efdfinterface_library
	Library with the df_ef_interface implementation.
std::unique_ptr< daq::df_ef_interface::EventHandler >	m_eventHandler
std::queue< std::future< std::unique_ptr< uint32_t[]> > >	m_getNextFuture
std::mutex	m_queueMutex
	Mutex for future queue.
Gaudi::Property< std::string >	m_interface_library_name
Gaudi::Property< int >	m_getNextTimeout
Gaudi::Property< int >	m_stride
Gaudi::Property< int >	m_fileOffset
Gaudi::Property< int >	m_numEvents
Gaudi::Property< int >	m_skipEvents
Gaudi::Property< bool >	m_loopOverFiles
Gaudi::Property< std::string >	m_outputFileName
Gaudi::Property< std::vector< std::string > >	m_files
Gaudi::Property< int >	m_runNumber
Gaudi::Property< int >	m_triggerType
Gaudi::Property< int >	m_beamType
Gaudi::Property< int >	m_beamEnergy
Gaudi::Property< std::string >	m_detMask
Gaudi::Property< std::string >	m_T0_project_tag
Gaudi::Property< std::string >	m_stream
Gaudi::Property< int >	m_lumiblock

Detailed Description

A service managing all the communication with the df_ef interface, for online use.

This service replaces the use of hltinterface::DataCollector in the online HLT dynamically loads proper implementation library calls interface methods for event retrieval or accept/reject decision manages the pTree for configuring the interface

Definition at line 28 of file EFInterfaceSvc.h.

Member Enumeration Documentation

◆ Status

enum class EFInterfaceSvc::Status

strong

Enumerator
OK	event returned
NO_EVENT	no event available
STOP	stop transition (no more events)

Definition at line 32 of file EFInterfaceSvc.h.

                    {
    OK = 0,      
    NO_EVENT,    
    STOP         
  };

Constructor & Destructor Documentation

◆ EFInterfaceSvc()

EFInterfaceSvc::EFInterfaceSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Definition at line 13 of file EFInterfaceSvc.cxx.

  : base_class(name, svc)
{
}

◆ ~EFInterfaceSvc()

virtual EFInterfaceSvc::~EFInterfaceSvc ( )

inlineoverridevirtualnoexcept

Definition at line 39 of file EFInterfaceSvc.h.

39{}

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

virtual StatusCode initialize EFInterfaceSvc::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

◆ eventDone()

void EFInterfaceSvc::eventDone ( std::unique_ptr< uint32_t[]> rawEventPtr )

Definition at line 115 of file EFInterfaceSvc.cxx.

{
  eformat::read::FullEventFragment ev(rawEventPtr.get());
  m_processedEvents++;
  bool accepted = ((ev.nstream_tag() > 0)?true:false);
  ATH_MSG_DEBUG("Number of stream tags: " <<  ev.nstream_tag());
  if(accepted){
    ATH_MSG_DEBUG("Event " << ev.lvl1_id() << " accepted");
    auto result = m_eventHandler->accept(ev.lvl1_id(), std::move(rawEventPtr));
    m_acceptedEvents++;
    //TODO: decide if we have to check for the future result
  }else{
    ATH_MSG_DEBUG("Event " << ev.lvl1_id() << " rejected");
    auto result = m_eventHandler->reject(ev.lvl1_id());
    m_rejectedEvents++;
  }
}

◆ finalize()

StatusCode EFInterfaceSvc::finalize ( )

overridevirtual

Definition at line 107 of file EFInterfaceSvc.cxx.

{
  ATH_MSG_DEBUG("EFInterfaceSvc finalized");
  m_eventHandler.reset();
  m_efdfinterface_library.unload();
  return StatusCode::SUCCESS;
}

◆ getNext()

EFInterfaceSvc::Status EFInterfaceSvc::getNext ( std::unique_ptr< uint32_t[]> & rawEventPtr )

virtual

Definition at line 133 of file EFInterfaceSvc.cxx.

{
  try{
    //check if we have a getNext call already pending
    std::future<std::unique_ptr<uint32_t []>> future;
    {
      std::lock_guard<std::mutex> lock(m_queueMutex);
      if (m_getNextFuture.empty()){
        ATH_MSG_DEBUG("No pending getNext call, creating a new one");
        future = m_eventHandler->getNext();
      } else {
        ATH_MSG_DEBUG("Pending getNext call found, using it");
        future = std::move(m_getNextFuture.front());
        m_getNextFuture.pop();
      }
    }
    // Wait for the future to be ready
    auto status = future.wait_for(std::chrono::milliseconds(m_getNextTimeout));
    if (status == std::future_status::ready) {
      auto result = future.get();
      rawEventPtr = std::move(result);
      return Status::OK; 
    } else {
      // Future is not ready, return NO_EVENT
      ATH_MSG_DEBUG("getNext timed out, returning NO_EVENT");
      rawEventPtr = nullptr;
      {
        //Add the future to the queue for later access
        std::lock_guard<std::mutex> lock(m_queueMutex);
        m_getNextFuture.push(std::move(future));
      }
      return Status::NO_EVENT;
    }
  }
  catch (daq::df_ef_interface::NoMoreEvents &ex){
    ATH_MSG_DEBUG("NoMoreEvents, returning");
    return Status::STOP;
  }
  catch (daq::df_ef_interface::CommunicationError &ex){
    ATH_MSG_DEBUG("CommunicationError received from EFInterface, returning NO_EVENT");
    return Status::NO_EVENT;
  }
  catch (std::exception &ex){
    ATH_MSG_ERROR("EFInterface: caught exception: \""<<ex.what()<<"\" throwing!");
    throw; 
  }
  catch(...) {
    ATH_MSG_ERROR("EFInterface: caught very unknown exception");
    throw;
  }
}

◆ handle()

void EFInterfaceSvc::handle ( const Incident & incident )

overridevirtual

Definition at line 29 of file EFInterfaceSvc.cxx.

{
  if (incident.type() == AthenaInterprocess::UpdateAfterFork::type()) 
  {
    ATH_MSG_DEBUG("Going to initialize the EFInterface"); 
    std::string full_libname = "lib" + m_interface_library_name + ".so";
    m_efdfinterface_library = boost::dll::shared_library(full_libname, boost::dll::load_mode::type::search_system_folders | boost::dll::load_mode::type::rtld_global);
    using cEventHandler = std::unique_ptr<daq::df_ef_interface::EventHandler> (const boost::property_tree::ptree&);
    std::function<cEventHandler> cs;
    try {
      cs = m_efdfinterface_library.get<cEventHandler>("createEventHandler");
    } catch (std::exception & ex) {
      ATH_MSG_ERROR("Cant load function createEventHandler. Are you trying to use incorrect library? - " << ex.what());
      throw; 
    }
    //Add Tree
    boost::property_tree::ptree configTree = prepInterfacePTree();
    std::ostringstream oss;
    boost::property_tree::write_json(oss, configTree, true);
    ATH_MSG_INFO("EFInterface configuration:\n" << oss.str());
    try {
      m_eventHandler = cs(configTree);
    } catch (std::exception & ex) {
      ATH_MSG_ERROR("Cant create EventHandler from DataSource library. Are you trying to use incorrect configuration? - " << ex.what());
      throw;
    }
    // Going to open the EventHandler connection
    try {
      ATH_MSG_DEBUG("Opening EventHandler");
      m_eventHandler->open();
    } 
    catch (daq::df_ef_interface::CommunicationError & ex) {
      ATH_MSG_ERROR("CommunicationError while opening EventHandler: " << ex.what());
      throw;
    } 
    catch (std::exception & ex) {
      ATH_MSG_ERROR("Exception while opening EventHandler: " << ex.what());
      throw;
    } 
    catch (...) {
      ATH_MSG_ERROR("Unknown exception while opening EventHandler");
      throw;
    }
  }
}

◆ prepInterfacePTree()

boost::property_tree::ptree EFInterfaceSvc::prepInterfacePTree ( )

Definition at line 185 of file EFInterfaceSvc.cxx.

{
  boost::property_tree::ptree configTree;
    // Top-level values
  configTree.put("name", "DFEFInterfaceSvc");
  configTree.put("stride", m_stride.value()); // NB: if this is set to 0 it will cause a seg fault! 
  configTree.put("fileOffset", m_fileOffset.value());
  configTree.put("numEvents", m_numEvents.value());
  configTree.put("skipEvents", m_skipEvents.value());
  configTree.put("loopOverFiles", m_loopOverFiles.value() ? "true" : "false");  // as string
  configTree.put("outputFileName", m_outputFileName.value());
  // File list
  boost::property_tree::ptree fileList;
  for (const std::string& fname : m_files.value()) {
    boost::property_tree::ptree fileNode;
    fileNode.put("", fname);
    fileList.push_back(std::make_pair("file", fileNode));
  }
  configTree.add_child("fileList", fileList);
  // Run parameters
  boost::property_tree::ptree runParams;
  runParams.put("run_number", m_runNumber.value());
  runParams.put("trigger_type", m_triggerType.value());
  runParams.put("beam_type", m_beamType.value());
  runParams.put("beam_energy", m_beamEnergy.value());
  runParams.put("det_mask", m_detMask.value());
  runParams.put("T0_project_tag", m_T0_project_tag.value());
  runParams.put("stream", m_stream.value());
  runParams.put("lumiblock", m_lumiblock.value());
  configTree.add_child("RunParams", runParams);
 
  return configTree;
}    

◆ stop()

StatusCode EFInterfaceSvc::stop ( )

overridevirtual

Definition at line 75 of file EFInterfaceSvc.cxx.

{
  ATH_MSG_DEBUG("EFInterfaceSvc stopped");
  // Close the EventHandler connection
  if (!m_eventHandler) {
    ATH_MSG_DEBUG("EventHandler is not initialized, probably I'm in the mother process.");
  }
  else
  {
    try {
      m_eventHandler->close();
    }
    catch (daq::df_ef_interface::CommunicationError & ex) {
      ATH_MSG_ERROR("CommunicationError while closing EventHandler: " << ex.what());
      throw;
    }
    catch (std::exception & ex) {
      ATH_MSG_ERROR("Exception while closing EventHandler: " << ex.what());
      throw;
    }
    catch (...) {
      ATH_MSG_ERROR("Unknown exception while closing EventHandler");
      throw;
    }
  }
  ATH_MSG_INFO("EFInterfaceSvc Stopping. Event processing summary:");
  ATH_MSG_INFO("Processed Events: " << m_processedEvents);
  ATH_MSG_INFO("Accepted Events: " << m_acceptedEvents);
  ATH_MSG_INFO("Rejected Events: " << m_rejectedEvents);
  return StatusCode::SUCCESS;
}

Member Data Documentation

◆ m_acceptedEvents

uint32_t EFInterfaceSvc::m_acceptedEvents {0}

Definition at line 51 of file EFInterfaceSvc.h.

51{0};

◆ m_beamEnergy

Gaudi::Property<int> EFInterfaceSvc::m_beamEnergy

private

Initial value:

{this, "BeamEnergy", 0,

"Beam energy"}

Definition at line 86 of file EFInterfaceSvc.h.

86 {this, "BeamEnergy", 0,

87 "Beam energy"};

◆ m_beamType

Gaudi::Property<int> EFInterfaceSvc::m_beamType

private

Initial value:

{this, "BeamType", 0,

"Beam type"}

Definition at line 84 of file EFInterfaceSvc.h.

84 {this, "BeamType", 0,

85 "Beam type"};

◆ m_detMask

Gaudi::Property<std::string> EFInterfaceSvc::m_detMask

private

Initial value:

{this, "DetMask", "00000000000000000000000000000000",

"Detector mask"}

Definition at line 88 of file EFInterfaceSvc.h.

88 {this, "DetMask", "00000000000000000000000000000000",

89 "Detector mask"};

◆ m_efdfinterface_library

boost::dll::shared_library EFInterfaceSvc::m_efdfinterface_library

private

Library with the df_ef_interface implementation.

Definition at line 56 of file EFInterfaceSvc.h.

◆ m_eventHandler

std::unique_ptr<daq::df_ef_interface::EventHandler> EFInterfaceSvc::m_eventHandler

private

Definition at line 57 of file EFInterfaceSvc.h.

◆ m_fileOffset

Gaudi::Property<int> EFInterfaceSvc::m_fileOffset

private

Initial value:

{this, "FileOffset", 0,

"File offset for the event retrieval"}

Definition at line 68 of file EFInterfaceSvc.h.

68 {this, "FileOffset", 0,

69 "File offset for the event retrieval"};

◆ m_files

Gaudi::Property<std::vector<std::string> > EFInterfaceSvc::m_files

private

Initial value:

{this, "Files", {""},

"List of input files"}

Definition at line 78 of file EFInterfaceSvc.h.

78 {this, "Files", {""},

79 "List of input files"};

◆ m_getNextFuture

std::queue<std::future<std::unique_ptr<uint32_t []> > > EFInterfaceSvc::m_getNextFuture

private

Definition at line 58 of file EFInterfaceSvc.h.

◆ m_getNextTimeout

Gaudi::Property<int> EFInterfaceSvc::m_getNextTimeout

private

Initial value:

{this, "GetNextTimeout", 1000,

"Timeout for getting the next event (in milliseconds)"}

Definition at line 64 of file EFInterfaceSvc.h.

64 {this, "GetNextTimeout", 1000,

65 "Timeout for getting the next event (in milliseconds)"};

◆ m_interface_library_name

Gaudi::Property<std::string> EFInterfaceSvc::m_interface_library_name

private

Initial value:

{this, "EFDFInterfaceLibraryName", "TrigDFEmulator",

"Name of the EFDF interface shared library to load"}

Definition at line 62 of file EFInterfaceSvc.h.

62 {this, "EFDFInterfaceLibraryName", "TrigDFEmulator",

63 "Name of the EFDF interface shared library to load"};

◆ m_loopOverFiles

Gaudi::Property<bool> EFInterfaceSvc::m_loopOverFiles

private

Initial value:

{this, "LoopOverFiles", true,

"Flag to enable looping over files"}

Definition at line 74 of file EFInterfaceSvc.h.

74 {this, "LoopOverFiles", true,

75 "Flag to enable looping over files"};

◆ m_lumiblock

Gaudi::Property<int> EFInterfaceSvc::m_lumiblock

private

Initial value:

{this, "Lumiblock", 0,

"Lumiblock"}

Definition at line 94 of file EFInterfaceSvc.h.

94 {this, "Lumiblock", 0,

95 "Lumiblock"};

◆ m_numEvents

Gaudi::Property<int> EFInterfaceSvc::m_numEvents

private

Initial value:

{this, "NumEvents", 100,

"Number of events to process"}

Definition at line 70 of file EFInterfaceSvc.h.

70 {this, "NumEvents", 100,

71 "Number of events to process"};

◆ m_outputFileName

Gaudi::Property<std::string> EFInterfaceSvc::m_outputFileName

private

Initial value:

{this, "OutputFileName", "test_output.data",

"Name of the output file"}

Definition at line 76 of file EFInterfaceSvc.h.

76 {this, "OutputFileName", "test_output.data",

77 "Name of the output file"};

◆ m_processedEvents

uint32_t EFInterfaceSvc::m_processedEvents {0}

Definition at line 53 of file EFInterfaceSvc.h.

53{0};

◆ m_queueMutex

std::mutex EFInterfaceSvc::m_queueMutex

private

Mutex for future queue.

Definition at line 59 of file EFInterfaceSvc.h.

◆ m_rejectedEvents

uint32_t EFInterfaceSvc::m_rejectedEvents {0}

Definition at line 52 of file EFInterfaceSvc.h.

52{0};

◆ m_runNumber

Gaudi::Property<int> EFInterfaceSvc::m_runNumber

private

Initial value:

{this, "RunNumber", 0,

"Run number for the events processing"}

Definition at line 80 of file EFInterfaceSvc.h.

80 {this, "RunNumber", 0,

81 "Run number for the events processing"};

◆ m_skipEvents

Gaudi::Property<int> EFInterfaceSvc::m_skipEvents

private

Initial value:

{this, "SkipEvents", 0,

"Number of events to skip"}

Definition at line 72 of file EFInterfaceSvc.h.

72 {this, "SkipEvents", 0,

73 "Number of events to skip"};

◆ m_stream

Gaudi::Property<std::string> EFInterfaceSvc::m_stream

private

Initial value:

{this, "Stream", "stream",

"Stream name"}

Definition at line 92 of file EFInterfaceSvc.h.

92 {this, "Stream", "stream",

93 "Stream name"};

◆ m_stride

Gaudi::Property<int> EFInterfaceSvc::m_stride

private

Initial value:

{this, "Stride", 1,

"Stride for the event retrieval"}

Definition at line 66 of file EFInterfaceSvc.h.

66 {this, "Stride", 1,

67 "Stride for the event retrieval"};

◆ m_T0_project_tag

Gaudi::Property<std::string> EFInterfaceSvc::m_T0_project_tag

private

Initial value:

{this, "T0ProjectTag", "T0_project_tag",

"T0 project tag"}

Definition at line 90 of file EFInterfaceSvc.h.

90 {this, "T0ProjectTag", "T0_project_tag",

91 "T0 project tag"};

◆ m_triggerType

Gaudi::Property<int> EFInterfaceSvc::m_triggerType

private

Initial value:

{this, "TriggerType", 0,

"Trigger type for the events processing"}

Definition at line 82 of file EFInterfaceSvc.h.

82 {this, "TriggerType", 0,

83 "Trigger type for the events processing"};

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

Public Types

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ Status

Constructor & Destructor Documentation

◆ EFInterfaceSvc()

◆ ~EFInterfaceSvc()

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

◆ eventDone()

◆ finalize()

◆ getNext()

◆ handle()

◆ prepInterfacePTree()

◆ stop()

Member Data Documentation

◆ m_acceptedEvents

◆ m_beamEnergy

◆ m_beamType

◆ m_detMask

◆ m_efdfinterface_library

◆ m_eventHandler

◆ m_fileOffset

◆ m_files

◆ m_getNextFuture

◆ m_getNextTimeout

◆ m_interface_library_name

◆ m_loopOverFiles

◆ m_lumiblock

◆ m_numEvents

◆ m_outputFileName

◆ m_processedEvents

◆ m_queueMutex

◆ m_rejectedEvents

◆ m_runNumber

◆ m_skipEvents

◆ m_stream

◆ m_stride

◆ m_T0_project_tag

◆ m_triggerType