Common::Timer: use chrono::steady_clock internally

1 files changed, 53 insertions, 163 deletions

diff --git a/Source/Core/Common/Timer.cpp b/Source/Core/Common/Timer.cpp
index f6d4c983cb..9ac3645841 100644
--- a/Source/Core/Common/Timer.cpp
+++ b/Source/Core/Common/Timer.cpp
@@ -9,13 +9,14 @@
 #ifdef _WIN32
 #include <cwchar>
 
-#include <windows.h>
+#include <Windows.h>
 #include <mmsystem.h>
 #include <sys/timeb.h>
 #else
 #include <sys/time.h>
 #endif
 
+#include <fmt/chrono.h>
 #include <fmt/format.h>
 
 #include "Common/CommonTypes.h"
@@ -23,157 +24,67 @@
 
 namespace Common
 {
-u32 Timer::GetTimeMs()
+template <typename Clock, typename Duration>
+static typename Clock::rep time_now()
 {
-#ifdef _WIN32
-  return timeGetTime();
-#elif defined __APPLE__
-  struct timeval t;
-  (void)gettimeofday(&t, nullptr);
-  return ((u32)(t.tv_sec * 1000 + t.tv_usec / 1000));
-#else
-  struct timespec t;
-  (void)clock_gettime(CLOCK_MONOTONIC, &t);
-  return ((u32)(t.tv_sec * 1000 + t.tv_nsec / 1000000));
-#endif
+  return std::chrono::time_point_cast<Duration>(Clock::now()).time_since_epoch().count();
 }
 
-#ifdef _WIN32
-double GetFreq()
+template <typename Duration>
+static auto steady_time_now()
 {
-  LARGE_INTEGER freq;
-  QueryPerformanceFrequency(&freq);
-  return 1000000.0 / double(freq.QuadPart);
+  return time_now<std::chrono::steady_clock, Duration>();
 }
-#endif
 
-u64 Timer::GetTimeUs()
+u64 Timer::NowUs()
 {
-#ifdef _WIN32
-  LARGE_INTEGER time;
-  static double freq = GetFreq();
-  QueryPerformanceCounter(&time);
-  return u64(double(time.QuadPart) * freq);
-#elif defined __APPLE__
-  struct timeval t;
-  (void)gettimeofday(&t, nullptr);
-  return ((u64)(t.tv_sec * 1000000 + t.tv_usec));
-#else
-  struct timespec t;
-  (void)clock_gettime(CLOCK_MONOTONIC, &t);
-  return ((u64)(t.tv_sec * 1000000 + t.tv_nsec / 1000));
-#endif
+  return steady_time_now<std::chrono::microseconds>();
 }
 
-// --------------------------------------------
-// Initiate, Start, Stop, and Update the time
-// --------------------------------------------
-
-// Set initial values for the class
-Timer::Timer() : m_LastTime(0), m_StartTime(0), m_Running(false)
+u64 Timer::NowMs()
 {
-  Update();
+  return steady_time_now<std::chrono::milliseconds>();
 }
 
-// Write the starting time
 void Timer::Start()
 {
-  m_StartTime = GetTimeMs();
-  m_Running = true;
+  m_start_ms = NowMs();
+  m_end_ms = 0;
+  m_running = true;
 }
 
-// Stop the timer
-void Timer::Stop()
+void Timer::StartWithOffset(u64 offset)
 {
-  // Write the final time
-  m_LastTime = GetTimeMs();
-  m_Running = false;
+  Start();
+  if (m_start_ms > offset)
+    m_start_ms -= offset;
 }
 
-// Update the last time variable
-void Timer::Update()
-{
-  m_LastTime = GetTimeMs();
-  // TODO(ector) - QPF
-}
-
-// -------------------------------------
-// Get time difference and elapsed time
-// -------------------------------------
-
-// Get the number of milliseconds since the last Update()
-u64 Timer::GetTimeDifference()
-{
-  return GetTimeMs() - m_LastTime;
-}
-
-// Add the time difference since the last Update() to the starting time.
-// This is used to compensate for a paused game.
-void Timer::AddTimeDifference()
+void Timer::Stop()
 {
-  m_StartTime += GetTimeDifference();
+  m_end_ms = NowMs();
+  m_running = false;
 }
 
-// Get the time elapsed since the Start()
-u64 Timer::GetTimeElapsed()
+u64 Timer::ElapsedMs() const
 {
   // If we have not started yet, return zero
-  if (m_StartTime == 0)
+  if (m_start_ms == 0)
     return 0;
 
-  // Return the final timer time if the timer is stopped
-  if (!m_Running)
-    return (m_LastTime - m_StartTime);
-
-  return (GetTimeMs() - m_StartTime);
-}
-
-// Get the formatted time elapsed since the Start()
-std::string Timer::GetTimeElapsedFormatted() const
-{
-  // If we have not started yet, return zero
-  if (m_StartTime == 0)
-    return "00:00:00:000";
-
-  // The number of milliseconds since the start.
-  // Use a different value if the timer is stopped.
-  u64 Milliseconds;
-  if (m_Running)
-    Milliseconds = GetTimeMs() - m_StartTime;
+  if (m_running)
+  {
+    u64 now = NowMs();
+    if (m_start_ms >= now)
+      return 0;
+    return now - m_start_ms;
+  }
   else
-    Milliseconds = m_LastTime - m_StartTime;
-  // Seconds
-  u32 Seconds = (u32)(Milliseconds / 1000);
-  // Minutes
-  u32 Minutes = Seconds / 60;
-  // Hours
-  u32 Hours = Minutes / 60;
-
-  return fmt::format("{:02}:{:02}:{:02}:{:03}", Hours, Minutes % 60, Seconds % 60,
-                     Milliseconds % 1000);
-}
-
-// Get current time
-void Timer::IncreaseResolution()
-{
-#ifdef _WIN32
-  timeBeginPeriod(1);
-#endif
-}
-
-void Timer::RestoreResolution()
-{
-#ifdef _WIN32
-  timeEndPeriod(1);
-#endif
-}
-
-// Get the number of seconds since January 1 1970
-u64 Timer::GetTimeSinceJan1970()
-{
-  time_t ltime;
-  time(&ltime);
-  return ((u64)ltime);
+  {
+    if (m_start_ms >= m_end_ms)
+      return 0;
+    return m_end_ms - m_start_ms;
+  }
 }
 
 u64 Timer::GetLocalTimeSinceJan1970()
@@ -195,41 +106,7 @@ u64 Timer::GetLocalTimeSinceJan1970()
   return static_cast<u64>(sysTime + tzDiff + tzDST);
 }
 
