restored previous timer class

CMakeLists.txt

@@ -64,6 +64,8 @@ add_executable(shadps4
     ${FILESYSTEM_SOURCES}
     ${HOST_SOURCES}
     ${UTIL_SOURCES}
+    src/Lib/Timer.cpp
+    src/Lib/Timer.h
     src/main.cpp
     src/types.h
     src/Core/FsFile.cpp

src/Core/PS4/HLE/Kernel/Objects/event_queue.cpp

@@ -1,7 +1,8 @@
 #include "event_queue.h"
-#include "debug.h"
 
-#include <chrono>
+#include <Lib/Timer.h>
+
+#include "debug.h"
 
 namespace HLE::Kernel::Objects {
 EqueueInternal::~EqueueInternal() {}
@@ -25,8 +26,9 @@ int EqueueInternal::addEvent(const EqueueEvent& event) {
 int EqueueInternal::waitForEvents(SceKernelEvent* ev, int num, u32 micros) {
     std::unique_lock lock{m_mutex};
 
-    u64 timeElapsed = 0;
+    u32 timeElapsed = 0;
-    const auto start = std::chrono::high_resolution_clock::now();
+    Lib::Timer t;
+    t.Start();
 
     for (;;) {
         int ret = getTriggeredEvents(ev, num);
@@ -41,8 +43,7 @@ int EqueueInternal::waitForEvents(SceKernelEvent* ev, int num, u32 micros) {
             m_cond.wait_for(lock, std::chrono::microseconds(micros - timeElapsed));
         }
 
-        const auto end = std::chrono::high_resolution_clock::now();
+        timeElapsed = static_cast<uint32_t>(t.GetTimeSec() * 1000000.0);
-        timeElapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
     }
 
     return 0;

src/Lib/Timer.cpp

@@ -0,0 +1,103 @@
+#include "Timer.h"
+
+#ifdef _WIN64
+#include <windows.h>
+#endif
+
+Lib::Timer::Timer() {
+#ifdef _WIN64
+    LARGE_INTEGER f;
+    QueryPerformanceFrequency(&f);
+    m_Frequency = f.QuadPart;
+#else
+#error Unimplemented Timer constructor
+#endif
+}
+
+void Lib::Timer::Start() {
+#ifdef _WIN64
+    LARGE_INTEGER c;
+    QueryPerformanceCounter(&c);
+    m_StartTime = c.QuadPart;
+#else
+#error Unimplemented Timer::Start()
+#endif
+    m_is_timer_paused = false;
+}
+
+void Lib::Timer::Pause() {
+#ifdef _WIN64
+    LARGE_INTEGER c;
+    QueryPerformanceCounter(&c);
+    m_PauseTime = c.QuadPart;
+#else
+#error Unimplemented Timer::Pause()
+#endif
+    m_is_timer_paused = true;
+}
+
+void Lib::Timer::Resume() {
+    u64 current_time = 0;
+#ifdef _WIN64
+    LARGE_INTEGER c;
+    QueryPerformanceCounter(&c);
+    current_time = c.QuadPart;
+#else
+#error Unimplemented Timer::Resume()
+#endif
+    m_StartTime += current_time - m_PauseTime;
+    m_is_timer_paused = false;
+}
+
+bool Lib::Timer::IsPaused() const { return m_is_timer_paused; }
+
+double Lib::Timer::GetTimeMsec() const {
+    if (m_is_timer_paused) {
+        return 1000.0 * (static_cast<double>(m_PauseTime - m_StartTime)) / static_cast<double>(m_Frequency);
+    }
+
+    u64 current_time = 0;
+#ifdef _WIN64
+    LARGE_INTEGER c;
+    QueryPerformanceCounter(&c);
+    current_time = c.QuadPart;
+#else
+#error Unimplemented Timer::GetTimeMsec()
+#endif
+    return 1000.0 * (static_cast<double>(current_time - m_StartTime)) / static_cast<double>(m_Frequency);
+}
+
+double Lib::Timer::GetTimeSec() const {
+    if (m_is_timer_paused) {
+        return (static_cast<double>(m_PauseTime - m_StartTime)) / static_cast<double>(m_Frequency);
+    }
+
+    u64 current_time = 0;
+#ifdef _WIN64
+    LARGE_INTEGER c;
+    QueryPerformanceCounter(&c);
+    current_time = c.QuadPart;
+#else
+#error Unimplemented Timer::GetTimeSec()
+#endif
+    return (static_cast<double>(current_time - m_StartTime)) / static_cast<double>(m_Frequency);
+}
+
+u64 Lib::Timer::GetTicks() const {
+    if (m_is_timer_paused) {
+        return (m_PauseTime - m_StartTime);
+    }
+
+    u64 current_time = 0;
+#ifdef _WIN64
+    LARGE_INTEGER c;
+    QueryPerformanceCounter(&c);
+    current_time = c.QuadPart;
+#else
+#error Unimplemented Timer::GetTicks()
+#endif
+    return (current_time - m_StartTime);
+}
+
+u64 Lib::Timer::GetFrequency() const { return m_Frequency; }
+

src/Lib/Timer.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "../types.h"
+
+namespace Lib {
+	class Timer final
+	{
+	public:
+		Timer();
+		~Timer() = default;
+
+		void Start();
+		void Pause();
+		void Resume();
+		bool IsPaused() const;
+
+		double GetTimeMsec() const;// return time in milliseconds		
+		double GetTimeSec() const;// return time in seconds		
+		u64 GetTicks() const;// return time in ticks
+		u64 GetFrequency() const;// return ticks frequency
+
+	public:
+		Timer(const Timer&) = delete;
+		Timer& operator=(const Timer&) = delete;
+		Timer(Timer&&) = delete;
+		Timer& operator=(Timer&&) = delete;
+
+	private:
+		bool m_is_timer_paused = true;
+		u64 m_Frequency = 0;
+		u64 m_StartTime = 0;
+		u64 m_PauseTime = 0;
+	};
+}