TicToc.hxx

Go to the documentation of this file.

/*--------------------------------------------------------------------------*\
 |                                                                          |
 |  Copyright (C) 2017                                                      |
 |                                                                          |
 |         , __                 , __                                        |
 |        /|/  \               /|/  \                                       |
 |         | __/ _   ,_         | __/ _   ,_                                |
 |         |   \|/  /  |  |   | |   \|/  /  |  |   |                        |
 |         |(__/|__/   |_/ \_/|/|(__/|__/   |_/ \_/|/                       |
 |                           /|                   /|                        |
 |                           \|                   \|                        |
 |                                                                          |
 |      Enrico Bertolazzi                                                   |
 |      Dipartimento di Ingegneria Industriale                              |
 |      Università degli Studi di Trento                                    |
 |      Via Sommarive 9, I-38123 Povo, Trento, Italy                        |
 |      email: enrico.bertolazzi@unitn.it                                   |
 |                                                                          |
\*--------------------------------------------------------------------------*/
 
//
// file: TicToc.hxx
//
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
#ifndef UTILS_OS_WINDOWS
  #include <chrono>
  #include <thread>
#endif
 
#endif
 
namespace Utils {

 
#ifdef UTILS_OS_WINDOWS
  class TicToc {
 
    using real_type = double;
    int64_t   m_frequency{0};   // ticks per second
    int64_t   m_t1{0}, m_t2{0};    // ticks
    real_type m_elapsed_time{0};
 
    TicToc( TicToc const & ) = delete;
    TicToc const & operator = ( TicToc const & ) const = delete;
 
  public:

    TicToc();
    ~TicToc() {}

    void tic();

    void toc();

    real_type elapsed_s()  const { return 1e-3*m_elapsed_time; }

    real_type elapsed_ms() const { return m_elapsed_time; }

    real_type elapsed_mus() const { return 1000*m_elapsed_time; }

    real_type elapsed_ns() const { return 1e6*m_elapsed_time; }
 
  };

  void sleep_for_seconds( unsigned s );

  void sleep_for_milliseconds( unsigned ms );

  void sleep_for_microseconds( unsigned mus );

  void sleep_for_nanoseconds( unsigned ns );
 
#else
  class TicToc {
 
    using real_type          = double;
    using clock              = std::chrono::high_resolution_clock;
    using elapsed_resolution = std::chrono::microseconds;
 
    clock::time_point m_start_time;
    clock::time_point m_stop_time;
 
    elapsed_resolution m_elapsed_time{0};
 
   public:
 
    TicToc( TicToc const & ) = delete;
    TicToc const & operator = ( TicToc const & ) const = delete;

    TicToc() { this->tic(); }
 
    ~TicToc() = default;

    void
    tic()
    { m_start_time = clock::now(); }

    void
    toc() {
      m_stop_time    = clock::now();
      m_elapsed_time = std::chrono::duration_cast<elapsed_resolution>(m_stop_time - m_start_time);
    }

    real_type elapsed_s() const { return real_type(1e-6*m_elapsed_time.count()); }

    real_type elapsed_ms() const { return real_type(1e-3*m_elapsed_time.count()); }

    real_type elapsed_mus() const { return real_type(m_elapsed_time.count()); }

    real_type elapsed_ns() const { return real_type(1e3*m_elapsed_time.count()); }
  };

  inline
  void
  sleep_for_seconds( unsigned s )
  { std::this_thread::sleep_for(std::chrono::seconds(s)); }

  inline
  void
  sleep_for_milliseconds( unsigned ms )
  {  std::this_thread::sleep_for(std::chrono::milliseconds(ms)); }

  inline
  void
  sleep_for_microseconds( unsigned mus )
  {  std::this_thread::sleep_for(std::chrono::microseconds(mus)); }

  inline
  void
  sleep_for_nanoseconds( unsigned ns )
  {  std::this_thread::sleep_for(std::chrono::nanoseconds(ns)); }
 
#endif
 
}
 
//
// eof: TicToc.hxx
//