Algorithm.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2026 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/IAlgorithm.h>
#include <GaudiKernel/IMessageSvc.h>
#include <GaudiKernel/IProperty.h>
#include <GaudiKernel/IService.h>
#include <GaudiKernel/IStateful.h>
#include <GaudiKernel/ISvcLocator.h>
#include <GaudiKernel/ITimelineSvc.h>
#include <string>
#include <vector>
 
// Extra include files (forward declarations should be sufficient)
#include <Gaudi/PluginService.h>
#include <Gaudi/Property.h>
#include <GaudiKernel/CommonMessaging.h>
#include <GaudiKernel/DataObjID.h> // must be include before Property.h, which is included in PropertyHolder.h
#include <GaudiKernel/IAlgContextSvc.h>
#include <GaudiKernel/IAuditorSvc.h>
#include <GaudiKernel/IChronoStatSvc.h>
#include <GaudiKernel/IConversionSvc.h>
#include <GaudiKernel/IDataProviderSvc.h>
#include <GaudiKernel/IExceptionSvc.h>
#include <GaudiKernel/IHistogramSvc.h>
#include <GaudiKernel/IHiveWhiteBoard.h>
#include <GaudiKernel/IMonitorSvc.h>
#include <GaudiKernel/INTupleSvc.h>
#include <GaudiKernel/IRndmGenSvc.h>
#include <GaudiKernel/IToolSvc.h>
#include <GaudiKernel/PropertyHolder.h>
#include <GaudiKernel/System.h>
#include <GaudiKernel/ToolHandle.h>
 
// For concurrency
#include <GaudiKernel/DataHandle.h>
#include <GaudiKernel/DataHandleHolderBase.h>
#include <GaudiKernel/EventContext.h>
#include <GaudiKernel/IAlgExecStateSvc.h>
 
class IAlgTool;
class ToolHandleInfo;
class AlgorithmManager;
 
#ifndef PACKAGE_VERSION
#  define PACKAGE_VERSION "unknown"
#endif
namespace Gaudi {
  namespace Details {
    bool getDefaultAuditorValue( ISvcLocator* loc );
  }

  class GAUDI_API Algorithm
      : public DataHandleHolderBase<
            PropertyHolder<CommonMessaging<implements<IAlgorithm, IDataHandleHolder, IProperty, IStateful>>>> {
  public:
#ifndef __REFLEX__
    typedef Gaudi::PluginService::Factory<IAlgorithm*( const std::string&, ISvcLocator* )> Factory;
#endif
    friend AlgorithmManager;

    Algorithm( std::string name, ISvcLocator* svcloc, std::string version = PACKAGE_VERSION )
        : m_name( std::move( name ) )
        , m_version( std::move( version ) ) // incremented by AlgResourcePool
        , m_pSvcLocator( svcloc ) {}

    StatusCode sysStart() override;

    StatusCode sysInitialize() override;

    StatusCode sysReinitialize() override;

    StatusCode sysRestart() override;

    StatusCode sysExecute( const EventContext& ctx ) override;

    StatusCode sysStop() override;

    StatusCode sysFinalize() override;

    const std::string&      name() const override;
    const Gaudi::StringKey& nameKey() const override;

    const std::string& type() const override { return m_type; }
    void setType( std::string type ) override { m_type = std::move( type ); } // BH, TODO: move to proper place
 
    const std::string& version() const override;
 
    unsigned int index() const override;

    StatusCode configure() override { return StatusCode::SUCCESS; }
    StatusCode terminate() override { return StatusCode::SUCCESS; }

    StatusCode initialize() override { return StatusCode::SUCCESS; }
    StatusCode start() override { return StatusCode::SUCCESS; }
    StatusCode stop() override { return StatusCode::SUCCESS; }
    StatusCode finalize() override { return StatusCode::SUCCESS; }
    StatusCode reinitialize() override;
    StatusCode restart() override;
    Gaudi::StateMachine::State FSMState() const override { return m_state; }
    Gaudi::StateMachine::State targetFSMState() const override { return m_targetState; }

    bool isEnabled() const override;

    bool isSequence() const override { return false; }

    unsigned int errorCount() const;

    SmartIF<IService> service( std::string_view name, const bool createIf = true, const bool quiet = false ) const;
 
    template <class T>
    SmartIF<T> service( std::string_view name, bool createIf = true, bool quiet = false ) const {
      return service( name, createIf, quiet ).as<T>();
    }

    SmartIF<IAuditorSvc>& auditorSvc() const;

    SmartIF<IChronoStatSvc>& chronoSvc() const;

    SmartIF<IDataProviderSvc>& detSvc() const;

    SmartIF<IConversionSvc>& detCnvSvc() const;

    SmartIF<IDataProviderSvc>& eventSvc() const;
    SmartIF<IDataProviderSvc>& evtSvc() const { return eventSvc(); }

    SmartIF<IConversionSvc>& eventCnvSvc() const;

    SmartIF<IHistogramSvc>& histoSvc() const;

    SmartIF<INTupleSvc>& ntupleSvc() const;

    SmartIF<IRndmGenSvc>& randSvc() const;

    SmartIF<IToolSvc>& toolSvc() const;

    SmartIF<IExceptionSvc>& exceptionSvc() const;

    SmartIF<IAlgContextSvc>& contextSvc() const;
 
    SmartIF<ITimelineSvc>& timelineSvc() const;

    SmartIF<ISvcLocator>& serviceLocator() const override;
    SmartIF<ISvcLocator>& svcLoc() const { return serviceLocator(); }
 
    SmartIF<IHiveWhiteBoard>& whiteboard() const;
 
    SmartIF<IAlgExecStateSvc>& algExecStateSvc() const;

    bool registerContext() const { return m_registerContext; }
 
    using PropertyHolderImpl::declareProperty;
 
    // declare Tools to the Algorithms
    template <class T>
    Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ToolHandle<T>& hndl,
                                                   const std::string& doc = "none" ) {
      this->declareTool( hndl, hndl.typeAndName() ).ignore();
      return PropertyHolderImpl::declareProperty( name, hndl, doc );
    }
 
