PerfMonMTSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
/*
 * @authors: Alaettin Serhan Mete, Hasan Ozturk - alaettin.serhan.mete@cern.ch, haozturk@cern.ch
 */
 
#ifndef PERFMONCOMPS_PERFMONMTSVC_H
#define PERFMONCOMPS_PERFMONMTSVC_H
 
// Thread-safety-checker
#include "CxxUtils/checker_macros.h"
 
// Framework includes
#include "AthenaBaseComps/AthService.h"
#include "GaudiKernel/IIncidentListener.h"
 
// PerfMonKernel includes
#include "PerfMonKernel/IPerfMonMTSvc.h"
 
// PerfMonComps includes
#include "LinFitSglPass.h"
#include "PerfMonMTUtils.h"
 
// Containers
#include <set>
#include <map>
#include <vector>
 
 
// Input/Output includes
#include <nlohmann/json.hpp>
 
// Other Libraries
 
 
#include <memory>
#include <mutex>
 
class PerfMonMTSvc : public extends<AthService, IPerfMonMTSvc, IIncidentListener> {
 public:
  PerfMonMTSvc(const std::string& name, ISvcLocator* pSvcLocator);
 
  // Destructor
  virtual ~PerfMonMTSvc() = default;
 
  virtual void handle( const Incident& incident ) override;
 
  virtual StatusCode initialize() override;
 
  virtual StatusCode finalize() override;
 
  virtual void startAud(const std::string& stepName, const std::string& compName) override;
 
  virtual void stopAud(const std::string& stepName, const std::string& compName) override;
 
  void startSnapshotAud(const std::string& stepName, const std::string& compName);
  void stopSnapshotAud(const std::string& stepName, const std::string& compName);
 
  void startCompAud(const std::string& stepName, const std::string& compName, const EventContext& ctx);
  void stopCompAud(const std::string& stepName, const std::string& compName, const EventContext& ctx);
 
  void report();
 
  void report2Log();
  void report2Log_Description() const;
  void report2Log_ComponentLevel();
  void report2Log_EventLevel_instant() const;
  void report2Log_EventLevel();
  void report2Log_Summary();  // make it const
  void report2Log_CpuInfo() const;
  void report2Log_EnvInfo() const;
 
  void report2JsonFile();
  void report2JsonFile_Summary(nlohmann::json& j) const;
  void report2JsonFile_ComponentLevel(nlohmann::json& j) const;
  void report2JsonFile_EventLevel(nlohmann::json& j) const;
 
  void aggregateSlotData();
  void divideData2Steps();
 
  std::string scaleTime(double timeMeas) const;
  std::string scaleMem(int64_t memMeas) const;
 
  std::string get_info_from_file(const std::string& fileName, const std::string& fieldName) const;
  std::string get_cpu_model_info() const;
  int get_cpu_core_info() const;
  uint64_t get_memory_info() const;
 
  PMonMT::StepComp generate_state(const std::string& stepName, const std::string& compName) const;
 
 private:
  PMonMT::SnapshotMeasurement m_measurementSnapshots;
 
  PMonMT::SnapshotMeasurement m_measurementEvents;
 
