Algorithm.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2022 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 files
// ============================================================================
#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 "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"
#include <Gaudi/PluginService.h>
#include <Gaudi/Property.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;
 
    template <class T>
    StatusCode service( std::string_view name, T*& psvc, bool createIf = true ) const {
      return service_i( name, createIf, T::interfaceID(), (void**)&psvc );
    }
 
    template <class T>
    StatusCode service( std::string_view svcType, std::string_view svcName, T*& psvc ) const {
      return service_i( svcType, svcName, T::interfaceID(), reinterpret_cast<void**>( &psvc ) );
    }
 
    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, 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 blocking flag
    bool isBlocking() const { return m_blocking; }
    // Set the blocking flag
    void setBlocking( bool value ) { m_blocking = value; }
 
  protected:
    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 std::vector<std::string>& 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:
    AlgExecState& execState( const EventContext& ctx ) const override;
 
    std::ostream& toControlFlowExpression( std::ostream& os ) const override;
 
  private:
    unsigned int maxErrors() const { return m_errorMax; }
 
  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; 
 
    // 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<unsigned int> m_errorMax{ this, "ErrorMax", 1, "[[deprecated]] max number of errors" };
 
    Gaudi::Property<bool> m_auditInit{ this, "AuditAlgorithms", Details::getDefaultAuditorValue( m_pSvcLocator ),
                                       "[[deprecated]] unused" };
    Gaudi::Property<bool> m_auditorInitialize{ this, "AuditInitialize", m_auditInit.value(),
                                               "trigger auditor on initialize()" };
    Gaudi::Property<bool> m_auditorReinitialize{ this, "AuditReinitialize", m_auditInit.value(),
                                                 "trigger auditor on reinitialize()" };
    Gaudi::Property<bool> m_auditorRestart{ this, "AuditRestart", m_auditInit.value(), "trigger auditor on restart()" };
    Gaudi::Property<bool> m_auditorExecute{ this, "AuditExecute", m_auditInit.value(), "trigger auditor on execute()" };
    Gaudi::Property<bool> m_auditorFinalize{ this, "AuditFinalize", m_auditInit.value(),
                                             "trigger auditor on finalize()" };
    Gaudi::Property<bool> m_auditorStart{ this, "AuditStart", m_auditInit.value(), "trigger auditor on start()" };
    Gaudi::Property<bool> m_auditorStop{ this, "AuditStop", m_auditInit.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<std::vector<std::string>> m_neededResources{
        this, "NeededResources", {}, "named resources needed during event looping" };
 
    Gaudi::Property<bool> m_blocking{
        this, "Blocking", false,
        "if algorithm invokes CPU-blocking system calls (offloads computations to accelerators or "
        "quantum processors, performs disk or network I/O, is bound by resource synchronization, etc)" };
 
    // 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; 
    bool                       m_isFinalized;                                   
 
    StatusCode service_i( std::string_view svcName, bool createIf, const InterfaceID& iid, void** ppSvc ) const;
    StatusCode service_i( std::string_view svcType, std::string_view svcName, const InterfaceID& iid,
                          void** ppSvc ) const;
 
    Algorithm( const Algorithm& ) = delete;
 
    Algorithm& operator=( const Algorithm& ) = delete;
  };
} // namespace Gaudi