MeVis/Foundation/Sources/MLProfilingManager/Include/mlTimer.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------
// A timer implementation that is thread aware.
//
// \file    mlTimer.h
// \author  Marcus Barann
// \date    6/2010
//
//----------------------------------------------------------------------------------
#ifndef _ML_TIMER_H_
#define _ML_TIMER_H_


#include "mlProfilingManagerDllExport.h"

#include <mlErrorOutput.h>
#include <mlTimeCounter.h>


class MLTimeProfile;

class MLPROFILINGMANAGER_EXPORT MLTimer
{
public:
  MLTimer();
  ~MLTimer();

  inline void start();
  inline void stop();

  inline void start(MLTimer& otherToPause);

  inline void stop(MLTimer& otherToResume);

  long double elapsed() const { return _elapsed; }

  long double consumed() const { return _elapsed - _pausedElapsed; }
  unsigned int startCount() const { return _startCount; }

private:
  long double       _startTime;
  long double       _pausedStartTime;
  long double       _pausedElapsed;
  long double       _elapsed;
  bool              _isActive;
  bool              _isPaused;
  unsigned int      _startCount;

  friend class MLTimeProfile;
  friend class MLCallGraphNode;
};


inline void MLTimer::start()
{
  if (!_isActive) {
    _elapsed = 0;
    _pausedElapsed = 0;
    _pausedStartTime = 0;
    _startTime = ML_NAMESPACE::TimeCounter().getCurrentValueInSeconds();
    _isActive = true;
    ++_startCount;
  } else {
    ML_PRINT_ERROR("MLTimer::start", "Timer is already active", "");
  }
}


inline void MLTimer::stop()
{
  if (_isActive) {
    _elapsed = ML_NAMESPACE::TimeCounter().getCurrentValueInSeconds()-_startTime;
    _isActive = false;
  } else {
    ML_PRINT_ERROR("MLTimer::stop", "Timer is not active", "");
  }
}


inline void MLTimer::stop(MLTimer& otherToResume)
{
  long double now = ML_NAMESPACE::TimeCounter().getCurrentValueInSeconds();

  if (otherToResume._isActive) {
    if (otherToResume._isPaused) {
      otherToResume._pausedElapsed += now-otherToResume._pausedStartTime;
      otherToResume._isPaused = false;
    } else {
      ML_PRINT_ERROR("MLTimer::stop", "Other timer is not paused", "");
    }
  } else {
    ML_PRINT_ERROR("MLTimer::stop", "Other timer is not active", "");
  }

  if (_isActive) {
    _elapsed = now-_startTime;
    _isActive = false;
  } else {
    ML_PRINT_ERROR("MLTimer::stop", "Timer is not active", "");
  }
}


inline void MLTimer::start(MLTimer& otherToPause)
{
  long double now = ML_NAMESPACE::TimeCounter().getCurrentValueInSeconds();

  if (otherToPause._isActive) {
    if (!otherToPause._isPaused) {
      otherToPause._pausedStartTime = now;
      otherToPause._isPaused = true;
    } else {
      ML_PRINT_ERROR("MLTimer::start", "Other timer is already paused", "");
    }
  } else {
    ML_PRINT_ERROR("MLTimer::start", "Other timer is not active", "");
  }

  if (!_isActive) {
    _elapsed = 0;
    _pausedElapsed = 0;
    _pausedStartTime = 0;
    _startTime = now;
    _isActive = true;
    ++_startCount;
  } else {
    ML_PRINT_ERROR("MLTimer::start", "Timer is already active", "");
  }
}


#endif // _ML_TIMER_H