HighResWallClockTimer.h

Go to the documentation of this file.

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000- 2008, Hammersmith Imanet Ltd
    Copyright (C) 2023 University College London
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/

/*
 Modification history:
 
  <TT>
  Sep 2023 -- Kris Thielemans -- fixed WIN32 version
  May 2015 -- Kris Thielemans -- removed overflow when using gettimeofday and reinstated AZ's WIN32 version (as MS had
 get_nanosec() wrong) May 2008 -- Kris Thielemans -- renamed PTimer to HighResWallClockTimer and renamed functions to by
 compatible with stir::Timer 18 Aug 99 -- Mustapha Sadki -- corrected the formula for HighResWallClockTimer::stop() &
 HighResWallClockTimer::GetTime() for WIN32\n 08 Jul 99 -- Mustapha Sadki -- added global Ptimers and #define manipulations\n 10
 Apr 99 -- Alexey Zverovich -- Ported to Linux\n 19 Oct 98 -- Alexey Zverovich -- Ported to Win32;\n 19 Oct 98 -- Alexey Zverovich
 -- Slightly reorganised HighResWallClockTimer::start() to reduce overhead\n 16 Oct 98 -- Alexey Zverovich -- created
  </TT>
 
*/
 
#ifndef __stir_HIGHRESWALLCLOCKTIMER_H__
#define __stir_HIGHRESWALLCLOCKTIMER_H__
 
#if defined(WIN32)
#  include <windows.h>
#else
#  include <sys/time.h>
#endif
 
#include <assert.h>
 
namespace stir
{

 
class HighResWallClockTimer
{
public:
  inline HighResWallClockTimer(void);
  inline virtual ~HighResWallClockTimer(void);
 
  // Default copy ctor & assignment op are just fine

  inline void start(bool bReset = false);
  inline void stop(void);
  inline void reset(void);
  inline bool is_running(void);

  inline int get_sec(void);
  inline int get_nanosec(void);
  inline double value(void);

