a small helper class for implementation of ChronoStatSvc service, It also could be used as some local timer More...

#include <GaudiKernel/ChronoEntity.h>

Collaboration diagram for ChronoEntity:

[legend]

Public Member Functions
	ChronoEntity ()=default
	default constructor

IChronoSvc::ChronoStatus	start ()
	start the current chrono

IChronoSvc::ChronoStatus	stop ()
	stop the chrono

IChronoSvc::ChronoTime	delta (IChronoSvc::ChronoType type) const
	return the last delta-time of type "type"

IChronoSvc::ChronoStatus	status () const
	return the status of chrono

unsigned long	nOfMeasurements () const
	number of chrono measurements

double	uMinimalTime () const
	minimal measurement for user time

double	kMinimalTime () const
	minimal measurement for kernel time

double	eMinimalTime () const
	minimal measurement for elapsed time

double	uMaximalTime () const
	maximal measurement for user time

double	kMaximalTime () const
	maximal measurement for kernel time

double	eMaximalTime () const
	maximal measurement for elapsed time

double	uTotalTime () const
	total user time

double	kTotalTime () const
	total Kernel time

double	eTotalTime () const
	total Elapsed time

double	totalTime () const
	total time

double	kMeanTime () const
	average Kernel Time

double	uMeanTime () const
	average User Time

double	eMeanTime () const
	average Elapsed Time

double	kRMSTime () const
	r.m.s Kernel Time

double	uRMSTime () const
	r.m.s User Time

double	eRMSTime () const
	r.m.s Elapsed Time

double	kMeanErrorTime () const
	error in mean Kernel time

double	uMeanErrorTime () const
	error in mean User time

double	eMeanErrorTime () const
	error in mean Elapsed time

ChronoEntity &	operator+= (const ChronoEntity &entity)
	Compound assignment operator.

std::string	outputUserTime () const
	print the chrono ;

std::string	outputSystemTime () const
	print the chrono ;

std::string	outputElapsedTime () const
	print the chrono ;

std::string	outputUserTime (std::string_view fmt, System::TimeType unit) const
	print the chrono according the format and units

std::string	outputSystemTime (std::string_view fmt, System::TimeType unit) const
	print the chrono according the format and units

std::string	outputElapsedTime (std::string_view fmt, System::TimeType unit) const
	print the chrono according the format and units

std::string	outputTime (IChronoSvc::ChronoType typ, std::string_view fmt, System::TimeType unit) const
	print the chrono according the format and units

Protected Member Functions
std::string	format (const double total, const double minimal, const double mean, const double rms, const double maximal, const unsigned long number) const
	format

Protected Attributes
IChronoSvc::ChronoStatus	m_status = IChronoSvc::UNKNOWN
	current status of this chrono object;

System::ProcessTime	m_delta
	delta process times

System::ProcessTime	m_start
	start stamp for current measurement of process times

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 Protected Attributes
static const System::TimeType	TimeUnit = System::microSec
	internal unit used for the system time conversion (microseconds)

Friends
bool	operator< (ChronoEntity const &lhs, ChronoEntity const &rhs)
	comparison operator

Detailed Description

a small helper class for implementation of ChronoStatSvc service, It also could be used as some local timer

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@i.nosp@m.tep..nosp@m.ru

Date: December 1, 1999

Definition at line 26 of file ChronoEntity.h.

Constructor & Destructor Documentation

◆ ChronoEntity()

ChronoEntity::ChronoEntity ( )

default

default constructor

Member Function Documentation

◆ delta()

IChronoSvc::ChronoTime ChronoEntity::delta ( IChronoSvc::ChronoType type ) const

inline

return the last delta-time of type "type"

Definition at line 184 of file ChronoEntity.h.

                                                                                   {
  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
}

◆ eMaximalTime()

double ChronoEntity::eMaximalTime ( ) const

inline

maximal measurement for elapsed time

Definition at line 170 of file ChronoEntity.h.

170{ return m_elapsed.flagMax(); }