    // declare ToolHandleArrays to the Algorithms
 
    template <class T>
    Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ToolHandleArray<T>& hndlArr,
                                                   const std::string& doc = "none" ) {
      addToolsArray( hndlArr );
      return PropertyHolderImpl::declareProperty( name, hndlArr, doc );
    }

    SmartIF<IMonitorSvc>& monitorSvc() const {
      // If not already located try to locate it without forcing a creation
      if ( !m_pMonitorSvc ) {
        m_pMonitorSvc = service( m_monitorSvcName, false, true ); // do not create and be quiet
      }
      return m_pMonitorSvc;
    }

    template <class T>
    void declareInfo( const std::string& name, const T& var, const std::string& desc ) const {
      IMonitorSvc* mS = monitorSvc().get();
      if ( mS ) mS->declareInfo( name, var, desc, this );
    }

    void declareInfo( const std::string& name, const std::string& format, const void* var, int size,
                      const std::string& desc ) const {
      IMonitorSvc* mS = monitorSvc().get();
      if ( mS ) mS->declareInfo( name, format, var, size, desc, this );
    }
 
  public:
    void acceptDHVisitor( IDataHandleVisitor* ) const override;
 
    void registerTool( IAlgTool* tool ) const;
    void deregisterTool( IAlgTool* tool ) const;
 
    template <class T>
    StatusCode declareTool( ToolHandle<T>& handle, bool createIf = true ) {
      return this->declareTool( handle, handle.typeAndName(), createIf );
    }
 
    template <class T>
    StatusCode declareTool( ToolHandle<T>& handle, const std::string& toolTypeAndName, bool createIf = true ) {
 
      StatusCode sc = handle.initialize( toolTypeAndName, handle.isPublic() ? nullptr : this, createIf );
      if ( !sc ) {
        throw GaudiException{ std::string{ "Cannot create handle for " } +
                                  ( handle.isPublic() ? "public" : "private" ) + " tool " + toolTypeAndName,
                              name(), sc };
      }
 
      m_toolHandles.push_back( &handle );
 
      return sc;
    }
 
    template <class T>
    void addToolsArray( ToolHandleArray<T>& hndlArr ) {
      m_toolHandleArrays.push_back( &hndlArr );
    }
 
    const std::vector<IAlgTool*>& tools() const;
 
    // Return the asynchronous flag
    bool isAsynchronous() const { return m_asynchronous; }
    // Set the asynchronous flag
    void setAsynchronous( bool value ) { m_asynchronous = value; }
 
  protected:
    // Disable synchronous timeline recording and return if it was enabled before
    bool setAsynchronousTimeline() { return std::exchange( m_doTimeline, false ); }
 
    std::vector<IAlgTool*>& tools();
 
    // // adds declared in- and outputs of subAlgorithms to own DOHs
    //  void addSubAlgorithmDataObjectHandles();
 
  private:
    // place IAlgTools defined via ToolHandles in m_tools
    void initToolHandles() const;
 
  public:
    // /// Specifies the clonability of the algorithm
    // bool isClonable() const override { return false; }

    unsigned int cardinality() const override { return m_cardinality; }
 
    const AlgResources_t& neededResources() const override { return m_neededResources; }
 
  protected:
    bool isInitialized() const override { return Gaudi::StateMachine::INITIALIZED == m_state; }

    bool isFinalized() const override { return Gaudi::StateMachine::CONFIGURED == m_state; }

    void setIndex( const unsigned int& idx ) override;
 
  public:
    AlgExecStateRef execState( const EventContext& ctx ) const override;

    std::ostream& toControlFlowExpression( std::ostream& os ) const override;
 
  protected:
    bool isReEntrant() const override { return true; }
 
  private:
    Gaudi::StringKey m_name;      
    std::string      m_type;      
    std::string      m_version;   
    unsigned int     m_index = 0; 

    AlgExecStateRef::AlgKey m_execSvcKey;
 
    // tools used by algorithm
    mutable std::vector<IAlgTool*>             m_tools;
    mutable std::vector<BaseToolHandle*>       m_toolHandles;
    mutable std::vector<GaudiHandleArrayBase*> m_toolHandleArrays;
 
  private:
    template <typename IFace>
    SmartIF<IFace>& get_svc_( SmartIF<IFace>& p, const char* service_name ) const;
 
    mutable SmartIF<IMessageSvc>      m_MS;          
    mutable SmartIF<IDataProviderSvc> m_EDS;         
    mutable SmartIF<IHiveWhiteBoard>  m_WB;          
    mutable SmartIF<IConversionSvc>   m_ECS;         
    mutable SmartIF<IDataProviderSvc> m_DDS;         
    mutable SmartIF<IConversionSvc>   m_DCS;         
    mutable SmartIF<IHistogramSvc>    m_HDS;         
    mutable SmartIF<INTupleSvc>       m_NTS;         
    mutable SmartIF<IChronoStatSvc>   m_CSS;         
    mutable SmartIF<IRndmGenSvc>      m_RGS;         
    mutable SmartIF<IExceptionSvc>    m_EXS;         
    mutable SmartIF<IAuditorSvc>      m_pAuditorSvc; 
    mutable SmartIF<IToolSvc>         m_ptoolSvc;    
    mutable SmartIF<IMonitorSvc>      m_pMonitorSvc; 
    mutable SmartIF<IAlgContextSvc>   m_contextSvc;  
 
    mutable SmartIF<ITimelineSvc>     m_timelineSvc; 
    mutable SmartIF<IAlgExecStateSvc> m_aess;        
 
    SmartIF<ISvcLocator> m_pSvcLocator; 
 
  protected:
    std::unique_ptr<IDataHandleVisitor> m_updateDataHandles;
 
  private:
    // Properties
    Gaudi::Property<int> m_outputLevel{
        this, "OutputLevel", MSG::NIL,
        [this]( Gaudi::Details::PropertyBase& ) { this->updateMsgStreamOutputLevel( this->m_outputLevel ); },
        "output level" };
    Gaudi::Property<bool> m_isEnabled{ this, "Enable", true, "should the algorithm be executed or not" };
 
    Gaudi::Property<bool> m_auditorInitialize{
        this, "AuditInitialize", Details::getDefaultAuditorValue( m_pSvcLocator ), "trigger auditor on initialize()" };
    Gaudi::Property<bool> m_auditorReinitialize{ this, "AuditReinitialize", m_auditorInitialize.value(),
                                                 "trigger auditor on reinitialize()" };
    Gaudi::Property<bool> m_auditorRestart{ this, "AuditRestart", m_auditorInitialize.value(),
                                            "trigger auditor on restart()" };
    Gaudi::Property<bool> m_auditorExecute{ this, "AuditExecute", m_auditorInitialize.value(),
                                            "trigger auditor on execute()" };
    Gaudi::Property<bool> m_auditorFinalize{ this, "AuditFinalize", m_auditorInitialize.value(),
                                             "trigger auditor on finalize()" };
    Gaudi::Property<bool> m_auditorStart{ this, "AuditStart", m_auditorInitialize.value(),
                                          "trigger auditor on start()" };
    Gaudi::Property<bool> m_auditorStop{ this, "AuditStop", m_auditorInitialize.value(), "trigger auditor on stop()" };
 
    Gaudi::Property<bool> m_doTimeline{ this, "Timeline", true, "send events to TimelineSvc" };
 
    Gaudi::Property<std::string> m_monitorSvcName{ this, "MonitorService", "MonitorSvc",
                                                   "name to use for Monitor Service" };
 
    Gaudi::Property<bool> m_registerContext{ this, "RegisterForContextService", false,
                                             "flag to enforce the registration for Algorithm Context Service" };
 
    Gaudi::Property<int>            m_cardinality{ this, "Cardinality", 0,
                                        "how many clones to create - 0 means algo is reentrant" };
    Gaudi::Property<AlgResources_t> m_neededResources{
        this, "NeededResources", {}, "named resources needed during event looping" };
 
    Gaudi::Property<bool> m_asynchronous{ this, "Asynchronous", false,
                                          "whether algorithm is asynchronous and uses Boost Fiber to suspend "
                                          "while offloaded code is running." };
    // The default should be changed to "false" for v29
    Gaudi::Property<bool> m_filterCircDeps{ this, "FilterCircularDependencies", true,
                                            "filter out circular data dependencies" };
 
    mutable bool m_toolHandlesInit = false; 
 
    Gaudi::StateMachine::State m_state       = Gaudi::StateMachine::CONFIGURED; 
    Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::CONFIGURED; 

    Algorithm( const Algorithm& ) = delete;

    Algorithm& operator=( const Algorithm& ) = delete;
  };
} // namespace Gaudi