Utils::AverageTiming Class Reference

Singleton timing class for average measurement of different timing blocks in loops. More...

#include <AverageTiming.h>

Inherits std::map< std::string, AverageTimingBlock * >.

Public Member Functions
	AverageTiming ()
	~AverageTiming ()

Static Public Member Functions
static void	start (const std::string &name)
	start timer for a new or existing block More...
static void	stop (const std::string &name)
	stop timer for a running block with name More...
static float	getTime (const std::string &name)
	get time for block with name More...
static float	getTime (const std::vector< std::string > &names)
	get time for multiple blocks with given names More...
static void	getTimingMessage (char *m)
	get timings formatted via string More...
static AverageTiming &	instance ()
	singleton More...

Private Member Functions
void	doStart (const std::string &name)
	do start timer for a new or existing block More...
void	doStop (const std::string &name)
	do stop timer for a running block with name More...
float	doGetTime (const std::string &name)
	do get time for block with name More...
float	doGetTime (const std::vector< std::string > &names) const
	do get time for multiple blocks with given names More...
void	doGetTimingMessage (char *m)
	do get timings formatted via string More...

Private Attributes
int	_averageNumValues = 200
int	_currentPosV = 0
int	_currentPosH = 0

Detailed Description

Singleton timing class for average measurement of different timing blocks in loops.

Call start("name") to define a new timing block and start timing or start timing of an existing block. Call stop("name") to finish measurement for this block. Define a hierarchy by posV and posH which is used in ui to arrange the measurements. The first found content with posV==0 is used as reference measurement for the percental value.

Definition at line 54 of file AverageTiming.h.

Constructor & Destructor Documentation

AverageTiming()

Utils::AverageTiming::AverageTiming

(

)

Definition at line 20 of file AverageTiming.cpp.

{
}

~AverageTiming()

Utils::AverageTiming::~AverageTiming

(

)

Definition at line 24 of file AverageTiming.cpp.

{
    for (auto& block : *this)
    {
        if (block.second)
            delete block.second;
    }
}

Member Function Documentation

doGetTime() [1/2]

float Utils::AverageTiming::doGetTime ( const std::string &  name )

private

do get time for block with name

get time for block with name

Definition at line 102 of file AverageTiming.cpp.

{
    if (find(name) != end())
    {
        return (*this)[name]->val.average();
    }
    else
        Utils::log("AverageTiming: A block with name %s does not exist!", name.c_str());
 
    return 0.0f;
}

doGetTime() [2/2]

float Utils::AverageTiming::doGetTime ( const std::vector< std::string > &  names ) const

private

do get time for multiple blocks with given names

get time for multiple blocks with given names

Definition at line 116 of file AverageTiming.cpp.

{
    AvgFloat val(_averageNumValues, 0.0f);
    for (const std::string& n : names)
    {
        val.set(getTime(n));
    }
 
    return val.average();
}

doGetTimingMessage()

void Utils::AverageTiming::doGetTimingMessage ( char *  m )

private

do get timings formatted via string

Definition at line 128 of file AverageTiming.cpp.

{
    // sort vertically
    std::vector<AverageTimingBlock*> blocks;
    for (auto& block : AverageTiming::instance())
    {
        blocks.push_back(block.second);
    }
    std::sort(blocks.begin(),
              blocks.end(),
              [](AverageTimingBlock* lhs, AverageTimingBlock* rhs) -> bool
              { return lhs->posV < rhs->posV; });
 
    // find reference time
    float refTime = 1.0f;
    if (!blocks.empty())
    {
        refTime = (*blocks.begin())->val.average();
        // insert number of measurement calls
        volatile int sizeofm = sizeof(m); // workaround against a warning in the next line
        snprintf(m + strlen(m), sizeofm, "Num. calls: %i\n", (int)(*blocks.begin())->nCalls);
    }
 
    // calculate longest blockname
    size_t maxLen = 0;
    for (auto* block : blocks)
        if (block->name.length() > maxLen)
            maxLen = block->name.length();
 
    // insert time measurements
    for (auto* block : blocks)
    {
        float  val   = block->val.average();
        float  valPC = Utils::clamp(val / refTime * 100.0f, 0.0f, 100.0f);
        string name  = block->name;
 
        name.append(maxLen - name.length(), ' ');
 
        stringstream ss;
        // for (int i = 0; i < block->posH; ++i)
        //     ss << " ";
        ss << "%s: %4.1f ms (%3d%%)\n";
        snprintf(m + strlen(m), sizeof(m), ss.str().c_str(), name.c_str(), val, (int)valPC);
    }
} //-----------------------------------------------------------------------------