ChronoEntity::m_elapsed

StatEntity m_elapsed

the actual storage of "elapsed" time

Definition ChronoEntity.h:158

◆ eMeanErrorTime()

double ChronoEntity::eMeanErrorTime ( ) const

inline

error in mean Elapsed time

Definition at line 183 of file ChronoEntity.h.

183{ return m_elapsed.flagMeanErr(); }

◆ eMeanTime()

double ChronoEntity::eMeanTime ( ) const

inline

average Elapsed Time

Definition at line 177 of file ChronoEntity.h.

177{ return m_elapsed.flagMean(); }

◆ eMinimalTime()

double ChronoEntity::eMinimalTime ( ) const

inline

minimal measurement for elapsed time

Definition at line 167 of file ChronoEntity.h.

167{ return m_elapsed.flagMin(); }

◆ eRMSTime()

double ChronoEntity::eRMSTime ( ) const

inline

r.m.s Elapsed Time

Definition at line 180 of file ChronoEntity.h.

180{ return m_elapsed.flagRMS(); }

◆ eTotalTime()

double ChronoEntity::eTotalTime ( ) const

inline

total Elapsed time

Definition at line 173 of file ChronoEntity.h.

173{ return m_elapsed.flag(); }

◆ format()

std::string ChronoEntity::format	(	const double	total,
		const double	minimal,
		const double	mean,
		const double	rms,
		const double	maximal,
		const unsigned long	number ) const

protected

format

Todo: : cache the format

Definition at line 80 of file ChronoEntity.cpp.

                                                                                           {
  constexpr auto fmt      = "Tot={1:5.3g}{0:5} {3} #={2:3}";
  constexpr auto stat_fmt = "Ave/Min/Max={1:8.3g}(+-{2:8.3g})/{3:8.3g}/{4:8.3g}{0:5}";
 
  static const std::array<std::tuple<int, double, std::string_view>, 9> tbl{ { { 500, microsecond, " [us]" },
                                                                               { 500, millisecond, " [ms]" },
                                                                               { 500, second, "  [s]" },
                                                                               { 500, minute, "[min]" },
                                                                               { 500, hour, "  [h]" },
                                                                               { 10, day, "[day]" },
                                                                               { 5, week, "  [w]" },
                                                                               { 20, month, "[mon]" },
                                                                               { -1, year, "  [y]" } } };
 
  auto             i         = find_if( begin( tbl ), prev( end( tbl ) ),
                                        [&]( const auto& i ) { return total < std::get<0>( i ) * std::get<1>( i ); } );
  long double      unit      = std::get<1>( *i );
  std::string_view unit_name = std::get<2>( *i );
 
  auto stats = [&]() -> std::string {
    if ( number > 1 ) {
      auto             i         = find_if( begin( tbl ), prev( end( tbl ) ),
                                            [&]( const auto& i ) { return total < std::get<0>( i ) * std::get<1>( i ); } );
      auto             unit      = std::get<1>( *i );
      std::string_view unit_name = std::get<2>( *i );
      return fmt::format( stat_fmt, unit_name, (double)( mean / unit ), (double)( rms / unit ),
                          (double)( minimal / unit ), (double)( maximal / unit ) );
    } else {
      return {};
    }
  };
 
  return fmt::format( fmt, unit_name, (double)( total / unit ), number, stats() );
}

◆ kMaximalTime()

double ChronoEntity::kMaximalTime ( ) const

inline

maximal measurement for kernel time

Definition at line 169 of file ChronoEntity.h.

169{ return m_kernel.flagMax(); }

ChronoEntity::m_kernel

StatEntity m_kernel

the actual storage of "kernel" time

Definition ChronoEntity.h:156

◆ kMeanErrorTime()

double ChronoEntity::kMeanErrorTime ( ) const

inline

error in mean Kernel time

Definition at line 181 of file ChronoEntity.h.

181{ return m_kernel.flagMeanErr(); }

◆ kMeanTime()

double ChronoEntity::kMeanTime ( ) const

inline

