time_stamp.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/base_header.hpp>
#include <kernel/util/string.hpp>
#include <kernel/util/assertion.hpp>
#include <kernel/util/os_windows.hpp>
 
// includes, system
#include <sstream>
#include <iomanip>
 
#if defined(__linux) || defined(__unix__)
#  define FEAT_HAVE_GETTIMEOFDAY 1
#  include <sys/time.h>
#else
#  include <ctime>
#endif
 
namespace FEAT
{
  enum class TimeFormat
  {
    h_m_s_m, 
    h_m_s, 
    m_s_m, 
    m_s, 
    s_m, 
  };
 
  class TimeStamp
  {
  private:
#if defined(FEAT_HAVE_GETTIMEOFDAY)
    timeval _time;
#elif defined(_WIN32)
    long long int _counter;
#else
    clock_t _clock;
#endif
 
  public:
    TimeStamp()
    {
      stamp();
    }
 
    TimeStamp& stamp()
    {
#if defined(FEAT_HAVE_GETTIMEOFDAY)
      gettimeofday(&_time, 0);
#elif defined(_WIN32)
      _counter = Windows::query_performance_counter();
#else
      _clock = ::clock();
#endif
      return *this;
    }
 
    double elapsed(const TimeStamp& before) const
    {
#if defined(FEAT_HAVE_GETTIMEOFDAY)
      return double(_time.tv_sec - before._time.tv_sec) + 1E-6 * double(_time.tv_usec - before._time.tv_usec);
#elif defined(_WIN32)
      long long freq = Windows::query_performance_frequency();
      return (freq == 0ll) ? 0.0 : (double(_counter - before._counter) / double(freq));
#else
      return double(_clock - before._clock) / double(CLOCKS_PER_SEC);
#endif
    }
 
    double elapsed_now() const
    {
      return TimeStamp().elapsed(*this);
    }
 
    long long elapsed_micros(const TimeStamp& before) const
    {
#if defined(FEAT_HAVE_GETTIMEOFDAY)
      return 1000000ll * (long long)(_time.tv_sec - before._time.tv_sec)
        + (long long)(_time.tv_usec - before._time.tv_usec);
#elif defined(_WIN32)
      long long freq = Windows::query_performance_frequency();
      return (freq == 0ll) ? 0ll : (1000000ll * (_counter - before._counter)) / freq;
#else
      return 1000000ll * (long long)(_clock - before._clock) / (long long)CLOCKS_PER_SEC;
#endif
    }
 
    long long elapsed_micros_now() const
    {
      return TimeStamp().elapsed_micros(*this);
    }
 
    static String format_micros(long long micros, TimeFormat format = TimeFormat::s_m)
    {
      std::ostringstream oss;
      oss << std::setfill('0');
 
      // check whether the time is negative
      if(micros < 0)
      {
        oss << '-';
        micros = -micros;
      }
 
      switch (format)
      {
        case TimeFormat::h_m_s_m:
          oss << (micros / 3600000000ll);
          oss << ":" << std::setw(2) << ((micros / 60000000ll) % 60ll);
          oss << ":" << std::setw(2) << ((micros / 1000000ll) % 60ll);
          oss << "." << std::setw(3) << ((micros / 1000ll) % 1000ll);
          break;
 
        case TimeFormat::h_m_s:
          oss << (micros / 3600000000ll);
          oss << ":" << std::setw(2) << ((micros / 60000000ll) % 60ll);
          oss << ":" << std::setw(2) << ((micros / 1000000ll) % 60ll);
          break;
 
        case TimeFormat::m_s_m:
          oss << (micros / 60000000ll);
          oss << ":" << std::setw(2) << ((micros / 1000000ll) % 60ll);
          oss << "." << std::setw(3) << ((micros / 1000ll) % 1000ll);
          break;
 
        case TimeFormat::m_s:
          oss << (micros / 60000000ll);
          oss << ":" << std::setw(2) << ((micros / 1000000ll) % 60ll);
          break;
 
        case TimeFormat::s_m:
          oss << (micros / 1000000ll);
          oss << "." << std::setw(3) << ((micros / 1000ll) % 1000ll);
          break;
 
        default:
          XABORTM("TimeFormat not supported!");
      }
 
      // return formatted string
      return oss.str();
    }
 
    String elapsed_string(const TimeStamp& before, TimeFormat format = TimeFormat::s_m) const
    {
      return format_micros(elapsed_micros(before), format);
    }
 
    String elapsed_string_now(TimeFormat format = TimeFormat::s_m) const
    {
      return TimeStamp().elapsed_string(*this, format);
    }
 
    bool operator< (const TimeStamp & other) const
    {
#if defined(FEAT_HAVE_GETTIMEOFDAY)
      return (_time.tv_sec < other._time.tv_sec) ||
        ((_time.tv_sec == other._time.tv_sec) && (_time.tv_usec < other._time.tv_usec));
#elif defined(_WIN32)
      return (_counter < other._counter);
#else
      return (_clock < other._clock);
#endif
    }
  }; // class TimeStamp
} // namespace FEAT