JClock.hh

Go to the documentation of this file.

#ifndef __JLANG__JCLOCK__
#define __JLANG__JCLOCK__
 
#include <chrono>
#include <ostream>
#include <iomanip>
 
#include "JLang/JTitle.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
  
  /**
   * Auxiliary class for CPU timing.
   */
  class JClock :
    public JTitle
  {
  public:
    /**
     * Default constructor.
     */
    JClock() :
      JTitle(),
      ts(0),
      count(0)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  title    title
     */
    JClock(const JTitle& title) :
      JTitle(title),
      ts(0),
      count(0)
    {}
 
 
    /**
     * Destructor.
     *
     * The clock data will optionally be printed to the set output stream.
     */
    ~JClock()
    {
      if (gets() != NULL && count != 0) {
        *gets() << (*this) << std::endl;
      }
    }
 
 
    /**
     * Auxiliary data structure for scoped timing.
     */
    struct sentry {
      /**
       * Constructor.
       *       
       * \param  clock       clock
       */
      sentry(JClock& clock) :
        clock(clock)
      {
        clock.start();
      }
 
      /**
       * Destructor.
       */
      ~sentry()
      {
        clock.stop();
      }
 
    private:
      JClock& clock;
    };
 
 
    /**
     * Reset clock.
     */
    void reset()
    {
      ts    = std::chrono::high_resolution_clock::duration(0);
      count = 0;
    }
 
 
    /**
     * Start clock.
     */
    void start()
    {
      t0 = std::chrono::high_resolution_clock::now();
    }
    
 
    /**
     * Stop clock.
     */
    void stop()
    {
      t1 = std::chrono::high_resolution_clock::now();
 
      ts += (t1 - t0);
 
      ++count;
    }
  
 
    /**
     * Get elapsed time.
     *
     * \return             elapsed time [ns]
     */
    size_t operator()() const
    {
      return ts / std::chrono::nanoseconds(1);
    }
 
 
    /**
     * Print clock data.
     *
     * \param  out         output stream
     */
    void print(std::ostream& out) const
    {
      using namespace std;
 
      out << setw(16) << left  << getTitle() << ' '
          << setw(12) << right << count      << ' '
          << setw(12) << ts / std::chrono::milliseconds(1) << " [ms]";
    }
 
 
    /**
     * Print clock data.
     *
     * \param  out         output stream
     * \param  clock       clock
     * \return             output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JClock& clock)
    {
      clock.print(out);
 
      return out;
    }
 
 
    /**
     * Set output stream.
     *
     * \param  out         output stream
     */
    static void sets(std::ostream& out)
    {
      gets() = &out;
    }
 
 
  protected:
 
    std::chrono::high_resolution_clock::time_point t0;
    std::chrono::high_resolution_clock::time_point t1;
    std::chrono::high_resolution_clock::duration   ts;
    size_t count;
 
    /**
     * Get output stream.
     *
     * \return             output stream
     */
    static std::ostream*& gets()
    {
      static std::ostream* out = NULL;
 
      return out;
    }
  };
}  
 
#endif