average Kernel Time

Definition at line 175 of file ChronoEntity.h.

175{ return m_kernel.flagMean(); }

◆ kMinimalTime()

double ChronoEntity::kMinimalTime ( ) const

inline

minimal measurement for kernel time

Definition at line 166 of file ChronoEntity.h.

166{ return m_kernel.flagMin(); }

◆ kRMSTime()

double ChronoEntity::kRMSTime ( ) const

inline

r.m.s Kernel Time

Definition at line 178 of file ChronoEntity.h.

178{ return m_kernel.flagRMS(); }

◆ kTotalTime()

double ChronoEntity::kTotalTime ( ) const

inline

total Kernel time

Definition at line 172 of file ChronoEntity.h.

172{ return m_kernel.flag(); }

◆ nOfMeasurements()

unsigned long ChronoEntity::nOfMeasurements ( ) const

inline

number of chrono measurements

Definition at line 164 of file ChronoEntity.h.

164{ return m_user.nEntries(); }

ChronoEntity::m_user

StatEntity m_user

the actual storage of "user" time

Definition ChronoEntity.h:154

◆ operator+=()

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

Compound assignment operator.

Definition at line 117 of file ChronoEntity.cpp.

                                                              {
  // System::ProcessTime type
  m_delta += e.m_delta;
 
  // Summing, massaging here does not make too much sense.
  // This is done only for final reductions
  // Keep by convention the original one.
  //    m_start += e.m_start;
 
  // Tymevaluetypes type
  m_user += e.m_user;
  m_kernel += e.m_kernel;
  m_elapsed += e.m_elapsed;
 
  return *this;
}

◆ outputElapsedTime() [1/2]

std::string ChronoEntity::outputElapsedTime ( ) const

print the chrono ;

Definition at line 76 of file ChronoEntity.cpp.

                                                {
  return "TimeElapsed: " +
         format( eTotalTime(), eMinimalTime(), eMeanTime(), eRMSTime(), eMaximalTime(), nOfMeasurements() );
}

◆ outputElapsedTime() [2/2]

std::string ChronoEntity::outputElapsedTime	(	std::string_view	fmt,
		System::TimeType	unit ) const

inline

print the chrono according the format and units

Parameters

fmt	the format string
unit	the unit

Returns: the string representations

See also: boost::format

Definition at line 225 of file ChronoEntity.h.

                                                                                                {
  return outputTime( IChronoSvc::ELAPSED, fmt, unit );
}

◆ outputSystemTime() [1/2]

std::string ChronoEntity::outputSystemTime ( ) const

print the chrono ;

Definition at line 72 of file ChronoEntity.cpp.

                                               {
  return "Time System : " +
         format( kTotalTime(), kMinimalTime(), kMeanTime(), kRMSTime(), kMaximalTime(), nOfMeasurements() );
}

◆ outputSystemTime() [2/2]

std::string ChronoEntity::outputSystemTime	(	std::string_view	fmt,
		System::TimeType	unit ) const

inline

print the chrono according the format and units

Parameters

fmt	the format string
unit	the unit

Returns: the string representations

See also: boost::format

Definition at line 215 of file ChronoEntity.h.

                                                                                               {
  return outputTime( IChronoSvc::KERNEL, fmt, unit );
}

◆ outputTime()

std::string ChronoEntity::outputTime	(	IChronoSvc::ChronoType	typ,
		std::string_view	fmt,
		System::TimeType	unit ) const

print the chrono according the format and units

The format fields are:

number of entries
total time (in the specified units)
mean time (in the specified units)
r.m.s. time (in the specified units)
error in mean time (in the specified units)
minimal time (in the specified units)
maximal time (in the specified units)

Parameters

typ	the chrono type
fmt	the format string
unit	the unit

Returns: the string representations

See also: boost::format

