TrigCostSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGCOSTMONITOR_TRIGCOSTSVC_H
#define TRIGCOSTMONITOR_TRIGCOSTSVC_H
 
#include <atomic>
#include <shared_mutex>
#include <thread>
#include <vector>
 
#include "GaudiKernel/ToolHandle.h"
 
#include "AthenaBaseComps/AthService.h"
#include "AthContainers/ConstDataVector.h"
#include "StoreGate/WriteHandle.h"
 
#include "xAODTrigger/TrigCompositeContainer.h"
 
#include "TrigCostMonitor/ITrigCostSvc.h"
#include "AlgorithmPayload.h"
#include "TrigCostDataStore.h"

class TrigCostSvc : public extends <AthService, ITrigCostSvc> {
  public:

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

  virtual ~TrigCostSvc();

  virtual StatusCode initialize() override;

  virtual StatusCode finalize() override;

  virtual StatusCode startEvent(const EventContext& context, const bool enableMonitoring = true) override; 

  virtual StatusCode processAlg(const EventContext& context, const std::string& caller, const AuditType type) override; 

  virtual StatusCode endEvent(const EventContext& context, SG::WriteHandle<xAOD::TrigCompositeContainer>& costOutputHandle) override; 

  virtual bool isMonitoredEvent(const EventContext& context, const bool includeMultiSlot = true) const override;

  virtual StatusCode generateTimeoutReport(const EventContext& context, std::string& report) override;
 

  virtual StatusCode discardEvent(const EventContext& context) override;
 
  private: 

  StatusCode monitor(const EventContext& context, const AlgorithmIdentifier& ai, const TrigTimeStamp& now, const AuditType type);

  StatusCode checkSlot(const EventContext& context) const;

  int32_t getROIID(const EventContext& context);

  struct ThreadHashCompare {
    static size_t hash(const std::thread::id& thread);
    static bool equal(const std::thread::id& x, const std::thread::id& y);
  };
 
  size_t  m_eventSlots; 
  std::unique_ptr< std::atomic<bool>[] > m_eventMonitored; 
  std::unique_ptr< std::shared_mutex[] > m_slotMutex; 
  std::mutex m_globalMutex; 
  TrigCostDataStore<AlgorithmPayload> m_algStartInfo; 
  TrigCostDataStore<TrigTimeStamp> m_algStopTime; 
 
  tbb::concurrent_hash_map<std::thread::id, AlgorithmIdentifier, ThreadHashCompare> m_threadToAlgMap; 
 
  std::unordered_map<uint32_t, uint32_t> m_threadToCounterMap; 
  size_t m_threadCounter; 
 
 
  Gaudi::Property<bool>        m_monitorAllEvents{this, "MonitorAllEvents", false, "Monitor every HLT event, e.g. for offline validation."};
  Gaudi::Property<bool>        m_enableMultiSlot{this, "EnableMultiSlot", false, "Monitored events in the MasterSlot collect data from events running in other slots."};
  Gaudi::Property<bool>        m_saveHashes{this, "SaveHashes", false, "Store a copy of the hash dictionary for easier debugging"};
  Gaudi::Property<size_t>      m_masterSlot{this, "MasterSlot", 0, "The slot responsible for saving MultiSlot data"};
  Gaudi::Property<std::string> m_costSupervisorAlgName{this, "CostSupervisorAlgName", "TrigCostSupervisorAlg", "The name of cost monitoring supervising algorithm, starting at the begining of the event"};
  Gaudi::Property<std::string> m_costFinalizeAlgName{this, "CostFinalizeAlgName", "TrigCostFinalizeAlg", "The name of cost monitoring finalize algorithm, starting at the end of the event"};
 
 
};
 
#endif // TRIGCOSTMONITOR_TRIGCOSTSVC_H