mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-16 13:59:56 -04:00
The review found that numbering these lines had been set aside as the performance branch's work, while it is the part of A-10 that may land on its own, and only this branch writes rtss_limit.c. A want that flips between a limit and kept out (low latency before the first swapchain and during a rebuild, or switched in the menu) creates the profile and removes it again at each flip; the play-test's live toggles item counts those lines. rtss_limit.c apply now ends the created line with "(creation N this run)" and put_back the removed line with "(removal N this run)", counted under the lock both run under. The settle rule that would stop the churn still waits for approval. tests/rtss_worker_check.c churn_run also checks that the ten flips log creations 1 to 6 and removals 1 to 5 and no more. rtss_limit_check passes 24 of 24. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
718 lines
30 KiB
C
718 lines
30 KiB
C
// The real runtime/rtss_limit.c against a fake RivaTuner Statistics Server: the Win32 calls it makes go to the fakes
|
|
// below (its folder in the registry, its hooks library with the profile calls, the profile files, the shared memory
|
|
// RTSSSharedMemoryV2), and its worker thread polls when a scenario says so (plat_sleep_ms on that thread waits for the
|
|
// next poll). Each scenario runs in a process of its own, since rtss_limit.c's state lasts the process. Windows only;
|
|
// built and run by tests/rtss_limit_check.py. Prints the log and each failed check, and exits 1 on any.
|
|
//
|
|
// rtss_worker_check <scenario>
|
|
#include <windows.h>
|
|
#include <stdarg.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
LSTATUS stub_RegGetValueA(HKEY, LPCSTR, LPCSTR, DWORD, LPDWORD, PVOID, LPDWORD);
|
|
HMODULE stub_LoadLibraryA(LPCSTR);
|
|
FARPROC stub_GetProcAddress(HMODULE, LPCSTR);
|
|
BOOL stub_FreeLibrary(HMODULE);
|
|
HANDLE stub_OpenFileMappingA(DWORD, BOOL, LPCSTR);
|
|
LPVOID stub_MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, SIZE_T);
|
|
BOOL stub_UnmapViewOfFile(LPCVOID);
|
|
SIZE_T stub_VirtualQuery(LPCVOID, PMEMORY_BASIC_INFORMATION, SIZE_T);
|
|
BOOL stub_CloseHandle(HANDLE);
|
|
DWORD stub_GetFileAttributesA(LPCSTR);
|
|
BOOL stub_GetFileAttributesExA(LPCSTR, GET_FILEEX_INFO_LEVELS, LPVOID);
|
|
DWORD stub_GetPrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD, LPCSTR);
|
|
DWORD stub_GetModuleFileNameA(HMODULE, LPSTR, DWORD);
|
|
DWORD stub_GetCurrentProcessId(void);
|
|
#define RegGetValueA stub_RegGetValueA
|
|
#define LoadLibraryA stub_LoadLibraryA
|
|
#define GetProcAddress stub_GetProcAddress
|
|
#define FreeLibrary stub_FreeLibrary
|
|
#define OpenFileMappingA stub_OpenFileMappingA
|
|
#define MapViewOfFile stub_MapViewOfFile
|
|
#define UnmapViewOfFile stub_UnmapViewOfFile
|
|
#define VirtualQuery stub_VirtualQuery
|
|
#define CloseHandle stub_CloseHandle
|
|
#define GetFileAttributesA stub_GetFileAttributesA
|
|
#define GetFileAttributesExA stub_GetFileAttributesExA
|
|
#define GetPrivateProfileStringA stub_GetPrivateProfileStringA
|
|
#define GetModuleFileNameA stub_GetModuleFileNameA
|
|
#define GetCurrentProcessId stub_GetCurrentProcessId
|
|
|
|
#include "rtss_limit.c"
|
|
|
|
static int fails;
|
|
#define CHECK(c, ...) do { if (!(c)) { fails++; printf("FAIL line %d: ", __LINE__); printf(__VA_ARGS__); printf("\n"); } } while (0)
|
|
|
|
// ---- the fake profiles: Global, and the game's own Profiles\ocarina.exe.cfg. LoadProfile copies one into the loaded
|
|
// copy (Global for a name without its own), SaveProfile writes the loaded copy as the game's own. Each [Framerate] key
|
|
// rtss_limit.c reads is a field; stamp is the file's write time, which every change moves on.
|
|
typedef struct {
|
|
int exists;
|
|
DWORD limit, denom; // FramerateLimit and FramerateLimitDenominator: Limit and LimitDenominator in the file
|
|
int time, time_den, scan0, scan1, sync_display, reflex, passive;
|
|
DWORD stamp;
|
|
} Prof;
|
|
static Prof global = {1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1}, own, loaded;
|
|
static int no_denominator; // an RTSS that does not know FramerateLimitDenominator
|
|
static int readonly; // SaveProfile does not reach the file (no administrator rights)
|
|
static DWORD refuse_over; // RTSS refuses a limit above this many frames a second (0: none refused)
|
|
static int no_library; // LoadLibraryA fails
|
|
static volatile LONG saves, deletes, updates, loads, created, removed;
|
|
|
|
static void touch(Prof *p) { p->stamp++; }
|
|
static void WINAPI f_load(LPCSTR name) {
|
|
(void)name;
|
|
loaded = own.exists ? own : global;
|
|
}
|
|
static void WINAPI f_save(LPCSTR name) {
|
|
(void)name;
|
|
saves++;
|
|
if (readonly) return;
|
|
DWORD stamp = own.stamp;
|
|
own = loaded, own.exists = 1, own.stamp = stamp;
|
|
touch(&own);
|
|
}
|
|
static void WINAPI f_delete(LPCSTR name) {
|
|
(void)name;
|
|
deletes++;
|
|
if (!readonly) own.exists = 0, touch(&own);
|
|
}
|
|
static BOOL WINAPI f_get(LPCSTR prop, LPBYTE data, DWORD size) {
|
|
if (size != 4) return FALSE;
|
|
if (!strcmp(prop, "FramerateLimit")) return memcpy(data, &loaded.limit, 4), TRUE;
|
|
if (!strcmp(prop, "FramerateLimitDenominator") && !no_denominator) return memcpy(data, &loaded.denom, 4), TRUE;
|
|
return FALSE;
|
|
}
|
|
static BOOL WINAPI f_set(LPCSTR prop, LPBYTE data, DWORD size) {
|
|
if (size != 4) return FALSE;
|
|
DWORD v;
|
|
memcpy(&v, data, 4);
|
|
if (!strcmp(prop, "FramerateLimit") && refuse_over && v / (loaded.denom ? loaded.denom : 1) > refuse_over) return FALSE;
|
|
if (!strcmp(prop, "FramerateLimit")) return memcpy(&loaded.limit, data, 4), TRUE;
|
|
if (!strcmp(prop, "FramerateLimitDenominator") && !no_denominator) return memcpy(&loaded.denom, data, 4), TRUE;
|
|
return FALSE;
|
|
}
|
|
static void WINAPI f_update(void) { updates++; }
|
|
static DWORD WINAPI f_enum(LPSTR list, DWORD size) { (void)size; list[0] = 0; return 1; }
|
|
|
|
static Prof *file_of(const char *path) {
|
|
if (strstr(path, "\\Profiles\\ocarina.exe.cfg")) return own.exists ? &own : NULL;
|
|
if (strstr(path, "\\Profiles\\Global")) return &global;
|
|
return NULL;
|
|
}
|
|
|
|
// ---- the fake shared memory: the header and one application entry, this process's (listed) or another's
|
|
static uint8_t shm[65536];
|
|
static volatile LONG running = 1;
|
|
enum { PID = 4242, ENTRY_AT = 0x100, ENTRY_SIZE = 1024 };
|
|
static void app_set(int listed, DWORD flags, DWORD t0, DWORD t1, DWORD frames) {
|
|
DWORD h[5] = {0x52545353u, 0x0002000Eu, ENTRY_SIZE, ENTRY_AT, 1};
|
|
memcpy(shm, h, sizeof h);
|
|
uint8_t *e = shm + ENTRY_AT;
|
|
DWORD pid = listed ? PID : 7;
|
|
DWORD t[3] = {t0, t1, frames};
|
|
memcpy(e, &pid, 4);
|
|
memcpy(e + 4 + MAX_PATH, &flags, 4);
|
|
memcpy(e + 4 + MAX_PATH + 4, t, sizeof t);
|
|
}
|
|
|
|
// The registry and file calls the thread that asks for a limit makes itself: a present must make none.
|
|
static DWORD present_tid;
|
|
static volatile LONG present_calls, reg_calls;
|
|
static int installed = 1;
|
|
static void on_call(void) {
|
|
if (GetCurrentThreadId() == present_tid) present_calls++;
|
|
}
|
|
|
|
LSTATUS stub_RegGetValueA(HKEY k, LPCSTR sub, LPCSTR val, DWORD fl, LPDWORD ty, PVOID data, LPDWORD size) {
|
|
(void)k, (void)sub, (void)val, (void)fl, (void)ty;
|
|
on_call();
|
|
reg_calls++;
|
|
if (!installed) return ERROR_FILE_NOT_FOUND;
|
|
snprintf(data, *size, "C:\\FakeRTSS");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
HMODULE stub_LoadLibraryA(LPCSTR p) {
|
|
(void)p;
|
|
loads++;
|
|
if (no_library) return NULL;
|
|
return (HMODULE)(uintptr_t)0x1000;
|
|
}
|
|
FARPROC stub_GetProcAddress(HMODULE m, LPCSTR n) {
|
|
(void)m;
|
|
if (!strcmp(n, "EnumProfiles")) return (FARPROC)(void *)f_enum;
|
|
if (!strcmp(n, "LoadProfile")) return (FARPROC)(void *)f_load;
|
|
if (!strcmp(n, "SaveProfile")) return (FARPROC)(void *)f_save;
|
|
if (!strcmp(n, "DeleteProfile")) return (FARPROC)(void *)f_delete;
|
|
if (!strcmp(n, "GetProfileProperty")) return (FARPROC)(void *)f_get;
|
|
if (!strcmp(n, "SetProfileProperty")) return (FARPROC)(void *)f_set;
|
|
if (!strcmp(n, "UpdateProfiles")) return (FARPROC)(void *)f_update;
|
|
return NULL;
|
|
}
|
|
BOOL stub_FreeLibrary(HMODULE m) { (void)m; return TRUE; }
|
|
HANDLE stub_OpenFileMappingA(DWORD a, BOOL b, LPCSTR n) {
|
|
(void)a, (void)b, (void)n;
|
|
return running ? (HANDLE)(uintptr_t)0x2000 : NULL;
|
|
}
|
|
LPVOID stub_MapViewOfFile(HANDLE h, DWORD a, DWORD b, DWORD c, SIZE_T d) {
|
|
(void)h, (void)a, (void)b, (void)c, (void)d;
|
|
return shm;
|
|
}
|
|
BOOL stub_UnmapViewOfFile(LPCVOID p) { (void)p; return TRUE; }
|
|
SIZE_T stub_VirtualQuery(LPCVOID p, PMEMORY_BASIC_INFORMATION mi, SIZE_T n) {
|
|
(void)p;
|
|
memset(mi, 0, n);
|
|
mi->RegionSize = sizeof shm;
|
|
return n;
|
|
}
|
|
BOOL stub_CloseHandle(HANDLE h) { (void)h; return TRUE; }
|
|
DWORD stub_GetFileAttributesA(LPCSTR p) {
|
|
on_call();
|
|
if (strstr(p, "RTSSHooks64.dll")) return FILE_ATTRIBUTE_NORMAL;
|
|
return file_of(p) ? FILE_ATTRIBUTE_NORMAL : INVALID_FILE_ATTRIBUTES;
|
|
}
|
|
BOOL stub_GetFileAttributesExA(LPCSTR p, GET_FILEEX_INFO_LEVELS level, LPVOID out) {
|
|
(void)level;
|
|
on_call();
|
|
const Prof *f = file_of(p);
|
|
if (!f) return FALSE;
|
|
WIN32_FILE_ATTRIBUTE_DATA *a = out;
|
|
memset(a, 0, sizeof *a);
|
|
a->ftLastWriteTime.dwLowDateTime = f->stamp;
|
|
return TRUE;
|
|
}
|
|
DWORD stub_GetPrivateProfileStringA(LPCSTR sec, LPCSTR key, LPCSTR def, LPSTR out, DWORD n, LPCSTR path) {
|
|
on_call();
|
|
const Prof *f = file_of(path);
|
|
long v = 0;
|
|
int have = f && !strcmp(sec, "Framerate");
|
|
if (have) {
|
|
if (!strcmp(key, "Limit")) v = (long)f->limit;
|
|
else if (!strcmp(key, "LimitDenominator")) v = (long)f->denom;
|
|
else if (!strcmp(key, "LimitTime")) v = f->time;
|
|
else if (!strcmp(key, "LimitTimeDenominator")) v = f->time_den;
|
|
else if (!strcmp(key, "SyncScanline0")) v = f->scan0;
|
|
else if (!strcmp(key, "SyncScanline1")) v = f->scan1;
|
|
else if (!strcmp(key, "SyncDisplay")) v = f->sync_display;
|
|
else if (!strcmp(key, "ReflexSleep")) v = f->reflex;
|
|
else if (!strcmp(key, "PassiveWait")) v = f->passive;
|
|
else have = 0;
|
|
}
|
|
if (have) return (DWORD)snprintf(out, n, "%ld", v);
|
|
return (DWORD)snprintf(out, n, "%s", def);
|
|
}
|
|
DWORD stub_GetModuleFileNameA(HMODULE m, LPSTR out, DWORD n) {
|
|
(void)m;
|
|
on_call();
|
|
return (DWORD)snprintf(out, n, "C:\\game\\ocarina.exe");
|
|
}
|
|
DWORD stub_GetCurrentProcessId(void) { return PID; }
|
|
|
|
// ---- host.h and platform.h, as far as rtss_limit.c uses them
|
|
static char logged_lines[1 << 16];
|
|
static size_t logged_at;
|
|
static int quiet; // the stress scenario: no lines kept or printed
|
|
void rt_log(const char *fmt, ...) {
|
|
if (quiet) return;
|
|
char line[512];
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
vsnprintf(line, sizeof line, fmt, ap);
|
|
va_end(ap);
|
|
if (strstr(line, " created;")) created++;
|
|
if (strstr(line, " removed,")) removed++;
|
|
int k = snprintf(logged_lines + logged_at, sizeof logged_lines - logged_at, "%s\n", line);
|
|
if (k > 0 && logged_at + (size_t)k < sizeof logged_lines) logged_at += (size_t)k;
|
|
printf(" log: %s\n", line);
|
|
}
|
|
static int logged(const char *text) { return strstr(logged_lines, text) != NULL; }
|
|
int rt_knob(const char *name, const char *def) { (void)name, (void)def; return 0; }
|
|
|
|
static DWORD worker_tid;
|
|
static HANDLE tick, done, at_lock, go;
|
|
static volatile LONG pause_at_lock; // the worker's next plat_mutex_lock stops before it takes the lock
|
|
|
|
void plat_mutex_lock(PlatMutex *m) {
|
|
if (GetCurrentThreadId() == worker_tid && InterlockedExchange(&pause_at_lock, 0)) {
|
|
SetEvent(at_lock);
|
|
WaitForSingleObject(go, INFINITE);
|
|
}
|
|
AcquireSRWLockExclusive((PSRWLOCK)m);
|
|
}
|
|
void plat_mutex_unlock(PlatMutex *m) { ReleaseSRWLockExclusive((PSRWLOCK)m); }
|
|
int plat_mutex_trylock(PlatMutex *m) { return TryAcquireSRWLockExclusive((PSRWLOCK)m) != 0; }
|
|
|
|
static PlatThreadFn worker_fn;
|
|
static HANDLE worker_thread;
|
|
static volatile LONG spawned;
|
|
static volatile LONG free_run; // the worker polls without waiting
|
|
static volatile LONG64 polls;
|
|
static DWORD WINAPI worker_main(void *arg) {
|
|
worker_tid = GetCurrentThreadId();
|
|
worker_fn(arg);
|
|
return 0;
|
|
}
|
|
int plat_thread_spawn(PlatThreadFn fn, void *arg, const char *name, size_t stack) {
|
|
(void)name, (void)stack;
|
|
worker_fn = fn;
|
|
spawned = 1;
|
|
worker_thread = CreateThread(NULL, 0, worker_main, arg, 0, NULL);
|
|
return worker_thread != NULL;
|
|
}
|
|
void plat_sleep_ms(uint32_t ms) {
|
|
if (GetCurrentThreadId() != worker_tid) {
|
|
Sleep(ms);
|
|
return;
|
|
}
|
|
InterlockedIncrement64(&polls);
|
|
if (free_run) return;
|
|
SetEvent(done); // a poll ended
|
|
WaitForSingleObject(tick, INFINITE); // the next one starts when the scenario says
|
|
}
|
|
|
|
// ---- the scenarios' steps
|
|
static int wait_done(void) { return WaitForSingleObject(done, 5000) == WAIT_OBJECT_0; }
|
|
static void poll(void) { // one more poll of the worker, waited for
|
|
SetEvent(tick);
|
|
CHECK(wait_done(), "the worker did not finish a poll");
|
|
}
|
|
static void ask(int64_t mhz) { // a want at a present; the first one that starts the worker waits for its first poll
|
|
int was = spawned;
|
|
rtss_limit_want(mhz);
|
|
if (spawned && !was) {
|
|
HANDLE h[2] = {done, worker_thread}; // or for its end, when it finds no RTSS
|
|
CHECK(WaitForMultipleObjects(2, h, FALSE, 5000) != WAIT_TIMEOUT, "the worker did not finish its first poll");
|
|
}
|
|
}
|
|
static void show(const char *what) {
|
|
printf(" %s: profile %s %lu/%lu; active %d; state %d; saves %ld deletes %ld updates %ld loads %ld\n", what,
|
|
own.exists ? "exists," : "absent,", own.limit, own.denom, rtss_limit_active(), rtss_limit_state(), saves,
|
|
deletes, updates, loads);
|
|
}
|
|
|
|
// The exit puts the profile back (rtss_limit_restore) and the game presents on until the process ends: a want after it
|
|
// never reaches the profile, and the pacer paces again.
|
|
static void restore_race(void) {
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
show("playing at 60");
|
|
CHECK(own.exists && own.limit == 60, "the limit went into the profile");
|
|
rtss_limit_restore();
|
|
show("after rtss_limit_restore");
|
|
CHECK(!own.exists, "the profile the game created is gone after the restore");
|
|
CHECK(!rtss_limit_active() && !rtss_limit_state(), "the game's limiter paces once the profile is back");
|
|
ask(60000); // frame_step_cap_ns at a present after the restore
|
|
poll();
|
|
poll();
|
|
show("two polls later");
|
|
CHECK(!own.exists, "the profile stays as it was put back");
|
|
CHECK(created == 1, "the profile was created %ld times", created);
|
|
CHECK(!rtss_limit_active() && !rtss_limit_state(), "the game's limiter paces until the end");
|
|
}
|
|
|
|
// The same with the player's own profile: it keeps the player's limit.
|
|
static void restore_player(void) {
|
|
own = (Prof){1, 30, 1, 0, 0, 0, 0, 0, 0, 0, 1};
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
CHECK(own.limit == 60, "the game's limit went into the profile");
|
|
rtss_limit_restore();
|
|
CHECK(own.exists && own.limit == 30, "the player's limit is back after the restore");
|
|
ask(144000);
|
|
poll();
|
|
show("a want and a poll after the restore");
|
|
CHECK(own.exists && own.limit == 30 && own.denom == 1, "the profile keeps the player's limit");
|
|
}
|
|
|
|
// A want the worker read before the restore and takes the lock with after it: it must not reach the profile.
|
|
static void restore_inflight(void) {
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
pause_at_lock = 1;
|
|
rtss_limit_want(144000);
|
|
SetEvent(tick);
|
|
CHECK(WaitForSingleObject(at_lock, 5000) == WAIT_OBJECT_0, "the worker did not reach its lock");
|
|
rtss_limit_restore(); // the worker read 144000 and waits for the lock
|
|
SetEvent(go);
|
|
CHECK(wait_done(), "the worker did not finish the poll");
|
|
show("the poll that read its want before the restore");
|
|
CHECK(!own.exists, "the profile stays as it was put back");
|
|
CHECK(created == 1, "the profile was created %ld times", created);
|
|
}
|
|
|
|
// An exit before the first want, and one while RTSS was kept out: a want after it does not reach the profile.
|
|
static void restore_first(void) {
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
rtss_limit_restore();
|
|
ask(60000);
|
|
if (spawned) poll();
|
|
show("a want after an exit before the first one");
|
|
CHECK(!own.exists && !created, "no profile written after the exit");
|
|
CHECK(!rtss_limit_active(), "the game's limiter paces");
|
|
}
|
|
static void restore_kept_out(void) {
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(RTSS_OUT_SETTING);
|
|
rtss_limit_restore();
|
|
ask(60000);
|
|
if (spawned) poll();
|
|
show("a want after an exit while RTSS was kept out");
|
|
CHECK(!own.exists && !created, "no profile written after the exit");
|
|
CHECK(!rtss_limit_active(), "the game's limiter paces");
|
|
}
|
|
|
|
// NX2NAVI_RTSS=0 with a limit set in RTSS's Global profile: the worker only reads, never loads the hooks library, and
|
|
// tells of the two limiters until the player clears that limit.
|
|
static void kept_two(void) {
|
|
global.limit = 50;
|
|
app_set(1, 0xA, 1000, 2000, 50);
|
|
ask(RTSS_OUT_SETTING);
|
|
poll();
|
|
show("kept out by the setting, Global limit 50");
|
|
CHECK(spawned, "a kept-out first want starts the worker");
|
|
CHECK(!loads && !saves && !deletes, "kept out, the hooks library is never loaded and no profile written");
|
|
CHECK(rtss_limit_state() == 4 && !rtss_limit_active(), "the menu says two limiters; the game's limiter paces");
|
|
CHECK(logged("kept out: NX2NAVI_RTSS=0"), "the kept-out line names the setting");
|
|
CHECK(logged("two limiters: RivaTuner Statistics Server's own setting for the game (Profiles\\Global: limit 50/1, "
|
|
"frame time limit 0/0, scanline sync 0/0) limits it beside the game's limiter"),
|
|
"the two-limiter line names the file and the values");
|
|
global.limit = 0, touch(&global);
|
|
poll();
|
|
show("the player cleared RTSS's limit");
|
|
CHECK(rtss_limit_state() == 0, "one limiter again");
|
|
CHECK(logged("RivaTuner Statistics Server no longer limits the game beside the game's limiter"), "logged once it ended");
|
|
}
|
|
|
|
// Low latency keeps RTSS out from the first present, with scanline sync set in the game's own profile (a negative line
|
|
// counts from the bottom); once low latency is off, a limit starts RTSS's part as usual.
|
|
static void kept_lowlat_then_limit(void) {
|
|
own = (Prof){1, 0, 1, 0, 0, -40, 0, 0, 0, 0, 1};
|
|
app_set(0, 0xA, 1000, 2000, 60);
|
|
ask(RTSS_OUT_LOWLAT);
|
|
poll();
|
|
CHECK(rtss_limit_state() == 0, "not listed yet: RTSS holds nothing");
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
poll();
|
|
show("listed, kept out by low latency");
|
|
CHECK(rtss_limit_state() == 4, "scanline sync -40 holds the game: two limiters");
|
|
CHECK(logged("kept out: the driver's low latency"), "the kept-out line names low latency");
|
|
CHECK(logged("(Profiles\\ocarina.exe.cfg: limit 0/1, frame time limit 0/0, scanline sync -40/0) limits it beside "
|
|
"the driver's low latency"),
|
|
"the two-limiter line names the game's profile and low latency");
|
|
CHECK(!loads, "kept out, the hooks library is never loaded");
|
|
ask(60000);
|
|
poll();
|
|
show("low latency off, limit 60");
|
|
CHECK(loads == 1 && own.exists && own.limit == 60, "the limit goes into the profile once RTSS is let in");
|
|
CHECK(rtss_limit_state() == 1 && rtss_limit_active(), "RTSS limits the game");
|
|
}
|
|
|
|
// Frame generation keeps RTSS out, with no limit of RTSS's own: one limiter, and the line names frame generation.
|
|
static void kept_framegen(void) {
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(RTSS_OUT_FRAMEGEN);
|
|
poll();
|
|
show("kept out by frame generation");
|
|
CHECK(logged("kept out: frame generation"), "the kept-out line names frame generation");
|
|
CHECK(!logged("two limiters") && rtss_limit_state() == 0, "no second limiter");
|
|
CHECK(!loads && !saves, "kept out, the hooks library is never loaded");
|
|
}
|
|
|
|
// Frame generation switched on while the worker polls without pause: from the switch until the worker sees it, the
|
|
// game's limiter paces, never RTSS's hold of the limit before (the worker's store for a want that changed after it
|
|
// read it must not count for the new one).
|
|
static void active_race(void) {
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
CHECK(rtss_limit_active(), "RTSS limits at 60");
|
|
quiet = 1, free_run = 1;
|
|
SetEvent(tick);
|
|
long hits = 0, n = 400000, stuck = 0;
|
|
srand(7);
|
|
for (long i = 0; i < n && !stuck; i++) {
|
|
for (volatile int k = rand() % 200; k > 0; k--) {}
|
|
rtss_limit_want(RTSS_OUT_FRAMEGEN);
|
|
LONG64 p0 = polls;
|
|
int seen = 0;
|
|
while (polls < p0 + 2) seen |= rtss_limit_active();
|
|
hits += seen;
|
|
rtss_limit_want(60000);
|
|
ULONGLONG t0 = GetTickCount64();
|
|
while (!rtss_limit_active() && !stuck) stuck = GetTickCount64() - t0 > 5000;
|
|
}
|
|
quiet = 0;
|
|
printf(" %ld of %ld switches read RTSS's hold afterwards (worker polls %lld)\n", hits, n, (long long)polls);
|
|
CHECK(!stuck, "RTSS did not take the limit back");
|
|
CHECK(!hits, "the game's limiter stood aside for a kept-out want %ld times", hits);
|
|
}
|
|
|
|
// A limit of a fractional monitor (display at 59.94 and 143.856 Hz): an RTSS that knows the denominator holds it as it
|
|
// is, one that does not holds it rounded to whole frames, and the log says what the profile holds, not what was asked.
|
|
static void round_logged(void) {
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(59940);
|
|
poll();
|
|
show("display at 59.94 Hz");
|
|
CHECK(own.limit == 59940 && own.denom == 1000, "the denominator holds the fraction");
|
|
CHECK(logged("profile ocarina.exe limits to 59.940 fps\n"), "the exact limit as it is");
|
|
}
|
|
static void round_logged_whole(void) {
|
|
no_denominator = 1;
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(59940);
|
|
poll();
|
|
show("display at 59.94 Hz, RTSS without a denominator");
|
|
CHECK(own.limit == 60, "rounded to whole frames");
|
|
CHECK(logged("profile ocarina.exe limits to 60/1 (60.000 fps; the game asked 59.940)"), "the log names 60/1");
|
|
ask(143856);
|
|
poll();
|
|
CHECK(logged("profile ocarina.exe limits to 144/1 (144.000 fps; the game asked 143.856)"), "the log names 144/1");
|
|
ask(60000);
|
|
poll();
|
|
CHECK(logged("profile ocarina.exe limits to 60.000 fps\n"), "a whole limit as it is");
|
|
}
|
|
|
|
// The first want comes at a present: the worker, not the present, reads RTSS's registry key and looks for its files.
|
|
static void start_off_present(void) {
|
|
present_tid = GetCurrentThreadId();
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
show("playing at 60");
|
|
CHECK(own.exists && own.limit == 60, "the limit went into the profile");
|
|
CHECK(reg_calls == 1, "RTSS's folder was looked up once (%ld)", reg_calls);
|
|
CHECK(!present_calls, "the presenting thread made %ld registry or file calls", present_calls);
|
|
}
|
|
|
|
// No RTSS: the worker says so and ends, the game's limiter paces, and the exit has nothing to put back.
|
|
static void not_installed(void) {
|
|
installed = 0;
|
|
ask(60000);
|
|
CHECK(spawned && WaitForSingleObject(worker_thread, 5000) == WAIT_OBJECT_0, "the worker ended");
|
|
CHECK(logged("RivaTuner Statistics Server is not installed; the game's own limiter"), "logged");
|
|
CHECK(!rtss_limit_active() && !rtss_limit_state(), "the game's limiter paces");
|
|
ask(144000);
|
|
rtss_limit_restore();
|
|
CHECK(!loads && !saves && !own.exists, "nothing loaded or written");
|
|
}
|
|
|
|
// While RTSS lists the game, its settings for the game are logged once per change: Global's before the game has a
|
|
// profile of its own, then the game's own with the limit it wrote, frame time limit, scanline sync and the modes.
|
|
static int count(const char *text) {
|
|
int n = 0;
|
|
for (const char *p = logged_lines; (p = strstr(p, text)); p++) n++;
|
|
return n;
|
|
}
|
|
static void settings_logged(void) {
|
|
global.time = 16667, global.time_den = 1, global.sync_display = 1, global.reflex = 1, global.passive = 1;
|
|
app_set(0, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
CHECK(!count("settings for the game"), "not listed: nothing read");
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
poll();
|
|
poll();
|
|
CHECK(logged("frame rate: RivaTuner Statistics Server's settings for the game (Profiles\\ocarina.exe.cfg): limit "
|
|
"60/1, frame time limit 16667/1, scanline sync 0/0, display sync 1, Reflex sleep 1, passive wait 1\n"),
|
|
"the game's profile, with what it took from Global");
|
|
CHECK(count("settings for the game") == 1, "logged once while nothing changes (%d)", count("settings for the game"));
|
|
ask(144000);
|
|
poll();
|
|
poll();
|
|
CHECK(logged("(Profiles\\ocarina.exe.cfg): limit 144/1, frame time limit 16667/1"), "logged again on a change");
|
|
CHECK(count("settings for the game") == 2, "once per change (%d)", count("settings for the game"));
|
|
}
|
|
|
|
// The decisions as they stand, pinned against the real worker (rtss_limit_check.c pins the same in rtss_decide.h).
|
|
|
|
// Profiles under Program Files without administrator rights: the save does not stick, and RTSS is out for the run.
|
|
static void readonly_run(void) {
|
|
readonly = 1;
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
show("read-only profiles");
|
|
CHECK(rtss_limit_state() == 2 && !rtss_limit_active(), "the menu says RTSS needs administrator rights");
|
|
ask(144000);
|
|
poll();
|
|
poll();
|
|
CHECK(saves == 1, "no write after the failure (%ld saves)", saves);
|
|
CHECK(logged("RivaTuner Statistics Server's profile cannot be changed"), "logged");
|
|
}
|
|
|
|
// RTSS refuses a limit out of its range: the game keeps that one, the earlier limit of this run is cleared to none,
|
|
// and a limit in range goes to RTSS again at once.
|
|
static void refused_run(void) {
|
|
refuse_over = 200;
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
CHECK(own.limit == 60 && rtss_limit_active(), "60 taken");
|
|
ask(240000);
|
|
poll();
|
|
show("240 refused");
|
|
CHECK(own.exists && own.limit == 0, "the earlier limit of this run is cleared to none");
|
|
CHECK(!rtss_limit_active() && rtss_limit_state() == 0, "the game's limiter keeps 240");
|
|
long s0 = saves;
|
|
poll();
|
|
poll();
|
|
CHECK(saves == s0, "the refused limit is not written again");
|
|
ask(144000);
|
|
poll();
|
|
show("144 after the refusal");
|
|
CHECK(own.limit == 144 && rtss_limit_active(), "144 taken at once");
|
|
ask(240000);
|
|
poll();
|
|
CHECK(!rtss_limit_active(), "240 stays with the game");
|
|
}
|
|
|
|
// RTSS lists the game but lets it run well over the limit: after six polls in a row over 1.2 times the limit the
|
|
// profile is put back and the game limits for the run. 1.15 times the limit is not caught (the rule as it stands),
|
|
// and a period RTSS no longer moves still counts.
|
|
static void over_run(void) {
|
|
app_set(1, 0xA, 1000, 2000, 144);
|
|
ask(60000);
|
|
for (int i = 0; i < 5; i++) poll();
|
|
CHECK(rtss_limit_active() && own.exists, "five polls over: RTSS still limits");
|
|
poll();
|
|
show("six polls at 144 fps with the limit at 60");
|
|
CHECK(rtss_limit_state() == 3 && !rtss_limit_active(), "the menu says RTSS does not limit the game");
|
|
CHECK(!own.exists, "the profile is put back");
|
|
CHECK(logged("RivaTuner Statistics Server measures 144.0 fps with its limit at 60.000 fps"), "logged");
|
|
ask(30000);
|
|
poll();
|
|
CHECK(saves == 1 && rtss_limit_state() == 3, "out for the run");
|
|
}
|
|
static void over_slack_run(void) {
|
|
app_set(1, 0xA, 1000, 2000, 69);
|
|
ask(60000);
|
|
for (int i = 0; i < 20; i++) poll();
|
|
show("20 polls at 69 fps with the limit at 60");
|
|
CHECK(rtss_limit_active() && rtss_limit_state() == 1, "1.15 times the limit is not caught");
|
|
app_set(1, 0xA, 1000, 2000, 73);
|
|
for (int i = 0; i < 6; i++) poll();
|
|
CHECK(rtss_limit_state() == 3, "1.22 times the limit is caught after six polls");
|
|
}
|
|
static void over_unlimited_run(void) {
|
|
app_set(1, 0xA, 1000, 2000, 700);
|
|
ask(0);
|
|
for (int i = 0; i < 10; i++) poll();
|
|
show("unlimited at 700 fps");
|
|
CHECK(rtss_limit_active() && rtss_limit_state() == 0, "no limit, nothing to check");
|
|
}
|
|
|
|
// RTSS quits while it limits and comes back: the profile stays for its return, no write either way.
|
|
static void quit_run(void) {
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
running = 0;
|
|
poll();
|
|
show("RTSS quit");
|
|
CHECK(!rtss_limit_active() && own.exists && own.limit == 60, "the game limits; the profile stays");
|
|
running = 1;
|
|
poll();
|
|
show("RTSS back");
|
|
CHECK(rtss_limit_active() && saves == 1, "RTSS limits again with no new write");
|
|
}
|
|
|
|
// RTSS's hooks library does not load: the game limits for the run.
|
|
static void library_run(void) {
|
|
no_library = 1;
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
ask(144000);
|
|
poll();
|
|
show("no hooks library");
|
|
CHECK(loads == 1 && !rtss_limit_active() && !saves, "one try, then the game's limiter for the run");
|
|
CHECK(logged("RivaTuner Statistics Server's hooks library did not load"), "logged");
|
|
}
|
|
|
|
// Low latency switching on and off at every poll (the want flips between a limit and kept out): each switch writes or
|
|
// puts back the profile, as it stands, and the log numbers each creation and removal so a play-test can count them.
|
|
static void churn_run(void) {
|
|
app_set(1, 0xA, 1000, 2000, 60);
|
|
ask(60000);
|
|
poll();
|
|
for (int i = 0; i < 10; i++) {
|
|
ask(i & 1 ? 60000 : RTSS_OUT_LOWLAT);
|
|
poll();
|
|
}
|
|
show("ten polls with the want flipping");
|
|
CHECK(created == 6 && removed == 5, "%ld creations, %ld removals", created, removed);
|
|
CHECK(logged("created; it goes away when the game closes (creation 1 this run)\n") &&
|
|
logged("(creation 6 this run)\n") && !logged("(creation 7"),
|
|
"the created lines are numbered");
|
|
CHECK(logged("removed, as before the game started (removal 1 this run)\n") && logged("(removal 5 this run)\n") &&
|
|
!logged("(removal 6"),
|
|
"the removed lines are numbered");
|
|
CHECK(rtss_limit_active(), "RTSS limits after the last want of a limit");
|
|
}
|
|
|
|
// A movie at 60 under a limit of 144: the want follows the movie, and each start and end is a write.
|
|
static void movie_run(void) {
|
|
app_set(1, 0xA, 1000, 2000, 144);
|
|
ask(144000);
|
|
poll();
|
|
long s0 = saves;
|
|
ask(60000);
|
|
poll();
|
|
CHECK(own.limit == 60 && rtss_limit_active(), "RTSS holds the movie's 60");
|
|
ask(144000);
|
|
poll();
|
|
show("after one movie");
|
|
CHECK(own.limit == 144 && saves - s0 == 2, "two writes for one movie");
|
|
}
|
|
|
|
static const struct { const char *name; void (*run)(void); } scenarios[] = {
|
|
{"restore_race", restore_race},
|
|
{"restore_player", restore_player},
|
|
{"restore_inflight", restore_inflight},
|
|
{"restore_first", restore_first},
|
|
{"restore_kept_out", restore_kept_out},
|
|
{"kept_two", kept_two},
|
|
{"kept_lowlat_then_limit", kept_lowlat_then_limit},
|
|
{"kept_framegen", kept_framegen},
|
|
{"active_race", active_race},
|
|
{"round_logged", round_logged},
|
|
{"round_logged_whole", round_logged_whole},
|
|
{"start_off_present", start_off_present},
|
|
{"not_installed", not_installed},
|
|
{"settings_logged", settings_logged},
|
|
{"readonly_run", readonly_run},
|
|
{"refused_run", refused_run},
|
|
{"over_run", over_run},
|
|
{"over_slack_run", over_slack_run},
|
|
{"over_unlimited_run", over_unlimited_run},
|
|
{"quit_run", quit_run},
|
|
{"library_run", library_run},
|
|
{"churn_run", churn_run},
|
|
{"movie_run", movie_run},
|
|
};
|
|
|
|
int main(int argc, char **argv) {
|
|
setvbuf(stdout, NULL, _IONBF, 0);
|
|
tick = CreateEventA(NULL, FALSE, FALSE, NULL), done = CreateEventA(NULL, FALSE, FALSE, NULL);
|
|
at_lock = CreateEventA(NULL, FALSE, FALSE, NULL), go = CreateEventA(NULL, FALSE, FALSE, NULL);
|
|
if (argc == 2 && !strcmp(argv[1], "--list")) {
|
|
for (size_t i = 0; i < sizeof scenarios / sizeof *scenarios; i++) printf("%s\n", scenarios[i].name);
|
|
return 0;
|
|
}
|
|
for (size_t i = 0; argc == 2 && i < sizeof scenarios / sizeof *scenarios; i++) {
|
|
if (strcmp(argv[1], scenarios[i].name)) continue;
|
|
printf("scenario %s\n", argv[1]);
|
|
scenarios[i].run();
|
|
return fails != 0;
|
|
}
|
|
fprintf(stderr, "usage: rtss_worker_check --list | <scenario>\n");
|
|
return 2;
|
|
}
|