  static int get_resolution_in_nanosecs(void); // in nanoseconds
 
protected:
private:
  bool m_bRunning;
  int m_Secs;
  int m_Nanosecs;
 
#if defined(_AIX)
  timebasestruct_t m_Start;
  timebasestruct_t m_Finish;
#elif defined(__sun)
  hrtime_t m_Start;
  hrtime_t m_Finish;
#elif defined(WIN32)
  LARGE_INTEGER m_Start;
  LARGE_INTEGER m_Finish;
#else
// default to using gettimeofday which is on most unix (and all Linux) systems
#  define STIR_HRWCT_Use_gettimeofday
  timeval m_Start;
  timeval m_Finish;
#endif
};

inline HighResWallClockTimer::HighResWallClockTimer(void)
    : m_bRunning(false)
{
  reset();
};

inline HighResWallClockTimer::~HighResWallClockTimer(void)
{
  assert(!m_bRunning);
};

inline void
HighResWallClockTimer::start(bool bReset /* = false */)
{
  if (bReset)
    reset();
  m_bRunning = true;
#if defined(_AIX)
  read_real_time(&m_Start, TIMEBASE_SZ);
#elif defined(__sun)
  m_Start = gethrtime();
#elif defined(WIN32)
#  ifndef NDEBUG
  BOOL Result =
#  endif
      QueryPerformanceCounter(&m_Start);
  assert(Result); // if failed, high-resolution timers are not supported by this hardware
#elif defined(STIR_HRWCT_Use_gettimeofday)
  // TODO: what will happen if the time gets changed?
#  ifndef NDEBUG
  int Result =
#  endif
      gettimeofday(&m_Start, NULL);
  assert(Result == 0);
#endif
};

inline void
HighResWallClockTimer::stop(void)
{
  assert(m_bRunning);
 
#if defined(_AIX)
 
  read_real_time(&m_Finish, TIMEBASE_SZ);
 
  time_base_to_time(&m_Start, TIMEBASE_SZ);
  time_base_to_time(&m_Finish, TIMEBASE_SZ);
 
  int Secs = m_Finish.tb_high - m_Start.tb_high;
  int Nanosecs = m_Finish.tb_low - m_Start.tb_low;
 
  // If there was a carry from low-order to high-order during
  // the measurement, we may have to undo it.
 
  if (Nanosecs < 0)
    {
      Secs--;
      Nanosecs += 1000000000;
    };
 
  m_Secs += Secs;
  m_Nanosecs += Nanosecs;
  if (m_Nanosecs >= 1000000000)
    {
      m_Secs++;
      m_Nanosecs -= 1000000000;
    };
 
#elif defined(__sun)
 
  m_Finish = gethrtime();
 
  m_Secs += (m_Finish - m_Start) / 1000000000;
  m_Nanosecs += (m_Finish - m_Start) % 1000000000;
  if (m_Nanosecs >= 1000000000)
    {
      m_Secs++;
      m_Nanosecs -= 1000000000;
    };
 
#elif defined(WIN32)
 
  BOOL Result = QueryPerformanceCounter(&m_Finish);
  assert(Result); // if failed, high-resolution timers are not supported by this hardware
 
  LONGLONG Delta = m_Finish.QuadPart - m_Start.QuadPart;
  LARGE_INTEGER Freq;
  Result = QueryPerformanceFrequency(&Freq);
  assert(Result); // if failed, high-resolution timers are not supported by this hardware
  const auto DeltaSecs = Delta / Freq.QuadPart;
  m_Secs += static_cast<int>(DeltaSecs);
  // handle remainder
  Delta -= DeltaSecs * Freq.QuadPart;
  // convert to nano-secs
  Delta *= 1000000000;
  Delta /= Freq.QuadPart;
  m_Nanosecs += static_cast<int>(Delta);
  if (m_Nanosecs >= 1000000000)
    {
      m_Secs++;
      m_Nanosecs -= 1000000000;
    }
 
#elif defined(STIR_HRWCT_Use_gettimeofday)
 
#  ifndef NDEBUG
  int Result =
#  endif
      gettimeofday(&m_Finish, NULL);
  assert(Result == 0);
  m_Secs += (m_Finish.tv_sec - m_Start.tv_sec);
  int Microsecs = (m_Finish.tv_usec - m_Start.tv_usec);
  if (Microsecs < 0)
    {
      m_Secs--;
      Microsecs += 1000000;
    };
 
  m_Nanosecs += (Microsecs * 1000);
  if (m_Nanosecs >= 1000000000)
    {
      m_Secs++;
      m_Nanosecs -= 1000000000;
    };
 
#endif
 
  assert(m_Secs >= 0);
  assert(m_Nanosecs >= 0 && m_Nanosecs < 1000000000);
 
  m_bRunning = false;
};

inline void
HighResWallClockTimer::reset(void)
{
  assert(!m_bRunning);
  m_Secs = m_Nanosecs = 0;
};

inline bool
HighResWallClockTimer::is_running(void)
{
  return m_bRunning;
};

inline int
HighResWallClockTimer::get_sec(void)
{
  assert(!m_bRunning);
  return m_Secs;
};

inline int
HighResWallClockTimer::get_nanosec(void)
{
  assert(!m_bRunning);
  return m_Nanosecs;
};

inline double
HighResWallClockTimer::value(void)
{
  return get_sec() + double(get_nanosec()) / 1e9;
}
 
// HighResWallClockTimer.cxx -- high-resolution timers implementation
 
// Modification history:
//
//  19 Oct 98 -- Alexey Zverovich -- created

 
inline int
HighResWallClockTimer::get_resolution_in_nanosecs(void)
{
 
  /*static*/ int Resolution = -1; // cached resolution
 
  if (Resolution > 0)
    return Resolution;
 
#if defined(_AIX)
 
  timebasestruct_t Start;
  timebasestruct_t Current;
 
  read_real_time(&Start, TIMEBASE_SZ);
  time_base_to_time(&Start, TIMEBASE_SZ);
 
  int MinSecs = -1; // no minimum yet
  int MinNanosecs = -1;
  int SecondsElapsed = 0;
 
  do
    {
      timebasestruct_t Times[2];
 
      read_real_time(&Times[0], TIMEBASE_SZ);
      do
        {
          read_real_time(&Times[1], TIMEBASE_SZ);
          assert(Times[1].flag == Times[0].flag);
      } while (Times[1].tb_high == Times[0].tb_high && Times[1].tb_low == Times[0].tb_low);
 
      time_base_to_time(&Times[0], TIMEBASE_SZ);
      time_base_to_time(&Times[1], TIMEBASE_SZ);
 
      int Secs = Times[1].tb_high - Times[0].tb_high;
      int Nanosecs = Times[1].tb_low - Times[0].tb_low;
 
      // If there was a carry from low-order to high-order during
      // the measurement, we may have to undo it.
 
      if (Nanosecs < 0)
        {
          Secs--;
          Nanosecs += 1000000000;
        };
 
      assert(Secs >= 0 && Nanosecs >= 0 && Nanosecs < 1000000000);
      assert(Secs != 0 || Nanosecs != 0); // shouldn't be the same as we checked in the 'do' loop
 
      //        cout << "[" << Secs << " " << Nanosecs << "]" << endl;
 
      if (MinSecs < 0 || Secs < MinSecs || (Secs == MinSecs && Nanosecs < MinNanosecs))
        {
          MinSecs = Secs;
          MinNanosecs = Nanosecs;
        };
 
      read_real_time(&Current, TIMEBASE_SZ);
      time_base_to_time(&Current, TIMEBASE_SZ);
 
      SecondsElapsed = Current.tb_high - Start.tb_high;
      if (Current.tb_low < Start.tb_low)
        SecondsElapsed--;
  } while (SecondsElapsed < 1);
 
  assert(MinSecs < 2); // otherwise it's too coarse for this measurement
 
  Resolution = MinSecs * 1000000000 + MinNanosecs;
 
#elif defined(__sun)
 
  hrtime_t Start = gethrtime();
  hrtime_t Current;
 
  hrtime_t MinNanosecs = -1;
 
  do
    {
      hrtime_t Times[2];
 
      Times[0] = gethrtime();
 
      while ((Times[1] = gethrtime()) == Times[0]) /* do nothing */
        ;
 
      hrtime_t Nanosecs = Times[1] - Times[0];
 
      assert(Nanosecs > 0);
 
      if (MinNanosecs < 0 || Nanosecs < MinNanosecs)
        {
          MinNanosecs = Nanosecs;
        };
 
      Current = gethrtime();
  } while (Current - Start < 1000000000); // 1 second
 
  assert(MinNanosecs < 2000000000); // otherwise it's too coarse for this measurement
 
  Resolution = static_cast<int>(MinNanosecs);
 
#elif defined(WIN32)
 
  LARGE_INTEGER Freq;
  BOOL Result;
 
  Result = QueryPerformanceFrequency(&Freq);
  assert(Result); // if failed, high-resolution timers are not supported by this hardware
 
  Resolution = static_cast<int>(1000000000 / Freq.QuadPart);
 
#elif defined(STIR_HRWCT_Use_gettimeofday)
 
    // TODO
 
#endif
 
  assert(Resolution > 0);
 
  return Resolution;
};
 
} // namespace stir
 
#endif // __HIGHRESWALLCLOCKTIMER_H__