timer.C

Go to the documentation of this file.

/* -*- mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

#ifndef __LINBOX__TIMER__C__
#define __LINBOX__TIMER__C__
// Description:
// - various timer objects
// - to be rewritten to be more efficient

#include <cmath>

extern "C" {
# include <sys/time.h>
# include <sys/resource.h>
//  int getrusage (int, struct rusage*) ;
}

#include <iostream>

#include <assert.h>

#include "timer.h"

long BaseTimer::seed() 
{
        struct timeval tp;
        gettimeofday(&tp, 0) ;
        return(tp.tv_usec);
}

std::ostream& BaseTimer::print( std::ostream& o ) const 
{ return o << _t ; }

BaseTimer& BaseTimer::operator = (const BaseTimer & T) 
{  
        _t = T._t ; 
        return *this ; 
}
      
const BaseTimer BaseTimer::operator - (const BaseTimer & T) const
{
        BaseTimer Tmp ;
        Tmp._t = _t - T._t ; 
        return Tmp ;
}

const BaseTimer BaseTimer::operator - () 
{
        BaseTimer Tmp ;
        Tmp._t = -_t ; 
        return Tmp ;
}

const BaseTimer BaseTimer::operator + (const BaseTimer & T)  const
{
        BaseTimer Tmp ;
        Tmp._t = _t + T._t ; 
        return Tmp ;
}

void RealTimer::start()
{  
        struct timeval tmp2 ; 
        gettimeofday (&tmp2, 0) ;

        // real time 
        _start_t = (double) tmp2.tv_sec + 
                ((double) tmp2.tv_usec)/ (double)BaseTimer::MSPSEC ; 
}


void RealTimer::stop()
{ 
        struct timeval tmp2 ;  
        gettimeofday (&tmp2, 0) ;

        // real time 
        _t += (double) tmp2.tv_sec + 
                ((double) tmp2.tv_usec)/ (double)BaseTimer::MSPSEC - _start_t ; 
}

void UserTimer::start()
{
        struct rusage  tmp1 ;  // to getrusage (sys+user times)
        getrusage (RUSAGE_SELF, &tmp1) ;
        // user time
        _start_t = (double) tmp1.ru_utime.tv_sec +
                ((double) tmp1.ru_utime.tv_usec)/ (double)MSPSEC ;
}


void UserTimer::stop()
{
        struct rusage  tmp1 ;  // to getrusage (sys+user times)
        getrusage (RUSAGE_SELF, &tmp1) ;
        // user time
        _t += (double) tmp1.ru_utime.tv_sec +
                ((double) tmp1.ru_utime.tv_usec)/ (double)MSPSEC - _start_t ;
}


void SysTimer::start()
{
        struct rusage  tmp1 ;  // to getrusage (sys+user times)
        getrusage (RUSAGE_SELF, &tmp1) ;
        // user time
        _start_t = (double) tmp1.ru_stime.tv_sec + 
                ((double) tmp1.ru_stime.tv_usec)/ (double)MSPSEC ;
}


void SysTimer::stop()
{
        struct rusage  tmp1 ;  // to getrusage (sys+user times)
        getrusage (RUSAGE_SELF, &tmp1) ;
        // user time
        _t += (double) tmp1.ru_stime.tv_sec +
                ((double) tmp1.ru_stime.tv_usec)/ (double)MSPSEC - _start_t ;
}



void Timer::clear() 
{ rt.clear() ; ut.clear(); st.clear(); _count = 0;      b_IsRunning=false; b_Paused=false; }

void Timer::start() 
{
        assert(!b_IsRunning || (b_IsRunning && b_Paused )); 
        if (!b_IsRunning || (b_IsRunning && b_Paused )) 
        {
                b_IsRunning=true; rt.start() ; ut.start(); st.start(); _count = 0; 
        } 
}

void Timer::continueTimer() 
{ 
        #ifdef CF_TEST
                assert ( b_Paused ) ;
        #endif
        if (b_Paused) 
        { 
                if (b_IsRunning) 
                {
                         rt.start() ; ut.start(); st.start(); _count = 0;  
                } 
                b_Paused=false; 
        } 
}

void Timer::stop() 
{ 
        #ifdef CF_TEST
                assert ( !b_Paused && b_IsRunning) ;
        #endif

        assert ( !b_Paused ) ;
        
        if (b_IsRunning)
        {
                 rt.stop() ; ut.stop(); st.stop(); _count = 1;   b_IsRunning=false; 
        } 
}

void Timer::pauseTimer() 
{ 
        b_Paused=true; 
        if (b_IsRunning) { rt.stop() ; ut.stop(); st.stop(); _count = 1; }   
}


std::ostream& Timer::print( std::ostream& o ) const
{
        o << "user time: " << usertime() << '\n' ;
        o << "sys. time: " << systime() << '\n' ;
        return o << "real time: " << realtime() << std::endl ;
}

Timer& Timer::operator = (const Timer & T)
{
        ut = T.ut ; 
        st = T.st ; 
        rt = T.rt ;
        _count = T._count;
        return *this ;
}

const Timer Timer::operator - (const Timer & T)  const
{
        Timer Tmp ;
        Tmp.ut = ut - T.ut ;
        Tmp.st = st - T.st ;
        Tmp.rt = rt - T.rt ;
        Tmp._count = _count - T._count;
        return Tmp ;
}

const Timer Timer::operator - ()
{
        Timer Tmp ;
        Tmp.ut = -ut ;
        Tmp.st = -st ;
        Tmp.rt = -rt ;
        Tmp._count = - _count;
        return Tmp ;
}

const Timer Timer::operator + (const Timer & T)  const
{
        Timer Tmp ;
        Tmp.ut = ut + T.ut ;
        Tmp.st = st + T.st ;
        Tmp.rt = rt + T.rt ;
        Tmp._count = _count + T._count;
        return Tmp ;
}
 

#endif