ChronoStatSvc.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 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
// ============================================================================
// STD & STL
// ============================================================================
#include <atomic>
#include <fstream>
#include <functional>
#include <map>
#include <mutex>
#include <string>
// ============================================================================
// GaudiKernel
// ============================================================================
#include <GaudiKernel/IChronoStatSvc.h>
#include <GaudiKernel/IIncidentListener.h>
#include <GaudiKernel/Kernel.h>
#include <GaudiKernel/Service.h>
#include <GaudiKernel/ServiceHandle.h>
#include <GaudiKernel/ThreadLocalContext.h>
// ============================================================================
// ============================================================================
class ISvcLocator;
class IMessageSvc;
// ============================================================================
class ChronoStatSvc : public extends<Service, IChronoStatSvc, IIncidentListener> {
public:
  // ============================================================================
  using ChronoMap = std::map<IChronoStatSvc::ChronoTag, ChronoEntity>;
  using StatMap   = std::map<IChronoStatSvc::StatTag, StatEntity>;
  // ============================================================================
public:
  // ============================================================================
  StatusCode initialize() override;
  StatusCode finalize() override;
  // ============================================================================
public:
  // ============================================================================
  ChronoEntity* chronoStart( const IChronoStatSvc::ChronoTag& chronoTag ) override;
  // ============================================================================
  const ChronoEntity* chronoStop( const IChronoStatSvc::ChronoTag& chronoTag ) override;
  // ============================================================================
  IChronoStatSvc::ChronoTime chronoDelta( const IChronoStatSvc::ChronoTag& chronoTag,
                                          IChronoStatSvc::ChronoType       theType ) override;
  // ============================================================================
  void chronoPrint( const IChronoStatSvc::ChronoTag& chronoTag ) override;
  // ============================================================================
  ChronoStatus chronoStatus( const IChronoStatSvc::ChronoTag& chronoTag ) override;
  // ============================================================================
  void stat( const IChronoStatSvc::StatTag& statTag, const IChronoStatSvc::StatFlag& statFlag ) override;
  // ============================================================================
  void statPrint( const IChronoStatSvc::ChronoTag& statTag ) override;
  // ============================================================================
  const ChronoEntity* chrono( const IChronoStatSvc::ChronoTag& t ) const override;
  // ============================================================================
  StatEntity* stat( const IChronoStatSvc::StatTag& t ) override;
  // ============================================================================
  ChronoStatSvc( const std::string& name, ISvcLocator* svcloc ) : base_class( name, svcloc ) {}
 
  void merge( const ChronoStatSvc& css );
  // ============================================================================
 
public:
  void handle( const Incident& incident ) override;
 
protected:
  // ============================================================================
  // print the "Stat" part of the ChronoStatSvc
  void printStats();
  // ============================================================================
private:
  // ============================================================================
  // default/copy constructor and assignment are disabled
  ChronoStatSvc()                                  = delete;
  ChronoStatSvc( const ChronoStatSvc& )            = delete;
  ChronoStatSvc& operator=( const ChronoStatSvc& ) = delete;
  // ============================================================================
  void saveStats();
  // ============================================================================
public:
  // ============================================================================
  // Standard Destructor
  ~ChronoStatSvc() override = default;
  // ============================================================================
private:
  bool isMT() const;
 
  ChronoEntity& getEntity( const ChronoTag& chronoTag ) {
    auto lock = std::scoped_lock{ m_mutex };
    return m_chronoEntities[chronoTag];
  }
 
  // basically limit the integer to MSG::Level range
  static MSG::Level int2level( int l ) {
    return static_cast<MSG::Level>(
        std::max( std::min( l, static_cast<int>( MSG::FATAL ) ), static_cast<int>( MSG::NIL ) ) );
  }
  // ============================================================================
  ChronoMap m_chronoEntities;
  mutable std::mutex m_mutex;
 
  MSG::Level m_chronoPrintLevel = MSG::INFO;
 
  StatMap m_statEntities;
  MSG::Level m_statPrintLevel = MSG::INFO;
 
  Gaudi::Property<bool> m_chronoTableFlag{ this, "ChronoPrintOutTable", true,
                                           "decide if the final printout should be performed" };
  Gaudi::Property<bool> m_chronoCoutFlag{ this, "ChronoDestinationCout", false,
                                          "define the destination of the table to be printed" };
  Gaudi::Property<int>  m_intChronoPrintLevel{
      this, "ChronoPrintLevel", MSG::INFO, [this]( auto& ) { m_chronoPrintLevel = int2level( m_intChronoPrintLevel ); },
      "print level" };
  Gaudi::Property<bool> m_chronoOrderFlag{ this, "ChronoTableToBeOrdered", true, "should the printout be ordered" };
  Gaudi::Property<bool> m_printUserTime{ this, "PrintUserTime", true };
  Gaudi::Property<bool> m_printSystemTime{ this, "PrintSystemTime", false };
  Gaudi::Property<bool> m_printEllapsedTime{ this, "PrintEllapsedTime", false };
  Gaudi::Property<bool> m_statTableFlag{ this, "StatPrintOutTable", true,
                                         "decide if the final printout should be performed" };
  Gaudi::Property<bool> m_statCoutFlag{ this, "StatDestinationCout", false,
                                        "define the destination of the table to be printed" };
  Gaudi::Property<int>  m_intStatPrintLevel{ this, "StatPrintLevel", MSG::INFO,
                                            [this]( auto& ) { m_statPrintLevel = int2level( m_intStatPrintLevel ); },
                                            "print level" };
  Gaudi::Property<bool> m_statOrderFlag{ this, "StatTableToBeOrdered", true, "should the printout be ordered" };
 
  Gaudi::Property<std::string> m_statsOutFileName{
      this, "AsciiStatsOutputFile", "",
      "Name of the output file storing the stats. If empty, no statistics will be saved (default)" };
 
  Gaudi::Property<std::string> m_header{
      this, "StatTableHeader",
      " |    Counter     |     #     |    sum     | mean/eff^* | rms/err^*  |     min     |     max     |",
      "The header row for the output Stat-table" };
  Gaudi::Property<bool> m_useEffFormat{ this, "UseEfficiencyRowFormat", true,
                                        "Use the special format for printout of efficiency counters" };
 
  Gaudi::Property<std::string> m_perEventFile{ this, "PerEventFile", "", "File name for per-event deltas" };
 
  ServiceHandle<IInterface> m_hiveWhiteBoardSvc{ this, "HiveWhiteBoardSvc", "EventDataSvc" };
 
  using TimeMap = std::map<ChronoTag, std::vector<IChronoSvc::ChronoTime>>;
  TimeMap       m_perEvtTime;
  std::ofstream m_ofd;
 
  // ============================================================================
};
// ============================================================================
// The END
// ============================================================================