shifathosn
/
AnyPS5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
AnyPS5/core/libs/prx/libkernel/Time/Time.cpp

439 lines
16 KiB
C++
Raw Blame History

#include "prx/libkernel/Time/include/Time.hpp"
#include "prx/libc/include/General.hpp"
#include <algorithm>
#include <cerrno>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <mutex>
#include <unordered_map>
#include <utility>
#include <vector>
#include <stdexcept>
#include <string>
#include <x86intrin.h>
#ifdef _WIN32
#include <windows.h>
#else
#include <time.h>
#include <sys/time.h>
#endif
static std::uint64_t RawMonotonicNanos() {
#ifdef _WIN32
static const std::uint64_t freq = [] {
LARGE_INTEGER f{};
QueryPerformanceFrequency(&f);
return static_cast<std::uint64_t>(f.QuadPart);
}();
LARGE_INTEGER counter{};
QueryPerformanceCounter(&counter);
return static_cast<std::uint64_t>(counter.QuadPart) * 1000000000ULL / freq;
#else
struct timespec ts{};
clock_gettime(CLOCK_MONOTONIC, &ts);
return static_cast<std::uint64_t>(ts.tv_sec) * 1000000000ULL +
static_cast<std::uint64_t>(ts.tv_nsec);
#endif
}
// Debug aid: APS5_TIME_SCALE=<factor> slows (or speeds) the guest's monotonic clocks and TSC, so a
// title running far below its frame rate sees plausible frame times. Sleeps still take real time.
static double TimeScale() {
static const double scale = [] {
const char* value = std::getenv("APS5_TIME_SCALE");
const double parsed = value ? std::strtod(value, nullptr) : 1.0;
return parsed > 0.0 ? parsed : 1.0;
}();
return scale;
}
static std::uint64_t ClockOrigin() {
static const std::uint64_t origin = RawMonotonicNanos();
return origin;
}
static std::uint64_t GetMonotonicNanos() {
const auto raw = RawMonotonicNanos();
if (TimeScale() == 1.0) return raw;
const auto origin = ClockOrigin();
return origin + static_cast<std::uint64_t>(static_cast<double>(raw - origin) * TimeScale());
}
static std::uint64_t GetStartNanos() {
static const std::uint64_t start = GetMonotonicNanos();
return start;
}
#ifdef _WIN32
// Every relative wait in the process (winpthreads nanosleep, std::condition_variable::wait_for, the
// GPU driver's poll sleeps) rounds up to the scheduler tick, 15.6 ms by default; a console game and
// its driver hand labels between queues dozens of times per frame, so the tick is raised to 0.5 ms at
// load, and Windows 11 is told not to drop it while the window is unfocused. APS5_NO_TIMER_RESOLUTION=1
// keeps the default for comparison.
static const bool g_timerResolutionRaised = [] {
if (std::getenv("APS5_NO_TIMER_RESOLUTION") != nullptr) return false;
using NtSetTimerResolutionFn = LONG(WINAPI*)(ULONG, BOOLEAN, PULONG);
const HMODULE ntdll = GetModuleHandleW(L"ntdll.dll");
const auto setResolution = ntdll ? reinterpret_cast<NtSetTimerResolutionFn>(reinterpret_cast<void*>(GetProcAddress(ntdll, "NtSetTimerResolution"))) : nullptr;
ULONG previous = 0;
const bool raised = setResolution != nullptr && setResolution(5000, TRUE, &previous) >= 0;
PROCESS_POWER_THROTTLING_STATE throttling{};
throttling.Version = PROCESS_POWER_THROTTLING_CURRENT_VERSION;
throttling.ControlMask = PROCESS_POWER_THROTTLING_IGNORE_TIMER_RESOLUTION;
throttling.StateMask = 0;
SetProcessInformation(GetCurrentProcess(), ProcessPowerThrottling, &throttling, sizeof(throttling));
std::fprintf(stderr, "[time] scheduler tick %s (was %.2f ms)\n", raised ? "raised to 0.5 ms" : "unchanged", previous / 10000.0);
return raised;
}();
#endif
static void SleepNanos(std::uint64_t nanos) {
if (nanos == 0) {
return;
}
#ifdef _WIN32
// Guest spin/backoff loops sleep for a few microseconds; Sleep() would either not sleep at all
// or round up to a whole scheduler tick, so short sleeps yield and longer ones use a
// high-resolution waitable timer.
if (nanos < 50000ULL) {
SwitchToThread();
return;
}
thread_local HANDLE timer = CreateWaitableTimerExW(nullptr, nullptr, CREATE_WAITABLE_TIMER_HIGH_RESOLUTION, TIMER_ALL_ACCESS);
if (timer) {
LARGE_INTEGER due{};
due.QuadPart = -static_cast<LONGLONG>(nanos / 100ULL);
if (SetWaitableTimer(timer, &due, 0, nullptr, nullptr, FALSE)) {
WaitForSingleObject(timer, INFINITE);
return;
}
}
Sleep(static_cast<DWORD>((nanos + 999999ULL) / 1000000ULL));
#else
struct timespec req{};
req.tv_sec = static_cast<time_t>(nanos / 1000000000ULL);
req.tv_nsec = static_cast<long>(nanos % 1000000000ULL);
while (nanosleep(&req, &req) == -1 && errno == EINTR) {}
#endif
}
extern "C" {
std::uint64_t APS5_VABI sceKernelGetProcessTime() {
return (GetMonotonicNanos() - GetStartNanos()) / 1000ULL;
}
std::uint64_t APS5_VABI sceKernelGetProcessTimeCounter() {
return GetMonotonicNanos() - GetStartNanos();
}
std::uint64_t APS5_VABI sceKernelGetProcessTimeCounterFrequency() {
return 1000000000ULL;
}
// Debug aid: APS5_TRACE_USLEEP reports every 2000 calls which guest call sites sleep, so a CPU
// thread polling for GPU or I/O completion can be found (offsets are relative to the executable).
static void TraceSleep(const void* caller, std::uint64_t microseconds) {
static const bool enabled = std::getenv("APS5_TRACE_USLEEP") != nullptr;
if (!enabled) return;
static std::mutex mutex;
static std::unordered_map<std::uintptr_t, std::pair<std::uint64_t, std::uint64_t>> sites;
static std::uint64_t calls = 0;
std::lock_guard lock(mutex);
auto& site = sites[reinterpret_cast<std::uintptr_t>(caller)];
++site.first;
site.second += microseconds;
if (++calls % 2000 != 0) return;
#ifdef _WIN32
const auto image = reinterpret_cast<std::uintptr_t>(GetModuleHandleW(nullptr));
#else
const std::uintptr_t image = 0;
#endif
std::vector<std::pair<std::uintptr_t, std::pair<std::uint64_t, std::uint64_t>>> hot(sites.begin(), sites.end());
std::sort(hot.begin(), hot.end(), [](const auto& a, const auto& b) { return a.second.first > b.second.first; });
std::fprintf(stderr, "[usleep] %llu calls:", static_cast<unsigned long long>(calls));
for (std::size_t i = 0; i < hot.size() && i < 6; ++i) std::fprintf(stderr, " exe+0x%llx x%llu (%llu us)", static_cast<unsigned long long>(hot[i].first - image), static_cast<unsigned long long>(hot[i].second.first), static_cast<unsigned long long>(hot[i].second.second));
std::fprintf(stderr, "\n");
}
void KernelTraceWait_nid_postfix(const char* kind, const void* caller, std::uint64_t waitedNanos, bool timedOut) {
static const bool enabled = std::getenv("APS5_TRACE_WAITS") != nullptr;
if (!enabled) return;
struct Site { std::uint64_t calls = 0; std::uint64_t timeouts = 0; std::uint64_t nanos = 0; std::uint64_t longest = 0; unsigned long lastThread = 0; };
static std::mutex mutex;
static std::unordered_map<std::string, Site> sites;
static std::uint64_t lastReport = 0;
char key[96];
#ifdef _WIN32
const auto image = reinterpret_cast<std::uintptr_t>(GetModuleHandleW(nullptr));
const unsigned long thread = GetCurrentThreadId();
#else
const std::uintptr_t image = 0;
const unsigned long thread = 0;
#endif
std::snprintf(key, sizeof(key), "%s exe+0x%llx", kind, static_cast<unsigned long long>(reinterpret_cast<std::uintptr_t>(caller) - image));
std::lock_guard lock(mutex);
auto& site = sites[key];
++site.calls;
site.timeouts += timedOut ? 1u : 0u;
site.nanos += waitedNanos;
site.longest = std::max(site.longest, waitedNanos);
site.lastThread = thread;
const auto now = GetMonotonicNanos();
if (lastReport == 0) lastReport = now;
if (now - lastReport < 3000000000ULL) return;
lastReport = now;
std::vector<std::pair<std::string, Site>> hot(sites.begin(), sites.end());
std::sort(hot.begin(), hot.end(), [](const auto& a, const auto& b) { return a.second.nanos > b.second.nanos; });
std::fprintf(stderr, "[waits]");
for (std::size_t i = 0; i < hot.size() && i < 8; ++i) {
const auto& s = hot[i].second;
std::fprintf(stderr, " | %s x%llu %.1fs (avg %.1f ms, max %.0f ms, %llu timeouts, tid %lu)", hot[i].first.c_str(), static_cast<unsigned long long>(s.calls), s.nanos / 1e9, s.nanos / 1e6 / static_cast<double>(s.calls), s.longest / 1e6, static_cast<unsigned long long>(s.timeouts), s.lastThread);
}
std::fprintf(stderr, "\n");
for (auto& [name, s] : sites) s = Site{};
}
int APS5_VABI sceKernelUsleep_nid_postfix(KernelUseconds microseconds) {
TraceSleep(__builtin_return_address(0), microseconds);
SleepNanos(static_cast<std::uint64_t>(microseconds) * 1000ULL);
return 0;
}
int APS5_VABI sceKernelNanosleep(const KernelTimespec* rqtp, KernelTimespec* rmtp) {
if (rqtp == nullptr) {
return -1;
}
if (rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 || rqtp->tv_nsec >= 1000000000LL) {
return -1;
}
SleepNanos(static_cast<std::uint64_t>(rqtp->tv_sec) * 1000000000ULL +
static_cast<std::uint64_t>(rqtp->tv_nsec));
if (rmtp != nullptr) {
rmtp->tv_sec = 0;
rmtp->tv_nsec = 0;
}
return 0;
}
int APS5_VABI nanosleep_nid_postfix(const KernelTimespec* rqtp, KernelTimespec* rmtp) {
return sceKernelNanosleep(rqtp, rmtp);
}
int APS5_VABI clock_gettime_nid_postfix(int clockId, KernelTimespec* tp) {
if (tp == nullptr) {
APS5_INVALID_ARG_EX;
}
#ifdef _WIN32
if (clockId == 0 || clockId == 9 || clockId == 10) {
FILETIME ft{};
GetSystemTimePreciseAsFileTime(&ft);
std::uint64_t t = (static_cast<std::uint64_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
t -= 116444736000000000ULL;
t *= 100ULL;
tp->tv_sec = static_cast<std::int64_t>(t / 1000000000ULL);
tp->tv_nsec = static_cast<std::int64_t>(t % 1000000000ULL);
return 0;
}
if (clockId == 4 || clockId == 1 || clockId == 5 || clockId == 7 || clockId == 8 || clockId == 11 || clockId == 12) {
std::uint64_t nanos = GetMonotonicNanos();
tp->tv_sec = static_cast<std::int64_t>(nanos / 1000000000ULL);
tp->tv_nsec = static_cast<std::int64_t>(nanos % 1000000000ULL);
return 0;
}
throw std::runtime_error(std::string(__func__) + ": unsupported clock_id " + std::to_string(clockId));
#else
clockid_t nativeId;
switch (clockId) {
case 0:
case 9:
case 10:
nativeId = CLOCK_REALTIME;
break;
case 4:
case 7:
case 11:
nativeId = CLOCK_MONOTONIC;
break;
case 5:
case 8:
case 12:
nativeId = CLOCK_MONOTONIC;
break;
case 14:
nativeId = CLOCK_THREAD_CPUTIME_ID;
break;
case 15:
nativeId = CLOCK_PROCESS_CPUTIME_ID;
break;
default:
throw std::runtime_error(std::string(__func__) + ": unsupported clock_id " + std::to_string(clockId));
}
struct timespec ts{};
if (clock_gettime(nativeId, &ts) != 0) {
return -1;
}
tp->tv_sec = static_cast<std::int64_t>(ts.tv_sec);
tp->tv_nsec = static_cast<std::int64_t>(ts.tv_nsec);
return 0;
#endif
}
int APS5_VABI gettimeofday_nid_postfix(KernelTimeval* tv, KernelTimezone* tz) {
if (tv == nullptr) {
APS5_INVALID_ARG_EX;
}
#ifdef _WIN32
FILETIME ft{};
GetSystemTimePreciseAsFileTime(&ft);
std::uint64_t t = (static_cast<std::uint64_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
t -= 116444736000000000ULL;
tv->tv_sec = static_cast<std::int64_t>(t / 10000000ULL);
tv->tv_usec = static_cast<std::int64_t>((t % 10000000ULL) / 10ULL);
#else
struct timeval native{};
if (gettimeofday(&native, nullptr) != 0) {
return -1;
}
tv->tv_sec = static_cast<std::int64_t>(native.tv_sec);
tv->tv_usec = static_cast<std::int64_t>(native.tv_usec);
#endif
if (tz != nullptr) {
tz->tz_minuteswest = 0;
tz->tz_dsttime = 0;
}
return 0;
}
int APS5_VABI clock_getres_nid_postfix(int clockId, KernelTimespec* res) {
if (res == nullptr) {
APS5_INVALID_ARG_EX;
}
#ifdef _WIN32
if (clockId == 0 || clockId == 9) {
res->tv_sec = 0;
res->tv_nsec = 100LL;
return 0;
}
if (clockId == 4 || clockId == 1 || clockId == 5 || clockId == 7 || clockId == 8 || clockId == 10 || clockId == 11 || clockId == 12) {
static const std::uint64_t freq = [] {
LARGE_INTEGER f{};
QueryPerformanceFrequency(&f);
return static_cast<std::uint64_t>(f.QuadPart);
}();
std::uint64_t nsPerTick = (1000000000ULL + freq - 1ULL) / freq;
res->tv_sec = 0;
res->tv_nsec = static_cast<std::int64_t>(nsPerTick);
return 0;
}
throw std::runtime_error(std::string(__func__) + ": unsupported clock_id " + std::to_string(clockId));
#else
clockid_t nativeId;
switch (clockId) {
case 0:
case 9:
case 10:
nativeId = CLOCK_REALTIME;
break;
case 4:
case 7:
case 11:
nativeId = CLOCK_MONOTONIC;
break;
case 5:
case 8:
case 12:
nativeId = CLOCK_MONOTONIC;
break;
case 14:
nativeId = CLOCK_THREAD_CPUTIME_ID;
break;
case 15:
nativeId = CLOCK_PROCESS_CPUTIME_ID;
break;
default:
throw std::runtime_error(std::string(__func__) + ": unsupported clock_id " + std::to_string(clockId));
}
struct timespec ts{};
if (clock_getres(nativeId, &ts) != 0) {
return -1;
}
res->tv_sec = static_cast<std::int64_t>(ts.tv_sec);
res->tv_nsec = static_cast<std::int64_t>(ts.tv_nsec);
return 0;
#endif
}
// ---------------------------------------------------------------------------
// Moved as-is (not yet implemented) from the monolithic libkernel/Export.cpp.
// ---------------------------------------------------------------------------
// The sce* clock calls share the POSIX implementations above. The console clock is kept in UTC:
// the time zone reported here and by gettimeofday has no offset and no daylight saving.
static constexpr int SceKernelErrorEfault = static_cast<int>(0x8002000e);
int APS5_VABI sceKernelClockGetres(KernelClockid clock_id, KernelTimespec* tp) {
if (tp == nullptr) return SceKernelErrorEfault;
return clock_getres_nid_postfix(static_cast<int>(clock_id), tp);
}
int APS5_VABI sceKernelClockGettime(KernelClockid clock_id, KernelTimespec* tp) {
if (tp == nullptr) return SceKernelErrorEfault;
return clock_gettime_nid_postfix(static_cast<int>(clock_id), tp);
}
int APS5_VABI sceKernelConvertLocaltimeToUtc(int64_t local_time, int64_t reserved, int64_t* utc_time, KernelTimezone* timezone, int32_t* dst_seconds) {
(void)reserved;
if (utc_time != nullptr) *utc_time = local_time;
if (timezone != nullptr) *timezone = {0, 0};
if (dst_seconds != nullptr) *dst_seconds = 0;
return 0;
}
int APS5_VABI sceKernelConvertUtcToLocaltime(int64_t utc_time, int64_t* local_time, KernelTimesec* st, uint64_t* dst_sec) {
if (local_time != nullptr) *local_time = utc_time;
if (st != nullptr) *st = {utc_time, 0u, 0u};
if (dst_sec != nullptr) *dst_sec = 0;
return 0;
}
int APS5_VABI sceKernelGettimeofday(KernelTimeval* tp) {
if (tp == nullptr) return SceKernelErrorEfault;
return gettimeofday_nid_postfix(tp, nullptr);
}
int APS5_VABI sceKernelGettimezone(KernelTimezone* tz) {
if (tz == nullptr) return SceKernelErrorEfault;
*tz = {0, 0};
return 0;
}
uint64_t APS5_VABI sceKernelReadTsc(void) {
if (TimeScale() == 1.0) return __rdtsc();
static const std::uint64_t origin = __rdtsc();
return origin + static_cast<std::uint64_t>(static_cast<double>(__rdtsc() - origin) * TimeScale());
}
uint64_t APS5_VABI sceKernelGetTscFrequency(void) {
static const std::uint64_t frequency = [] {
const std::uint64_t startNanos = RawMonotonicNanos();
const std::uint64_t startTicks = __rdtsc();
SleepNanos(20000000ULL);
const std::uint64_t elapsedNanos = RawMonotonicNanos() - startNanos;
const std::uint64_t elapsedTicks = __rdtsc() - startTicks;
return static_cast<std::uint64_t>(static_cast<long double>(elapsedTicks) * 1000000000.0L / static_cast<long double>(elapsedNanos));
}();
return frequency;
}
unsigned int APS5_VABI sceKernelSleep(unsigned int seconds) {
(void)seconds;
NotImplemented_nid_no_patch(__func__);
return 0;
}
}
Reference in New Issue View Git Blame Copy Permalink