Algorithm.h

Go to the documentation of this file.

#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/CounterHolder.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/Property.h"
#include "GaudiKernel/PropertyHolder.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/ToolHandle.h"
#include <Gaudi/PluginService.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<CounterHolder<
            PropertyHolder<CommonMessaging<implements<IAlgorithm, IDataHandleHolder, IProperty, IStateful>>>>> {
  public:
#ifndef __REFLEX__
    typedef Gaudi::PluginService::Factory<IAlgorithm*( const std::string&, ISvcLocator* )> Factory;
#endif
    friend AlgorithmManager;

    Algorithm( const std::string& name, ISvcLocator* svcloc, const std::string& version = PACKAGE_VERSION );

    StatusCode sysStart() override;

    StatusCode sysInitialize() override;

    StatusCode sysReinitialize() override;

    StatusCode sysRestart() override;

    StatusCode sysExecute( const EventContext& ctx ) override;

    StatusCode sysStop() override;

    StatusCode sysFinalize() override;

    StatusCode sysBeginRun() override;

    StatusCode sysEndRun() override;

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

    const std::string& type() const override { return m_type; }
    void               setType( const std::string& type ) override { m_type = 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; }

    [[deprecated( "try using Algorithm::Start instead" )]] StatusCode beginRun() override;

    [[deprecated( "try using Algorithm::Stop instead" )]] StatusCode endRun() override;

    bool isEnabled() const override;

    bool isSequence() const override { return false; }

    unsigned int errorCount() const;

    template <class T>
    StatusCode service( const std::string& name, T*& psvc, bool createIf = true ) const {
      return service_i( name, createIf, T::interfaceID(), (void**)&psvc );
    }

    template <class T>
    StatusCode service( const std::string& svcType, const std::string& svcName, T*& psvc ) const {
      return service_i( svcType, svcName, T::interfaceID(), reinterpret_cast<void**>( &psvc ) );
    }

    SmartIF<IService> service( const std::string& name, const bool createIf = true, const bool quiet = false ) const;

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

    SmartIF<IAuditorSvc>& auditorSvc() const;

    SmartIF<IChronoStatSvc>&                                             chronoSvc() const;
    [[deprecated( "use chronoSvc() instead" )]] SmartIF<IChronoStatSvc>& chronoStatService() const {
      return chronoSvc();
    }

    SmartIF<IDataProviderSvc>&                                          detSvc() const;
    [[deprecated( "use detSvc() instead" )]] SmartIF<IDataProviderSvc>& detDataService() const { return detSvc(); }

    SmartIF<IConversionSvc>&                                             detCnvSvc() const;
    [[deprecated( "use detCnvSvc() instead" )]] SmartIF<IConversionSvc>& detDataCnvService() const {
      return detCnvSvc();
    }

    SmartIF<IDataProviderSvc>& eventSvc() const;
    SmartIF<IDataProviderSvc>&                                            evtSvc() const { return eventSvc(); }
    [[deprecated( "use eventSvc() instead" )]] SmartIF<IDataProviderSvc>& eventDataService() const {
      return eventSvc();
    }

    SmartIF<IConversionSvc>&                                               eventCnvSvc() const;
    [[deprecated( "use eventCnvSvc() instead" )]] SmartIF<IConversionSvc>& eventDataCnvService() const {
      return eventCnvSvc();
    }

    SmartIF<IHistogramSvc>&                                            histoSvc() const;
    [[deprecated( "use histoSvc() instead" )]] SmartIF<IHistogramSvc>& histogramDataService() const {
      return histoSvc();
    }

    SmartIF<INTupleSvc>&                                             ntupleSvc() const;
    [[deprecated( "use ntupleSvc() instead" )]] SmartIF<INTupleSvc>& ntupleService() const { return ntupleSvc(); }

    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; }

    StatusCode setProperties();

    // ==========================================================================
    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 );
    }

    // ==========================================================================
    inline 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;

  public:
    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 ( UNLIKELY( !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 I/O-boundness flag
    bool isIOBound() const { return m_isIOBound; }
    // Set the I/O-boundness flag
    void setIOBound( bool value ) { m_isIOBound = 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_auditorBeginRun{this, "AuditBeginRun", m_auditInit.value(),
                                            "trigger auditor on beginRun()"};
    Gaudi::Property<bool> m_auditorEndRun{this, "AuditEndRun", m_auditInit.value(), "trigger auditor on endRun()"};
    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_isIOBound{this, "IsIOBound", false,
                                      "if the algorithm is I/O-bound (in the broad sense of Von Neumann bottleneck)"};

    // 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;                                   

    bool m_beginRunCalled;
    bool m_endRunCalled;

    StatusCode service_i( const std::string& svcName, bool createIf, const InterfaceID& iid, void** ppSvc ) const;
    StatusCode service_i( const std::string& svcType, const std::string& svcName, const InterfaceID& iid,
                          void** ppSvc ) const;

    Algorithm( const Algorithm& a ) = delete;

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