PHTimer.h

Go to the documentation of this file.

// $Id: PHTimer.h,v 1.6 2013/01/07 09:27:01 bbannier Exp $
 
#ifndef __PHTIMER_H__
#define __PHTIMER_H__
 
#include <iostream>
#include <sstream>
#include <unistd.h>
 
#define rdtsc(low,high) \
__asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))
 
 
class PHTimer
{
    public:
 
    enum State
    {
        STOP=0,
        RUN=1
    };
 
    State get_state( void ) const
    { return _state; }
 
    PHTimer(const std::string& name = "Generic Timer") :
        _name(name),
        _state( STOP ),
      _start_time(get_clock_counts()),
      _stop_time(get_clock_counts()),
        _accumulated_time( 0 ),
        _ncycle( 0 )
    {
        _stop_time._low++;
    }
 
    void reset() {
      _state = STOP;
        _start_time = get_clock_counts();
      _stop_time = get_clock_counts();
      _accumulated_time = 0;
      _ncycle = 0;
      _stop_time._low++;
    }
 
    void stop(){
        if( _state == STOP ) return;
        _stop_time = get_clock_counts();
        _state = STOP;
        _ncycle++;
        _accumulated_time+=elapsed();
    }
 
    void restart(){ _start_time = get_clock_counts(); _state = RUN; }
 
    void print(std::ostream& os = std::cout) const
    {
        double elapse( elapsed() );
        PRINT(os,"Timing for " + _name);
        os << "time (ms): " << elapse << std::endl;
        PRINT();
    }
 
    void print_stat( std::ostream& os = std::cout ) const
    {
        PRINT(os, std::string( "Stats for " + _name ) );
        if( _ncycle )
        {
            os << "accumulated time (ms):       " << _accumulated_time << std::endl;
            os << "per event time: (ms)  " <<   _accumulated_time/_ncycle << std::endl;
        } else {
            os << "never started.\n";
        }
        PRINT(os,"**");
    }
 
    void set_name(const std::string& name)
    { _name = name; }
 
    std::string get_name( void ) const
    { return _name; }
 
    double get_accumulated_time( void ) const
    { return _accumulated_time; }
 
    unsigned int get_ncycle( void ) const
    { return _ncycle; }
 
    double get_time_per_cycle( void ) const
    { return _accumulated_time/_ncycle; }
 
    double elapsed( void ) const
    {
        return 1000.0*get_difference(
            ( _state==RUN ) ? get_clock_counts():_stop_time,
            _start_time );
    }
 
    void test( double time, std::ostream& os = std::cout)
    {
        std::ostringstream tmp;
        tmp << "Test for " << _name << " - " << time << "ms";
        PRINT(os, tmp.str());
        restart();
        usleep( (unsigned int)(time*1000) );
        print( os );
    }
 
    static void PRINT(std::ostream& os = std::cout, const std::string& message = "");
 
    private:
 
    class Frequency
    {
        public:
 
      Frequency()
        {
            try { set_cpu_freq(); }
            catch (std::exception& e) { std::cerr << e.what() << std::endl; }
            _period = 1.0/_frequency;
        }
 
        operator double() const
        {return _frequency;}
 
        double period() const
        {return _period;}
 
        private:
 
        double _frequency;
 
        double _period;
 
        void set_cpu_freq(const char * cpuinfopath = "/proc/cpuinfo");
    };
 
    struct time_struct
    {
 
        time_struct( void ):
            _low(0),
            _high(0)
        {}
 
        unsigned long _low;
 
        unsigned long _high;
 
    };
 
    static time_struct get_clock_counts( void ) {
        time_struct t;
        rdtsc(t._low, t._high);
        return t;
    }
 
    static double get_difference(
        const time_struct &,
        const time_struct & );
 
    static Frequency _frequency;
 
    static const double _twopower32;
 
    std::string _name;
 
    State _state;
 
    time_struct _start_time;
 
    time_struct _stop_time;
 
    double _accumulated_time;
 
    unsigned int _ncycle;
 
};
 
#endif