|| || || || || || || ||

---

Timer.h

Go to the documentation of this file.

#ifndef Impala_Basis_Timer_h
#define Impala_Basis_Timer_h

#ifdef unix
// mode = 0
#include <sys/param.h>
#include <sys/times.h>
#include <limits.h>
#include <unistd.h>
// mode = 1
#include <sys/time.h>
#else
// mode = 0
#include <ctime>
// mode = 1
#include <windows.h> // it might be possible to include a 'smaller' headerfile
#undef small // the fucking idiots define this to char apparently
#endif

#include <stdio.h>
#include "Basis/String.h"

namespace Impala
{


class Timer
{
public: 

    // mode 0 == process time using milliseconds
    // mode 1 == real time using high resolution
    Timer(int mode = 1) : mMode(mode) // also starts the timer
    {
#ifdef unix
        // no platform dependent initialization required
#else
        LARGE_INTEGER freqStruct;
        if (QueryPerformanceFrequency(&freqStruct))
        {
            mFreq = freqStruct.HighPart;
            mFreq = mFreq << 32;
            mFreq |= freqStruct.LowPart;
        }
        else
        {
            std::cout << "Timer: no QueryPerformanceFrequency" << std::endl;
        }
        if (! QueryPerformanceCounter(&freqStruct)) // is this test needed?
            std::cout << "Timer: no QueryPerformanceCounter" << std::endl;
#endif
        Start();
    }

    void
    Start() // (re-) start the timer
    {
#ifdef unix
        if (mMode == 0)
        {
            times(&mCpuTime);
            mUsrTime = mCpuTime.tms_utime;
            mSysTime = mCpuTime.tms_stime;
        }
        else
        {
            gettimeofday(&mStartTime, 0);
        }
#else
        if (mMode == 0)
        {
            mCpuTime = clock();
        }
        else
        {
            LARGE_INTEGER countStruct;
            QueryPerformanceCounter(&countStruct);
            mStartTime = countStruct.HighPart;
            mStartTime = mStartTime << 32;
            mStartTime |= countStruct.LowPart;
        }
#endif
    }

    double
    SplitTime() // returns elapsed time (seconds), timer keeps running
    {
        double val;
#ifdef unix
        if (mMode == 0)
        {
            times(&mCpuTime);
            time_t splitUsrTime = mCpuTime.tms_utime - mUsrTime;
            time_t splitSysTime = mCpuTime.tms_stime - mSysTime;
            val = (double) (splitUsrTime + splitSysTime) / HZ;
        }
        else
        {
            struct timeval splitTime;
            gettimeofday(&splitTime, 0);
            val = (double) (splitTime.tv_sec - mStartTime.tv_sec);
            long uSec = splitTime.tv_usec - mStartTime.tv_usec;
            val += (double) uSec / 1000000;
        }
#else
        if (mMode == 0)
        {
            clock_t splitCpuTime = clock() - mCpuTime;
            val = (double) splitCpuTime / CLOCKS_PER_SEC;
        }
        else
        {
            LARGE_INTEGER splitTimeStruct;
            QueryPerformanceCounter(&splitTimeStruct);
            LONGLONG splitTime = splitTimeStruct.HighPart;
            splitTime = splitTime << 32;
            splitTime |= splitTimeStruct.LowPart;
            splitTime -= mStartTime;
            val = (double) splitTime / mFreq;
        }
#endif
        return val;
    }

    String
    SplitTimeStr(double divide = 1.0) // SplitTime/divide as a formatted string
    {
        char printBuf[2048];
        double secs = SplitTime() / divide;
        int hours = int (secs / 3600);
        secs -= hours * 3600;
        int minutes = int (secs / 60);
        secs -= minutes * 60;
        sprintf(printBuf, "%dh%dm%.2fs", hours, minutes, secs);
        return String(printBuf);
    }

    double
    Stop() // stop timer and return elapsed time
    {
        double val;
#ifdef unix
        if (mMode == 0)
        {
            times(&mCpuTime);
            mUsrTime = mCpuTime.tms_utime - mUsrTime;
            mSysTime = mCpuTime.tms_stime - mSysTime;
            val = (double) (mUsrTime + mSysTime) / HZ;
        }
        else
        {
            struct timeval splitTime;
            gettimeofday(&splitTime, 0);
            val = (double) (splitTime.tv_sec - mStartTime.tv_sec);
            long uSec = splitTime.tv_usec - mStartTime.tv_usec;
            val += (double) uSec / 1000000;
        }
#else
        if (mMode == 0)
        {
            mCpuTime = clock() - mCpuTime;
            val = (double) mCpuTime / CLOCKS_PER_SEC;
        }
        else
        {
            LARGE_INTEGER splitTimeStruct;
            QueryPerformanceCounter(&splitTimeStruct);
            LONGLONG splitTime = splitTimeStruct.HighPart;
            splitTime = splitTime << 32;
            splitTime |= splitTimeStruct.LowPart;
            splitTime -= mStartTime;
            val = (double) splitTime / mFreq;
        }
#endif
        return val;
    }

private:

    int            mMode;

#ifdef unix
    // mode = 0
    struct tms     mCpuTime;
    time_t         mSysTime;
    time_t         mUsrTime;
    // mode = 1
    struct timeval mStartTime;
#else
    // mode = 0
    clock_t        mCpuTime;
    // mode = 1
    LONGLONG       mFreq; // signed 64bit integer
    LONGLONG       mStartTime;
#endif

};

} // namespace Impala

#endif

---