manafiles/src/util/timer.cpp

#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