PHTimer.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file PHTimer.h

#ifndef PHOOL_PHTIMER_H
#define PHOOL_PHTIMER_H

#include <unistd.h>
#include <exception>
#include <iostream>
#include <string>
#include <sstream>

#define rdtsc(low, high)       \
  __asm__ __volatile__("rdtsc" \
                       : "=a"(low), "=d"(high))



class PHTimer
{
 public:
  enum State
  {
    STOP = 0,
    RUN = 1
  };

  State get_state(void) const
  {
    return _state;
  }

  explicit PHTimer(const std::string& name = "Generic Timer")
    : _name(name)
    , _state(STOP)
    , _start_time(get_clock_counts())
    , _stop_time(get_clock_counts())
    , _accumulated_time(0)
    , _ncycle(0)
  {
    _stop_time._low++;
  }

  void stop()
  {
    if (_state == STOP) return;
    _stop_time = get_clock_counts();
    _state = STOP;
    _ncycle++;
    _accumulated_time += elapsed();
  }

  void restart()
  {
    _start_time = get_clock_counts();
    _state = RUN;
  }

  void print(std::ostream& os = std::cout) const
  {
    double elapse(elapsed());
    PRINT(os, "Timing for " + _name);
    os << "time (ms): " << elapse << std::endl;
    PRINT();
  }

  void print_stat(std::ostream& os = std::cout) const
  {
    //   PRINT(os, std::string("Stats for " + _name));
    if (_ncycle)
    {
      os << _name << ": accumulated time (ms):  " << _accumulated_time << std::endl;
      os << _name << ": per event time (ms):    " << _accumulated_time / _ncycle << std::endl;
    }
    else
    {
      os <<  _name << ": timer never started.\n";
    }
    PRINT(os, "**");
  }

  void set_name(const std::string& name)
  {
    _name = name;
  }

  std::string get_name(void) const
  {
    return _name;
  }

  double get_accumulated_time(void) const
  {
    return _accumulated_time;
  }

  unsigned int get_ncycle(void) const
  {
    return _ncycle;
  }

  double get_time_per_cycle(void) const
  {
    return _accumulated_time / _ncycle;
  }

  double elapsed(void) const
  {
    return 1000.0 * get_difference(
                        (_state == RUN) ? get_clock_counts() : _stop_time,
                        _start_time);
  }

  void test(double time, std::ostream& os = std::cout)
  {
    std::ostringstream tmp;
    tmp << "Test for " << _name << " - " << time << "ms";
    PRINT(os, tmp.str());
    restart();
    usleep((unsigned int) (time * 1000));
    print(os);
  }

  static void PRINT(std::ostream& os = std::cout, const std::string& message = "");

 private:
  class Frequency
  {
   public:
    Frequency()
    {
      try
      {
        set_cpu_freq();
      }
      catch (std::exception& e)
      {
        std::cerr << e.what() << std::endl;
      }
      _period = 1.0 / _frequency;
    }

    operator double() const
    {
      return _frequency;
    }

    double period() const
    {
      return _period;
    }

   private:
    double _frequency;

    double _period;

    void set_cpu_freq(const std::string &cpuinfopath = "/proc/cpuinfo");
  };

  struct time_struct
  {
    time_struct(void)
      : _low(0)
      , _high(0)
    {
    }

    unsigned long _low;

    unsigned long _high;
  };

  static time_struct get_clock_counts(void)
  {
    time_struct t;
    rdtsc(t._low, t._high);
    return t;
  }

  static double get_difference(
      const time_struct&,
      const time_struct&);

  static Frequency _frequency;

  static const double _twopower32;

  std::string _name;

  State _state;

  time_struct _start_time;

  time_struct _stop_time;

  double _accumulated_time;

  unsigned int _ncycle;
};

#endif