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:
  // ==========================================================================
  bool operator<( const ChronoEntity& entity ) const;
  // ==========================================================================
  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
// ============================================================================