perf(vk): AMD FSR 4's unrolled layers in a pipeline cache of their own, kept across updates, and taken from it with no memory asked #1752

Merged
HumanBean merged 2 commits from madebyjordan/Longshot:perf/fsr4-own-cache into main 2026-11-19 16:27:09 +00:00
Member

Type: perf · Risk: low · Tested on: Windows 11, RX 6700 XT (Adrenalin 26.10.1) · Needs: Linux, AMD (RADV); another AMD card on Windows

TL;DR

AMD FSR 4's three fastest layers (#2798's unrolled ones) take about 50 s and 3 GB of memory each to build the first time, and most updates threw them away, so after each update FSR 4 ran slower for its first minutes while they were built again. They are kept in a file of their own now, which updates keep, and loaded from it in a fraction of a second. A PC with less than 8 GB of memory to spare also gets them now when they are already built, instead of running without them. Checked in game from a new folder (what an update is): 0.1-0.5 s from the file, a cold build without it.

Breakdown

  • Who it helps: AMD FSR 4 players after every update that changes the shader translator (most of them), and 16 GB PCs with little memory to spare.
  • What was wrong: the layers were kept in the translator's pipeline cache, whose files a new translator deletes; and the 8 GB memory check came before the cache was even asked.
  • What changes: the layers are built and kept in cache/longshot_fsr4_pipelines.bin, and a layer already built is taken from the caches before the memory check.
  • What does not change: AMD's FSR 4 output, the layers' code, the translator's pipeline cache, other GPUs (the tune is AMD-only), the cold build's memory rules.
  • How it was checked: a new game-free test fails on main and passes here; in game, from a game folder at a new path, the layers come from the file (0.1-0.5 s) and fail the cache ask without it; the renderer builds whole.
  • What is still open: Linux (RADV) and other AMD cards; a real update (a player's next one).
  • Risk: low: if the file can't be read the layers are built as before; it is about 60 KB here.

Why

Since #2798 (Hookshot's https://github.com/NotRexed/Hookshot/pull/2798) AMD FSR 4's passes 1, 2 and 12 run as unrolled pipelines, built in the background at the first FSR 4 frames: about 50 s and 3 GB of memory each when the driver compiles them, which is why at most one builds at a time and only with 8 GB of memory to spare (kBuildHeadroom). They were kept in the translator's pipeline cache, and pcache_drop_stale drops that cache's files whenever the translator changes, which is most updates. On this PC the first start of v3.0.0 built them cold again (48.9 s, 48.7 s, 50.7 s to build in its log), though nightly-486 had built them the day before. And the memory check came first: a run with less than 8 GB to spare (not unrolled now: 7103 MB of memory to spare, 8192 wanted, seen here) ran without them even when they were in the caches, at about 4.5 ms for FSR 4's passes instead of 4.0 on an RX 6700 XT.

What changed

The unrolled layers get a pipeline cache of their own, outside the translator's files, and are asked of the caches before the memory a compile needs is asked for.

  • vk: build_unrolled and own_cache in gpu/vk/vk_fsr4.cpp: the layer is first created with VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT through its own cache; only when that needs a compile does build_headroom decide, as before. The cache is read at the first build and written after a layer's build whenever its data grew since it was read or last written: the driver may hand a layer over at once from its own disk cache (kept per game folder path), so a quick build is no sign that the file holds it. RX_VK_PCACHE_LOAD=0 (or its rule) leaves the file unread and unsaved, as the pipeline cache's file.
  • vk: own_pipeline_cache, own_pipeline_cache_save and own_cache_compute_pipeline in gpu/vk/vk_draw.cpp, beside shared_compute_pipeline: the file read through pcache_file_read (another driver's or GPU's file is not given to the driver), written through play_file_write (a .tmp moved over it, under the fetch lock) when its size changed, and the build with the same compile turn and gates as shared_compute_pipeline. pipeline_cache_file.h's sweep of cut-short saves knows the file's .tmp names too.
  • tests: tests/test_fsr4_own_cache.py runs pcache_stamp.h's drop against a folder with the translator's files and FSR 4's: a new translator drops its own files and keeps FSR 4's; it also checks that build_unrolled builds and saves through the file and asks the caches before the memory, and runs the sweep on a leftover .tmp of the file. docs/development.md: RX_VK_PCACHE_LOAD=0 names the file. tests/test_compute_gate.py knows the third gated caller of guarded_compute_held, with the same checks as cached_compute's.

Measurements

Verdict: after an update the layers load from their file in 0.1-0.5 s instead of building cold, and a cached layer no longer needs 8 GB to spare. The game-free test fails on main and passes here.

Hardware: Windows 11, RX 6700 XT 12 GB, Adrenalin 26.10.1, Ryzen 5 5600, 16 GB (RAM at JEDEC speed)
Scene: Hyrule Field by day, standing; 2560x1440, AMD FSR 4 Performance, uncapped
Method: the change applied to the v3.0.0 renderer (its vk_fsr4.cpp is main's; renderer built alone) in a copy of a v3.0.0 game folder, headless through the control bridge. An update is a game folder at a new path, so it was run through a directory junction to the same folder (a new path, the same files): AMD's own shader cache is kept per path. The control: a second new path with the file moved away. Log lines below.
How to reproduce: python -I -B tests/test_fsr4_own_cache.py --cxx clang++; in game, FSR 4 on an AMD card, play until the log has bound in its place from now for passes 1, 2 and 12 (the file appears in cache/), then start the same build from another path (mklink /J <new> <game folder> and run <new>\bin\longshot.exe), expecting the unrolled layers' pipeline cache: read and from the caches

Before: main @ 8b0ea786 After: this PR @ feb6b43e
test_fsr4_own_cache FAIL (the layers are built into the translator's cache) PASS
After a translator change (the update case) built cold: 48.9 / 48.7 / 50.7 s (v3.0.0's first start on this PC, see Why) kept: the file is not one the drop touches (the test)
A new folder path, the file there (no such file) 0.2 / 0.5 / 0.1 s, "from the caches"
A new folder path, the file moved away (control) not in the caches: a cold build needed (not unrolled now with 5.8 GB to spare)
Less than 8 GB to spare, the layers cached not unrolled now ... 8192 wanted taken from the caches
new path, with the file:
vk: AMD FSR 4: the unrolled layers' pipeline cache: read
vk: AMD FSR 4: tuned fsr4_model_v07_fp8_no_scale_pass1: its loops unrolled (12275 -> 106544 words), bound in its place from now (0.2 s from the caches)
vk: AMD FSR 4: tuned fsr4_model_v07_fp8_no_scale_pass12: its loops unrolled (12273 -> 106732 words), bound in its place from now (0.5 s from the caches)
vk: AMD FSR 4: tuned fsr4_model_v07_fp8_no_scale_pass2: its loops unrolled (12261 -> 106720 words), bound in its place from now (0.1 s from the caches)
new path, the file moved away:
vk: AMD FSR 4: the unrolled layers' pipeline cache: starts empty
vk: AMD FSR 4: fsr4_model_v07_fp8_no_scale_pass1: not unrolled now: 5814 MB of memory to spare, 8192 wanted (the next start tries again)

No fps comparison: the change moves when the layers become available, not their speed (4.04 ms against 4.48 ms without them, #2798's numbers), and another game run shared this GPU during these runs.

Flags and settings

None

Testing

Tested: in game as in Measurements (the first start writes the file, about 60 KB; the next reads it and leaves it as it was; a new path reads it; a new path without it does not find the layers). A cold review by a second agent: its points are in (the save rule by size, not by build time; the sweep of cut-short saves; RX_VK_PCACHE_LOAD=0; no log when the cache could not be made). The new test both ways, and against a broken fix (the memory asked before the cache: it fails). The renderer builds whole from this branch (Windows, llvm-mingw), with a local workaround for main's own Windows build break in descriptor_array_census.h (#1729; not in this PR). The tests that read vk_fsr4.cpp, vk_draw.cpp or pcache_stamp.h pass, except ones that fail the same way on main on this PC (test_upscaler_rows, test_pipeline_play_cache, test_prepare_cache_save, test_dev_packs, test_linux_pressure, test_linux_driver_fault_guard, test_pipeline_tour, test_tracy_funcs, test_recorder_sync, test_vk_occlusion_queries, test_draw_stream_visibility, test_fsr_uniform_ownership; each run on main's sources here).

Not testable by hand: a real update's first start: the new-path runs stand in for it.

Not tested: Linux (RADV, fsr4-vk), other AMD cards, a driver update (another driver's file is refused by pcache_file_read and the layers are built as before, then the file is written again).

Must be tested:

  • Linux, AMD with FSR 4 (fsr4-vk): play once with FSR 4 until the log has bound in its place from now for passes 1, 2 and 12, then start again, expecting the unrolled layers' pipeline cache: read and from the caches (Test Farm: @Beanstalk linux amd, FSR 4 on, two starts, check the log)
  • Windows, another AMD card that runs FSR 4: the same two starts, expecting the same lines (Test Farm: @Beanstalk windows amd, FSR 4 on, two starts)

Risks

What could break: the file can't be written (a read-only folder): the layers are built as before at each start that has 8 GB to spare, and the log says so. A damaged file: refused by the header check, or the driver ignores what it can't use.

Turning it off: RX_VK_FSR4_TUNE=0 turns the whole tune off, as before; otherwise revert the commit.

Compatibility: one new file in cache/ (~60 KB here). It is never pruned: a new AMD library or unroller adds its layers beside the old ones (another ~60 KB each time) rather than replacing them. The translator's pipeline cache is unchanged; the layers' pipelines left in old play files go when those files next go.

Issues

See #744 (FSR 4 performance reports)

Checklist

Everyone

  • One topic.
  • The title is a Conventional Commit (type(scope): description) of the status line's type.
  • Why gives the reason plainly and links the issues that fit (the tracker searched).
  • Tested on my own PC where it runs (in the game, for a change the game runs), as Testing's Tested says; what
    can't be run by hand is in Testing's Not testable by hand, with why.
  • Measurements has a verdict, or one line saying why there is nothing to measure.
  • Nothing gets worse that I know of: any cost (speed, latency, memory, a setup that worked before) is measured and
    in Risks.
  • Testing names what was tested, what wasn't, and what must still be tested, where and how.
  • Rebased on current main.
  • python -I -B tests/run_all.py passes (any failure that also fails on main is named).
  • No game files, dumps, build output or generated files.
  • third_party/ untouched (a new folder with a PROVENANCE.md instead).
  • The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled.

When it applies

  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.
  • A game-free test added for the fix, failing on main and passing here.
  • A check under tests/ that reads changed source updated in this PR, not weakened.

🤖 Generated with Claude Code

**Type:** perf · **Risk:** low · **Tested on:** Windows 11, RX 6700 XT (Adrenalin 26.10.1) · **Needs:** Linux, AMD (RADV); another AMD card on Windows ## TL;DR AMD FSR 4's three fastest layers (#2798's unrolled ones) take about 50 s and 3 GB of memory each to build the first time, and most updates threw them away, so after each update FSR 4 ran slower for its first minutes while they were built again. They are kept in a file of their own now, which updates keep, and loaded from it in a fraction of a second. A PC with less than 8 GB of memory to spare also gets them now when they are already built, instead of running without them. Checked in game from a new folder (what an update is): 0.1-0.5 s from the file, a cold build without it. ## Breakdown - **Who it helps:** AMD FSR 4 players after every update that changes the shader translator (most of them), and 16 GB PCs with little memory to spare. - **What was wrong:** the layers were kept in the translator's pipeline cache, whose files a new translator deletes; and the 8 GB memory check came before the cache was even asked. - **What changes:** the layers are built and kept in `cache/longshot_fsr4_pipelines.bin`, and a layer already built is taken from the caches before the memory check. - **What does not change:** AMD's FSR 4 output, the layers' code, the translator's pipeline cache, other GPUs (the tune is AMD-only), the cold build's memory rules. - **How it was checked:** a new game-free test fails on main and passes here; in game, from a game folder at a new path, the layers come from the file (0.1-0.5 s) and fail the cache ask without it; the renderer builds whole. - **What is still open:** Linux (RADV) and other AMD cards; a real update (a player's next one). - **Risk:** low: if the file can't be read the layers are built as before; it is about 60 KB here. ## Why Since #2798 (Hookshot's https://github.com/NotRexed/Hookshot/pull/2798) AMD FSR 4's passes 1, 2 and 12 run as unrolled pipelines, built in the background at the first FSR 4 frames: about 50 s and 3 GB of memory each when the driver compiles them, which is why at most one builds at a time and only with 8 GB of memory to spare (`kBuildHeadroom`). They were kept in the translator's pipeline cache, and `pcache_drop_stale` drops that cache's files whenever the translator changes, which is most updates. On this PC the first start of v3.0.0 built them cold again (`48.9 s`, `48.7 s`, `50.7 s to build` in its log), though nightly-486 had built them the day before. And the memory check came first: a run with less than 8 GB to spare (`not unrolled now: 7103 MB of memory to spare, 8192 wanted`, seen here) ran without them even when they were in the caches, at about 4.5 ms for FSR 4's passes instead of 4.0 on an RX 6700 XT. ## What changed The unrolled layers get a pipeline cache of their own, outside the translator's files, and are asked of the caches before the memory a compile needs is asked for. - vk: `build_unrolled` and `own_cache` in `gpu/vk/vk_fsr4.cpp`: the layer is first created with `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` through its own cache; only when that needs a compile does `build_headroom` decide, as before. The cache is read at the first build and written after a layer's build whenever its data grew since it was read or last written: the driver may hand a layer over at once from its own disk cache (kept per game folder path), so a quick build is no sign that the file holds it. `RX_VK_PCACHE_LOAD=0` (or its rule) leaves the file unread and unsaved, as the pipeline cache's file. - vk: `own_pipeline_cache`, `own_pipeline_cache_save` and `own_cache_compute_pipeline` in `gpu/vk/vk_draw.cpp`, beside `shared_compute_pipeline`: the file read through `pcache_file_read` (another driver's or GPU's file is not given to the driver), written through `play_file_write` (a .tmp moved over it, under the fetch lock) when its size changed, and the build with the same compile turn and gates as `shared_compute_pipeline`. `pipeline_cache_file.h`'s sweep of cut-short saves knows the file's `.tmp` names too. - tests: `tests/test_fsr4_own_cache.py` runs `pcache_stamp.h`'s drop against a folder with the translator's files and FSR 4's: a new translator drops its own files and keeps FSR 4's; it also checks that `build_unrolled` builds and saves through the file and asks the caches before the memory, and runs the sweep on a leftover `.tmp` of the file. `docs/development.md`: `RX_VK_PCACHE_LOAD=0` names the file. `tests/test_compute_gate.py` knows the third gated caller of `guarded_compute_held`, with the same checks as `cached_compute`'s. ## Measurements **Verdict:** after an update the layers load from their file in 0.1-0.5 s instead of building cold, and a cached layer no longer needs 8 GB to spare. The game-free test fails on main and passes here. Hardware: Windows 11, RX 6700 XT 12 GB, Adrenalin 26.10.1, Ryzen 5 5600, 16 GB (RAM at JEDEC speed) Scene: Hyrule Field by day, standing; 2560x1440, AMD FSR 4 Performance, uncapped Method: the change applied to the v3.0.0 renderer (its `vk_fsr4.cpp` is main's; renderer built alone) in a copy of a v3.0.0 game folder, headless through the control bridge. An update is a game folder at a new path, so it was run through a directory junction to the same folder (a new path, the same files): AMD's own shader cache is kept per path. The control: a second new path with the file moved away. Log lines below. How to reproduce: `python -I -B tests/test_fsr4_own_cache.py --cxx clang++`; in game, FSR 4 on an AMD card, play until the log has `bound in its place from now` for passes 1, 2 and 12 (the file appears in `cache/`), then start the same build from another path (`mklink /J <new> <game folder>` and run `<new>\bin\longshot.exe`), expecting `the unrolled layers' pipeline cache: read` and `from the caches` | | Before: main @ 8b0ea786 | After: this PR @ feb6b43e | |---|---|---| | `test_fsr4_own_cache` | FAIL (the layers are built into the translator's cache) | PASS | | After a translator change (the update case) | built cold: 48.9 / 48.7 / 50.7 s (v3.0.0's first start on this PC, see Why) | kept: the file is not one the drop touches (the test) | | A new folder path, the file there | (no such file) | 0.2 / 0.5 / 0.1 s, "from the caches" | | A new folder path, the file moved away (control) | | not in the caches: a cold build needed (`not unrolled now` with 5.8 GB to spare) | | Less than 8 GB to spare, the layers cached | `not unrolled now ... 8192 wanted` | taken from the caches | ``` new path, with the file: vk: AMD FSR 4: the unrolled layers' pipeline cache: read vk: AMD FSR 4: tuned fsr4_model_v07_fp8_no_scale_pass1: its loops unrolled (12275 -> 106544 words), bound in its place from now (0.2 s from the caches) vk: AMD FSR 4: tuned fsr4_model_v07_fp8_no_scale_pass12: its loops unrolled (12273 -> 106732 words), bound in its place from now (0.5 s from the caches) vk: AMD FSR 4: tuned fsr4_model_v07_fp8_no_scale_pass2: its loops unrolled (12261 -> 106720 words), bound in its place from now (0.1 s from the caches) new path, the file moved away: vk: AMD FSR 4: the unrolled layers' pipeline cache: starts empty vk: AMD FSR 4: fsr4_model_v07_fp8_no_scale_pass1: not unrolled now: 5814 MB of memory to spare, 8192 wanted (the next start tries again) ``` No fps comparison: the change moves when the layers become available, not their speed (4.04 ms against 4.48 ms without them, #2798's numbers), and another game run shared this GPU during these runs. ### Flags and settings None ## Testing **Tested:** in game as in Measurements (the first start writes the file, about 60 KB; the next reads it and leaves it as it was; a new path reads it; a new path without it does not find the layers). A cold review by a second agent: its points are in (the save rule by size, not by build time; the sweep of cut-short saves; `RX_VK_PCACHE_LOAD=0`; no log when the cache could not be made). The new test both ways, and against a broken fix (the memory asked before the cache: it fails). The renderer builds whole from this branch (Windows, llvm-mingw), with a local workaround for main's own Windows build break in `descriptor_array_census.h` (#1729; not in this PR). The tests that read `vk_fsr4.cpp`, `vk_draw.cpp` or `pcache_stamp.h` pass, except ones that fail the same way on main on this PC (`test_upscaler_rows`, `test_pipeline_play_cache`, `test_prepare_cache_save`, `test_dev_packs`, `test_linux_pressure`, `test_linux_driver_fault_guard`, `test_pipeline_tour`, `test_tracy_funcs`, `test_recorder_sync`, `test_vk_occlusion_queries`, `test_draw_stream_visibility`, `test_fsr_uniform_ownership`; each run on main's sources here). **Not testable by hand:** a real update's first start: the new-path runs stand in for it. **Not tested:** Linux (RADV, fsr4-vk), other AMD cards, a driver update (another driver's file is refused by `pcache_file_read` and the layers are built as before, then the file is written again). **Must be tested:** - Linux, AMD with FSR 4 (fsr4-vk): play once with FSR 4 until the log has `bound in its place from now` for passes 1, 2 and 12, then start again, expecting `the unrolled layers' pipeline cache: read` and `from the caches` (Test Farm: @Beanstalk linux amd, FSR 4 on, two starts, check the log) - Windows, another AMD card that runs FSR 4: the same two starts, expecting the same lines (Test Farm: @Beanstalk windows amd, FSR 4 on, two starts) ## Risks **What could break:** the file can't be written (a read-only folder): the layers are built as before at each start that has 8 GB to spare, and the log says so. A damaged file: refused by the header check, or the driver ignores what it can't use. **Turning it off:** `RX_VK_FSR4_TUNE=0` turns the whole tune off, as before; otherwise revert the commit. **Compatibility:** one new file in `cache/` (~60 KB here). It is never pruned: a new AMD library or unroller adds its layers beside the old ones (another ~60 KB each time) rather than replacing them. The translator's pipeline cache is unchanged; the layers' pipelines left in old play files go when those files next go. ## Issues See #744 (FSR 4 performance reports) ## Checklist ### Everyone - [x] One topic. - [x] The title is a Conventional Commit (`type(scope): description`) of the status line's type. - [x] Why gives the reason plainly and links the issues that fit (the tracker searched). - [x] Tested on my own PC where it runs (in the game, for a change the game runs), as Testing's Tested says; what can't be run by hand is in Testing's Not testable by hand, with why. - [x] Measurements has a verdict, or one line saying why there is nothing to measure. - [x] Nothing gets worse that I know of: any cost (speed, latency, memory, a setup that worked before) is measured and in Risks. - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [x] Rebased on current `main`. - [x] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). - [x] No game files, dumps, build output or generated files. - [x] `third_party/` untouched (a new folder with a `PROVENANCE.md` instead). - [x] The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled. ### When it applies - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. - [x] A game-free test added for the fix, failing on `main` and passing here. - [x] A check under `tests/` that reads changed source updated in this PR, not weakened. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
Their pipelines went into the translator's pipeline cache, whose files a
new translator drops (pcache_stamp.h). Fails on main: build_unrolled
builds through shared_compute_pipeline into that cache.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Assisted-by: Claude Code
perf(vk): AMD FSR 4's unrolled layers in a pipeline cache of their own, kept across updates, and taken from it with no memory asked
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 6s
CI / Workflow lint (actionlint) (pull_request) Successful in 16s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 20s
PR description / Description follows the template (pull_request_target) Successful in 12s
Third-party parts / As their notes say (pull_request) Successful in 20s
feb6b43e1c
An update that changed the translator dropped the pipeline cache's files,
and with them FSR 4's unrolled layers: each such update built them cold
again at its first FSR 4 frames (about 50 s and 3 GB of memory each on an
RX 6700 XT, three layers). They are built and saved through
cache/longshot_fsr4_pipelines.bin now, which the translator's stamp does
not drop and the launcher moves into the update's folder with the rest of
cache/. The same compile turn and gates as shared_compute_pipeline's
(own_cache_compute_pipeline); test_compute_gate knows the third caller.

A layer is asked of the caches first, with no compile: one found there is
taken without kBuildHeadroom (8 GB to spare), which a 16 GB PC often
lacked at the first FSR 4 frame, leaving it without the unrolled layers
although they were cached.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Assisted-by: Claude Code
Author
Member

Tested in game: Windows 11, RX 6700 XT, Adrenalin 26.10.1: the change on the v3.0.0 renderer (its vk_fsr4.cpp is main's) in a v3.0.0 game folder, Hyrule Field, FSR 4 Performance, headless: first start writes cache/longshot_fsr4_pipelines.bin, the next reads it; from a new folder path (a junction, as an update) the layers load from the file in 0.1-0.5 s, and without it the cache ask fails (a cold build needed)

Tested in game: Windows 11, RX 6700 XT, Adrenalin 26.10.1: the change on the v3.0.0 renderer (its vk_fsr4.cpp is main's) in a v3.0.0 game folder, Hyrule Field, FSR 4 Performance, headless: first start writes cache/longshot_fsr4_pipelines.bin, the next reads it; from a new folder path (a junction, as an update) the layers load from the file in 0.1-0.5 s, and without it the cache ask fails (a cold build needed)
Author
Member

Description: fixed the path in Measurements' How to reproduce (a backslash had been eaten).

Description: fixed the path in Measurements' How to reproduce (a backslash had been eaten).
HumanBean deleted branch perf/fsr4-own-cache 2026-11-19 16:27:09 +00:00
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/Longshot!1752
No description provided.