relative_clock.hpp

#pragma once
 
#include "phonebook.hpp"
 
#include <cassert>
#include <chrono>
#include <ratio>
 
namespace ILLIXR {
 
using _clock_rep      = long;
using _clock_period   = std::nano;
using _clock_duration = std::chrono::duration<_clock_rep, _clock_period>;
 
class time_point {
public:
    using duration = _clock_duration;
 
    time_point() = default;
 
    constexpr explicit time_point(const duration& time_since_epoch)
        : _m_time_since_epoch{time_since_epoch} { }
 
    [[nodiscard]] duration time_since_epoch() const {
        return _m_time_since_epoch;
    }
 
    time_point& operator+=(const duration& d) {
        this->_m_time_since_epoch += d;
        return *this;
    }
 
    time_point& operator-=(const duration& d) {
        this->_m_time_since_epoch -= d;
        return *this;
    }
 
private:
    duration _m_time_since_epoch;
};
 
inline time_point::duration operator-(const time_point& lhs, const time_point& rhs) {
    return lhs.time_since_epoch() - rhs.time_since_epoch();
}
 
inline time_point operator+(const time_point& pt, const time_point::duration& d) {
    return time_point(pt.time_since_epoch() + d);
}
 
inline time_point operator+(const time_point::duration& d, const time_point& pt) {
    return time_point(pt.time_since_epoch() + d);
}
 
inline bool operator<(const time_point& lhs, const time_point& rhs) {
    return lhs.time_since_epoch() < rhs.time_since_epoch();
}
 
inline bool operator>(const time_point& lhs, const time_point& rhs) {
    return lhs.time_since_epoch() > rhs.time_since_epoch();
}
 
inline bool operator<=(const time_point& lhs, const time_point& rhs) {
    return lhs.time_since_epoch() <= rhs.time_since_epoch();
}
 
inline bool operator>=(const time_point& lhs, const time_point& rhs) {
    return lhs.time_since_epoch() >= rhs.time_since_epoch();
}
 
inline bool operator==(const time_point& lhs, const time_point& rhs) {
    return lhs.time_since_epoch() == rhs.time_since_epoch();
}
 
inline bool operator!=(const time_point& lhs, const time_point& rhs) {
    return lhs.time_since_epoch() != rhs.time_since_epoch();
}
 
class RelativeClock : public phonebook::service {
public:
    using rep      = _clock_rep;
    using period   = _clock_period;
    using duration = _clock_duration;
    // using time_point                = time_point;
    static constexpr bool is_steady = true;
    static_assert(std::chrono::steady_clock::is_steady);
 
    [[nodiscard]] time_point now() const {
        assert(this->is_started() && "Can't call now() before this clock has been start()ed.");
        return time_point{std::chrono::steady_clock::now() - _m_start};
    }
 
    int64_t absolute_ns(time_point relative) {
        return std::chrono::nanoseconds{_m_start.time_since_epoch()}.count() +
            std::chrono::nanoseconds{relative.time_since_epoch()}.count();
    }
 
    void start() {
        _m_start = std::chrono::steady_clock::now();
    }
 
    [[nodiscard]] bool is_started() const {
        return _m_start > std::chrono::steady_clock::time_point{};
    }
 
    [[nodiscard]] time_point start_time() const {
        return time_point{_m_start.time_since_epoch()};
    }
 
private:
    std::chrono::steady_clock::time_point _m_start;
};
 
using duration = RelativeClock::duration;
 
template<typename unit = std::ratio<1>>
double duration2double(duration dur) {
    return std::chrono::duration<double, unit>{dur}.count();
}
 
constexpr duration freq2period(double fps) {
    return duration{static_cast<size_t>(std::chrono::nanoseconds{std::chrono::seconds{1}}.count() / fps)};
}
 
} // namespace ILLIXR