Files
spark/src/lib/utils/TimeStamp.h
T

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()); }
};
}