You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
131 lines
2.3 KiB
131 lines
2.3 KiB
#include <chrono> // high_resolution_clock, seconds, milliseconds, microseconds, nanoseconds |
|
#include <cstdint> // uint64_t |
|
#include <cstdio> // printf |
|
|
|
#include "util/timer.h" |
|
|
|
namespace Util { |
|
|
|
Timer::Timer() |
|
: m_running(true) |
|
, m_accumulated(TimePoint::min()) |
|
, m_start(now()) |
|
{ |
|
} |
|
|
|
Timer::Timer(const TimePoint& timePoint) |
|
: m_running(true) |
|
, m_accumulated(TimePoint::min()) |
|
, m_start(timePoint) |
|
{ |
|
} |
|
|
|
// ----------------------------------------- |
|
|
|
Timer Timer::operator-(const Timer& timer) |
|
{ |
|
return Timer(TimePoint { m_start - timer.start() }); |
|
} |
|
|
|
TimePoint Timer::now() |
|
{ |
|
return std::chrono::high_resolution_clock::now(); |
|
} |
|
|
|
void Timer::pause() |
|
{ |
|
if (!m_running) { |
|
return; |
|
} |
|
|
|
m_accumulated += now() - m_start; |
|
m_running = false; |
|
} |
|
|
|
void Timer::resume() |
|
{ |
|
if (m_running) { |
|
return; |
|
} |
|
|
|
m_running = true; |
|
m_start = now(); |
|
} |
|
|
|
template<typename To, typename From> |
|
To Timer::to(From from) |
|
{ |
|
return std::chrono::duration_cast<To>(from); |
|
} |
|
|
|
uint64_t Timer::toSeconds() |
|
{ |
|
return to<std::chrono::seconds>(m_start.time_since_epoch()).count(); |
|
} |
|
|
|
uint64_t Timer::toMilliseconds() |
|
{ |
|
return to<std::chrono::milliseconds>(m_start.time_since_epoch()).count(); |
|
} |
|
|
|
uint64_t Timer::toMicroseconds() |
|
{ |
|
return to<std::chrono::microseconds>(m_start.time_since_epoch()).count(); |
|
} |
|
|
|
uint64_t Timer::toNanoseconds() |
|
{ |
|
return to<std::chrono::nanoseconds>(m_start.time_since_epoch()).count(); |
|
} |
|
|
|
template<typename T> |
|
uint64_t Timer::elapsed() |
|
{ |
|
uint64_t elapsed = 0; |
|
|
|
if (m_running) { |
|
elapsed += std::chrono::duration_cast<T>(now() - m_start).count(); |
|
} |
|
|
|
elapsed += std::chrono::duration_cast<T>(m_accumulated - TimePoint::min()).count(); |
|
|
|
return elapsed; |
|
} |
|
|
|
uint64_t Timer::elapsedSeconds() |
|
{ |
|
return elapsed<std::chrono::seconds>(); |
|
} |
|
|
|
uint64_t Timer::elapsedMilliseconds() |
|
{ |
|
return elapsed<std::chrono::milliseconds>(); |
|
} |
|
|
|
uint64_t Timer::elapsedMicroseconds() |
|
{ |
|
return elapsed<std::chrono::microseconds>(); |
|
} |
|
|
|
uint64_t Timer::elapsedNanoseconds() |
|
{ |
|
return elapsed<std::chrono::nanoseconds>(); |
|
} |
|
|
|
void Timer::fancyPrint(uint64_t nanoseconds) |
|
{ |
|
if (nanoseconds > 999999999) { |
|
printf("%.3fs", nanoseconds / 1000000000.0); |
|
} |
|
else if (nanoseconds > 999999) { |
|
printf("%.0fms", nanoseconds / 1000000.0); |
|
} |
|
else if (nanoseconds > 999) { |
|
printf("%.0fμs", nanoseconds / 1000.0); |
|
} |
|
else { |
|
printf("%luns", nanoseconds); |
|
} |
|
} |
|
|
|
} // namespace Util
|
|
|