Auxilliary class. More...

#include <TimerForSequencer.h>

Collaboration diagram for TimerForSequencer:

Public Member Functions
	TimerForSequencer (std::string name, double factor)
	Constructor.
	~TimerForSequencer ()
void	start ()
	Start a time measurement.
double	stop ()
	Stop time measurement and return the last elapsed time.
std::string	name () const
	returns the name
double	lastTime () const
	returns the last measured time
double	lastCpu () const
	returns the last measured time
MsgStream &	fillStream (MsgStream &s) const
	Write measured time into the message stream.
Static Public Member Functions
static std::string	header (std::string::size_type size)
	header matching the previous format
Private Attributes
std::string	m_name
double	m_factor
longlong	m_startClock
longlong	m_startCpu
long	m_num
double	m_lastTime
double	m_lastCpu
double	m_min
double	m_max
double	m_sum
double	m_sumCpu

Detailed Description

Auxilliary class.

Measure the time between start and stop, and compute average, min and max. In fact, measure the cpu time, and the elapsed time but givesmin/max only for elapsed.

Author:: O.Callot

Definition at line 14 of file TimerForSequencer.h.

Constructor & Destructor Documentation

TimerForSequencer::TimerForSequencer	(	std::string	name,
		double	factor
	)		`[inline]`

Constructor.

Specify the name, for later printing.

Definition at line 19 of file TimerForSequencer.h.

                                                     {
    m_name   = name;
    m_num    = 0L;
    m_min    = 0.;
    m_max    = 0.;
    m_sum    = 0.;
    m_sumCpu = 0.;
    m_factor = factor;
    m_lastTime = 0.;
    m_lastCpu  = 0.;
    m_startClock = 0LL;
    m_startCpu = 0LL;
  }

TimerForSequencer::~TimerForSequencer ( ) [inline]

Definition at line 33 of file TimerForSequencer.h.

{};

Member Function Documentation

MsgStream& TimerForSequencer::fillStream ( MsgStream & s ) const [inline]

Write measured time into the message stream.

Definition at line 79 of file TimerForSequencer.h.

                                              {
    double ave = 0.;
    double cpu = 0.;

    if ( 0 != m_num ) {
      ave = m_sum    / m_num;
      cpu = m_sumCpu / m_num;
    }

    return s << m_name
             << format( "| %9.3f | %9.3f | %8.3f %9.1f | %7d | %9.3f |",
                        cpu, ave, m_min, m_max, m_num, m_sum * 0.001 );
  }

static std::string TimerForSequencer::header ( std::string::size_type size ) [inline, static]

header matching the previous format

Definition at line 94 of file TimerForSequencer.h.

                                                     {
    if ( size < 21 ) size = 21;
    std::string blank( size - 20, ' ' );
    std::string s = "Algorithm" + blank + "(millisec) |    <user> |   <clock> |";
    s += "      min       max | entries | total (s) |";
    return s;
  }

double TimerForSequencer::lastCpu ( ) const [inline]

returns the last measured time

Definition at line 76 of file TimerForSequencer.h.

{ return m_lastCpu; }

double TimerForSequencer::lastTime ( ) const [inline]

returns the last measured time

Definition at line 73 of file TimerForSequencer.h.

{ return m_lastTime; }

std::string TimerForSequencer::name ( ) const [inline]

returns the name

Definition at line 70 of file TimerForSequencer.h.

{ return m_name; }

void TimerForSequencer::start ( ) [inline]

Start a time measurement.

Definition at line 36 of file TimerForSequencer.h.

                {
    m_startClock = System::currentTime( System::microSec );
    m_startCpu   = System::cpuTime( System::microSec );
  }

double TimerForSequencer::stop ( ) [inline]

Stop time measurement and return the last elapsed time.

Returns:: Measured time in ms

Definition at line 44 of file TimerForSequencer.h.

                {
    double cpuTime  =  double(System::cpuTime( System::microSec ) - m_startCpu );
    double lastTime =  double(System::currentTime( System::microSec ) - m_startClock );

    //== Change to normalized millisecond
    cpuTime  *= m_factor;
    lastTime *= m_factor;

    //== Update the counter
    m_num    += 1;
    m_sum    += lastTime;
    m_sumCpu += cpuTime;

    if ( 1 == m_num ) {
      m_min = lastTime;
      m_max = lastTime;
    } else {
      if ( lastTime < m_min ) m_min = lastTime;
      if ( lastTime > m_max ) m_max = lastTime;
    }
    m_lastTime = lastTime;
    m_lastCpu  = cpuTime;
    return lastTime;
  }