source: GTP/trunk/Lib/Vis/Preprocessing/src/Timer/PerfTimerSkeleton.h @ 2015

// ---------------------------------------------------------------------------
//  class PERFTIMER definition
// ---------------------------------------------------------------------------

#ifndef DUMMY_TIMER

/** Very accurate Timer class for benchmarking on SGI systems.
        This timer can be used to accurately take measurements
        on all SGI-systems, usually in the microseconds range.

        Note: getting the time on an unavailable Timer returns garbage.
*/
class PERFTIMER
{
private:
        static TIMEVAL_T frequency;
        static bool isinitialized;
        static bool available;

public: // public for macro versions of Entry/Exit
        TIMEVAL_T start_count;
        TIMEVAL_T total_count;


public:
        
        // this retrieves the timer frequency - will be called by constructor
        // NOTE: allow this to be called externally, so logging can be enabled!
        static void InitClass(bool verbose);

        
        /// the time type used for Perftimers
        typedef double t_time;

        /// returns the frequency
        static double GetFrequency(bool verbose = false);

        /// Constructor calls Start
        PERFTIMER(bool verbose = false);

        /// use in conjunction with Exit() to time parts of code that are called more than once
        void Entry();
        /// stop counting but remember total
        void Exit();
        /// read total time elapsed and reset the time - to be used with Entry()/Exit()
        double TotalTime();
        
        /// reset and start the counter - use for timing one piece of code (implicit Entry())
        void Start();
        /** returns elapsed time in seconds - if restart is true, timer is also restarted - use with Start()
                (implicit Exit()/Entry() with same timestamp, with restart: implicit Exit()/TotalTime()/Entry())
        */
        double Elapsed(bool restart = true);
        /** returns elapsed time in milliseconds - if restart is true, timer is also restarted - use with Start()
                (implicit Exit()/Entry() with same timestamp, with restart: implicit Exit()/TotalTime()/Entry())
        */
        double Elapsedms(bool restart = true);
        
        // returns elapsed time in cycles - if restart is true, timer is also restarted
        //unsigned int ElapsedCycles(bool restart = true);
        
        /// false if no appropriate hardware found
        bool Available();
};

// ---------------------------------------------------------------------------
//  class PERFTIMER inline implementation
// ---------------------------------------------------------------------------

PERFTIMER_INLINE bool PERFTIMER::Available()
{
        /// HACK: no SGI detection!
        return available;
}

// macro version to ensure inlining
#define PERF_ENTRY(perftimer) TIMEVAL_GET((perftimer).start_count);

PERFTIMER_INLINE void PERFTIMER::Entry()
{
        TIMEVAL_GET(start_count);
}

PERFTIMER_INLINE void PERFTIMER::Start()
{
        TIMEVAL_ZERO(total_count);
        Entry();
}

// macro version to ensure inlining
#define PERF_EXIT(perftimer) { TIMEVAL_T end_count; TIMEVAL_GET(end_count); TIMEVAL_ADD((perftimer).total_count, end_count, (perftimer).start_count);}

PERFTIMER_INLINE void PERFTIMER::Exit()
{
        TIMEVAL_T end_count;
        TIMEVAL_GET(end_count);
        TIMEVAL_ADD(total_count, end_count, start_count);
}


PERFTIMER_INLINE double PERFTIMER::TotalTime()
{
        double time = TIMEVAL_TODOUBLE(total_count);
        TIMEVAL_ZERO(total_count);

        return time;
}

// returns elapsed time in seconds - if restart is true, timer is also restarted
PERFTIMER_INLINE double PERFTIMER::Elapsed(bool restart)
{
        TIMEVAL_T end_count;
        TIMEVAL_GET(end_count);
        TIMEVAL_ADD(total_count, end_count, start_count);

        TIMEVAL_ASSIGN(start_count, end_count); // unnecessary for entry/exit operation, but doesn't hurt

        double time = TIMEVAL_TODOUBLE(total_count);

        if (restart)
        {
                TIMEVAL_ZERO(total_count);
        }
        
        return time;
}

// returns elapsed time in milliseconds - if restart is true, timer is also restarted
PERFTIMER_INLINE double PERFTIMER::Elapsedms(bool restart)
{
        TIMEVAL_T end_count;
        TIMEVAL_GET(end_count);
        TIMEVAL_ADD(total_count, end_count, start_count);

        TIMEVAL_ASSIGN(start_count, end_count); // unnecessary for entry/exit operation, but doesn't hurt

        double time = TIMEVAL_TODOUBLE(total_count);

        if (restart)
        {
                TIMEVAL_ZERO(total_count);
        }
        
        return time * 1000.;
}

// Constructor calls Start
PERFTIMER_INLINE PERFTIMER::PERFTIMER(bool verbose)
{
        if (!isinitialized)
                InitClass(verbose);

        //TIMEVAL_ZERO(total_count);
        Start();
}

#else

class PERFTIMER
{
public:
        PERFTIMER(bool x = false) {}
        static double GetFrequency(bool) {return 1;}
        void Start() {}
        double Elapsed(bool restart = true) { return 0; }
        double Elapsedms(bool restart = true) { return 0; }
        void Entry() {}
        void Exit() {}
        double TotalCount() { return 0; }
        bool Available() { return false; }
};

#endif