DataOnDemandSvc.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/ChronoEntity.h>
#include <GaudiKernel/IDODAlgMapper.h>
#include <GaudiKernel/IDODNodeMapper.h>
#include <GaudiKernel/IIncidentListener.h>
#include <GaudiKernel/Service.h>
#include <GaudiKernel/StatEntity.h>
#include <GaudiKernel/StringKey.h>
#include <TClass.h>
#include <map>
#include <vector>
 
class IAlgTool;
class IAlgorithm;
class IAlgManager;
class IIncidentSvc;
class IDataProviderSvc;
class IToolSvc;
 
class DataOnDemandSvc : public extends<Service, IIncidentListener> {
public:
  typedef std::vector<std::string> Setup;
  typedef TClass*                  ClassH;
 
  struct Protection {
    bool& m_bool;
    Protection( bool& b ) : m_bool( b ) { m_bool = true; }
    ~Protection() { m_bool = false; }
  };
  struct Node final {
    ClassH        clazz; // the actual class
    std::string   name;
    unsigned long num       = 0;
    bool          executing = false;
    bool dataObject = false; // trivial object? DataObject?
 
    Node() = default;
 
    Node( ClassH c, bool e, std::string n )
        : clazz( c ), name( std::move( n ) ), executing( e ), dataObject( "DataObject" == name ) {}
  };
  struct Leaf {
    IAlgorithm*   algorithm = nullptr;
    std::string   name;
    std::string   type;
    unsigned long num                = 0;
    bool          executing          = false;
    Leaf()                           = default;
    Leaf( const Leaf& l )            = default;
    Leaf& operator=( const Leaf& l ) = default;
    Leaf( std::string t, std::string n ) : name( std::move( n ) ), type( std::move( t ) ) {}
  };
 
public:
  typedef GaudiUtils::HashMap<Gaudi::StringKey, Node> NodeMap;
  typedef GaudiUtils::HashMap<Gaudi::StringKey, Leaf> AlgMap;
  StatusCode initialize() override;
  StatusCode finalize() override;
  StatusCode reinitialize() override;
  void handle( const Incident& incident ) override;
  using extends::extends;
 
protected:
  StatusCode configureHandler( Leaf& leaf );
  StatusCode execHandler( const std::string& tag, Leaf& leaf );
  StatusCode execHandler( const std::string& tag, Node& node );
  StatusCode setupNodeHandlers();
  StatusCode setupAlgHandlers();
  StatusCode setup();
  void i_setNodeHandler( const std::string& name, const std::string& type );
  StatusCode i_setAlgHandler( const std::string& name, const Gaudi::Utils::TypeNameString& alg );
 
protected:
  StatusCode update();
  void dump( const MSG::Level level, const bool mode = true ) const;
 
private:
  void force_update( Gaudi::Details::PropertyBase& p ) {
    verbose() << "updated property " << p.name() << ", forcing update" << endmsg;
    m_updateRequired = true;
  };
  void deprecated_property( Gaudi::Details::PropertyBase& p ) {
    warning() << p.name() << " " << p.documentation() << endmsg;
    force_update( p );
  };
 
  SmartIF<IIncidentSvc> m_incSvc = nullptr;
  SmartIF<IAlgManager> m_algMgr = nullptr;
  SmartIF<IDataProviderSvc> m_dataSvc = nullptr;
  SmartIF<IToolSvc> m_toolSvc;
  AlgMap m_algs;
  NodeMap m_nodes;
 
  bool m_updateRequired = true;
 
  ChronoEntity       m_total;
  unsigned long long m_statAlg  = 0;
  unsigned long long m_statNode = 0;
  unsigned long long m_stat     = 0;
 
  ChronoEntity m_timer_nodes;
  ChronoEntity m_timer_algs;
  ChronoEntity m_timer_all;
  bool         m_locked_nodes = false;
  bool         m_locked_algs  = false;
  bool         m_locked_all   = false;
 
  std::vector<IDODNodeMapper*> m_nodeMappers;
  std::vector<IDODAlgMapper*>  m_algMappers;
 
  Gaudi::Property<std::string> m_trapType{ this, "IncidentName", "DataFault", "the type of handled Incident" };
  Gaudi::Property<std::string> m_dataSvcName{ this, "DataSvc", "EventDataSvc", "DataSvc name" };
 
  Gaudi::Property<bool> m_partialPath{ this, "UsePreceedingPath", true, "allow creation of partial leaves" };
  Gaudi::Property<bool> m_dump{
      this, "Dump", false,
      [this]( auto& ) {
        if ( m_dump && FSMState() >= Gaudi::StateMachine::INITIALIZED ) { dump( MSG::ALWAYS ); }
      },
      "dump configuration and stastics, if set to True after initialize it triggers a dump immediately" };
  Gaudi::Property<bool> m_init{ this, "PreInitialize", false, "(pre)initialize all algorithms" };
  Gaudi::Property<bool> m_allowInitFailure{
      this, "AllowPreInitializeFailure", false,
      "allow (pre)initialization of algorithms to fail without stopping the application" };
 
  Gaudi::Property<Setup> m_algMapping{
      this, "Algorithms", {}, &DataOnDemandSvc::deprecated_property, "[[deprecated]] use AlgMap" };
  Gaudi::Property<Setup> m_nodeMapping{
      this, "Nodes", {}, &DataOnDemandSvc::deprecated_property, "[[deprecated]] use NodeMap" };
 
  typedef std::map<std::string, std::string> Map;
  Gaudi::Property<Map> m_algMap{ this, "AlgMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'algorithm'}" };
  Gaudi::Property<Map> m_nodeMap{ this, "NodeMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'type'}" };
 
  Gaudi::Property<std::string> m_prefix{ this, "Prefix", "/Event/" };
 
  Gaudi::Property<std::vector<std::string>> m_nodeMapTools{
      this, "NodeMappingTools", {}, "list of tools of type IDODNodeMapper" };
  Gaudi::Property<std::vector<std::string>> m_algMapTools{
      this, "AlgMappingTools", {}, "list of tools of type IDODAlgMapper" };
};