UT_StopWatch.h

Go to the documentation of this file.

#ifndef _UT_StopWatch_h_
#define _UT_StopWatch_h_

#include "UT_API.h"
#include <SYS/SYS_Deprecated.h>
#include <SYS/SYS_Time.h>
#include <SYS/SYS_Types.h>
#include <stdlib.h>

/// A simple stopwatch class.
///
/// It implements functions much like a regular stopwatch:
///    start():     resets stopwatch to zero, and starts it.
///    lap():       returns the elapsed time.
///    stop():      stop the stopwatch
///    resume():    resumes the stopwatch
///    getTime():   returns elapsed time, may be used when stopped.
///    operator-:   difference in start time between two watches
///
class UT_StopWatch
{
public:
    void        clear();
    void        start();
    fpreal64    lap() const;
    fpreal64    stop();
    void        resume();
    fpreal64    restart();

    fpreal64    getTime() const;
    bool        isRunning() const;

    fpreal64    operator-(const UT_StopWatch &other);
    SYS_TimeVal getStartTime() const;

protected:
    bool        myRunning = false;  // is the watch is running?
    fpreal64    myElapsedTime = 0;

    SYS_TimeVal myStartTime;
};

// this class replaces the old timeStamp function, and can be used to more
// easily take timing measurements
//
// you still have the old timeStamp function that works in the same way, but
// also, you can use begin and end event functions which will output a duration
// along with the timestamps. another benefit is that it becomes easy to see
// the contained duration of a function.
//
// you can additionally use the indent function to give you the right
// indentation when inserting your own printfs
//
//
// so, to add timestamps, do this:
// UT_Timer             ts( "block 1" );
// ts.end();    // no need if scope ends, otherwise it displays
//
// don't mismatch your begins and ends or else everything will break
// if you want running totals send in the pointer to total
class UT_API UT_Timer
{
public:
    UT_Timer();
    explicit UT_Timer(const char *block_name);

    ~UT_Timer();

    UT_Timer(const UT_Timer &) = delete;
    UT_Timer &operator=(const UT_Timer &) = delete;

    static void indent();

    static void timeStamp(const char *msg1, const char *msg2=0);

    void clear();

    void begin( const char *block_name = NULL );
    int lap() { myCount++; return myCount; }
    void end();

    bool     isRunning() const { return myBegun; }

    fpreal64 getBlockDuration();
    fpreal64 getTotalDuration();
    fpreal64 getAverageDuration();

    void setDisplay( bool d )   { myDisplay = d; }
    bool willDisplay() const    { return myDisplay; }

    void displayBlockDuration( const char *block_name = NULL );
    void displayTotalDuration( const char *block_name = NULL );
    void displayAverageDuration( const char *block_name = NULL );

    static UT_Timer *getTimer(int id);

private:
    bool                        myBegun;
    bool                        myDisplay;
    UT_StopWatch                myBlockTimer;
    UT_StopWatch                mySavedBlockTimer;
    fpreal64                    myTotal;
    int                         myCount;

    static int                  theIndentation;
    static UT_StopWatch         theLastBlockTimer;
};

// For use with UT_TimerAuto to keep track of total time
class UT_TimerDisplayTotal : public UT_Timer
{
public:
    UT_TimerDisplayTotal(const char* block_name)
        : myBlockName(block_name)
    {
    }
    ~UT_TimerDisplayTotal()
    {
        displayAverageDuration(myBlockName);
        displayTotalDuration(myBlockName);
    }
private:
    const char* myBlockName;
};

// Used to accumulate time into a UT_Timer/UT_TimerDisplayTotal
class UT_API UT_TimerAuto
{
public:
    UT_TimerAuto(UT_Timer &ts, const char *name): myTimeStamp( ts )
    {
        myTimeStamp.begin( name );
    }

    UT_TimerAuto(UT_Timer &ts): myTimeStamp( ts )
    {
        myTimeStamp.begin();
    }

    ~UT_TimerAuto()
    {
        myTimeStamp.end();
    }

    UT_Timer    &myTimeStamp;
};

SYS_DEPRECATED_REPLACE(21.0, SYS_TimeVal) typedef SYS_TimeVal UT_TIMERVAL;

/////////////////////////////////////////////////////////////////////////////
//
// Inline implementations
//

inline void
UT_StopWatch::clear()
{
    myElapsedTime = 0;
}

inline void
UT_StopWatch::start()
{
    clear();
    resume();
}

inline fpreal64
UT_StopWatch::lap() const
{
    if (myRunning)
    {
        SYS_TimeVal now;

        SYSgettimeofday(&now);
        return myElapsedTime + SYStimeDiff(now, myStartTime);
    }
    return myElapsedTime;
}

inline fpreal64
UT_StopWatch::stop()
{
    if (myRunning)
    {
        SYS_TimeVal now;

        SYSgettimeofday(&now);
        myRunning = false;

        return myElapsedTime += SYStimeDiff(now, myStartTime);
    }
    return myElapsedTime;
}

inline void
UT_StopWatch::resume()
{
    if (myRunning)
        clear();

    SYSgettimeofday(&myStartTime);
    myRunning = true;
}

inline fpreal64
UT_StopWatch::restart()
{
    fpreal64 now = stop();
    start();
    return now;
}

inline fpreal64
UT_StopWatch::getTime() const
{
    return lap(); // should they be different?
}

inline bool
UT_StopWatch::isRunning() const
{
    return myRunning;
}

inline fpreal64
UT_StopWatch::operator-(const UT_StopWatch &other)
{
    return SYStimeDiff(myStartTime, other.myStartTime);
}

inline SYS_TimeVal
UT_StopWatch::getStartTime() const
{
    return myStartTime;
}

#endif  // _UT_StopWatch_h_