G3D::Stopwatch Class Reference

Accurately measure durations and framerates. More...

#include <Stopwatch.h>

Public Member Functions
	Stopwatch (const std::string &name="Stopwatch")
void	setEnabled (bool e)
bool	enabled () const
double	FPS () const
RealTime	elapsedTime () const
RealTime	smoothElapsedTime () const
double	smoothFPS () const
uint64	elapsedCycles () const
void	tick ()
void	tock ()
void	reset ()
void	after (const std::string &s="")

Private Member Functions
void	computeOverhead ()

Private Attributes
std::string	myName
bool	m_enabled
double	startTime
std::string	prevMark
double	prevTime
bool	inBetween
uint64	cycleStart
RealTime	timeStart
RealTime	lastTockTime
RealTime	lastDuration
int64	lastCycleCount
double	m_fps
double	emwaFPS
double	m_smoothFPS
RealTime	emwaDuration
int64	cycleOverhead

Detailed Description

Accurately measure durations and framerates.

Example 1: For profiling code in the context of a rendering loop:

    sw.tick();
    ...timed code...
    sw.tock();

    screenPrintf("%f\n", sw.smoothFPS());
  

Example 2: For profiling pieces of a sequence:

  Stopwatch sw;
  slowOperation();
  sw.after("slowOperation");
  kdTree.balance();
  sw.after("Balance tree");
 

Constructor & Destructor Documentation

G3D::Stopwatch::Stopwatch

(

const std::string &

name = "Stopwatch"

)

 : 
 myName(myName), 
 inBetween(false), lastTockTime(-1), 
 lastDuration(0), lastCycleCount(0), m_fps(0), emwaFPS(0),
 m_smoothFPS(0), emwaDuration(0) {
 computeOverhead();
 reset();
}

Here is the call graph for this function:

Member Function Documentation

void G3D::Stopwatch::after

(

const std::string &

s = ""

)

Call after an operation has completed, with the name of the operation, to print a debug message listing the time since the previous after() call.

Does nothing if the stopwatch is disabled.

 {
 RealTime now = System::time();
 if (m_enabled) {
 debugPrintf("%s: %10s - %8fs since %s (%fs since start)\n",
 myName.c_str(),
 s.c_str(),
 now - prevTime,
 prevMark.c_str(),
 now - startTime);
 }
 prevTime = now;
 prevMark = s;
}

Here is the call graph for this function:

void G3D::Stopwatch::computeOverhead ( )

private

