ChronoEntity.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 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 <GaudiKernel/IChronoSvc.h>
#include <GaudiKernel/StatEntity.h>
#include <GaudiKernel/Timing.h>

class GAUDI_API ChronoEntity {
public:
  ChronoEntity() = default;
 
  // ==========================================================================
  // The basic Chrono Operations
  // ==========================================================================
  IChronoSvc::ChronoStatus start();
  IChronoSvc::ChronoStatus stop();
  IChronoSvc::ChronoTime delta( IChronoSvc::ChronoType type ) const;
  IChronoSvc::ChronoStatus status() const;
 
  // ==========================================================
  // Access to Chrono Statistics
  // ==========================================================
  unsigned long nOfMeasurements() const;
  double uMinimalTime() const;
  double kMinimalTime() const;
  double eMinimalTime() const;
  double uMaximalTime() const;
  double kMaximalTime() const;
  double eMaximalTime() const;
  double uTotalTime() const;
  double kTotalTime() const;
  double eTotalTime() const;
  double totalTime() const;
  double kMeanTime() const;
  double uMeanTime() const;
  double eMeanTime() const;
  double kRMSTime() const;
  double uRMSTime() const;
  double eRMSTime() const;
  double kMeanErrorTime() const;
  double uMeanErrorTime() const;
  double eMeanErrorTime() const;

  friend bool operator<( ChronoEntity const& lhs, ChronoEntity const& rhs ) {
    return std::make_tuple( lhs.totalTime(), lhs.m_user, lhs.m_kernel, lhs.m_elapsed ) <
           std::make_tuple( rhs.totalTime(), rhs.m_user, rhs.m_kernel, rhs.m_elapsed );
  }

  ChronoEntity& operator+=( const ChronoEntity& entity );

  std::string outputUserTime() const;
  std::string outputSystemTime() const;
  std::string outputElapsedTime() const;

  std::string outputUserTime( std::string_view fmt, System::TimeType unit ) const;
  std::string outputSystemTime( std::string_view fmt, System::TimeType unit ) const;
  std::string outputElapsedTime( std::string_view fmt, System::TimeType unit ) const;
  std::string outputTime( IChronoSvc::ChronoType typ, std::string_view fmt, System::TimeType unit ) const;
 
protected:
  std::string format( const double total, const double minimal, const double mean, const double rms,
                      const double maximal, const unsigned long number ) const;
  IChronoSvc::ChronoStatus m_status = IChronoSvc::UNKNOWN;
  System::ProcessTime m_delta;
  System::ProcessTime m_start;
  StatEntity m_user; // the actual storage of "user" time
  StatEntity m_kernel; // the actual storage of "kernel" time
  StatEntity m_elapsed; // the actual storage of "elapsed" time
  static const System::TimeType TimeUnit = System::microSec;
};
 
inline IChronoSvc::ChronoStatus ChronoEntity::status() const { return m_status; }
inline unsigned long            ChronoEntity::nOfMeasurements() const { return m_user.nEntries(); }
inline double                   ChronoEntity::uMinimalTime() const { return m_user.flagMin(); }
inline double                   ChronoEntity::kMinimalTime() const { return m_kernel.flagMin(); }
inline double                   ChronoEntity::eMinimalTime() const { return m_elapsed.flagMin(); }
inline double                   ChronoEntity::uMaximalTime() const { return m_user.flagMax(); }
inline double                   ChronoEntity::kMaximalTime() const { return m_kernel.flagMax(); }
inline double                   ChronoEntity::eMaximalTime() const { return m_elapsed.flagMax(); }
inline double                   ChronoEntity::uTotalTime() const { return m_user.flag(); }
inline double                   ChronoEntity::kTotalTime() const { return m_kernel.flag(); }
inline double                   ChronoEntity::eTotalTime() const { return m_elapsed.flag(); }
inline double                   ChronoEntity::totalTime() const { return uTotalTime() + kTotalTime(); }
inline double                   ChronoEntity::kMeanTime() const { return m_kernel.flagMean(); }
inline double                   ChronoEntity::uMeanTime() const { return m_user.flagMean(); }
inline double                   ChronoEntity::eMeanTime() const { return m_elapsed.flagMean(); }
inline double                   ChronoEntity::kRMSTime() const { return m_kernel.flagRMS(); }
inline double                   ChronoEntity::uRMSTime() const { return m_user.flagRMS(); }
inline double                   ChronoEntity::eRMSTime() const { return m_elapsed.flagRMS(); }
inline double                   ChronoEntity::kMeanErrorTime() const { return m_kernel.flagMeanErr(); }
inline double                   ChronoEntity::uMeanErrorTime() const { return m_user.flagMeanErr(); }
inline double                   ChronoEntity::eMeanErrorTime() const { return m_elapsed.flagMeanErr(); }
inline IChronoSvc::ChronoTime   ChronoEntity::delta( IChronoSvc::ChronoType type ) const {
  const IChronoSvc::ChronoTime result = -1;
  switch ( type ) {
  case IChronoSvc::USER:
    return m_delta.userTime<TimeUnit>();
  case IChronoSvc::KERNEL:
    return m_delta.kernelTime<TimeUnit>();
  case IChronoSvc::ELAPSED:
    return m_delta.elapsedTime<TimeUnit>();
  default:
    return result;
  }
  // cannot reach this point
}
 
/*  print the chrono according the format and units
 *  @param fmt  the format string
 *  @param unit the unit
 *  @return the string representations
 *  @see boost::format
 */
inline std::string ChronoEntity::outputUserTime( std::string_view fmt, System::TimeType unit ) const {
  return outputTime( IChronoSvc::USER, fmt, unit );
}
 
/*  print the chrono according the format and units
 *  @param fmt  the format string
 *  @param unit the unit
 *  @return the string representations
 *  @see boost::format
 */
inline std::string ChronoEntity::outputSystemTime( std::string_view fmt, System::TimeType unit ) const {
  return outputTime( IChronoSvc::KERNEL, fmt, unit );
}
 
/*  print the chrono according the format and units
 *  @param fmt  the format string
 *  @param unit the unit
 *  @return the string representations
 *  @see boost::format
 */
inline std::string ChronoEntity::outputElapsedTime( std::string_view fmt, System::TimeType unit ) const {
  return outputTime( IChronoSvc::ELAPSED, fmt, unit );
}