Definition at line 134 of file ChronoEntity.cpp.

                                                                                                            {
  boost::format _fmt( std::string{ fmt } );
  // allow various number of arguments
  using namespace boost::io;
  _fmt.exceptions( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) );
  double _unit = microsecond;
  switch ( unit ) {
  case System::Year:
    _unit = year;
    break;
  case System::Month:
    _unit = month;
    break;
  case System::Day:
    _unit = day;
    break;
  case System::Hour:
    _unit = hour;
    break;
  case System::Min:
    _unit = minute;
    break;
  case System::Sec:
    _unit = second;
    break;
  case System::milliSec:
    _unit = millisecond;
    break;
  case System::microSec:
    _unit = microsecond;
    break;
  case System::nanoSec:
    _unit = nanosecond;
    break;
  default:
    _unit = microsecond;
    break;
  }
  const StatEntity* stat = &m_user;
  switch ( typ ) {
  case IChronoSvc::USER:
    stat = &m_user;
    break;
  case IChronoSvc::KERNEL:
    stat = &m_kernel;
    break;
  case IChronoSvc::ELAPSED:
    stat = &m_elapsed;
    break;
  default:
    stat = &m_user;
    break;
  }
  _fmt % ( stat->nEntries() )           // %1 : #entries
      % ( stat->flag() / _unit )        // %2 : total time
      % ( stat->flagMean() / _unit )    // %3 : mean time
      % ( stat->flagRMS() / _unit )     // %4 : RMS  time
      % ( stat->flagMeanErr() / _unit ) // %5 : error in mean time
      % ( stat->flagMin() / _unit )     // %6 : minimal time
      % ( stat->flagMax() / _unit );    // %7 : maximal time
  return _fmt.str();
}

◆ outputUserTime() [1/2]

std::string ChronoEntity::outputUserTime ( ) const

print the chrono ;

Definition at line 68 of file ChronoEntity.cpp.

                                             {
  return "Time User   : " +
         format( uTotalTime(), uMinimalTime(), uMeanTime(), uRMSTime(), uMaximalTime(), nOfMeasurements() );
}

◆ outputUserTime() [2/2]

std::string ChronoEntity::outputUserTime	(	std::string_view	fmt,
		System::TimeType	unit ) const

inline

print the chrono according the format and units

Parameters

fmt	the format string
unit	the unit

Returns: the string representations

See also: boost::format

Definition at line 205 of file ChronoEntity.h.

                                                                                             {
  return outputTime( IChronoSvc::USER, fmt, unit );
}

◆ start()

IChronoSvc::ChronoStatus ChronoEntity::start ( )

start the current chrono

Definition at line 35 of file ChronoEntity.cpp.

                                           {
  if ( IChronoSvc::RUNNING == m_status ) { return m_status; }
  //
  // following lines could be platform dependent!
  //
  // Store in object the measured times
  m_start = System::getProcessTime();
 
  m_status = IChronoSvc::RUNNING;
 
  return m_status;
}

◆ status()

IChronoSvc::ChronoStatus ChronoEntity::status ( ) const

inline

return the status of chrono

Definition at line 163 of file ChronoEntity.h.

163{ return m_status; }

◆ stop()

IChronoSvc::ChronoStatus ChronoEntity::stop ( )

stop the chrono

Definition at line 50 of file ChronoEntity.cpp.

                                          {
  if ( IChronoSvc::RUNNING != m_status ) { return m_status; }
 
  // following lines could be platform dependent!
  m_delta = System::getProcessTime() - m_start;
 
  // update the counters:
 
  m_user += m_delta.userTime<TimeUnit>();
  m_kernel += m_delta.kernelTime<TimeUnit>();
  m_elapsed += m_delta.elapsedTime<TimeUnit>();
 
  // set new status
 
  m_status = IChronoSvc::STOPPED;
 
  return m_status;
}

◆ totalTime()

double ChronoEntity::totalTime ( ) const

inline

total time

Definition at line 174 of file ChronoEntity.h.

174{ return uTotalTime() + kTotalTime(); }

◆ uMaximalTime()

double ChronoEntity::uMaximalTime ( ) const

inline

maximal measurement for user time

Definition at line 168 of file ChronoEntity.h.