Called from the constructor.

 {
 cycleOverhead = 0;
 tick();
 tock();
 cycleOverhead = elapsedCycles();
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint64 G3D::Stopwatch::elapsedCycles ( ) const

inline

The elapsed cycle time between tick and tock. An attempt is made to factor out all tick/tock overhead, so that back-to-back calls should return zero. Unreliable on non-x86 platforms.

 {
 return lastCycleCount;
 }

Here is the caller graph for this function:

RealTime G3D::Stopwatch::elapsedTime ( ) const

inline

Amount of time between the most recent tick and tock calls. 0 if tick has never been called.

 {
 return lastDuration;
 }

bool G3D::Stopwatch::enabled ( ) const

inline

A stopwatch only prints output when enabled

 {
 return m_enabled;
 }

double G3D::Stopwatch::FPS ( ) const

inline

Returns the number of times that tick was called per wall-clock second; e.g. frames-per-second.

 {
 return m_fps;
 }

void G3D::Stopwatch::reset

(

)

Reset the start time used by after() and the emwa value.

 {
 prevTime = startTime = System::time();
 prevMark = "start";
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Stopwatch::setEnabled ( bool  e )

inline

 {
 m_enabled = e;
 }

RealTime G3D::Stopwatch::smoothElapsedTime ( ) const

inline

Time-smoothed value that is stable to the nearest 1%. This is useful if you are displaying elapsed time in real-time and want a stable number.

 {
 return emwaDuration;
 }

double G3D::Stopwatch::smoothFPS ( ) const

inline

Time-smoothed value of fps that is stable to the nearest integer for fps > 10 and to the first decimal place for fps <= 10. This is useful if you are displaying the frame rate in real-time and want a stable (readable) number.

 {
 return m_smoothFPS;
 }

void G3D::Stopwatch::tick

(

)

Call at the beginning of the period that you want timed.

 {
 // This is 'alwaysAssert' instead of 'debugAssert'
 // since people rarely profile in debug mode.
 alwaysAssertM(! inBetween, "Stopwatch::tick() called twice in a row.");
 inBetween = true;

 // We read RDTSC twice here, but it is more abstract to implement this
 // way and at least we're reading the cycle count last.
 timeStart = System::time();
 System::beginCycleCount(cycleStart);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Stopwatch::tock

(

)

Call at the end of the period that you want timed.

 {
 System::endCycleCount(cycleStart);
 RealTime now = System::time();
 lastDuration = now - timeStart;
 if (abs(emwaDuration - lastDuration) > max(emwaDuration, lastDuration) * 0.50) {
 // Off by more than 50%
 emwaDuration = lastDuration;
 } else {
 emwaDuration = lastDuration * 0.05 + emwaDuration * 0.95;
 }

 lastCycleCount = cycleStart - cycleOverhead;
 if (lastCycleCount < 0) {
 lastCycleCount = 0;
 }

 if (lastTockTime != -1.0) {
 m_fps = 1.0 / (now - lastTockTime);

 const double blend = 0.01;
 emwaFPS = m_fps * blend + emwaFPS * (1.0 - blend);

 double maxDiscrepancyPercentage = 0.25;
 if (abs(emwaFPS - m_fps) > max(emwaFPS, m_fps) * maxDiscrepancyPercentage) {
 // The difference between emwa and m_fps is way off, so
 // update emwa directly.
 emwaFPS = m_fps * 0.20 + emwaFPS * 0.80;
 }

 // Update m_smoothFPS only when the value varies significantly.
 // We round so as to not mislead the user as to the accuracy of 
 // the number. 
 if (m_smoothFPS == 0) {
 m_smoothFPS = m_fps;
 } else if (emwaFPS <= 20) {
 if (::fabs(m_smoothFPS - emwaFPS) > 0.75) {
 // Small number and display is off by more than 0.75; round to the nearest 0.1
 m_smoothFPS = floor(emwaFPS * 10.0 + 0.5) / 10.0;
 }
 } else if (::fabs(m_smoothFPS - emwaFPS) > 1.25) {
 // Large number and display is off by more than 1.25; round to the nearest 1.0
 m_smoothFPS = floor(emwaFPS + 0.5);
 } 
 }
 lastTockTime = now;

 alwaysAssertM(inBetween, "Stopwatch::tock() called without matching tick.");
 inBetween = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

int64 G3D::Stopwatch::cycleOverhead

private

The overhead for calling into the class.

uint64 G3D::Stopwatch::cycleStart

private

The initial cycle count.

RealTime G3D::Stopwatch::emwaDuration

private

Weighted duration

double G3D::Stopwatch::emwaFPS

private

Weighted fps

bool G3D::Stopwatch::inBetween

private

True between tick and tock

int64 G3D::Stopwatch::lastCycleCount

private

RealTime G3D::Stopwatch::lastDuration

private

RealTime G3D::Stopwatch::lastTockTime

private

The time at which the previous tock was called, -1 if never.

bool G3D::Stopwatch::m_enabled

private

double G3D::Stopwatch::m_fps

private

Frames per second.

double G3D::Stopwatch::m_smoothFPS

private

std::string G3D::Stopwatch::myName

private

std::string G3D::Stopwatch::prevMark

private

double G3D::Stopwatch::prevTime

private

double G3D::Stopwatch::startTime

private

RealTime G3D::Stopwatch::timeStart

private

The time at which tick was called.

---

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

• dep/g3dlite/include/G3D/Stopwatch.h
• dep/g3dlite/source/Stopwatch.cpp