  Gaudi::Property<bool> m_doEventLoopMonitoring{
      this, "doEventLoopMonitoring", true,
      "True if event loop monitoring is enabled, false o/w. Event loop monitoring may cause a decrease in the "
      "performance due to the usage of locks."};
  Gaudi::Property<bool> m_doComponentLevelMonitoring{
      this, "doComponentLevelMonitoring", false,
      "True if component level monitoring is enabled, false o/w. Component monitoring may cause a decrease in the "
      "performance due to the usage of locks."};
  Gaudi::Property<bool> m_reportResultsToJSON{this, "reportResultsToJSON", true, "Report results into the json file."};
  Gaudi::Property<std::string> m_jsonFileName{this, "jsonFileName", "PerfMonMTSvc_result.json",
                                              "Name of the JSON file that contains the results."};
  Gaudi::Property<bool> m_printDetailedTables{this, "printDetailedTables", true,
                                              "Print detailed component-level metrics."};
  Gaudi::Property<uint64_t> m_memFitLowerLimit{
      this, "memFitLowerLimit", 25,
      "Lower limit (in number of events) for the memory fit."};
  Gaudi::Property<uint64_t> m_checkPointThreshold{
      this, "checkPointThreshold", 30,
      "Least amount of time (in seconds) between event-level checks."};
  Gaudi::Property<double> m_wallTimeOffset{this, "wallTimeOffset", 0, "Job start wall time in miliseconds."};
  Gaudi::Property<int> m_printNComps{
      this, "printNComps", 50, "Maximum number of components to be printed."};
  Gaudi::Property<int> m_numberOfThreads{this, "numberOfThreads", 1, "Number of threads in the job."};
  Gaudi::Property<int> m_numberOfSlots{this, "numberOfSlots", 1, "Number of slots in the job."};
  Gaudi::Property<uint64_t> m_eventLoopMsgLimit{this, "eventLoopMsgLimit", 10, "Maximum number of event-level messages."};
 
  const std::set<std::string> m_exclusionSet = {"AthMasterSeq", "AthAlgEvtSeq", "AthAllAlgSeq", "AthAlgSeq", "AthOutSeq",
    "AthCondSeq", "AthBeginSeq", "AthEndSeq", "AthenaEventLoopMgr", "AthenaHiveEventLoopMgr", "AthMpEvtLoopMgr", "AthenaMtesEventLoopMgr",
    "PerfMonMTSvc"};
 
  int m_motherPID;
  std::vector<PMonMT::SnapshotData> m_snapshotData;
  std::vector<std::string> m_snapshotStepNames = {"Configure", "Initialize", "FirstEvent", "Execute", "Finalize"};
  enum Snapshots {CONFIGURE, INITIALIZE, FIRSTEVENT, EXECUTE, FINALIZE, NSNAPSHOTS};
 
  // Store event level measurements
  PMonMT::EventLevelData m_eventLevelData{};
 
  // Lock for capturing event loop measurements
  std::mutex m_mutex_capture;
 
  // Are we processing the first event?
  std::atomic<bool> m_isFirstEvent;
 
  // Count the number of events processed
  std::atomic<uint64_t> m_eventCounter;
 
  // Instant event-loop report counter
  std::atomic<uint64_t> m_eventLoopMsgCounter;
 
  // The last event-level measurement time in seconds
  std::atomic<double> m_checkPointTime;
 
  // This flag protects against double stopping the event loop measurement
  std::atomic<bool> m_isEvtLoopStopped;
 
  /*
   * Data structure  to store component level measurements
   */
  typedef std::map<PMonMT::StepComp, PMonMT::ComponentData*> data_map_t;
  typedef std::map<PMonMT::StepComp, std::unique_ptr<PMonMT::ComponentData>> data_map_unique_t;
  // Here I'd prefer to use SG::SlotSpecificObj<data_map_t>
  // However, w/ invalid context it seems to segfault
  // Can investigate in the future, for now std::vector should be OK
  data_map_t m_compLevelDataMap;
 
  // m_compLevelDataMap is divided into following maps and these are stored in the m_stdoutVec_serial.
  // There should be a more clever way!
  std::vector<data_map_unique_t> m_compLevelDataMapVec; // all
  data_map_t m_compLevelDataMap_ini;  // initialize
  data_map_t m_compLevelDataMap_1stevt;  // first event
  data_map_t m_compLevelDataMap_evt;  // execute
  data_map_t m_compLevelDataMap_fin;  // finalize
  data_map_t m_compLevelDataMap_plp;  // preLoadProxy
  data_map_t m_compLevelDataMap_cbk;  // callback
 
  std::vector<data_map_t> m_stdoutVec_serial;
 
  // Leak estimates
  PerfMon::LinFitSglPass m_fit_vmem;
  PerfMon::LinFitSglPass m_fit_pss;
 
  // Estimate CPU efficiency
  int getCpuEfficiency() const;
 
};  // class PerfMonMTSvc
 
#endif  // PERFMONCOMPS_PERFMONMTSVC_H