doStart()

void Utils::AverageTiming::doStart ( const std::string &  name )

private

do start timer for a new or existing block

start timer for a new or existing block

Definition at line 64 of file AverageTiming.cpp.

{
    if (find(name) == end())
    {
        AverageTimingBlock* block = new AverageTimingBlock(
          _averageNumValues, name, this->_currentPosV++, this->_currentPosH);
        (*this)[name] = block;
    }
 
    // if ((*this)[name]->isStarted)
    //     SL_LOG("AverageTiming: Block with name %s started twice!", name.c_str());
 
    (*this)[name]->timer.start();
    (*this)[name]->isStarted = true;
 
    this->_currentPosH++;
}

doStop()

void Utils::AverageTiming::doStop ( const std::string &  name )

private

do stop timer for a running block with name

stop timer for a running block with name

Definition at line 84 of file AverageTiming.cpp.

{
    if (find(name) != end())
    {
        if (!(*this)[name]->isStarted)
            Utils::log("AverageTiming: Block with name %s stopped without being started!", name.c_str());
        (*this)[name]->timer.stop();
        (*this)[name]->val.set((*this)[name]->timer.elapsedTimeInMilliSec());
        (*this)[name]->nCalls++;
        (*this)[name]->isStarted = false;
        this->_currentPosH--;
    }
    else
        Utils::log("AverageTiming: A block with name %s does not exist!", name.c_str());
}

getTime() [1/2]

float Utils::AverageTiming::getTime ( const std::string &  name )

static

get time for block with name

Definition at line 46 of file AverageTiming.cpp.

{
    return AverageTiming::instance().doGetTime(name);
}

getTime() [2/2]

float Utils::AverageTiming::getTime ( const std::vector< std::string > &  names )

static

get time for multiple blocks with given names

Definition at line 52 of file AverageTiming.cpp.

{
    return AverageTiming::instance().doGetTime(names);
}

getTimingMessage()

void Utils::AverageTiming::getTimingMessage ( char *  m )

static

get timings formatted via string

Definition at line 58 of file AverageTiming.cpp.

{
    AverageTiming::instance().doGetTimingMessage(m);
}

instance()

static AverageTiming& Utils::AverageTiming::instance ( )

inlinestatic

singleton

Definition at line 72 of file AverageTiming.h.

    {
        static AverageTiming timing;
        return timing;
    }

start()

void Utils::AverageTiming::start ( const std::string &  name )

static

start timer for a new or existing block

Definition at line 34 of file AverageTiming.cpp.

{
    AverageTiming::instance().doStart(name);
}

stop()

void Utils::AverageTiming::stop ( const std::string &  name )

static

stop timer for a running block with name

Definition at line 40 of file AverageTiming.cpp.

{
    AverageTiming::instance().doStop(name);
}

Member Data Documentation

_averageNumValues

int Utils::AverageTiming::_averageNumValues = 200

private

Definition at line 91 of file AverageTiming.h.

_currentPosH

int Utils::AverageTiming::_currentPosH = 0

private

Definition at line 93 of file AverageTiming.h.

_currentPosV

int Utils::AverageTiming::_currentPosV = 0

private

Definition at line 92 of file AverageTiming.h.

---

The documentation for this class was generated from the following files:

• AverageTiming.h
• AverageTiming.cpp