CacheGlobalMemory.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGGER_DECISION_TOOL_CACHE_GLOBAL_MEMORY_H
#define TRIGGER_DECISION_TOOL_CACHE_GLOBAL_MEMORY_H
 
/**********************************************************************************
 * @Project: TrigDecisionTool
 * @Package: TrigDecisionTool
 * @class  : CacheGlobalMemory
 *
 * @brief registry for ChainGroups
 *
 * @author Michael Begel  <michael.begel@cern.ch> - Brookhaven National Laboratory
 *
 ***********************************************************************************/
 
#include<vector>
#include<set>
#include<map>
#include<unordered_map>
#include<string>
#include<mutex>
#include<memory>
 
#include "TrigConfHLTData/HLTChain.h"
#include "TrigConfHLTData/HLTChainList.h"
#include "TrigConfHLTData/HLTStreamTag.h"
 
#include "TrigConfL1Data/CTPConfig.h"
 
#include "TrigSteeringEvent/Chain.h"
#include "TrigSteeringEvent/Lvl1Item.h"
 
#include "TrigDecisionInterface/GroupProperties.h"
#include "TrigDecisionTool/IDecisionUnpacker.h"
#include "TrigDecisionTool/Logger.h"
 
#include "CxxUtils/checker_macros.h"
#include "AsgDataHandles/ReadHandleKey.h"
#include "AsgTools/EventStoreType.h"
 
#include "xAODTrigger/TrigCompositeContainer.h"
#include "xAODTrigger/TrigDecision.h"
#include "xAODTrigger/TrigNavigation.h"
 
#ifndef XAOD_ANALYSIS // Full Athena only
#include "EventInfo/EventInfo.h"
#include "TrigDecisionEvent/TrigDecision.h"
#endif
 
namespace HLT {
  class Chain;
  class TriggerElement;
}
 
namespace LVL1CTP {
  class Lvl1Result;
}
 
 
namespace Trig {
 
  class ChainGroup;
 
  class CacheGlobalMemory : public virtual Logger {
 
  public:
    // constructors, destructor
    CacheGlobalMemory() = default;
    ~CacheGlobalMemory() = default;

    const Trig::ChainGroup* createChainGroup(const std::vector< std::string >& patterns,
                                             const std::string& alias="",
                                             TrigDefs::Group props = TrigDefs::Group::Default) const;

    void update(const TrigConf::HLTChainList* confChains,
                const TrigConf::CTPConfig* ctp);
 
    const LVL1CTP::Lvl1Item* item(const std::string& name) const;            
    const LVL1CTP::Lvl1Item* item(const TrigConf::TriggerItem& i) const;     
    const TrigConf::TriggerItem* config_item(const std::string& name) const; 
    float item_prescale(int ctpid) const;                                      
 
    const HLT::Chain* chain(const std::string& name) const;                  
    const HLT::Chain* chain(const TrigConf::HLTChain& chIt) const;           
    const TrigConf::HLTChain* config_chain(const std::string& name) const;   
 
    const HLT::TrigNavStructure* navigation() const {   
      /*
        Assumed intentional (cid 24125)
        Accessing this->m_navigationUnpacked without holding lock 
        Trig::CacheGlobalMemory.m_cgmMutex. Elsewhere, 
        Trig::CacheGlobalMemory.m_navigationUnpacked is written to with 
        CacheGlobalMemory.m_cgmMutex held 1 out of 2 times
      */
      //coverity[MISSING_LOCK]
      if(!m_navigationUnpacked){
        // CGM is slot-specific and unpackNavigation is locked
        auto cgm ATLAS_THREAD_SAFE = const_cast<CacheGlobalMemory*>(this);
        if(cgm->unpackNavigation().isFailure()){
          ATH_MSG_WARNING("unpack Navigation failed");
        }
      }
      return m_navigation;
    }
    void navigation(HLT::TrigNavStructure* nav) { m_navigation = nav; }       
 
    const Trig::ChainGroup* getChainGroup (const std::vector<std::string>& triggerNames,
                                           TrigDefs::Group props) const;
    size_t nChainGroups() const;
    const std::map<std::string, std::vector<std::string> >& getStreams() const {return m_streams;};

    bool assert_decision() const;

    void reset_decision();

    void setStore( asg::EventStoreType* store ) { m_store = store; }
    const asg::EventStoreType* store() const { return m_store; }
 
