Timer.h

Go to the documentation of this file.

//
//    Minotaur -- It's only 1/2 bull
//
//    (C)opyright 2009 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURTIMER_H
#define MINOTAURTIMER_H
 
#include <time.h>
 
#ifndef CLOCKS_PER_SEC
#define CLOCKS_PER_SEC 1000000
#endif
 
#ifdef MINOTAUR_RUSAGE
#include <sys/resource.h>
 
#ifndef MICROSEC
#define MICROSEC 1000000
#endif
#endif
 
#include "Types.h"
#include <chrono>
namespace Minotaur {
  class Timer {
  public:
    Timer() {};
    virtual ~Timer() {};
    virtual void start() = 0;
    virtual void stop() = 0;
    virtual double query() const = 0;
    // New function to query wall time
    virtual double wQuery() const
    {
      using namespace std::chrono;
      steady_clock::time_point currentTime = steady_clock::now();
      duration<double> time_span =
          duration_cast<duration<double>>(currentTime - w_);
      return time_span.count();
    }
 
  protected:
    std::chrono::steady_clock::time_point w_;
    bool is_started_ = false;
 
  private:
    Timer(const Timer &);
    Timer &operator=(const Timer &);
  };
 
  class ClockTimer : public Timer {
  private:
    clock_t s_;
    bool is_started_;
 
  public:
    ClockTimer()
      : is_started_(false) {};
    ~ClockTimer() {};
 
    void start()
    {
      w_ = std::chrono::steady_clock::now();
      s_ = clock();
      is_started_ = true;
      return;
    };
 
    void stop()
    {
      is_started_ = false;
      return;
    };
 
    double query() const
    {
      if (!is_started_) {
        throw("Some exception");
      }
 
      return ((double)(clock() - s_) / (double)CLOCKS_PER_SEC);
    };
  };
 
#ifdef MINOTAUR_RUSAGE
  class UsageTimer : public Timer {
  private:
    struct rusage s_;
    bool is_started_;
 
  public:
    UsageTimer()
      : is_started_(false) {};
    ~UsageTimer() {};
 
    void start()
    {
      getrusage(RUSAGE_SELF, &s_);
      is_started_ = true;
      return;
    };
 
    void stop()
    {
      is_started_ = false;
      return;
    };
 
    double query() const
    {
      double t1, t2, m1, m2, s1, s2, m, s;
      struct rusage e;
      if (!is_started_) {
        throw("Some exception");
      }
      getrusage(RUSAGE_SELF, &e);
 
      m1 = (double)e.ru_utime.tv_usec;
      m2 = (double)s_.ru_utime.tv_usec;
      m = m1 - m2;
 
      s1 = (double)e.ru_utime.tv_sec;
      s2 = (double)s_.ru_utime.tv_sec;
      s = s1 - s2;
 
      t1 = s + m / MICROSEC;
 
      m1 = (double)e.ru_stime.tv_usec;
      m2 = (double)s_.ru_stime.tv_usec;
      m = m1 - m2;
 
      s1 = (double)e.ru_stime.tv_sec;
      s2 = (double)s_.ru_stime.tv_sec;
      s = s1 - s2;
 
      t2 = s + m / MICROSEC;
 
      return t1 + t2;
    };
  };
#endif
 
  class TimerFactory {
  public:
    TimerFactory() {};
 
    virtual ~TimerFactory() {};
 
    virtual Timer *getTimer()
    {
#ifdef MINOTAUR_RUSAGE
      return new UsageTimer;
#else
      return new ClockTimer;
#endif
    };
 
  private:
    TimerFactory(const TimerFactory &);
    TimerFactory &operator=(const TimerFactory &);
  };
}  //namespace Minotaur
 
#endif