Timer.h

Go to the documentation of this file.

#ifndef Timer_h
#define Timer_h
//----------------------------------------------------------------------
#include <iostream>
#include <stdio.h>
#include <time.h>

#ifndef WIN32
#  include <sys/time.h>
#  include <sys/times.h>
#  include <unistd.h>
#endif

using namespace std;
//----------------------------------------------------------------------
class Timer {
  private:
    static long    indent;  
    //for summary stats
    static double  best;
    static double  worst;
    static double  total;
    static long    count;

    double  mStart;
    #ifdef WIN32
        //long            tc_start;
        FILETIME  mKernelTime, mUserTime;
    #else
        //struct timeval  tv_start;
        struct tms  mStartUsage;
    #endif
    char*  msg;
    bool   summary;

  public:
    inline Timer ( const bool summary=false ) {
        Timer( (char*)NULL, summary );
    }
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    inline Timer ( char* m, const bool summary=false ) {
        //init our "timer" to determine how long will this take.
        ++Timer::indent;
        this->msg = m;
        this->summary = summary;
        reset();
    }
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    inline void reset ( void ) {
        #ifdef WIN32
            mStart = GetTickCount();

            FILETIME  creationTime, exitTime;
            GetProcessTimes( GetCurrentProcess(), &creationTime, &exitTime,
                &mKernelTime, &mUserTime );
        #else
            struct timeval   tv_start;
            struct timezone  tz_start;
            gettimeofday( &tv_start, &tz_start );
            mStart = tv_start.tv_sec + (tv_start.tv_usec / 1E6);

            times( &mStartUsage );
        #endif
    }
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    inline double getElapsedTime ( void ) {
        #ifdef WIN32
            long  tc_end = GetTickCount();
            return  (tc_end-mStart) / 1E3;
        #else
            struct timeval  tv_end;
            struct timezone tz_end;
            gettimeofday(&tv_end, &tz_end);
            double d_end   = tv_end.tv_sec + (tv_end.tv_usec / 1E6);
            return (d_end-mStart);
        #endif
    }
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    inline void report ( void ) {
        for (int i=0; i<Timer::indent; i++)    cout << "  ";
        if (this->msg != NULL) {
            cout << this->msg << " ";
        }
        cout << "elapsed time=" << getElapsedTime() << "s,";
        cout << " CPU time=" << getCPUTime() << "s";

        if (this->summary) {
            cout << ", best=" << Timer::best << ", worst=" << Timer::worst
                 << ", average=" << (Timer::total/Timer::count);
        }

        cout << endl;
    }
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    inline double getCPUTime ( void ) {
      #ifdef  WIN32
        FILETIME  creationTime, exitTime, kernelTime, userTime;
        GetProcessTimes( GetCurrentProcess(), &creationTime, &exitTime,
            &kernelTime, &userTime );
        //as recommended by bill:
        // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/filetime_str.asp
        ULARGE_INTEGER  u2;
        memcpy( &u2, &userTime, sizeof(userTime) );
        __int64*  i2 = (__int64*)&u2;
        ULARGE_INTEGER  u1;
        memcpy( &u1, &mUserTime, sizeof(mUserTime) );
        __int64*  i1 = (__int64*)&u1;
        __int64   i3 = *i2 - *i1;
        //from http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/filetime_str.asp
        // The FILETIME structure is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC).
        const double  userCPUTime = i3 * 100 / 1E9;

        //determine kernel cpu time
        memcpy( &u2, &kernelTime, sizeof(kernelTime) );
        i2 = (__int64*)&u2;
        memcpy( &u1, &mKernelTime, sizeof(mKernelTime) );
        i1 = (__int64*)&u1;
        i3 = *i2 - *i1;
        const double  kernelCPUTime = i3 * 100 / 1E9;

        return userCPUTime + kernelCPUTime;
      #else
        struct tms  usageAfter;
        times( &usageAfter );
        double  cpuTime = ((double)usageAfter.tms_utime - mStartUsage.tms_utime)
                                 / sysconf(_SC_CLK_TCK);
        cpuTime += ((double)usageAfter.tms_stime - mStartUsage.tms_stime)
                                 / sysconf(_SC_CLK_TCK);
        return cpuTime;
      #endif
    }
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    inline ~Timer ( ) {
        const double t = getElapsedTime();
        if (this->summary) {
            Timer::total += t;
            ++Timer::count;
            if (t>Timer::worst)  Timer::worst=t;
            if (t<Timer::best)   Timer::best =t;
        }
        report();
        --Timer::indent;
    }
};

long   Timer::indent = 0;
double Timer::best   = FLT_MAX;
double Timer::worst  = 0.0;
double Timer::total  = 0.0;
long   Timer::count  = 0;

#endif
//----------------------------------------------------------------------

---