HltROBDataProviderSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TRIGSERVICES_HLTROBDATAPROVIDERSVC_H
#define TRIGSERVICES_HLTROBDATAPROVIDERSVC_H
 
// Package includes
#include "ByteStreamCnvSvcBase/IROBDataProviderSvc.h"
#include "ByteStreamData/RawEvent.h"
#include "eformat/SourceIdentifier.h"
 
// Framework includes
#include "AthenaBaseComps/AthService.h"
#include "AthenaKernel/SlotSpecificObj.h"
#include "AthenaMonitoringKernel/Monitored.h"
#include "TrigCostMonitor/ITrigCostSvc.h"
#include "TrigDataAccessMonitoring/ROBDataMonitor.h"
 
// STL includes
#include <string>
#include <string_view>
#include <vector>
#include <map>
#include <mutex>
 
// TBB includes
#include "tbb/concurrent_unordered_map.h"

class HltROBDataProviderSvc : public extends<AthService, IROBDataProviderSvc> {
public:
  typedef OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment ROBF;
 
  HltROBDataProviderSvc(const std::string& name, ISvcLocator* pSvcLocator);
 
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;

  virtual void addROBData(const EventContext& /*context*/, const std::vector<uint32_t>& /*robIds*/, 
              const std::string_view callerName="UNKNOWN") override;

  virtual void setNextEvent(const EventContext& /*context*/, const std::vector<ROBF>& /*result*/) override;

  virtual void setNextEvent(const EventContext& /*context*/, const RawEvent* /*re*/) override;

  virtual void getROBData(const EventContext& /*context*/, 
              const std::vector<uint32_t>& /*robIds*/, std::vector<const ROBF*>& /*robFragments*/, 
              const std::string_view callerName="UNKNOWN") override;

  virtual const RawEvent* getEvent(const EventContext& /*context*/) override;

  virtual void setEventStatus(const EventContext& /*context*/, uint32_t /*status*/) override;

  virtual uint32_t getEventStatus(const EventContext& /*context*/) override;

  virtual void processCachedROBs(const EventContext& /*context*/, const std::function< void(const ROBF* )>& /*fn*/) const override;

  virtual bool isEventComplete(const EventContext& /*context*/) const override;

  virtual int collectCompleteEventData(const EventContext& /*context*/, 
                       const std::string_view callerName="UNKNOWN") override;
 
private:
  /*--------------+
   *  Event cache |
   *--------------+ 
   */
  typedef tbb::concurrent_unordered_map<uint32_t, ROBF> ROBMAP;

  struct EventCache {
    ~EventCache();
    const RawEvent* event      = 0;
    uint32_t currentLvl1ID     = 0; 
    uint64_t globalEventNumber = 0;
    uint32_t eventStatus       = 0;    
    bool     isEventComplete   = false;    
    ROBMAP   robmap;
    std::mutex eventCache_mtx;
  };

  SG::SlotSpecificObj<EventCache> m_eventsCache;
 
  /*------------------------------+
   * Attributes for configuration |
   *------------------------------+ 
   */
  typedef std::vector< std::pair<int, int> > ArrayPairIntType;
  Gaudi::Property< ArrayPairIntType > m_filterRobWithStatus{
    this, "filterRobWithStatus", {} , "List of ROBs with status code to remove"};
  Gaudi::Property< ArrayPairIntType > m_filterSubDetWithStatus{
    this, "filterSubDetWithStatus", {} , "List of SubDets with status code to remove"};

  typedef std::map<uint32_t, std::vector<uint32_t> > FilterRobMap;
  FilterRobMap          m_filterRobMap;
  typedef std::map<eformat::SubDetector, std::vector<uint32_t> > FilterSubDetMap;
  FilterSubDetMap       m_filterSubDetMap;

  Gaudi::Property<bool> m_filterEmptyROB{
    this, "filterEmptyROB", false , "Filter out empty ROB fragments"};

  bool m_maskL2EFModuleID = false;    
 
  // read enabled ROBs from OKS when possible
  Gaudi::Property<bool> m_readROBfromOKS{
    this, "readROBfromOKS", true , "Read enabled ROBs from OKS"};
 
  // list of all enabled ROBs which can be retrieved    
  Gaudi::Property< std::vector<uint32_t> > m_enabledROBs{
    this, "enabledROBs", {} , "Enabled ROBs for retrieval"};
 
  // prefetch all ROBs from a ROS if ROB data from this ROS are requested
  Gaudi::Property<bool> m_prefetchAllROBsfromROS{
    this, "prefetchAllROBsfromROS", false , "When ROBs from a ROS are requested then prefetch all ROBs in this ROS"};
  // list of sub-detector ids for which all ROBs in their ROSes are prefetched
  //      list empty or sub-det ID = 0x0 --> all ROSes will use complete prefetching
  //      For sub-detector specific prefetching sub-detector IDs or sub-detector groups should be specified. 
  //      Both types of identifiers can be mixed,
  //      e.g. [ 0x4, 0x5, 0x13, 0x14 ] means prefetching is used for all LAR and TILE ROSes and
  //      for the ROSes of PIXEL_B_LAYER and PIXEL_IBL  
  Gaudi::Property< std::vector<uint8_t> > m_prefetchSubDetROS{
    this, "prefetchSubDetROS", {} , "List of sub-detectors for which whole ROS prefetching is used"};
  // internal array, which holds list of ROBs for whole ROS prefetching
  std::vector<uint32_t> m_prefetchWholeROSList ;
 
  Gaudi::Property<bool> m_doCostMonitoring{
    this, "doCostMonitoring", false, "Enables start-of-event cost monitoring behavior."};
 
  ServiceHandle<ITrigCostSvc> m_trigCostSvcHandle{ 
    this, "TrigCostSvc", "TrigCostSvc", "The trigger cost service" };
 
  /*------------------------+
   * Methods acting on ROBs |
   *------------------------+ 
   */
  bool robmap_filterRobWithStatus(const ROBF*);

  robmonitor::ROBDataStruct robmap_getRobData(const ROBF&, robmonitor::ROBHistory) ;
 
  /*------------------------------+
   * Methods acting on EventCache |
   *------------------------------+ 
   */
  void eventCache_clear(EventCache*);

  void eventCache_checkRobListToCache(EventCache*, const std::vector<uint32_t>&, 
                      std::vector<const ROBF*>&, std::vector<uint32_t>&, 
              std::optional<std::reference_wrapper<std::set<uint32_t>>> robIds_disabled = std::nullopt);

  void eventCache_addRobData(EventCache*, std::vector<ROBF>&&,
              std::optional<std::reference_wrapper<std::set<uint32_t>>> robIds_ignored = std::nullopt) ;

  ToolHandle<GenericMonitoringTool> m_monTool{this, "MonTool", "", "Monitoring tool"};
};
 
#endif // TRIGSERVICES_HLTROBDATAPROVIDERSVC_H