chrono.hpp

Go to the documentation of this file.

 
#ifndef RUSH_CHRONO_HPP
#define RUSH_CHRONO_HPP
 
#include <chrono>
#include <iostream>
#include <ratio>
#include <string>
#include <thread>
#include <utility>
 
namespace rush::chrono {
 
#define DEFINE_UNIT_MACRO(name, unit)    \
  template <>                            \
  struct Unit<name> {                    \
    static constexpr const char *str() { \
      return unit;                       \
    }                                    \
  };
 
template <typename T>
struct Unit;
 
DEFINE_UNIT_MACRO(std::nano, "ns")
DEFINE_UNIT_MACRO(std::micro, "us")
DEFINE_UNIT_MACRO(std::milli, "ms")
DEFINE_UNIT_MACRO(std::ratio<1>, "s")
DEFINE_UNIT_MACRO(std::ratio<60>, "min")
DEFINE_UNIT_MACRO(std::ratio<3600>, "h")
DEFINE_UNIT_MACRO(std::ratio<86400>, "day")
using ns = std::nano;          
using us = std::micro;         
using ms = std::milli;         
using s = std::ratio<1>;       
using min = std::ratio<60>;    
using hour = std::ratio<3600>; 
using day = std::ratio<86400>; 
 
template <typename T = s>
inline void sleep(double t) {
  std::this_thread::sleep_for(std::chrono::duration<double, T>(t));
}
 
template <typename T = s>
class Chrono {
public:
  Chrono() : t0_(std::chrono::high_resolution_clock::now()) {}
  ~Chrono() = default;
  Chrono(const Chrono &) = delete;
  Chrono(Chrono &&) noexcept = delete;
  Chrono &operator=(const Chrono &) = delete;
  Chrono &operator=(Chrono &&other) noexcept = delete;
 
  inline void tic() {
    t0_ = std::chrono::high_resolution_clock::now();
  }
 
  [[nodiscard]] inline double toc() const {
    return std::chrono::duration_cast<std::chrono::duration<double, T>>(std::chrono::high_resolution_clock::now() - t0_).count();
  }
 
  [[nodiscard]] inline std::string unit() const {
    return Unit<T>().str();
  }
 
private:
  std::chrono::time_point<std::chrono::high_resolution_clock> t0_;
};
 
template <typename T = s>
class Chronometer : public Chrono<T> {
public:
  explicit Chronometer(std::string name = "") : name_{std::move(name)} {}
 
  ~Chronometer() {
    double t = Chrono<T>::toc();
    if(!name_.empty()) {
      std::cout << "[" << name_ << "] ";
    }
    std::cout << "Elapsed time: " << t << " " << Chrono<T>::unit() << std::endl;
  }
 
  Chronometer(const Chronometer &) = delete;
  Chronometer(Chronometer &&) noexcept = delete;
  Chronometer &operator=(const Chronometer &) = delete;
  Chronometer &operator=(Chronometer &&other) noexcept = delete;
 
private:
  std::string name_;
};
 
} // namespace rush::chrono
 
#endif // RUSH_CHRONO_HPP