Merge branch 'claude/pr-intake-6-43af31' into release-0.9.2

This commit is contained in:
chrg6
2026-11-12 12:10:44 -05:00
8 changed files with 174 additions and 4 deletions

View File

@@ -473,6 +473,11 @@ builds the header alone and replays an area change after a loading screen from a
half-resolution passes are per-frame again at once, a lookup table, a volume's slices and an icon capture still wait, half-resolution passes are per-frame again at once, a lookup table, a volume's slices and an icon capture still wait,
and an image taken over by another texture starts without the history of the one before. No GPU, no game files. and an image taken over by another texture starts without the history of the one before. No GPU, no game files.
A change to which frames FSR 3.1 frame generation is told are camera cuts (`runtime/vk_fg_reset.h`, `runtime/vk_fg.cpp`
`generate` and `vk_fg_frame`) passes `python tests\fg_reset_check.py`, which builds the header alone and checks that each
frame id gets its own frame's cut, that an id never noted or no longer held counts as a cut, and that a slot rewritten
on another thread never answers an old id with a newer frame's value. No GPU, no game files.
The lifter (`recomp/`) and the CPU headers (`runtime/cpu.h`, `runtime/simd.h`) are checked against Unicorn. Every lifter The lifter (`recomp/`) and the CPU headers (`runtime/cpu.h`, `runtime/simd.h`) are checked against Unicorn. Every lifter
change passes these, all run with `.venv`: change passes these, all run with `.venv`:

View File

@@ -89,6 +89,10 @@
# recorder_core = 0 # recorder_core = 0
# Submissions handed to the GPU queue together in one call, 1 to 16 (1 = each one at once). # Submissions handed to the GPU queue together in one call, 1 to 16 (1 = each one at once).
# submit_batch = 4 # submit_batch = 4
# Mesa's Vulkan drivers (RADV, ANV, NVK): every submission to the GPU queue goes to a thread of the queue's own, so its
# kernel call leaves the thread that prepares the frames, 0 or 1. Default: on (Linux), off (Windows). 0 leaves the
# driver's own choice. Unused when MESA_VK_ENABLE_SUBMIT_THREAD is set.
# submit_thread = 1
# Occlusion query results are read back from the video card in batches, 0 or 1. Default: on. 0 reads each query with a # Occlusion query results are read back from the video card in batches, 0 or 1. Default: on. 0 reads each query with a
# call of its own, as before, which on AMD's Windows driver held every frame's "GPU done" back by about 4 ms. # call of its own, as before, which on AMD's Windows driver held every frame's "GPU done" back by about 4 ms.
# oq_batch = 1 # oq_batch = 1

View File