-// Return the current time formatted as Minutes:Seconds:Milliseconds
-// in the form 00:00:000.
-std::string Timer::GetTimeFormatted()
-{
-  time_t sysTime;
-  time(&sysTime);
-
-  struct tm* gmTime = localtime(&sysTime);
-
-#ifdef _WIN32
-  wchar_t tmp[13];
-  wcsftime(tmp, 6, L"%M:%S", gmTime);
-#else
-  char tmp[13];
-  strftime(tmp, 6, "%M:%S", gmTime);
-#endif
-
-// Now tack on the milliseconds
-#ifdef _WIN32
-  struct timeb tp;
-  (void)::ftime(&tp);
-  return WStringToUTF8(tmp) + fmt::format(":{:03}", tp.millitm);
-#elif defined __APPLE__
-  struct timeval t;
-  (void)gettimeofday(&t, nullptr);
-  return fmt::format("{}:{:03}", tmp, t.tv_usec / 1000);
-#else
-  struct timespec t;
-  (void)clock_gettime(CLOCK_MONOTONIC, &t);
-  return fmt::format("{}:{:03}", tmp, t.tv_nsec / 1000000);
-#endif
-}
-
-// Returns a timestamp with decimals for precise time comparisons
-double Timer::GetDoubleTime()
+double Timer::GetSystemTimeAsDouble()
 {
   // FYI: std::chrono::system_clock epoch is not required to be 1970 until c++20.
   // We will however assume time_t IS unix time.
@@ -244,10 +121,9 @@ double Timer::GetDoubleTime()
   return std::chrono::duration_cast<std::chrono::duration<double>>(since_double_time_epoch).count();
 }
 
-// Formats a timestamp from GetDoubleTime() into a date and time string
-std::string Timer::GetDateTimeFormatted(double time)
+std::string Timer::SystemTimeAsDoubleToString(double time)
 {
-  // revert adjustments from GetDoubleTime() to get a normal Unix timestamp again
+  // revert adjustments from GetSystemTimeAsDouble() to get a normal Unix timestamp again
   time_t seconds = (time_t)time + DOUBLE_TIME_OFFSET;
   tm* localTime = localtime(&seconds);
 
@@ -262,4 +138,18 @@ std::string Timer::GetDateTimeFormatted(double time)
 #endif
 }
 
+void Timer::IncreaseResolution()
+{
+#ifdef _WIN32
+  timeBeginPeriod(1);
+#endif
+}
+
+void Timer::RestoreResolution()
+{
+#ifdef _WIN32
+  timeEndPeriod(1);
+#endif
+}
+
 }  // Namespace Common