Eigen::BenchTimer Class Reference

#include <BenchTimer.h>

Public Member Functions
	BenchTimer ()
	~BenchTimer ()
void	reset ()
void	start ()
void	stop ()
double	value (int TIMER=CPU_TIMER) const
double	best (int TIMER=CPU_TIMER) const
double	worst (int TIMER=CPU_TIMER) const
double	total (int TIMER=CPU_TIMER) const
double	getCpuTime () const
double	getRealTime () const

Protected Attributes
Vector2d	m_starts
Vector2d	m_times
Vector2d	m_bests
Vector2d	m_worsts
Vector2d	m_totals

Detailed Description

Elapsed time timer keeping the best try.

On POSIX platforms we use clock_gettime with CLOCK_PROCESS_CPUTIME_ID. On Windows we use QueryPerformanceCounter

Important: on linux, you must link with -lrt

Constructor & Destructor Documentation

BenchTimer()

Eigen::BenchTimer::BenchTimer ( )

inline

               {
#if defined(_WIN32) || defined(__CYGWIN__)
    LARGE_INTEGER freq;
    QueryPerformanceFrequency(&freq);
    m_frequency = (double)freq.QuadPart;
#endif
    reset();
  }

References reset().

~BenchTimer()

Eigen::BenchTimer::~BenchTimer ( )

inline

{}

Member Function Documentation

best()

double Eigen::BenchTimer::best ( int  TIMER = CPU_TIMER ) const

inline

Return the best elapsed time in seconds

{ return m_bests[TIMER]; }

References m_bests.

Referenced by __attribute__(), bench(), and main().

getCpuTime()

double Eigen::BenchTimer::getCpuTime ( ) const

inline

                                   {
#ifdef _WIN32
    LARGE_INTEGER query_ticks;
    QueryPerformanceCounter(&query_ticks);
    return query_ticks.QuadPart / m_frequency;
#elif __APPLE__
    return double(mach_absolute_time()) * 1e-9;
#else
    timespec ts;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
    return double(ts.tv_sec) + 1e-9 * double(ts.tv_nsec);
#endif
  }

References e().

Referenced by start(), and stop().

getRealTime()

double Eigen::BenchTimer::getRealTime ( ) const

inline

                                    {
#ifdef _WIN32
    SYSTEMTIME st;
    GetSystemTime(&st);
    return (double)st.wSecond + 1.e-3 * (double)st.wMilliseconds;
#elif __APPLE__
    return double(mach_absolute_time()) * 1e-9;
#else
    timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    return double(ts.tv_sec) + 1e-9 * double(ts.tv_nsec);
#endif
  }

References e().

Referenced by start(), and stop().

reset()

void Eigen::BenchTimer::reset ( )

inline

                      {
    m_bests.fill(1e9);
    m_worsts.fill(0);
    m_totals.setZero();
  }

References m_bests, m_totals, and m_worsts.

Referenced by __attribute__(), bench_svd(), and BenchTimer().

start()

void Eigen::BenchTimer::start ( )

inline

                      {
    m_starts[CPU_TIMER] = getCpuTime();
    m_starts[REAL_TIMER] = getRealTime();
  }

References Eigen::CPU_TIMER, getCpuTime(), getRealTime(), m_starts, and Eigen::REAL_TIMER.

Referenced by __attribute__(), bench_svd(), and main().

stop()

void Eigen::BenchTimer::stop ( )

inline

                     {
    m_times[CPU_TIMER] = getCpuTime() - m_starts[CPU_TIMER];
    m_times[REAL_TIMER] = getRealTime() - m_starts[REAL_TIMER];
#if EIGEN_VERSION_AT_LEAST(2, 90, 0)
    m_bests = m_bests.cwiseMin(m_times);
    m_worsts = m_worsts.cwiseMax(m_times);
#else
    m_bests(0) = std::min(m_bests(0), m_times(0));
    m_bests(1) = std::min(m_bests(1), m_times(1));
    m_worsts(0) = std::max(m_worsts(0), m_times(0));
    m_worsts(1) = std::max(m_worsts(1), m_times(1));
#endif
    m_totals += m_times;
  }

References Eigen::CPU_TIMER, getCpuTime(), getRealTime(), m_bests, m_starts, m_times, m_totals, m_worsts, max, min, and Eigen::REAL_TIMER.

Referenced by __attribute__(), bench_svd(), and main().

total()

double Eigen::BenchTimer::total ( int  TIMER = CPU_TIMER ) const

inline

Return the total elapsed time in seconds.

{ return m_totals[TIMER]; }

References m_totals.

Referenced by main().

value()

double Eigen::BenchTimer::value ( int  TIMER = CPU_TIMER ) const

inline

Return the elapsed time in seconds between the last start/stop pair

{ return m_times[TIMER]; }

References m_times.

Referenced by __attribute__(), bench_svd(), and main().

worst()

double Eigen::BenchTimer::worst ( int  TIMER = CPU_TIMER ) const

inline

Return the worst elapsed time in seconds

{ return m_worsts[TIMER]; }

References m_worsts.

Member Data Documentation

m_bests

Vector2d Eigen::BenchTimer::m_bests

protected

Referenced by best(), reset(), and stop().

m_starts

Vector2d Eigen::BenchTimer::m_starts

protected

Referenced by start(), and stop().

m_times

Vector2d Eigen::BenchTimer::m_times

protected

Referenced by stop(), and value().

m_totals

Vector2d Eigen::BenchTimer::m_totals

protected

Referenced by reset(), stop(), and total().

m_worsts

Vector2d Eigen::BenchTimer::m_worsts

protected

Referenced by reset(), stop(), and worst().

---

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

• BenchTimer.h