@@ -75,7 +75,7 @@ static const char *const known[] = {
"VK_PRESENT", "VK_RECONVERGE", "VK_NAN_BITS", "VK_RECORDER", "VK_SSBO_ALIGN", "VK_SUBGROUP", "VK_SUBGROUP_PIN", "VK_VALIDATION", "VOLUME", "VRAM_HEADROOM", "VS_OUTS", "WATER_PROJECTIVE", "VK_PRESENT", "VK_RECONVERGE", "VK_NAN_BITS", "VK_RECORDER", "VK_SSBO_ALIGN", "VK_SUBGROUP", "VK_SUBGROUP_PIN", "VK_VALIDATION", "VOLUME", "VRAM_HEADROOM", "VS_OUTS", "WATER_PROJECTIVE",
"WAIT_WATCH_S", "WALK_KEY", "WALK_SCALE", "WB_EXACT", "WB_FENCE_LIMIT", "WB_MERGE", "WB_NO_REUP", "WB_MERGE_MAX", "WB_PROBE", "WB_SPLIT", "WB_LAZY", "WB_LAZY_CHUNK", "WB_LAZY_TOUCH", "WINDOW_SIZE", "XLATE", "XLATE_ID", "XLATE_KEEP", "XLATE_PROCS", "WAIT_WATCH_S", "WALK_KEY", "WALK_SCALE", "WB_EXACT", "WB_FENCE_LIMIT", "WB_MERGE", "WB_NO_REUP", "WB_MERGE_MAX", "WB_PROBE", "WB_SPLIT", "WB_LAZY", "WB_LAZY_CHUNK", "WB_LAZY_TOUCH", "WINDOW_SIZE", "XLATE", "XLATE_ID", "XLATE_KEEP", "XLATE_PROCS",
"ZSTD_CHECK", "ZSTD_NATIVE", "ZSTD_CHECK", "ZSTD_NATIVE",
"BIND_REUSE", "DYN_DELTA", "STG_ARENA", "SUBMIT_BATCH", "ASTC_GPU_DESWIZZLE", "ASTC_SCRATCH_KEEP", "ASTC_ARENA", "ASTC_BC1", "BIND_REUSE", "DYN_DELTA", "STG_ARENA", "SUBMIT_BATCH", "SUBMIT_THREAD", "ASTC_GPU_DESWIZZLE", "ASTC_SCRATCH_KEEP", "ASTC_ARENA", "ASTC_BC1",
"TEXUP_LOG_MS", "DYN_RES", "DYN_RES_TARGET", "DYN_RES_STEP", "TEXTURE_DETAIL", "TEXUP_LOG_MS", "DYN_RES", "DYN_RES_TARGET", "DYN_RES_STEP", "TEXTURE_DETAIL",
"RECORDER_CORE", "RECORDER_PRIO", "REPLAY_TIME", "LOCK_TIME", "POOL_CREATE_BUDGET", "POOL_CREATE_MS", "POOL_FINI_IDLE", "POOL_LOAD_BACKLOG", "POOL_LOAD_MS", "RECORDER_CORE", "RECORDER_PRIO", "REPLAY_TIME", "LOCK_TIME", "POOL_CREATE_BUDGET", "POOL_CREATE_MS", "POOL_FINI_IDLE", "POOL_LOAD_BACKLOG", "POOL_LOAD_MS",
"VMA_BLOCK_MB", "SYNC_WAKE_ALL", "LOG_ASYNC", "DEVICE_LOST_AT", "STAGING_FAIL_AT", "VRAM_BALLAST_MB", "VMA_BLOCK_MB", "SYNC_WAKE_ALL", "LOG_ASYNC", "DEVICE_LOST_AT", "STAGING_FAIL_AT", "VRAM_BALLAST_MB",
@@ -126,7 +126,7 @@ static const struct { const char *key, *section; } sections[] = {
{"FREE_CORES", "performance"}, {"FREE_CORES", "performance"},
{"DYN_RES", "performance"}, {"DYN_RES_TARGET", "performance"}, {"DYN_RES_STEP", "performance"}, {"DYN_RES", "performance"}, {"DYN_RES_TARGET", "performance"}, {"DYN_RES_STEP", "performance"},
{"RECORDER_CORE", "performance"}, {"RECORDER_PRIO", "performance"}, {"BIND_REUSE", "performance"}, {"RECORDER_CORE", "performance"}, {"RECORDER_PRIO", "performance"}, {"BIND_REUSE", "performance"},
{"DYN_DELTA", "performance"}, {"STG_ARENA", "performance"}, {"SUBMIT_BATCH", "performance"}, {"DYN_DELTA", "performance"}, {"STG_ARENA", "performance"}, {"SUBMIT_BATCH", "performance"}, {"SUBMIT_THREAD", "performance"},
{"BUILD_FREE_MB", "performance"}, {"BUILD_RESERVE_MB", "performance"}, {"MEM_NEED_MB", "diagnostics"}, {"BUILD_FREE_MB", "performance"}, {"BUILD_RESERVE_MB", "performance"}, {"MEM_NEED_MB", "diagnostics"},
{"ASTC_GPU_DESWIZZLE", "performance"}, {"ASTC_SCRATCH_KEEP", "performance"}, {"ASTC_ARENA", "performance"}, {"ASTC_BC1", "performance"}, {"POOL_CREATE_BUDGET", "performance"}, {"ASTC_GPU_DESWIZZLE", "performance"}, {"ASTC_SCRATCH_KEEP", "performance"}, {"ASTC_ARENA", "performance"}, {"ASTC_BC1", "performance"}, {"POOL_CREATE_BUDGET", "performance"},
{"POOL_CREATE_MS", "performance"}, {"POOL_FINI_IDLE", "performance"}, {"FREEZE_BUDGET_US", "performance"}, {"POOL_LOAD_BACKLOG", "performance"}, {"POOL_LOAD_MS", "performance"}, {"POOL_CREATE_MS", "performance"}, {"POOL_FINI_IDLE", "performance"}, {"FREEZE_BUDGET_US", "performance"}, {"POOL_LOAD_BACKLOG", "performance"}, {"POOL_LOAD_MS", "performance"},
@@ -259,6 +259,11 @@ static const CfgMeta metas[] = {
{"RECORDER_CORE", "0", "auto|0|1", RESTART}, {"RECORDER_PRIO", "1", "0|1", RESTART}, {"REPLAY_TIME", "0", "0|1", RESTART}, {"LOCK_TIME", "0", "0|1", RESTART}, {"POOL_CREATE_BUDGET", "16", "1..4096", RESTART}, {"POOL_CREATE_MS", "6", "0..100", RESTART}, {"POOL_FINI_IDLE", "0", "0|1", RESTART}, {"FREEZE_BUDGET_US", "1000", "0..100000", RESTART}, {"POOL_LOAD_BACKLOG", "512", "0..65536", RESTART}, {"POOL_LOAD_MS", "50", "1..1000", RESTART}, {"RECORDER_CORE", "0", "auto|0|1", RESTART}, {"RECORDER_PRIO", "1", "0|1", RESTART}, {"REPLAY_TIME", "0", "0|1", RESTART}, {"LOCK_TIME", "0", "0|1", RESTART}, {"POOL_CREATE_BUDGET", "16", "1..4096", RESTART}, {"POOL_CREATE_MS", "6", "0..100", RESTART}, {"POOL_FINI_IDLE", "0", "0|1", RESTART}, {"FREEZE_BUDGET_US", "1000", "0..100000", RESTART}, {"POOL_LOAD_BACKLOG", "512", "0..65536", RESTART}, {"POOL_LOAD_MS", "50", "1..1000", RESTART},
// held submissions handed to the queue together (vk_sync.c, submit batching) // held submissions handed to the queue together (vk_sync.c, submit batching)
{"SUBMIT_BATCH", "4", "1..16", RESTART}, {"SUBMIT_BATCH", "4", "1..16", RESTART},
#ifdef _WIN32
{"SUBMIT_THREAD", "0", "0|1", RESTART}, // vk_device.c mesa_submit_thread: Mesa's submit thread (RADV)
#else
{"SUBMIT_THREAD", "1", "0|1", RESTART}, // vk_device.c mesa_submit_thread: Mesa's submit thread (RADV)
#endif
{"CACHE_DIE", "1", "0|1|ab", RESTART}, {"ONE_PER_CORE", "0", "0|1|ab", RESTART}, // perf.c cpu_placement {"CACHE_DIE", "1", "0|1|ab", RESTART}, {"ONE_PER_CORE", "0", "0|1|ab", RESTART}, // perf.c cpu_placement
// shaders and pipelines // shaders and pipelines
{"PIPE_WAIT", "default", "default|draw", RESTART}, {"PIPE_SKIP", "any", "strict|any|fullscreen", RESTART}, {"PIPE_WAIT", "default", "default|draw", RESTART}, {"PIPE_SKIP", "any", "strict|any|fullscreen", RESTART},

View File

@@ -123,6 +123,30 @@ static void nvidia_cache_beside_exe(void) {
} }
#endif #endif
// Mesa's Vulkan drivers on Linux (RADV, ANV, NVK) keep timeline semaphores as kernel sync objects, which cannot wait
// for a value not submitted yet. Their queues therefore submit on the calling thread and use a thread of the queue's
// own only for a submission that waits on such a value. Every other vkQueueSubmit2, the command stream's checks and
// the kernel's ioctl, runs on the replaying thread, once for every part the replay hands to the queue early (vk_exec.c
// maybe_split). MESA_VK_ENABLE_SUBMIT_THREAD=1 sends every submission to the queue's thread: in Kokiri Forest on an
// RX 6800 XT (Mesa 26.2) the replay took 13.9 ms a frame with it and 15.0 ms without. NX2NAVI_SUBMIT_THREAD (default
// 1 on Linux, 0 on Windows) sets it unless the environment already sets it; 0 leaves the driver's own choice. Drivers
// that do not read the variable ignore it. vk_driver_cache_env calls this before any thread can load the driver.
static const char *submit_thread_why; // create_device logs it on a Mesa driver
static void mesa_submit_thread(void) {
char cur[16];
if (plat_getenv("MESA_VK_ENABLE_SUBMIT_THREAD", cur, sizeof cur)) {
submit_thread_why = "MESA_VK_ENABLE_SUBMIT_THREAD is set in the environment";
return;
}
if (!cfg_bool("NX2NAVI_SUBMIT_THREAD")) {
submit_thread_why = "NX2NAVI_SUBMIT_THREAD=0: the driver's own choice";
return;
}
plat_setenv("MESA_VK_ENABLE_SUBMIT_THREAD", "1");
submit_thread_why = "every one on the queue's own thread (NX2NAVI_SUBMIT_THREAD=0 leaves the driver's own choice)";
}
// A driver may read these variables when it loads, and a thread can load the Vulkan driver before create_instance: // A driver may read these variables when it loads, and a thread can load the Vulkan driver before create_instance:
// widescreen.c's wide_init asks for the monitor's size (fullscreen with a monitor chosen and the picture at the // widescreen.c's wide_init asks for the monitor's size (fullscreen with a monitor chosen and the picture at the
// window's size), and SDL's load of the Vulkan library there lists the instance extensions, which loads the drivers, // window's size), and SDL's load of the Vulkan library there lists the instance extensions, which loads the drivers,
@@ -134,6 +158,7 @@ void vk_driver_cache_env(void) {
if (done) return; if (done) return;
done = 1; done = 1;
mesa_cache_beside_exe(); mesa_cache_beside_exe();
mesa_submit_thread();
#ifdef __linux__ #ifdef __linux__
nvidia_cache_beside_exe(); nvidia_cache_beside_exe();
#endif #endif
@@ -507,6 +532,7 @@ static int create_device(void) {
VkResult r = vk_dlssg_create_device(g_vk.instance, g_vk.phys, &di, &g_vk.device); VkResult r = vk_dlssg_create_device(g_vk.instance, g_vk.phys, &di, &g_vk.device);
free(c); free(c);
if (r != VK_SUCCESS) { rt_log("vk: vkCreateDevice failed (%d)", (int)r); return 0; } if (r != VK_SUCCESS) { rt_log("vk: vkCreateDevice failed (%d)", (int)r); return 0; }
if (submit_thread_why && vk_caps.mesa) rt_log("vk: queue submissions: %s", submit_thread_why);
vk_dlssg_device_ready(g_vk.phys, g_vk.device); vk_dlssg_device_ready(g_vk.phys, g_vk.device);
if (vk_dlssg_dpa()) { // Streamline's, so its plugins hook every entry point the replay fetches if (vk_dlssg_dpa()) { // Streamline's, so its plugins hook every entry point the replay fetches
vk_dpa = vk_dlssg_dpa(); vk_dpa = vk_dlssg_dpa();

View File

@@ -28,6 +28,7 @@ extern "C" {
#include "vk_dlssg.h" #include "vk_dlssg.h"
#include "vk_ffx.h" #include "vk_ffx.h"
#include "vk_fg.h" #include "vk_fg.h"
#include "vk_fg_reset.h"
#include "ui/menu.h" #include "ui/menu.h"
} }
@@ -45,6 +46,9 @@ struct {
int failed = 0; int failed = 0;
uint64_t generated = 0, paused = 0, no_inputs = 0, hudless = 0, no_hudless = 0; uint64_t generated = 0, paused = 0, no_inputs = 0, hudless = 0, no_hudless = 0;
int on = 0; // the last configured frame had generation on (vk_fg_generating) int on = 0; // the last configured frame had generation on (vk_fg_generating)
FgrRing cuts; // each frame id's camera cut, for the generation callback (vk_fg_reset.h)
uint64_t cut_frames = 0; // frames handed to the callback as cuts
int prepared = 0; // the last frame was prepared (generation on with its inputs)
} F; } F;
VkResult submit_game(uint32_t n, const VkSubmitInfo *si, VkFence fence) { VkResult submit_game(uint32_t n, const VkSubmitInfo *si, VkFence fence) {
@@ -56,6 +60,8 @@ VkResult submit_game(uint32_t n, const VkSubmitInfo *si, VkFence fence) {
ffxReturnCode_t generate(ffxDispatchDescFrameGeneration *d, void *user) { ffxReturnCode_t generate(ffxDispatchDescFrameGeneration *d, void *user) {
F.generated++; F.generated++;
// the swapchain's own reset (a frame id that did not follow the last) stays; a cut vk_fg_frame noted is added
if (fgr_cut(&F.cuts, d->frameID)) d->reset = true;
return vk_ffx_dispatch((ffxContext *)user, &d->header); return vk_ffx_dispatch((ffxContext *)user, &d->header);
} }
@@ -267,6 +273,11 @@ extern "C" void vk_fg_frame(VkCommandBuffer cb, VkSwapchainKHR sc, VkFormat fmt,
else if (!hudless) F.no_hudless++; else if (!hudless) F.no_hudless++;
else if (!on) F.paused++; else if (!on) F.paused++;
F.frame++; F.frame++;
// A cut: DLSS started a new history (vk_dlaa_fg_inputs), or the frame before was not prepared (generation off for
// the menu, no inputs), so the frame between the two would be made from a stale depth and motion
fgr_note(&F.cuts, F.frame, reset || !F.prepared);
if ((reset || !F.prepared) && on) F.cut_frames++;
F.prepared = on;
ffxConfigureDescFrameGeneration cfg = {}; ffxConfigureDescFrameGeneration cfg = {};
cfg.header.type = FFX_API_CONFIGURE_DESC_TYPE_FRAMEGENERATION; cfg.header.type = FFX_API_CONFIGURE_DESC_TYPE_FRAMEGENERATION;
cfg.swapChain = (void *)sc; cfg.swapChain = (void *)sc;
@@ -312,9 +323,9 @@ extern "C" void vk_fg_frame(VkCommandBuffer cb, VkSwapchainKHR sc, VkFormat fmt,
if (r != FFX_API_RETURN_OK) return fail("frame generation preparation", r); if (r != FFX_API_RETURN_OK) return fail("frame generation preparation", r);
if (F.frame == 2 || F.frame % 3600 == 0) if (F.frame == 2 || F.frame % 3600 == 0)
rt_log("fg: %llu frames presented, %llu generated (%llu with the HUD kept out); paused %llu (menu), %llu without depth " rt_log("fg: %llu frames presented, %llu generated (%llu with the HUD kept out); paused %llu (menu), %llu without depth "
"and motion, %llu without the HUD-less picture", (unsigned long long)F.frame, (unsigned long long)F.generated, "and motion, %llu without the HUD-less picture; %llu after a camera cut", (unsigned long long)F.frame, (unsigned long long)F.generated,
(unsigned long long)F.hudless, (unsigned long long)F.paused, (unsigned long long)F.no_inputs, (unsigned long long)F.hudless, (unsigned long long)F.paused, (unsigned long long)F.no_inputs,
(unsigned long long)F.no_hudless); (unsigned long long)F.no_hudless, (unsigned long long)F.cut_frames);
} }
extern "C" void vk_fg_release(void) { extern "C" void vk_fg_release(void) {
@@ -322,4 +333,5 @@ extern "C" void vk_fg_release(void) {
if (F.fg) vk_ffx_destroy(&F.fg), F.fg = nullptr; if (F.fg) vk_ffx_destroy(&F.fg), F.fg = nullptr;
if (F.sc) vk_ffx_destroy(&F.sc), F.sc = nullptr; if (F.sc) vk_ffx_destroy(&F.sc), F.sc = nullptr;
__atomic_store_n(&F.on, 0, __ATOMIC_RELAXED); __atomic_store_n(&F.on, 0, __ATOMIC_RELAXED);
F.prepared = 0;
} }

32
runtime/vk_fg_reset.h Normal file
View File

@@ -0,0 +1,32 @@
// Camera cuts for FSR 3.1 frame generation (vk_fg.cpp). DLSS starts a new history on a cut, another scene size or
// another target, and vk_dlaa.c vk_dlaa_fg_inputs hands that out with the frame's depth and motion vectors. FSR 3.1
// takes it only in the generation callback (ffxDispatchDescFrameGeneration.reset), which its swapchain calls later,
// on its own present thread, for the frame id the configuration gave. So vk_fg_frame notes each frame's cut here
// under its id, and the callback looks it up. Without it every generated frame of a cut was blended from two unrelated
// pictures: an area load or a cutscene's cut flashed a frame of both.
//
// A ring of FGR_SLOTS frames; each slot holds the frame id and its cut as one atomic word, so a slot being rewritten
// never pairs an old id with a new frame's answer. An id the ring no longer holds (the callback fell that far behind,
// or the slot was never written) counts as a cut: a lost history costs one plain frame, a wrong one blends two.
// Own header so tests/fg_reset_check.c checks it without a GPU.
#pragma once
#include <stdint.h>
#define FGR_SLOTS 32
typedef struct {
uint64_t slot[FGR_SLOTS]; // (frame id << 1) | cut, written by vk_fg_frame; 0 never matches (ids start at 1)
} FgrRing;
// Frame ids above this do not fit beside the cut bit; they always count as a cut.
#define FGR_MAX_ID (UINT64_MAX >> 1)
static inline void fgr_note(FgrRing *r, uint64_t id, int cut) {
if (id && id <= FGR_MAX_ID) __atomic_store_n(&r->slot[id % FGR_SLOTS], id << 1 | (cut != 0), __ATOMIC_RELEASE);
}
static inline int fgr_cut(const FgrRing *r, uint64_t id) {
if (!id || id > FGR_MAX_ID) return 1;
uint64_t v = __atomic_load_n(&r->slot[id % FGR_SLOTS], __ATOMIC_ACQUIRE);
return v >> 1 != id || (v & 1);
}

46
tests/fg_reset_check.c Normal file
View File

@@ -0,0 +1,46 @@
// runtime/vk_fg_reset.h: the camera cut FSR 3.1 frame generation's callback is told of for a frame id. Built and run
// by tests/fg_reset_check.py; prints each failed check and exits 1 on any.
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include "vk_fg_reset.h"
static int fails;
#define CHECK(c, ...) do { if (!(c)) { fails++; printf("FAIL line %d: ", __LINE__); printf(__VA_ARGS__); printf("\n"); } } while (0)
static FgrRing ring;
static volatile int stop;
// Rewrites one slot over and over: frame 3, a cut, and frame 3 + FGR_SLOTS, none.
static void *writer(void *arg) {
(void)arg;
while (!stop) fgr_note(&ring, 3, 1), fgr_note(&ring, 3 + FGR_SLOTS, 0);
return NULL;
}
int main(void) {
// nothing noted: every id is a cut, id 0 and ids past the range too
CHECK(fgr_cut(&ring, 0) && fgr_cut(&ring, 1) && fgr_cut(&ring, 77), "an id never noted is a cut");
CHECK(fgr_cut(&ring, FGR_MAX_ID + 1) && fgr_cut(&ring, UINT64_MAX), "an id past the range is a cut");
// a run of frames, a cut at 40: the callback for each id gets that frame's answer
for (uint64_t f = 1; f <= 60; f++) fgr_note(&ring, f, f == 40);
int wrong = 0;
for (uint64_t f = 60 - FGR_SLOTS + 1; f <= 60; f++) wrong += fgr_cut(&ring, f) != (f == 40);
CHECK(!wrong, "%d of the last %d frames answered wrong", wrong, FGR_SLOTS);
// the callback fell behind by more than the ring: its frame's slot holds a later one, so it is a cut
CHECK(fgr_cut(&ring, 60 - FGR_SLOTS), "a frame the ring no longer holds is a cut");
CHECK(fgr_cut(&ring, 61), "a frame not noted yet is a cut");
// the id and its cut are one word: a slot rewritten on another thread never answers frame 3 with the next one's
// "no cut"
memset(&ring, 0, sizeof ring);
pthread_t t;
pthread_create(&t, NULL, writer, NULL);
int paired = 0;
for (int i = 0; i < 2000000; i++) paired += !fgr_cut(&ring, 3);
stop = 1;
pthread_join(t, NULL);
CHECK(!paired, "frame 3 was answered with the other frame's value %d times", paired);
printf(fails ? "fg_reset_check: %d failed\n" : "fg_reset_check: ok\n", fails);
return fails != 0;
}

40
tests/fg_reset_check.py Normal file
View File

@@ -0,0 +1,40 @@
"""Build and run tests/fg_reset_check.c: runtime/vk_fg_reset.h, which frames FSR 3.1 frame generation's callback is
told are camera cuts.
No GPU, no game files, any Python.
Usage: fg_reset_check.py
"""
import os
import shutil
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
MSYS_BIN = Path(r'C:\msys64\ucrt64\bin')
def compiler():
"""$CC, else MSYS2 UCRT64's clang, else clang on PATH (as tests/diff/common.py picks it, without its Unicorn)."""
if os.environ.get('CC'):
return os.environ['CC']
if os.name == 'nt' and (MSYS_BIN / 'clang.exe').exists():
return str(MSYS_BIN / 'clang.exe')
return shutil.which('clang') or 'clang'
def main():
work = ROOT / 'build' / 'test' / 'fg_reset'
work.mkdir(parents=True, exist_ok=True)
exe = work / ('fg_reset_check.exe' if os.name == 'nt' else 'fg_reset_check')
env = dict(os.environ)
if os.name == 'nt' and MSYS_BIN.exists():
env['PATH'] = str(MSYS_BIN) + os.pathsep + env.get('PATH', '')
subprocess.check_call([compiler(), '-std=gnu11', '-O1', '-Wall', '-Werror', '-pthread', '-I', str(ROOT / 'runtime'),
str(ROOT / 'tests' / 'fg_reset_check.c'), '-o', str(exe)], env=env)
return subprocess.run([str(exe)], env=env).returncode
if __name__ == '__main__':
sys.exit(main())