PerfMonSvc.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
// PerfMonSvc.h 
// Header file for class PerfMonSvc
// Author: S.Binet<binet@cern.ch>
#ifndef PERFMONCOMPS_PERFMONSVC_H 
#define PERFMONCOMPS_PERFMONSVC_H 1
 
// Local includes
#include "LinFitSglPass.h"
 
// C includes
#include <stdio.h>
 
// STL includes
#include <string>
#include <iosfwd>
#include <unordered_map>
 
// FrameWork includes
#include "GaudiKernel/INamedInterface.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/StatEntity.h"
#include "GaudiKernel/IIoComponent.h"
#include "AthenaBaseComps/AthService.h"
#include "CxxUtils/checker_macros.h"
 
// PerfMonKernel includes
#include "PerfMonKernel/IPerfMonSvc.h"
 
// PerfMonEvent includes
#include "PerfMonEvent/DataModel.h"
 
// Forward declaration
class ISvcLocator;
template <class TYPE> class SvcFactory;
class IChronoStatSvc;
class StoreGateSvc;
struct _object; typedef _object PyObject;
 
namespace PerfMon {
  struct Tuple
  {
    typedef std::unordered_map<std::string,  PerfMon::Component> CompStore_t;
    typedef std::unordered_map<std::string,PerfMon::IoContainer> IoCompStore_t;
  
    typedef std::unordered_map<std::string,  CompStore_t> CompTuple_t;
    typedef std::unordered_map<std::string,IoCompStore_t> IoCompTuple_t;
 
    CompTuple_t comp;
    IoCompTuple_t iocomp;
  };
} //> namespace PerfMon
 
namespace PMonSD { class SemiDetHelper; }
 