168{ return m_user.flagMax(); }

◆ uMeanErrorTime()

double ChronoEntity::uMeanErrorTime ( ) const

inline

error in mean User time

Definition at line 182 of file ChronoEntity.h.

182{ return m_user.flagMeanErr(); }

◆ uMeanTime()

double ChronoEntity::uMeanTime ( ) const

inline

average User Time

Definition at line 176 of file ChronoEntity.h.

176{ return m_user.flagMean(); }

◆ uMinimalTime()

double ChronoEntity::uMinimalTime ( ) const

inline

minimal measurement for user time

Definition at line 165 of file ChronoEntity.h.

165{ return m_user.flagMin(); }

◆ uRMSTime()

double ChronoEntity::uRMSTime ( ) const

inline

r.m.s User Time

Definition at line 179 of file ChronoEntity.h.

179{ return m_user.flagRMS(); }

◆ uTotalTime()

double ChronoEntity::uTotalTime ( ) const

inline

total user time

Definition at line 171 of file ChronoEntity.h.

171{ return m_user.flag(); }

Friends And Related Symbol Documentation

◆ operator<

bool operator<	(	ChronoEntity const &	lhs,
		ChronoEntity const &	rhs )

friend

comparison operator

Definition at line 88 of file ChronoEntity.h.

                                                                            {
    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 );
  }

Member Data Documentation

◆ m_delta

System::ProcessTime ChronoEntity::m_delta

protected

delta process times

Definition at line 150 of file ChronoEntity.h.

◆ m_elapsed

StatEntity ChronoEntity::m_elapsed

protected

the actual storage of "elapsed" time

Definition at line 158 of file ChronoEntity.h.

◆ m_kernel

StatEntity ChronoEntity::m_kernel

protected

the actual storage of "kernel" time

Definition at line 156 of file ChronoEntity.h.

◆ m_start

System::ProcessTime ChronoEntity::m_start

protected

start stamp for current measurement of process times

Definition at line 152 of file ChronoEntity.h.

◆ m_status

IChronoSvc::ChronoStatus ChronoEntity::m_status = IChronoSvc::UNKNOWN

protected

current status of this chrono object;

Definition at line 148 of file ChronoEntity.h.

◆ m_user

StatEntity ChronoEntity::m_user

protected

the actual storage of "user" time

Definition at line 154 of file ChronoEntity.h.

◆ TimeUnit

const System::TimeType ChronoEntity::TimeUnit = System::microSec

staticprotected

internal unit used for the system time conversion (microseconds)

Definition at line 160 of file ChronoEntity.h.

The documentation for this class was generated from the following files:

GaudiKernel/include/GaudiKernel/ChronoEntity.h
GaudiKernel/src/Lib/ChronoEntity.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ ChronoEntity()

Member Function Documentation

◆ delta()

◆ eMaximalTime()

◆ eMeanErrorTime()

◆ eMeanTime()

◆ eMinimalTime()

◆ eRMSTime()

◆ eTotalTime()

◆ format()

◆ kMaximalTime()

◆ kMeanErrorTime()

◆ kMeanTime()

◆ kMinimalTime()

◆ kRMSTime()

◆ kTotalTime()

◆ nOfMeasurements()

◆ operator+=()

◆ outputElapsedTime() [1/2]

◆ outputElapsedTime() [2/2]

◆ outputSystemTime() [1/2]

◆ outputSystemTime() [2/2]

◆ outputTime()

◆ outputUserTime() [1/2]

◆ outputUserTime() [2/2]

◆ start()

◆ status()

◆ stop()

◆ totalTime()

◆ uMaximalTime()

◆ uMeanErrorTime()

◆ uMeanTime()

◆ uMinimalTime()

◆ uRMSTime()

◆ uTotalTime()

Friends And Related Symbol Documentation

◆ operator<

Member Data Documentation

◆ m_delta

◆ m_elapsed

◆ m_kernel

◆ m_start

◆ m_status

◆ m_user

◆ TimeUnit