JTimer.hh

Go to the documentation of this file.

#ifndef __JEEP__JTIMER__
#define __JEEP__JTIMER__
 
#include <unistd.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <string>
#include <ostream>
#include <iomanip>
 
#include "JLang/JTitle.hh"
#include "JLang/JManip.hh"
#include "Jeep/JScale.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JEEP {}
namespace JPP { using namespace JEEP; }
 
namespace JEEP {
 
  using JLANG::JTitle;
 
  
  /**
   * Auxiliary class for CPU timing and usage.
   */
  class JTimer :
    public JTitle
  {
  public:
 
    typedef unsigned long long   ull;
 
    /**
     * Status of clock.
     */
    enum JStatus_t { CLK_STOPPED = 0, CLK_RUNNING = 1 };
 
 
    /**
     * Default constructor.
     */
    JTimer() :
      JTitle(),
      usec_wall(0ULL),
      usec_ucpu(0ULL),
      usec_scpu(0ULL),
      counter  (0ULL),
      status   (CLK_STOPPED)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  title    title
     */
    JTimer(const JTitle& title) :
      JTitle(title),
      usec_wall(0ULL),
      usec_ucpu(0ULL),
      usec_scpu(0ULL),
      counter  (0ULL),
      status   (CLK_STOPPED)
    {}
 
 
    /**
     * Enable timers.
     */
    static void enable()
    {
      get_status() = true;
    }
 
 
    /**
     * Disable timers.
     */
    static void disable()
    {
      get_status() = false;
    }
      
 
    /**
     * Reset timer.
     */
    void reset()
    {
      usec_wall = 0;
      usec_ucpu = 0;
      usec_scpu = 0;
      counter   = 0;
      status    = CLK_STOPPED;
    }
 
 
    /**
     * Start timer.
     */
    void start()
    {
      if (status == CLK_STOPPED && get_status()) {
        
        gettimeofday(&tv, NULL);
        getrusage(RUSAGE_SELF, &usage);
        
        usec_wall -= timeval_to_usec(tv);
        usec_ucpu -= timeval_to_usec(usage.ru_utime);
        usec_scpu -= timeval_to_usec(usage.ru_stime);
        
        status    = CLK_RUNNING;
        
        ++counter;
      }
    }
    
 
    /**
     * Stop timer.
     */
    void stop()
    {
      if (status == CLK_RUNNING && get_status()) {
        
        gettimeofday(&tv, NULL);
        getrusage(RUSAGE_SELF, &usage);
        
        usec_wall += timeval_to_usec(tv);
        usec_ucpu += timeval_to_usec(usage.ru_utime);
        usec_scpu += timeval_to_usec(usage.ru_stime);
      }
 
      status    = CLK_STOPPED;
    }
    
 
    /**
     * Get CPU usage.
     *
     * \return       CPU usage [%]
     */
    unsigned int timing_get_cpu_percentage() const
    {
      return (100ULL * (usec_ucpu + usec_scpu) / (usec_wall+1));
    }
 
 
    /**
     * Convert timeval to micro-seconds.
     *
     * \param   tv   timeval
     * \return       time [us]
     */
    static inline unsigned long long timeval_to_usec(const struct timeval& tv)
    {
      return (unsigned long long) tv.tv_sec * 1000000ULL + (unsigned long long) tv.tv_usec;
    }
 
 
    /**
     * Print timer data.
     *
     * \param  out         output stream
     * \param  scale       scale
     */
    void print(std::ostream& out, const JScale_t scale = milli_t) const
    {
      print(out, 1.0, scale);
    }
 
 
    /**
     * Print timer data.
     *
     * \param  out         output stream
     * \param  normalise   normalise to number of starts
     * \param  scale       scale
     */
    void print(std::ostream& out, const bool normalise, const JScale_t scale = milli_t) const
    {
      double factor = 1.0;
 
      if (normalise && counter != 0) {
        factor = 1.0 / (double) counter;
      }
 
      print(out, factor, scale);
    }
 
 
    /**
     * Print timer data.
     *
     * \param  out         output stream
     * \param  factor      multiplication factor 
     * \param  scale       scale
     */
    void print(std::ostream& out, const double factor, const JScale_t scale = milli_t) const
    {
      using namespace std;
      using namespace JPP;
 
      if (get_status()) {
 
        const double y = factor * 1e-3 * getValue(milli_t) / getValue(scale);
        const char*  u = getUnit(scale);
 
        out << getTitle()  << endl;
        out << FIXED(10,3) << usec_wall * y << " " << u << "s elapsed" << endl;
        out << FIXED(10,3) << usec_ucpu * y << " " << u << "s user"    << endl;
        out << FIXED(10,3) << usec_scpu * y << " " << u << "s system"  << endl;
        out << setw( 3)    << timing_get_cpu_percentage() << "%CPU" << endl;
      }
    }
 
 
    /**
     * Print timer data.
     *
     * \param  out         output stream
     * \param  timer       timer
     * \return             output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTimer& timer)
    {
      timer.print(out);
 
      return out;
    }
 
 
    unsigned long long usec_wall;       /* clock time */
    unsigned long long usec_ucpu;       /* CPU user time */
    unsigned long long usec_scpu;       /* CPU system time */
    unsigned long long counter;         /* counter */
 
  protected:
    JStatus_t status;
 
  private:
    struct timeval tv;
    struct rusage  usage;
 
    /**
     * Get status.
     *
     * \return             status
     */
    static bool& get_status()
    {
      static bool status = true;
 
      return status;
    }
  };
}  
 
#endif