class ATLAS_NOT_THREAD_SAFE PerfMonSvc : virtual public IPerfMonSvc,
                                         virtual public IIncidentListener,
                                         virtual public IIoComponent,
                                         public AthService
{ 
 
protected:
    
  friend class SvcFactory<PerfMonSvc>;
 
  // Public methods: 
public: 
 
  // Copy constructor: 
 
  PerfMonSvc( const std::string& name, ISvcLocator* pSvcLocator );
 
  virtual ~PerfMonSvc(); 
 
 
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
  virtual StatusCode queryInterface( const InterfaceID& riid, 
                                     void** ppvInterface ) override;
 
 
 
  virtual
  StatusCode io_reinit() override final;
  virtual
  StatusCode io_finalize() override final;
 
  // Const methods: 
 
  virtual
  std::vector<std::string>
  components(const std::string& stepName) const override;
 
  virtual
  std::vector<std::string>
  io_components() const override;
 
  virtual
  const PerfMon::Component*
  component(const std::string& stepName,
            const std::string& compName) const override;
 
  virtual
  const PerfMon::IoContainer*
  io_component(const std::string& compName) const override;
 
  virtual
  void
  domain(const std::string& compName, std::string& domain) const override;
 
  // Non-const methods: 
 
  static const InterfaceID& interfaceID();
 
  virtual
  void handle( const Incident& incident ) override;
 
  virtual void declareInfo( const std::string& name, 
                            const bool& var, 
                            const std::string& desc, 
                            const IInterface* owner ) override;
  virtual void declareInfo( const std::string& name, 
                            const int& var, 
                            const std::string& desc,  
                            const IInterface* owner ) override;
  virtual void declareInfo( const std::string& name, 
                            const long& var, 
                            const std::string& desc, 
                            const IInterface* owner ) override;
  virtual void declareInfo( const std::string& name, 
                            const double& var, 
                            const std::string& desc, 
                            const IInterface* owner ) override;
  virtual void declareInfo( const std::string& name, 
                            const std::string& var, 
                            const std::string& desc, 
                            const IInterface* owner ) override;
  virtual void declareInfo( const std::string& name, 
                            const std::pair<double,double>& var, 
                            const std::string& desc, 
                            const IInterface* owner ) override;
  virtual void declareInfo( const std::string& name, 
                            const AIDA::IBaseHistogram* var, 
                            const  std::string& desc, 
                            const IInterface* owner ) override;
  virtual void declareInfo( const std::string& name, 
                            const std::string& format, 
                            const void * var, int size, 
                            const std::string& desc, 
                            const IInterface* owner ) override;
  virtual void declareInfo(const std::string& name, 
                           const StatEntity& var, 
                           const std::string& desc, 
                           const IInterface* owner) override;
 
  virtual void undeclareInfo( const std::string& name, 
                              const IInterface* owner ) override;
  virtual void undeclareAll( const IInterface* owner ) override;
 
  virtual std::set<std::string>* getInfos( const IInterface* owner ) override;
 
 
  void startAud( const std::string& stepName, const std::string& compName ) override;
 
  void stopAud ( const std::string& stepName, const std::string& compName ) override;
 
  // Private methods: 
private: 
 
  PerfMonSvc();
 
  void setupProfiledAlgList( Gaudi::Details::PropertyBase& profiledAlgNames );
 
  void setupIoContainerList( Gaudi::Details::PropertyBase& ioContainerNames );
 
  void poll();
 
  void comp_startAud(const std::string& stepName, 
                     const std::string& compName);
 
  void comp_stopAud(const std::string& stepName, 
                    const std::string& compName);
 
  void do_io_mon();
 
  void postFinalize();
 
  // Private data: 
private: 
 
  PyObject* m_pySvc;
 
  ServiceHandle<IChronoStatSvc> m_chrono;
 
  DoubleProperty m_deltaVMemAlert;
 
  StringArrayProperty m_profiledAlgNames;
 
  StringArrayProperty m_ioContainerNames;
 
  StringProperty m_outFileName;
 
  BooleanProperty m_enableDblCountingCorrection;
 
  int m_monLvl;
 
  StringProperty m_shelveFileName;
 
  int m_semiDetMonLvl;
 
  std::string m_jobStartJiffies;
 
  //Trigger tons of extra printouts, before and after each component
  bool m_extraPrintouts;
 
  PerfMon::Tuple m_ntuple;
 
  float m_firstVmem;
 
  float m_10evtVmem;
 
  float m_lastVmem;
 
  PerfMon::LinFitSglPass m_vmemfit_evt2to20;
  PerfMon::LinFitSglPass m_vmemfit_evt21to100;
  PerfMon::LinFitSglPass m_vmemfit_evt101plus;
 
  int m_stream;
 
  std::string m_workerDir;
 
  long m_nevts;
 
  std::size_t m_nalgs;
 
  struct Stats_t {
    StatEntity cpu;
    StatEntity cpu_user;
    StatEntity cpu_sys;
    StatEntity real;
    StatEntity vmem;
    StatEntity malloc;
    StatEntity nalloc;
    StatEntity rt;
  };
  typedef std::unordered_map<std::string, Stats_t>    StatStore_t;
  StatStore_t m_stats;
 
  // a struct which shadows PerfMon::Mem to correct for double counting
  // memory-related resources in possible deeply nested callgraphs 
  struct CgHandler {
    float vmem;
    float rss;
    float mall;
    float nmall;
    float nfree;
 
    CgHandler() :
      vmem(0.), rss(0.), mall(0.), nmall(0.), nfree(0.)
    {}
  };
  CgHandler m_corrector;
 
  //PMonSD:
  PMonSD::SemiDetHelper * m_pmonsd;
 
  bool m_pf;
 
private:
 
  // In serial Athena each job starts w/ Before AthMasterSeq Execute auditor call
  // and ends w/ After AthMasterSeq Execute auditor call. However, in MT this is
  // not the case. Although this Service is not MT-safe (see PerfMonMTSvc)
  // we still use it in MT = 1 jobs. There we use the incident algorithms as a
  // workaround.
 
  // Component name that'll trigger begin event
  Gaudi::Property<std::string> m_compBeginEvent {
    this, "compBeginEvent", "AthMasterSeq", "Component name that'll trigger begin event" };
 
  // Component name that'll trigger end event
  Gaudi::Property<std::string> m_compEndEvent {
    this, "compEndEvent", "AthMasterSeq", "Component name that'll trigger end event" };
}; 
 
 
inline const InterfaceID& PerfMonSvc::interfaceID() 
{ 
  return IPerfMonSvc::interfaceID(); 
}
 
#endif //> PERFMONCOMPS_PERFMONSVC_H