ChronoEntity.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_CHRONOENTITY_H
#define GAUDIKERNEL_CHRONOENTITY_H 1
// ============================================================================
// Include files
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/IChronoSvc.h"
#include "GaudiKernel/StatEntity.h"
#include "GaudiKernel/Timing.h"
// ============================================================================
class GAUDI_API ChronoEntity {
public:
  ChronoEntity() = default;

public:
  // ==========================================================================
  // The basic Chrono Operations
  // ==========================================================================
  IChronoSvc::ChronoStatus start();
  IChronoSvc::ChronoStatus stop();
  // ==========================================================================
  inline IChronoSvc::ChronoTime delta( IChronoSvc::ChronoType type ) const;
  inline IChronoSvc::ChronoStatus status() const;
  // ==========================================================================
public:
  // ==========================================================
  // Access to Chrono Statistics
  // ==========================================================
  inline unsigned long nOfMeasurements() const;
  // ==========================================================
  inline double uMinimalTime() const;
  inline double kMinimalTime() const;
  inline double eMinimalTime() const;
  inline double uMaximalTime() const;
  inline double kMaximalTime() const;
  inline double eMaximalTime() const;
  inline double uTotalTime() const;
  inline double kTotalTime() const;
  inline double eTotalTime() const;
  inline double totalTime() const;
  inline double kMeanTime() const;
  inline double uMeanTime() const;
  inline double eMeanTime() const;
  inline double kRMSTime() const;
  inline double uRMSTime() const;
  inline double eRMSTime() const;
  inline double kMeanErrorTime() const;
  inline double uMeanErrorTime() const;
  inline double eMeanErrorTime() const;
  // ==========================================================================
public:
  // ==========================================================================
  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 );
  // ==========================================================================
public:
  // ==========================================================================
  std::string outputUserTime() const;
  std::string outputSystemTime() const;
  std::string outputElapsedTime() const;
  // ==========================================================================
public:
  // ==========================================================================
  inline std::string outputUserTime( const std::string& fmt, System::TimeType unit ) const;
  inline std::string outputSystemTime( const std::string& fmt, System::TimeType unit ) const;
  inline std::string outputElapsedTime( const std::string& fmt, System::TimeType unit ) const;
  // ==========================================================================
  std::string outputTime( IChronoSvc::ChronoType typ, const std::string& 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;
  // ==========================================================================
private:
  // ==========================================================================
  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;
  // ==========================================================================
};
// ============================================================================
// return the status of chrono
// ============================================================================
inline IChronoSvc::ChronoStatus ChronoEntity::status() const { return m_status; }
// ============================================================================
// number of chrono measurements
// ============================================================================
inline unsigned long ChronoEntity::nOfMeasurements() const { return m_user.nEntries(); }
// ============================================================================
// minimal measurement for user time
// ============================================================================
inline double ChronoEntity::uMinimalTime() const { return m_user.flagMin(); }
// ============================================================================
// minimal measurement for kernel time
// ============================================================================
inline double ChronoEntity::kMinimalTime() const { return m_kernel.flagMin(); }
// ============================================================================
// minimal measurement for elapsed time
// ============================================================================
inline double ChronoEntity::eMinimalTime() const { return m_elapsed.flagMin(); }
// ============================================================================
// maximal measurement for user time
// ============================================================================
inline double ChronoEntity::uMaximalTime() const { return m_user.flagMax(); }
// ============================================================================
// maximal measurement for kernel time
// ============================================================================
inline double ChronoEntity::kMaximalTime() const { return m_kernel.flagMax(); }
// ============================================================================
// maximal measurement for ellapsed time
// ============================================================================
inline double ChronoEntity::eMaximalTime() const { return m_elapsed.flagMax(); }
// ============================================================================
// total user time
// ============================================================================
inline double ChronoEntity::uTotalTime() const { return m_user.flag(); }
// ============================================================================
// total Kernel time
// ============================================================================
inline double ChronoEntity::kTotalTime() const { return m_kernel.flag(); }
// ============================================================================
// total Elapsed time
// ============================================================================
inline double ChronoEntity::eTotalTime() const { return m_elapsed.flag(); }
// ============================================================================
// total time
// ============================================================================
inline double ChronoEntity::totalTime() const { return uTotalTime() + kTotalTime(); }
// ============================================================================
// average Kernel Time
// ============================================================================
inline double ChronoEntity::kMeanTime() const { return m_kernel.flagMean(); }
// ============================================================================
// average User   Time
// ============================================================================
inline double ChronoEntity::uMeanTime() const { return m_user.flagMean(); }
// ============================================================================
// average Elapsed   Time
// ============================================================================
inline double ChronoEntity::eMeanTime() const { return m_elapsed.flagMean(); }
// ============================================================================
// r.m.s Kernel Time
// ============================================================================
inline double ChronoEntity::kRMSTime() const { return m_kernel.flagRMS(); }
// ============================================================================
// r.m.s User Time
// ============================================================================
inline double ChronoEntity::uRMSTime() const { return m_user.flagRMS(); }
// ============================================================================
// r.m.s Elapsed Time
// ============================================================================
inline double ChronoEntity::eRMSTime() const { return m_elapsed.flagRMS(); }
// ============================================================================
// error in mean Kernel time
// ============================================================================
inline double ChronoEntity::kMeanErrorTime() const { return m_kernel.flagMeanErr(); }
// ============================================================================
// error in mean User   time
// ============================================================================
inline double ChronoEntity::uMeanErrorTime() const { return m_user.flagMeanErr(); }
// ============================================================================
// error in mean Elapsed   time
// ============================================================================
inline double ChronoEntity::eMeanErrorTime() const { return m_elapsed.flagMeanErr(); }
// ============================================================================
// return the last delta-time of type "type"
// ============================================================================
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( const std::string& 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( const std::string& 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( const std::string& fmt, System::TimeType unit ) const {
  return outputTime( IChronoSvc::ELAPSED, fmt, unit );
}
// ============================================================================
// The END
// ============================================================================
#endif //  GAUDIKERNEL_CHRONOENTITY_H