187 lines
5.7 KiB
C++
187 lines
5.7 KiB
C++
#pragma once
|
|
|
|
#ifdef _WIN32
|
|
#include "windows_wrapper.h"
|
|
#elif __linux__
|
|
#include <ctime>
|
|
#else
|
|
#error Unsupported platform
|
|
#endif
|
|
|
|
#include "../os/os.h"
|
|
#include "bts_assert.h"
|
|
#include <cstdint>
|
|
#include <limits>
|
|
|
|
namespace bts {
|
|
namespace utils {
|
|
|
|
class TimeStamp
|
|
{
|
|
public:
|
|
TimeStamp() noexcept : _time(0) {}
|
|
explicit constexpr TimeStamp (uint64_t time) : _time (time) {}
|
|
|
|
static TimeStamp now();
|
|
constexpr static TimeStamp invalid() { return TimeStamp(std::numeric_limits<uint64_t>().max()); }
|
|
|
|
class Interval {
|
|
public:
|
|
Interval() : _val(0) {}
|
|
double seconds() const;
|
|
int64_t microseconds() const;
|
|
int64_t milliseconds() const;
|
|
int64_t nanoseconds() const;
|
|
bool zero() const;
|
|
|
|
friend class bts::utils::TimeStamp;
|
|
friend Interval operator-( const TimeStamp& t1, const TimeStamp& t2);
|
|
friend Interval operator+( const Interval& a, const Interval& b) {
|
|
return Interval(a._val + b._val);
|
|
}
|
|
friend Interval operator-( const Interval& a, const Interval& b) {
|
|
return Interval(a._val - b._val);
|
|
}
|
|
Interval& operator+=(const Interval& other) { _val += other._val; return *this; }
|
|
Interval& operator-=(const Interval& other) { _val -= other._val; return *this; }
|
|
bool operator > (const Interval& other) const { return _val > other._val; }
|
|
bool operator < (const Interval& other) const { return _val < other._val; }
|
|
bool operator >= (const Interval& other) const { return _val >= other._val; }
|
|
bool operator <= (const Interval& other) const { return _val <= other._val; }
|
|
static Interval from_microseconds(uint64_t microseconds);
|
|
|
|
private:
|
|
explicit Interval(uint64_t val) : _val(val) {}
|
|
uint64_t _val;
|
|
};
|
|
|
|
friend Interval operator - (const TimeStamp& t1, const TimeStamp& t2);
|
|
friend bool operator == (const TimeStamp& t1, const TimeStamp& t2);
|
|
friend bool operator != (const TimeStamp& t1, const TimeStamp& t2);
|
|
friend bool operator > (const TimeStamp& t1, const TimeStamp& t2);
|
|
friend bool operator < (const TimeStamp& t1, const TimeStamp& t2);
|
|
friend bool operator >= (const TimeStamp& t1, const TimeStamp& t2);
|
|
friend bool operator <= (const TimeStamp& t1, const TimeStamp& t2);
|
|
|
|
TimeStamp operator-(const TimeStamp::Interval& delta) {
|
|
bts_assert_d(*this != TimeStamp::invalid());
|
|
return TimeStamp(to_uint64() - delta._val);
|
|
}
|
|
|
|
// implicit conversion to bool
|
|
operator bool() const { return _time != 0; }
|
|
|
|
uint64_t to_uint64 () const
|
|
{return _time;}
|
|
|
|
TimeStamp shift_ns (int64_t ns) const { return TimeStamp(_time + ns); }
|
|
TimeStamp shift_us (int64_t us) const {return shift_ns(us*1000);};
|
|
TimeStamp shift_ms (int64_t ms) const {return shift_us(ms*1000);};
|
|
TimeStamp shift_secs (int64_t secs) const {return shift_ms(secs*1000);};
|
|
TimeStamp shift_mins (int64_t mins) const {return shift_secs(mins*60);};
|
|
TimeStamp shift_hours (int64_t hours) const {return shift_mins(hours*60);};
|
|
TimeStamp shift_days (int64_t days) const {return shift_hours(days*24);};
|
|
|
|
private:
|
|
uint64_t _time;
|
|
};
|
|
|
|
inline TimeStamp TimeStamp::now() {
|
|
TimeStamp result;
|
|
#ifdef _WIN32
|
|
LARGE_INTEGER qpcnt;
|
|
QueryPerformanceCounter(&qpcnt);
|
|
result._time = qpcnt.QuadPart;
|
|
#else
|
|
struct timespec ts;
|
|
clock_gettime( CLOCK_MONOTONIC, &ts );
|
|
result._time =
|
|
static_cast<int64_t>(1000000000UL)*
|
|
static_cast<int64_t>(ts.tv_sec) +
|
|
static_cast<int64_t>(ts.tv_nsec);
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
inline TimeStamp::Interval TimeStamp::Interval::from_microseconds(uint64_t microseconds) {
|
|
TimeStamp::Interval result;
|
|
#ifdef _WIN32
|
|
LARGE_INTEGER qpfreq;
|
|
QueryPerformanceFrequency(&qpfreq);
|
|
result._val = static_cast<uint64_t>(microseconds * qpfreq.QuadPart / 1000000);
|
|
#else
|
|
result._val = microseconds * 1E3;
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
inline double TimeStamp::Interval::seconds() const {
|
|
#ifdef _WIN32
|
|
LARGE_INTEGER qpfreq;
|
|
QueryPerformanceFrequency(&qpfreq);
|
|
return _val / (double)qpfreq.QuadPart;
|
|
#else
|
|
return _val * 1E-9;
|
|
#endif
|
|
}
|
|
inline int64_t TimeStamp::Interval::microseconds() const {
|
|
#ifdef _WIN32
|
|
LARGE_INTEGER qpfreq;
|
|
QueryPerformanceFrequency(&qpfreq);
|
|
return (_val * 1E6 )/ qpfreq.QuadPart;
|
|
#else
|
|
return _val / 1000;
|
|
#endif
|
|
}
|
|
inline int64_t TimeStamp::Interval::nanoseconds() const {
|
|
#ifdef _WIN32
|
|
LARGE_INTEGER qpfreq;
|
|
QueryPerformanceFrequency(&qpfreq);
|
|
return (_val * 1000000000 )/ qpfreq.QuadPart;
|
|
#else
|
|
return _val ;
|
|
#endif
|
|
}
|
|
inline bool TimeStamp::Interval::zero() const {
|
|
return _val == 0;
|
|
}
|
|
|
|
inline int64_t TimeStamp::Interval::milliseconds() const {
|
|
return microseconds() / 1000;
|
|
}
|
|
|
|
inline TimeStamp::Interval operator-(const TimeStamp& t1, const TimeStamp& t2) {
|
|
bts_assert_d(t1 != TimeStamp::invalid());
|
|
bts_assert_d(t2 != TimeStamp::invalid());
|
|
return TimeStamp::Interval(t1._time - t2._time);
|
|
}
|
|
|
|
inline bool operator == ( const TimeStamp& t1, const TimeStamp& t2) {
|
|
return t1._time == t2._time;
|
|
}
|
|
inline bool operator != ( const TimeStamp& t1, const TimeStamp& t2) {
|
|
return t1._time != t2._time;
|
|
}
|
|
inline bool operator > ( const TimeStamp& t1, const TimeStamp& t2) {
|
|
return t1._time > t2._time;
|
|
}
|
|
inline bool operator < ( const TimeStamp& t1, const TimeStamp& t2) {
|
|
return t1._time < t2._time;
|
|
}
|
|
inline bool operator >= ( const TimeStamp& t1, const TimeStamp& t2) {
|
|
return t1._time >= t2._time;
|
|
}
|
|
inline bool operator <= ( const TimeStamp& t1, const TimeStamp& t2) {
|
|
return t1._time <= t2._time;
|
|
}
|
|
|
|
}}//namespace
|
|
|
|
namespace std {
|
|
template <>
|
|
struct numeric_limits<bts::utils::TimeStamp> {
|
|
static bts::utils::TimeStamp min() { return bts::utils::TimeStamp(); }
|
|
static bts::utils::TimeStamp max() { return bts::utils::TimeStamp(std::numeric_limits<uint64_t>().max()); }
|
|
};
|
|
}
|