    void setDecisionKeyPtr(SG::ReadHandleKey<xAOD::TrigDecision>* k) { m_decisionKeyPtr = k; }
    void setRun2NavigationKeyPtr(SG::ReadHandleKey<xAOD::TrigNavigation>* k) { m_run2NavigationKeyPtr = k; }
    void setRun3NavigationKeyPtr(SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer>* k) { m_run3NavigationKeyPtr = k; }
    const SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer>& getRun3NavigationKey() const { return *m_run3NavigationKeyPtr; }
    const SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer>* getRun3NavigationKeyPtr() const { return m_run3NavigationKeyPtr; }
 
#ifndef XAOD_ANALYSIS // Full Athena only
    void setOldDecisionKeyPtr(SG::ReadHandleKey<TrigDec::TrigDecision>* k) { m_oldDecisionKeyPtr = k; }
    void setOldEventInfoKeyPtr(SG::ReadHandleKey<EventInfo>* k) { m_oldEventInfoKeyPtr = k; }
#endif
 
    const SG::ReadHandleKey<xAOD::TrigDecision>* xAODTrigDecisionKey() const { return m_decisionKeyPtr; }
 
    //
    template<class T>
    void deleteAtTheEndOfEvent(T t) const { m_deleteAtEndOfEvent.insert(t); }
 
 
 
 
  private:
    friend class DecisionAccess;

    StatusCode unpackDecision(const EventContext& ctx);
    StatusCode unpackNavigation();

    void updateChainGroup(Trig::ChainGroup& chainGroup,
                          TrigDefs::Group props = TrigDefs::Group::Default);
 
    //
    // Data members
    //

    const asg::EventStoreType* m_store{nullptr};

    mutable std::unique_ptr<IDecisionUnpacker> m_unpacker ATLAS_THREAD_SAFE;  // for assert_decision
 
    bool m_decisionUnpacked{false};   
    bool m_navigationUnpacked{false}; 

    HLT::TrigNavStructure* m_navigation{nullptr};
 
    // chain groups (protected by mutex)
    mutable std::map< std::vector< std::string >, Trig::ChainGroup > m_chainGroups ATLAS_THREAD_SAFE;     
    mutable std::map< std::vector< std::string >, Trig::ChainGroup* > m_chainGroupsRef ATLAS_THREAD_SAFE; 
 
    std::unordered_map<std::string, const LVL1CTP::Lvl1Item*> m_itemsByName;     
    std::unordered_map<std::string, const HLT::Chain*> m_l2chainsByName;  
    std::unordered_map<std::string, const HLT::Chain*> m_efchainsByName;  
 
    typedef unsigned CTPID;
    typedef unsigned CHAIN_COUNTER;
    std::map<CTPID, LVL1CTP::Lvl1Item>  m_itemsCache;               
    std::map<CHAIN_COUNTER, HLT::Chain> m_l2chainsCache;            
    std::map<CHAIN_COUNTER, HLT::Chain> m_efchainsCache;            
 
    std::map<std::string, std::vector<std::string> > m_groups;          
    std::map<std::string, std::vector<std::string> > m_streams;         
 
    const TrigConf::ItemContainer* m_confItems{nullptr};             
    const TrigConf::HLTChainList*  m_confChains{nullptr};            
 
    SG::ReadHandleKey<xAOD::TrigDecision>* m_decisionKeyPtr{nullptr}; 
 
#ifndef XAOD_ANALYSIS // Full Athena
    SG::ReadHandleKey<TrigDec::TrigDecision>* m_oldDecisionKeyPtr{nullptr}; 
    SG::ReadHandleKey<EventInfo>* m_oldEventInfoKeyPtr{nullptr}; 
#endif
 
    SG::ReadHandleKey<xAOD::TrigNavigation>* m_run2NavigationKeyPtr{nullptr}; 
    SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer>* m_run3NavigationKeyPtr{nullptr}; 
 
    typedef std::unordered_map<std::string, const TrigConf::HLTChain*> ChainHashMap_t;
    ChainHashMap_t     m_mConfChains;            
 
    char     m_bgCode{0}; 
 
 
    class AnyTypeDeleter {
 
 
      struct iholder {
        virtual ~iholder() {}
        virtual const void* ptr() const { return nullptr;}
      };
 
      struct holder_comp {
        bool operator()(iholder* lhs, iholder* rhs) const {
          return lhs->ptr() < rhs->ptr(); }
      };
      template<class T>
      class holder : public iholder {
      public:
        holder(T& t): m_held(t) {}
        virtual ~holder() {
          delete m_held;
          m_held = 0; }
        virtual const void* ptr() const { return m_held;}
      private:
        T m_held;
      };
 
    public:
      template<class T>
      void insert(T t) {
        m_todel.insert(new holder<T>(t));
      }
      void clear() {
        for(iholder* i : m_todel) {
          delete i;
        }
        m_todel.clear();
      }
      ~AnyTypeDeleter();
    private:
      std::set< iholder*, holder_comp > m_todel;
    };  // end of deleter
 
    // Thread-safe because CacheGlobalMemory is slot-specific
    mutable AnyTypeDeleter m_deleteAtEndOfEvent ATLAS_THREAD_SAFE;
 
    mutable std::recursive_mutex m_cgmMutex; 
 
 
 
  };
} // End of namespace
 
#endif