WIP: fix(vk): heavy compiles run alone under Metal's compiler service; the first giant behind the game no longer waits for 16 GB #784

Closed

mooki wants to merge 118 commits from mooki/Longshot:mac/giant-compile-2 into main

pull from: mooki/Longshot:mac/giant-compile-2

merge into: MagicBeanDev:main

MagicBeanDev:main

Conversation 1 Commits 118 Files changed 210 +35937 -850

mooki commented 2026-11-15 11:56:02 +00:00

Member

• Copy link
• Copy Markdown

Type: fix · Risk: medium · Tested on: macOS 26.7.1, Apple M4 Max (MoltenVK main 5189f8de with the argbuf-slots patch), game-free on arm64 and x86_64 under Rosetta; GPU probe GC-02 on arm64 (history) · Needs: macOS, Apple silicon (a start to play on the rebased stack); Windows and Linux, any GPU (build and start)

Why

On a Mac, Metal compiles every pipeline in its compiler service, in a few service processes the game shares. Four of the
game's mesh programs drawn through the compute fallback are giants: 347,000 and 464,000 SPIR-V words, with a 9 KB local
memory array reached by about 8,000 access chains. Each takes one to several GB of a service process. With two of the
464k ones in one process, or three giants, the process runs out of the address ranges it keeps every compile in
(Failed to allocate segment from range group - out of space) and dies; Metal hands the same compiles to a new process,
which dies the same way. Run #31 lost four service processes in a row and three giants were never made; run #35 lost the two
464k ones. Alone, a giant is made: 5c945415 was made in every run from #17 to #31, and GPU probe GC-02's twin of the 464k
giants was made alone, even after 48 other compiles. Separately, #669's memory gate let no giant start behind the game in run #32: it waited for 16 GB
available, which a loaded game never leaves. This PR compiles such heavy programs alone, nothing else of the precompile
beside them, and lets the first giant behind the game start unless memory is critical. It is part of the macOS port. See #420.

How to reproduce

Seen on: macOS 26.7.1, Apple M4 Max, MoltenVK main 5189f8de with the argbuf-slots patch; main does not start on macOS yet:
seen on the macOS port's integration builds b4732392 (run #31) and 3f872b0c (runs #32 and #35), which carry the open macOS PRs
Settings and switches: defaults (RX_VK_COMPILER_SERVICE on, MoltenVK's), the field-dawn save, slot 00
Steps: a start from the field-dawn save with START and A at the title, the precompile building the giants before and
behind the game; read the vk: slow compile: … lines for 5096bcc7, 6dbfda5a, 55d1da3f and 5c945415, and the system log's
MTLCompilerService lines.
Expected: every giant pipeline made.
Actual: run #31: 5096bcc7, 6dbfda5a and 55d1da3f not made after 460-463 s, four compiler service processes ended with
the range-group line; run #35: 55d1da3f and 5c945415 not made after 133 s; run #32: no giant started behind the game for
the whole run (reports/2026-11-15-giant-compile-2.md §2.4, the run reports).

What changed

Under compiler_service (MoltenVK's driver; the precompile's behind_worker), a heavy compile runs alone: it starts only
once no other run of the precompile is in flight, and nothing else starts until it ends. Heavy means a module whose local
memory weight (its largest Private or Function array's access chains times its words) reaches 10,000,000, or 1,000,000 SPIR-V
words. Behind the game, with no giant in flight one starts unless the memory pressure is critical. Every other driver, and
the precompile's gate called as before, run the code they ran before.

• gpu/vk/precompile_handoff.h: heavy_weight (RX_VK_HEAVY_WEIGHT), heavy_words (RX_VK_HEAVY_WORDS), heavy_compile;
  Giants::next with heavy_of and alone: a heavy run claimed while others run waits in its own queue; while the hold,
  play's want or giant, or critical memory keep it back the other runs go on; once only the runs in flight do, nothing new is
  taken until they drain. Every run counts in flight until run_left. The 7-argument next is the gate as before.
  memory_lets_first_giant: the first giant behind the game starts unless the pressure is critical; the room
  (RX_VK_GIANT_ROOM_MB) bounds the second and those after it.
• gpu/vk/private_memory.h local_weight; gpu/vk/vk_shader.h Stage::local_weight; gpu/vk/vk_progcache.cpp
note_local_weight, beside each of the three places a stage's SPIR-V is noted, for modules over 100,000 words, whatever
  RX_VK_LMEM_LOG, on macOS only (694edb10).
• gpu/vk/vk_draw.cpp precompile_run: each item's weight and whether it is heavy (its stages' largest weight); behind_worker
  asks next with them and lets each run go; lines: the count at setup (vk: precompile: N heavy compiles, each run alone …),
  … deferred: a heavy compile runs alone …, … a heavy compile begins alone …, the done line's count; the memory lines say
  the first-giant rule.
• docs/development.md: the RX_VK_HEAVY_WEIGHT, RX_VK_HEAVY_WORDS row; the RX_VK_GIANT_ROOM_MB row says the first-giant rule
  (27753a2e).
• tests: tests/test_giant_alone.py + giant_alone_test.cpp (new: the measure on the logged modules, drain-then-alone step by
  step, the waits for play's giant, play's want, the hold and critical memory with the other runs going on, 16 workers over 400
  items with 6 heavy: every item once, 0 runs beside a heavy one; the old next() unchanged; the source's wiring);
  giant_memory_test.cpp (the first-giant rule); test_loading_stall.py (held_back checked in three places). GC-02's
  module generator (tests/giant_shape_ir.cpp, test_giant_shape.py) is its own test-only PR, #787: it needs the
  shader stack's test helpers (#697), which this base does not carry, and nothing here uses it.

Measurements

Verdict: the mechanism is measured; the game with this PR is not yet. GPU probe GC-02 compiled synthetic giants made by
LS's own lowering in Metal's compiler service: one of four times the giants' size ended every service process it was given,
alone (about 4.6 GB each); the twin of the 464k giants was made alone (1.07 GB), after 48 other compiles too; what the
service pays for is control flow (the same program straight-line 121 MiB, branchy 759 MiB), not the local array (moved to a
storage buffer, 747 MiB). So scheduling a heavy compile alone is what makes the game's giants; no public switch helps (Metal's
MTL_MONOLITHIC_COMPILER is ignored; MoltenVK's maximize-concurrency switch spawned no more service processes).

Baseline: main does not start on macOS. The game columns are the integration builds named (runs #31 and #35, without this
change); GC-02 is a standalone probe (no game code or data), arm64, the probe's pinned MoltenVK main 5189f8de with the
argbuf-slots patch.

Hardware: macOS 26.7.1 (25G241), Apple M4 Max (40-core GPU), 16-core CPU, 64 GB
Scene: runs #31/#35: a start from the field-dawn save, START and A at the title, windowless (#31) and windowed (#35); GC-02: 12
synthetic modules from GC-02's generator (tests/giant_shape_ir.cpp, #787), each compiled in a fresh process, then
ladders of 2-16 at once
Method: runs: the precompile's slow compile lines (made or not, seconds) per giant; GC-02: made or not per module, each
service process's lifetime peak footprint (proc_pid_rusage, every 0.5 s), every made pipeline dispatched and its out words
compared bit for bit; one run (reports/GiantCompile2-files/gc02/runs-gc02-arm64/run.json 7154e184…)
How to reproduce: GC-02's run command (reports/2026-11-15-giant-compile-2.md §6); a start reading vk: precompile: … heavy
lines and the giants' slow compile lines

	Before: integration @ b4732392 (run #31)	Before: integration @ 3f872b0c (run #35)	After: this PR @ 694edb10
the four giant mesh fallbacks	5c945415 made (171 s); 5096bcc7, 6dbfda5a, 55d1da3f not made (460-463 s); four service processes ended	the 347k pair made (32 s); the 464k pair not made (133 s)	(E-series numbers: pending)

GC-02 module (SPIR-V words, blocks, phis)	made	service processes' lifetime peaks (MiB)
flat: the giants' array and chains, straight-line (343k, 10, 0)	1/1	121
branchy: the 347k giants' shape (391k, 9.4k, 7.1k)	1/1	759
branchy with the array in a storage buffer	1/1	747
branchy-a2: the 464k giants' twin (536k, 9.6k, 11.7k) alone / after 48 compiles / 16 at once	1/1, 1/1, 16/16	1,067 / 870 / 4,242 in one process
branchy-x2 (772k)	1/1	2,362
branchy-x4 (1.53M) alone	0/1	4,637 / 4,626 / 4,543 / 2,257: four processes, four range-group lines, four SIGABRTs

GC-02: ROUTE parts=19 skipped=0 complete=1 reproduced=1 reproducing=scan-branchy-x4 heaviest=branchy-a2 alone_made=1 inproc_spawned=1 exact=1 footprint_stops=0

Reports: reports/2026-11-15-giant-compile-2.md (the giants' shape, GC-01 and GC-02, the routes, the branch),
reports/2026-11-14-mac-startup-31.md, -32.md, reports/2026-11-15-mac-startup-35-windowed.md.

Flags and settings

Two new switches, read only with RX_VK_COMPILER_SERVICE (MoltenVK); one switch's rule changes. The diff against main also
shows the switches of the PRs it stacks on (#669's and #681's stacks), theirs to list: HOS_KEEP_FREED_PAGES,
HOS_ZERO_ALL_PAGES, RX_NVN_WATCH_AFTER, RX_NVN_WATCH_ALL, RX_NVN_WATCH_TEXELS_SRC, RX_VK_ALONE_TRIES,
RX_VK_COMPILE_QOS, RX_VK_DLSS_ACTORS, RX_VK_GIANT_COMPILES, RX_VK_GIANT_HOLD_PRESENTS, RX_VK_GIANT_HOLD_S,
RX_VK_GIANT_WORDS, RX_VK_GPU_DUMP, RX_VK_LIBRARY, RX_VK_LMEM_LOG, RX_VK_LMEM_LOG_MIN, RX_VK_MESH_IND_COUNT_WORD,
RX_VK_NO_UPSCALE_STUB, RX_VK_SET_FOR_LENGTHS, RX_VK_SET_FOR_TABLES, RX_VK_SKIP_LOG, RX_VK_SKIP_PROG,
RX_VK_SLOW_COMPILE_S, RX_VK_TEXEL_CODECS, RX_VK_UNIFIED_BUDGET, RX_VK_WORKER_CACHES.

Flag	What it is	Before this PR	After this PR	Effect	Helps / doesn't help / untested	Recommendation
RX_VK_HEAVY_WEIGHT=<n>	the local memory weight (largest array's access chains × words) from which a compile is heavy and runs alone; 0: none by weight	(no switch)	10000000	the four giants (18.2M-18.5M) compile alone; every other module the runs noted is 5.4M at most	helps: GC-02 (alone fits); untested in the game	as it ships
RX_VK_HEAVY_WORDS=<words>	the SPIR-V words from which a compile is heavy too; 0: none by size	(no switch)	1000000	the 1.09M-word mesh fallbacks (lost their service in runs #17-#21 among others) compile alone	untested: whether they fit alone	as it ships
RX_VK_GIANT_ROOM_MB=<MB>	the memory one giant compile is given behind the game (#669)	every giant behind the game waits for a normal pressure and this many MB available	the first giant starts unless the pressure is critical; the room bounds the second and those after it	run #32's starvation (no giant for the whole run) ends	untested in the game	as it ships

Testing

Tested: on macOS 26.7.1, Apple M4 Max:

• At this head (main e090cc48, #669 with #681 merged and the two merge fixes, this PR), every run under the shared check slot
  with a fresh HOME and TMPDIR (reports/PubWave-files/PubLate5/StartTrio/proof/gc2b-*; the first runs at 06881766, whose
  code is this head's, gc2-*):
  • arm64 and x86_64 (Rosetta), exit 0 on each: test_giant_alone (PASS: heavy compiles run alone, with nothing else of the precompile in flight, none dropped; the first giant behind the game starts unless the memory pressure is critical),
    test_giant_memory, test_loading_stall, test_private_memory, test_precompile_handoff, test_warm_handoff,
    test_seg_gathers; at 06881766 also test_retry_alone, test_program_cache_cleanup, test_program_cache_one_variant
    (both arches) and test_intel_quick_compute.
  • On this PR's base 4f888d6d with this PR's test files, exit 1 on each arch: test_giant_alone (use of undeclared identifier 'local_weight'), test_giant_memory (FAIL: warning, none in flight: the first giant not started and 19 more),
    test_loading_stall (Giants: a giant starts while the board holds, or is not counted on it: the third held_back).
  • The merge fixes: at the merge before them (2c91cc6b) test_loading_stall, test_warm_handoff and
    test_precompile_handoff fail (arm64) on the p/plain names and the unnamed skips, and at 5a6f21fe test_private_memory
    fails (the stage's length use … is not followed by note_private_memory ×3); each passes at this head.
  • vk_draw.cpp, vk_progcache.cpp and the files the base's merge combines (vk_main.cpp, vk_memory.cpp, vk_replay.cpp,
    vk_texture.cpp, vk_vma.cpp) compiled whole for arm64 and x86_64 with main's renderer flags (#476's, #492's and #490's
    macOS compile pieces merged in a scratch tree only): 14 of 14, exit 0 (…/StartTrio/compile/giant-compile-2/, at
    06881766: gpu/, docs/ and host/ are the same at this head).
• The topic as written (macos/giant-compile-2 78f3e5b3, on the integration branch 79e2e006): its named checks passed
  (8/8 twice, 2/2), test_giant_alone and the updated giant_memory_test.cpp failed on 79e2e006's code; vk_draw.cpp and
  vk_progcache.cpp compiled for arm64 and x86_64; its full suite at b969a068 585 passed, 3 failed, 16 skipped (the base's
  test_menu_i18n, and two program-cache fixtures fixed by b694aeb4) (reports/GiantCompile2-files/checks/).
• Off Apple (unifdef -U__APPLE__, base against head): precompile_handoff.h, private_memory.h, vk_draw.cpp,
  vk_progcache.cpp and vk_shader.h differ: the gate's code and lines are compiled everywhere and reached only under
  compiler_service (pre->hand), and off macOS note_local_weight scans nothing
  (reports/PubWave-files/PubLate5/StartTrio/offapple-giant-compile-2.txt).
• GPU probe GC-02 as in Measurements (history).

Known gap, being fixed on this branch: game run #36 on the integration carrying this PR (2b4b7b8e, windowed) had 0 XPC
errors, and 5096bcc7 began alone and was made in 91.5 s. But compute pipeline 44511d69 (126,010 words) was in flight from
05:28:55 to the run's end (641 s in run #32 too), and the alone rule waits for every compile in flight. So 6dbfda5a,
55d1da3f and 5c945415 never began: 1 of 8 deferred heavy compiles began in the 15-minute hold. A fix that stops a
never-ending compile from blocking the heavy ones is in progress, and this PR stays WIP until it is here.

Not tested: whether the 1.09M-word mesh fallbacks fit alone; a program heavier than one service process can hold alone
(GC-02's 4× synthetic) cannot be made by any scheduling, and none is known in the game; Windows and Linux: not built there
(the new code there is compiled and not reached); its test request covers it.

Must be tested:

• macOS, Apple silicon, on the rebased macOS stack: a start from the field-dawn save with START and A at the title, expecting
  vk: precompile: N heavy compiles, each run alone … at setup, … a heavy compile begins alone … for each of the four giants,
  each giant made, no MTLCompilerService range-group line in a live log stream, and behind the game a giant started
  while the pressure is not critical (by hand: the parent's game run)
• Windows and Linux, any GPU: build this PR (head 694edb10, it carries #669 and #681 and what they carry) and #669's head the
  same way and start each to the title, expecting no heavy compiles line (the gate needs compiler_service) and every other
  line to match #669's (by hand: test request T-XXXX)

Risks

What could break: on MoltenVK the precompile drains its runs before each heavy compile and starts nothing beside it, so
the four giants (and any 1M-word module) compile one after another: the precompile can take longer where they used to share
the service, and longer still before the title if they come before the hand-off. Behind the game the first giant starts at
warning pressure too, where #669 waited. A heavy program that dies even alone is still not made (as before), and its dispatch
compiles it where first needed.

Turning it off: RX_VK_HEAVY_WEIGHT=0 RX_VK_HEAVY_WORDS=0 (no compile is heavy), RX_VK_COMPILER_SERVICE=0 (none of the
precompile's path), or revert the PR.

Compatibility: Nothing changes for players outside macOS. No shader-stamp file changes (vk_progcache.cpp,
vk_shader.h, precompile_handoff.h, private_memory.h and vk_draw.cpp are not hashed), no cache format change, no
MKWVK_API_VERSION change.

Reviewer notes

• Review 4f888d6d..694edb10: the topic's three code commits picked with -x from macos/giant-compile-2 (b969a068 heavy
  compiles alone, b694aeb4 the weight in private_memory.h, 78f3e5b3 a comment), each the source commit line for line with
  no conflict, then two of mine: 27753a2e (the RX_VK_GIANT_ROOM_MB row: #669's row, which the topic's tree did not have, said
  every giant waits for the room) and 694edb10 (note_local_weight on macOS only: off it the scan had no reader; the check
  follows). Read Giants::next and heavy_ready first, then behind_worker. The topic's first commit, 31ff4adc (GC-02's
  module generator, test-only), is #787, on #697.
• Depends on #669 (the gate this changes: Giants, the memory gate, the compile board, and what #669 carries: #666, #665, #664,
  #652, #650, #651, #642) and on #681 (private_memory.h's scan, which gives the weight, and note_private_memory's places;
  and the renderer stack #681 carries, #663 and below). The branch is #669's head 4d16d199 with #681's head f9dc41ac merged
  (2c91cc6b), resolved as the integration branch 79e2e006 has it: vk_shader.h (Stage's fields), vk_progcache.cpp (the
  three places a stage is noted), vk_vendor.h, vk_main.cpp (the vendor fixes line), vk_draw.cpp (dispatch(): #681's
  program names and stand-in admission with #669's named skips), docs/development.md (rows).
• Semantic merge fixes 5a6f21fe and 4f888d6d (#669 × #681), sibling items: whichever of the two lands second needs them;
  this PR carries them:
  • 5a6f21fe: #669's LoadingStall names every dispatch left out and its test allows no bare SKIP_HERE() in dispatch();
    #681's SegBind brings five: each is SKIP_DISPATCH with the integration branch's reason (off macOS the file's text is
    unchanged: SegBind's dispatch path is Apple-only); seg_gathers_test.cpp gets the SKIP_DISPATCH stand-in;
    test_loading_stall, test_warm_handoff and test_precompile_handoff read the dispatch's program as plain (#681's
    stack's name) and the count of named skips as 13 (#666's own comment said the segmented binding's five would come).
  • 4f888d6d: #681's test_private_memory looks for note_private_memory on the line after a stage's .array_length; on
    #669's stack the stage's .words line (#652) sits between them, so its source check looks after the .words line, with
    the integration branch's regex and messages (found by the wave suite at 4cc29486).
• Sibling conflicts (git merge-tree; none of this PR's own commits beyond its base's): docs/development.md and
  gpu/vk/vk_vendor.h with #785 (rows and neighbouring fields: keep both); gpu/vk/vk_draw.cpp's dispatch()
  with #786, #667 and the other PRs that carry #666 without #681's stack (the base merge's: resolve as here);
  the rest are #669's and #681's own.
• Conflicts with main (35465d12): inherited from the base (vk_draw.cpp, test_pipeline_play_cache.py); none of this PR's own.
• Code comments cite reports/2026-11-1*.md (the port's design notes), which are not in this repository.

Issues

See #420

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).
• Measurements has a verdict, or one line saying why there is nothing to measure.
• Testing names what was tested, what wasn't, and what must still be tested, where and how. (Test requests not open yet.)
• Rebased on current main. (On main e090cc48 through #669 4d16d199 and #681 f9dc41ac; main has moved since (35465d12): a delta sweep follows.)
• python -I -B tests/run_all.py passes (any failure that also fails on main is named). (On wave S c08ae52d = this head 694edb10 with #786 5c37ec10 and #785 a4d31a59 merged: 586 passed, 31 failed, 18 skipped against main e090cc48's 544/32/17 on this Mac; the 31 failures are main's own and nothing that passes on main fails; test_collect_wide now passes; 41 new tests pass; reports/PubWave-files/PubLate5/wave/full-S-c08ae52d/.)
• 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.
• Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value.
• A game-free test added for the fix, failing on main and passing here. (They fail on this PR's base with this PR's test files; main has no precompile gate.)
• A check under tests/ that reads changed source updated in this PR, not weakened.
• Docs updated.

**Type:** fix · **Risk:** medium · **Tested on:** macOS 26.7.1, Apple M4 Max (MoltenVK main 5189f8de with the argbuf-slots patch), game-free on arm64 and x86_64 under Rosetta; GPU probe GC-02 on arm64 (history) · **Needs:** macOS, Apple silicon (a start to play on the rebased stack); Windows and Linux, any GPU (build and start) ## Why On a Mac, Metal compiles every pipeline in its compiler service, in a few service processes the game shares. Four of the game's mesh programs drawn through the compute fallback are giants: 347,000 and 464,000 SPIR-V words, with a 9 KB local memory array reached by about 8,000 access chains. Each takes one to several GB of a service process. With two of the 464k ones in one process, or three giants, the process runs out of the address ranges it keeps every compile in (`Failed to allocate segment from range group - out of space`) and dies; Metal hands the same compiles to a new process, which dies the same way. Run #31 lost four service processes in a row and three giants were never made; run #35 lost the two 464k ones. Alone, a giant is made: 5c945415 was made in every run from #17 to #31, and GPU probe GC-02's twin of the 464k giants was made alone, even after 48 other compiles. Separately, #669's memory gate let no giant start behind the game in run #32: it waited for 16 GB available, which a loaded game never leaves. This PR compiles such heavy programs alone, nothing else of the precompile beside them, and lets the first giant behind the game start unless memory is critical. It is part of the macOS port. See #420. ## How to reproduce **Seen on:** macOS 26.7.1, Apple M4 Max, MoltenVK main 5189f8de with the argbuf-slots patch; main does not start on macOS yet: seen on the macOS port's integration builds b4732392 (run #31) and 3f872b0c (runs #32 and #35), which carry the open macOS PRs **Settings and switches:** defaults (`RX_VK_COMPILER_SERVICE` on, MoltenVK's), the field-dawn save, slot 00 **Steps:** a start from the field-dawn save with START and A at the title, the precompile building the giants before and behind the game; read the `vk: slow compile: …` lines for 5096bcc7, 6dbfda5a, 55d1da3f and 5c945415, and the system log's `MTLCompilerService` lines. **Expected:** every giant pipeline made. **Actual:** run #31: 5096bcc7, 6dbfda5a and 55d1da3f `not made` after 460-463 s, four compiler service processes ended with the range-group line; run #35: 55d1da3f and 5c945415 `not made` after 133 s; run #32: no giant started behind the game for the whole run (`reports/2026-11-15-giant-compile-2.md` §2.4, the run reports). ## What changed Under `compiler_service` (MoltenVK's driver; the precompile's `behind_worker`), a heavy compile runs alone: it starts only once no other run of the precompile is in flight, and nothing else starts until it ends. Heavy means a module whose local memory weight (its largest Private or Function array's access chains times its words) reaches 10,000,000, or 1,000,000 SPIR-V words. Behind the game, with no giant in flight one starts unless the memory pressure is critical. Every other driver, and the precompile's gate called as before, run the code they ran before. - `gpu/vk/precompile_handoff.h`: `heavy_weight` (`RX_VK_HEAVY_WEIGHT`), `heavy_words` (`RX_VK_HEAVY_WORDS`), `heavy_compile`; `Giants::next` with `heavy_of` and `alone`: a heavy run claimed while others run waits in its own queue; while the hold, play's want or giant, or critical memory keep it back the other runs go on; once only the runs in flight do, nothing new is taken until they drain. Every run counts in flight until `run_left`. The 7-argument `next` is the gate as before. `memory_lets_first_giant`: the first giant behind the game starts unless the pressure is critical; the room (`RX_VK_GIANT_ROOM_MB`) bounds the second and those after it. - `gpu/vk/private_memory.h` `local_weight`; `gpu/vk/vk_shader.h` `Stage::local_weight`; `gpu/vk/vk_progcache.cpp` `note_local_weight`, beside each of the three places a stage's SPIR-V is noted, for modules over 100,000 words, whatever `RX_VK_LMEM_LOG`, on macOS only (`694edb10`). - `gpu/vk/vk_draw.cpp` `precompile_run`: each item's weight and whether it is heavy (its stages' largest weight); `behind_worker` asks `next` with them and lets each run go; lines: the count at setup (`vk: precompile: N heavy compiles, each run alone …`), `… deferred: a heavy compile runs alone …`, `… a heavy compile begins alone …`, the done line's count; the memory lines say the first-giant rule. - `docs/development.md`: the `RX_VK_HEAVY_WEIGHT`, `RX_VK_HEAVY_WORDS` row; the `RX_VK_GIANT_ROOM_MB` row says the first-giant rule (`27753a2e`). - tests: `tests/test_giant_alone.py` + `giant_alone_test.cpp` (new: the measure on the logged modules, drain-then-alone step by step, the waits for play's giant, play's want, the hold and critical memory with the other runs going on, 16 workers over 400 items with 6 heavy: every item once, 0 runs beside a heavy one; the old `next()` unchanged; the source's wiring); `giant_memory_test.cpp` (the first-giant rule); `test_loading_stall.py` (`held_back` checked in three places). GC-02's module generator (`tests/giant_shape_ir.cpp`, `test_giant_shape.py`) is its own test-only PR, #787: it needs the shader stack's test helpers (#697), which this base does not carry, and nothing here uses it. ## Measurements **Verdict:** the mechanism is measured; the game with this PR is not yet. GPU probe GC-02 compiled synthetic giants made by LS's own lowering in Metal's compiler service: one of four times the giants' size ended every service process it was given, alone (about 4.6 GB each); the twin of the 464k giants was made alone (1.07 GB), after 48 other compiles too; what the service pays for is control flow (the same program straight-line 121 MiB, branchy 759 MiB), not the local array (moved to a storage buffer, 747 MiB). So scheduling a heavy compile alone is what makes the game's giants; no public switch helps (Metal's `MTL_MONOLITHIC_COMPILER` is ignored; MoltenVK's maximize-concurrency switch spawned no more service processes). Baseline: main does not start on macOS. The game columns are the integration builds named (runs #31 and #35, without this change); GC-02 is a standalone probe (no game code or data), arm64, the probe's pinned MoltenVK main 5189f8de with the argbuf-slots patch. Hardware: macOS 26.7.1 (25G241), Apple M4 Max (40-core GPU), 16-core CPU, 64 GB Scene: runs #31/#35: a start from the field-dawn save, START and A at the title, windowless (#31) and windowed (#35); GC-02: 12 synthetic modules from GC-02's generator (`tests/giant_shape_ir.cpp`, #787), each compiled in a fresh process, then ladders of 2-16 at once Method: runs: the precompile's `slow compile` lines (made or not, seconds) per giant; GC-02: made or not per module, each service process's lifetime peak footprint (`proc_pid_rusage`, every 0.5 s), every made pipeline dispatched and its out words compared bit for bit; one run (`reports/GiantCompile2-files/gc02/runs-gc02-arm64/run.json` `7154e184…`) How to reproduce: GC-02's `run` command (`reports/2026-11-15-giant-compile-2.md` §6); a start reading `vk: precompile: … heavy` lines and the giants' `slow compile` lines | | Before: integration @ b4732392 (run #31) | Before: integration @ 3f872b0c (run #35) | After: this PR @ 694edb10 | |---|---|---|---| | the four giant mesh fallbacks | 5c945415 made (171 s); 5096bcc7, 6dbfda5a, 55d1da3f not made (460-463 s); four service processes ended | the 347k pair made (32 s); the 464k pair not made (133 s) | (E-series numbers: pending) | | GC-02 module (SPIR-V words, blocks, phis) | made | service processes' lifetime peaks (MiB) | |---|---|---| | flat: the giants' array and chains, straight-line (343k, 10, 0) | 1/1 | 121 | | branchy: the 347k giants' shape (391k, 9.4k, 7.1k) | 1/1 | 759 | | branchy with the array in a storage buffer | 1/1 | 747 | | branchy-a2: the 464k giants' twin (536k, 9.6k, 11.7k) alone / after 48 compiles / 16 at once | 1/1, 1/1, 16/16 | 1,067 / 870 / 4,242 in one process | | branchy-x2 (772k) | 1/1 | 2,362 | | branchy-x4 (1.53M) alone | 0/1 | 4,637 / 4,626 / 4,543 / 2,257: four processes, four range-group lines, four SIGABRTs | ``` GC-02: ROUTE parts=19 skipped=0 complete=1 reproduced=1 reproducing=scan-branchy-x4 heaviest=branchy-a2 alone_made=1 inproc_spawned=1 exact=1 footprint_stops=0 ``` Reports: `reports/2026-11-15-giant-compile-2.md` (the giants' shape, GC-01 and GC-02, the routes, the branch), `reports/2026-11-14-mac-startup-31.md`, `-32.md`, `reports/2026-11-15-mac-startup-35-windowed.md`. ### Flags and settings Two new switches, read only with `RX_VK_COMPILER_SERVICE` (MoltenVK); one switch's rule changes. The diff against main also shows the switches of the PRs it stacks on (#669's and #681's stacks), theirs to list: `HOS_KEEP_FREED_PAGES`, `HOS_ZERO_ALL_PAGES`, `RX_NVN_WATCH_AFTER`, `RX_NVN_WATCH_ALL`, `RX_NVN_WATCH_TEXELS_SRC`, `RX_VK_ALONE_TRIES`, `RX_VK_COMPILE_QOS`, `RX_VK_DLSS_ACTORS`, `RX_VK_GIANT_COMPILES`, `RX_VK_GIANT_HOLD_PRESENTS`, `RX_VK_GIANT_HOLD_S`, `RX_VK_GIANT_WORDS`, `RX_VK_GPU_DUMP`, `RX_VK_LIBRARY`, `RX_VK_LMEM_LOG`, `RX_VK_LMEM_LOG_MIN`, `RX_VK_MESH_IND_COUNT_WORD`, `RX_VK_NO_UPSCALE_STUB`, `RX_VK_SET_FOR_LENGTHS`, `RX_VK_SET_FOR_TABLES`, `RX_VK_SKIP_LOG`, `RX_VK_SKIP_PROG`, `RX_VK_SLOW_COMPILE_S`, `RX_VK_TEXEL_CODECS`, `RX_VK_UNIFIED_BUDGET`, `RX_VK_WORKER_CACHES`. | Flag | What it is | Before this PR | After this PR | Effect | Helps / doesn't help / untested | Recommendation | |---|---|---|---|---|---|---| | `RX_VK_HEAVY_WEIGHT=<n>` | the local memory weight (largest array's access chains × words) from which a compile is heavy and runs alone; `0`: none by weight | (no switch) | 10000000 | the four giants (18.2M-18.5M) compile alone; every other module the runs noted is 5.4M at most | helps: GC-02 (alone fits); untested in the game | as it ships | | `RX_VK_HEAVY_WORDS=<words>` | the SPIR-V words from which a compile is heavy too; `0`: none by size | (no switch) | 1000000 | the 1.09M-word mesh fallbacks (lost their service in runs #17-#21 among others) compile alone | untested: whether they fit alone | as it ships | | `RX_VK_GIANT_ROOM_MB=<MB>` | the memory one giant compile is given behind the game (#669) | every giant behind the game waits for a normal pressure and this many MB available | the first giant starts unless the pressure is critical; the room bounds the second and those after it | run #32's starvation (no giant for the whole run) ends | untested in the game | as it ships | ## Testing **Tested:** on macOS 26.7.1, Apple M4 Max: - At this head (main e090cc48, #669 with #681 merged and the two merge fixes, this PR), every run under the shared check slot with a fresh HOME and TMPDIR (`reports/PubWave-files/PubLate5/StartTrio/proof/gc2b-*`; the first runs at `06881766`, whose code is this head's, `gc2-*`): - arm64 and x86_64 (Rosetta), exit 0 on each: `test_giant_alone` (`PASS: heavy compiles run alone, with nothing else of the precompile in flight, none dropped; the first giant behind the game starts unless the memory pressure is critical`), `test_giant_memory`, `test_loading_stall`, `test_private_memory`, `test_precompile_handoff`, `test_warm_handoff`, `test_seg_gathers`; at `06881766` also `test_retry_alone`, `test_program_cache_cleanup`, `test_program_cache_one_variant` (both arches) and `test_intel_quick_compute`. - On this PR's base `4f888d6d` with this PR's test files, exit 1 on each arch: `test_giant_alone` (`use of undeclared identifier 'local_weight'`), `test_giant_memory` (`FAIL: warning, none in flight: the first giant not started` and 19 more), `test_loading_stall` (`Giants: a giant starts while the board holds, or is not counted on it`: the third `held_back`). - The merge fixes: at the merge before them (`2c91cc6b`) `test_loading_stall`, `test_warm_handoff` and `test_precompile_handoff` fail (arm64) on the `p`/`plain` names and the unnamed skips, and at `5a6f21fe` `test_private_memory` fails (`the stage's length use … is not followed by note_private_memory` ×3); each passes at this head. - `vk_draw.cpp`, `vk_progcache.cpp` and the files the base's merge combines (`vk_main.cpp`, `vk_memory.cpp`, `vk_replay.cpp`, `vk_texture.cpp`, `vk_vma.cpp`) compiled whole for arm64 and x86_64 with main's renderer flags (#476's, #492's and #490's macOS compile pieces merged in a scratch tree only): 14 of 14, exit 0 (`…/StartTrio/compile/giant-compile-2/`, at `06881766`: `gpu/`, `docs/` and `host/` are the same at this head). - The topic as written (`macos/giant-compile-2` `78f3e5b3`, on the integration branch `79e2e006`): its named checks passed (8/8 twice, 2/2), `test_giant_alone` and the updated `giant_memory_test.cpp` failed on `79e2e006`'s code; `vk_draw.cpp` and `vk_progcache.cpp` compiled for arm64 and x86_64; its full suite at `b969a068` 585 passed, 3 failed, 16 skipped (the base's `test_menu_i18n`, and two program-cache fixtures fixed by `b694aeb4`) (`reports/GiantCompile2-files/checks/`). - Off Apple (`unifdef -U__APPLE__`, base against head): `precompile_handoff.h`, `private_memory.h`, `vk_draw.cpp`, `vk_progcache.cpp` and `vk_shader.h` differ: the gate's code and lines are compiled everywhere and reached only under `compiler_service` (`pre->hand`), and off macOS `note_local_weight` scans nothing (`reports/PubWave-files/PubLate5/StartTrio/offapple-giant-compile-2.txt`). - GPU probe GC-02 as in Measurements (history). **Known gap, being fixed on this branch:** game run #36 on the integration carrying this PR (2b4b7b8e, windowed) had 0 XPC errors, and `5096bcc7` began alone and was made in 91.5 s. But compute pipeline `44511d69` (126,010 words) was in flight from 05:28:55 to the run's end (641 s in run #32 too), and the alone rule waits for every compile in flight. So `6dbfda5a`, `55d1da3f` and `5c945415` never began: 1 of 8 deferred heavy compiles began in the 15-minute hold. A fix that stops a never-ending compile from blocking the heavy ones is in progress, and this PR stays WIP until it is here. **Not tested:** whether the 1.09M-word mesh fallbacks fit alone; a program heavier than one service process can hold alone (GC-02's 4× synthetic) cannot be made by any scheduling, and none is known in the game; Windows and Linux: not built there (the new code there is compiled and not reached); its test request covers it. **Must be tested:** - macOS, Apple silicon, on the rebased macOS stack: a start from the field-dawn save with START and A at the title, expecting `vk: precompile: N heavy compiles, each run alone …` at setup, `… a heavy compile begins alone …` for each of the four giants, each giant `made`, no `MTLCompilerService` range-group line in a live `log stream`, and behind the game a giant started while the pressure is not critical (by hand: the parent's game run) - Windows and Linux, any GPU: build this PR (head `694edb10`, it carries #669 and #681 and what they carry) and #669's head the same way and start each to the title, expecting no `heavy compiles` line (the gate needs `compiler_service`) and every other line to match #669's (by hand: test request T-XXXX) ## Risks **What could break:** on MoltenVK the precompile drains its runs before each heavy compile and starts nothing beside it, so the four giants (and any 1M-word module) compile one after another: the precompile can take longer where they used to share the service, and longer still before the title if they come before the hand-off. Behind the game the first giant starts at warning pressure too, where #669 waited. A heavy program that dies even alone is still not made (as before), and its dispatch compiles it where first needed. **Turning it off:** `RX_VK_HEAVY_WEIGHT=0 RX_VK_HEAVY_WORDS=0` (no compile is heavy), `RX_VK_COMPILER_SERVICE=0` (none of the precompile's path), or revert the PR. **Compatibility:** Nothing changes for players outside macOS. No shader-stamp file changes (`vk_progcache.cpp`, `vk_shader.h`, `precompile_handoff.h`, `private_memory.h` and `vk_draw.cpp` are not hashed), no cache format change, no `MKWVK_API_VERSION` change. ## Reviewer notes - Review `4f888d6d..694edb10`: the topic's three code commits picked with `-x` from `macos/giant-compile-2` (`b969a068` heavy compiles alone, `b694aeb4` the weight in `private_memory.h`, `78f3e5b3` a comment), each the source commit line for line with no conflict, then two of mine: `27753a2e` (the `RX_VK_GIANT_ROOM_MB` row: #669's row, which the topic's tree did not have, said every giant waits for the room) and `694edb10` (`note_local_weight` on macOS only: off it the scan had no reader; the check follows). Read `Giants::next` and `heavy_ready` first, then `behind_worker`. The topic's first commit, `31ff4adc` (GC-02's module generator, test-only), is #787, on #697. - Depends on #669 (the gate this changes: `Giants`, the memory gate, the compile board, and what #669 carries: #666, #665, #664, #652, #650, #651, #642) and on #681 (`private_memory.h`'s scan, which gives the weight, and `note_private_memory`'s places; and the renderer stack #681 carries, #663 and below). The branch is #669's head `4d16d199` with #681's head `f9dc41ac` merged (`2c91cc6b`), resolved as the integration branch `79e2e006` has it: `vk_shader.h` (Stage's fields), `vk_progcache.cpp` (the three places a stage is noted), `vk_vendor.h`, `vk_main.cpp` (the vendor fixes line), `vk_draw.cpp` (`dispatch()`: #681's program names and stand-in admission with #669's named skips), `docs/development.md` (rows). - **Semantic merge fixes `5a6f21fe` and `4f888d6d` (#669 × #681), sibling items: whichever of the two lands second needs them; this PR carries them:** - `5a6f21fe`: #669's LoadingStall names every dispatch left out and its test allows no bare `SKIP_HERE()` in `dispatch()`; #681's SegBind brings five: each is `SKIP_DISPATCH` with the integration branch's reason (off macOS the file's text is unchanged: SegBind's dispatch path is Apple-only); `seg_gathers_test.cpp` gets the `SKIP_DISPATCH` stand-in; `test_loading_stall`, `test_warm_handoff` and `test_precompile_handoff` read the dispatch's program as `plain` (#681's stack's name) and the count of named skips as 13 (#666's own comment said the segmented binding's five would come). - `4f888d6d`: #681's `test_private_memory` looks for `note_private_memory` on the line after a stage's `.array_length`; on #669's stack the stage's `.words` line (#652) sits between them, so its source check looks after the `.words` line, with the integration branch's regex and messages (found by the wave suite at `4cc29486`). - Sibling conflicts (`git merge-tree`; none of this PR's own commits beyond its base's): `docs/development.md` and `gpu/vk/vk_vendor.h` with #785 (rows and neighbouring fields: keep both); `gpu/vk/vk_draw.cpp`'s `dispatch()` with #786, #667 and the other PRs that carry #666 without #681's stack (the base merge's: resolve as here); the rest are #669's and #681's own. - Conflicts with main (`35465d12`): inherited from the base (`vk_draw.cpp`, `test_pipeline_play_cache.py`); none of this PR's own. - Code comments cite `reports/2026-11-1*.md` (the port's design notes), which are not in this repository. ## Issues See #420 ## 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] Measurements has a verdict, or one line saying why there is nothing to measure. - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. (Test requests not open yet.) - [ ] Rebased on current `main`. (On main e090cc48 through #669 `4d16d199` and #681 `f9dc41ac`; main has moved since (`35465d12`): a delta sweep follows.) - [x] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). (On wave S `c08ae52d` = this head `694edb10` with #786 `5c37ec10` and #785 `a4d31a59` merged: 586 passed, 31 failed, 18 skipped against main e090cc48's 544/32/17 on this Mac; the 31 failures are main's own and nothing that passes on main fails; `test_collect_wide` now passes; 41 new tests pass; `reports/PubWave-files/PubLate5/wave/full-S-c08ae52d/`.) - [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] Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value. - [x] A game-free test added for the fix, failing on `main` and passing here. (They fail on this PR's base with this PR's test files; main has no precompile gate.) - [x] A check under `tests/` that reads changed source updated in this PR, not weakened. - [x] Docs updated.

mooki added 118 commits 2026-11-15 11:56:03 +00:00

fix(runtime): preserve guest pages when discarding on macOS ... c71ae93353

Reserve the fixed guest window with a non-overwriting Mach mapping. Reclaim
complete owned host pages with fresh anonymous mappings and zero only the
partial-page edges, preserving adjacent 4 KiB guest pages on 16 KiB hosts.
Use the actual host granule for non-guest allocation/protection and report
macOS discard failures instead of returning success.

Add game-free source-linked arm64/Rosetta tests covering collisions, repeated
free/recommit, unaligned ranges, failure paths and resident-memory reduction.
Keep Linux and Windows paths unchanged. Build-list integration is separate.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>

fix(runtime): retain guest-page rounding in Darwin memory wrappers ... 23ae3872be

Keep the POSIX layer's outward 4 KiB MEM_DECOMMIT and inward 4 KiB MEM_RESET
contracts above the byte-exact Darwin helper. Check arithmetic before rounding,
and keep separate real-memory assertions for helper and wrapper ranges.

Default the Darwin regression test to the native architecture. Both CPU routes
remain explicitly selectable for acceptance without requiring Rosetta or arm64
execution from every ordinary macOS suite run.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>

test(runtime): cut main's int hos_commit in the Darwin guest-memory test ... d4d89421d9

Main's #324 (a4c77174) made hos_commit in host/mkw_glue.c return whether
the range was committed, so its definition now starts "int hos_commit(".
The Darwin guest-memory test cut the function by its old "void" head and
stopped with a ValueError on main's source, on this branch and on main alike,
before compiling anything. Cut it by the new head.

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

test(runtime): follow main's HLE call counts in the Darwin guest-memory fixture ... ae36a96bb0

Main's HOS_HLE_STATS (#153) made HLE() a counting wrapper: a static
HleCount named by its first field, hos_hle_stats and hos_hle_counted. The
fixture's cut of hos_mem.c now gets those two (off: each body runs
directly) and main's -Wno-missing-field-initializers, as main's other
C fixtures pass. The guest-memory checks are unchanged.

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

fix(runtime): translate macOS fault contexts on both CPU routes ... 4ddb671f77

Decode Darwin signal contexts and access faults for arm64 and x86_64,
copy supported context edits back on signal return, and prevent recursive
callback dispatch when a fault handler itself faults. Keep the non-Apple
bridge text and the x64-shaped CONTEXT layout unchanged.

Add source-linked, game-free owned-memory fault tests for both targets,
including page repair, PC redirection, prior handlers and an inaccessible
handler stack. Document the native PC/SP contract and remaining limits.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>

test(runtime): keep Darwin fault checks native by default ... c60d8d05d1

Do not make the ordinary Apple Silicon suite depend on Rosetta. Default
to the running Python process's architecture and retain explicit repeated
--arch options for dual-route qualification. Document that command and
count only files when reporting crash-report directory changes.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>

test(runtime): classify the fault bridge's fatal _exit in main's exit inventory ... 1b028c8419

Main's crash records (#75) added an exhaustive inventory of host process
exits to test_crash_record.py, which scans every host/**/*.c on every
platform. darwin_fault.c's nested-fault _exit(128 + sig) is fatal, so it
is listed as one and exempt from the clean-end mark, like hos_thread.c's
ExitProcess(3). Without it the inventory fails on Windows and Linux too.

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

feat(vk): add macOS Vulkan loader and device admission ... 624e909b79

Select a local Vulkan loader or MoltenVK with RX_VK_LIBRARY and keep SDL and
renderer startup on that same library. Capture SDL's instance extensions on
the window thread, enable advertised portability extensions, and name missing
admission requirements and VkResults without changing Windows or Linux paths.

Keep the non-Apple host API at 21 for existing prebuilt renderers; append the
two macOS callbacks only in Apple's version 22. Cover pure decisions, legacy
platform expectations, ABI layout, and the SDL2/SDL3 bridge without a GPU.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>

test(vk): use semantic admission contracts ... 45df17e92d

Remove the SDL source-string wiring and source-index ordering assertions while
keeping the sixteen compiled behavioral cases and surface adapter compile.
Replace the comment-sensitive API header hash with fixed baseline field names,
byte offsets, versions and sizes, retaining typed Apple callback checks and
both platforms' actual admission decisions and negative controls.

Production code is unchanged. Prior full-suite and device receipts remain
bound to 818e33b1; only the affected game-free tests were rerun.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>

test(vk): follow main's LoadLibraryA and float-add choice in the admission fixture ... 1b306e47e5

The fixture cuts LoadLibraryA and create_device out of main's source. Since
#34, LoadLibraryA keeps dlerror()'s text in load_error, and since #191
native_fadd_wanted also takes the device ID and driver version, so the cut
code no longer compiled against the fixture's stand-ins on this base. Give
it load_error and a dlerror stand-in, and the four-argument stand-in. No
expectation changed.

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

test(vk): pin the admission ABI at main's version 22 and macOS 23 ... 9aa916d0ce

Main's custom output size (#51) took MKWVK_API_VERSION 22 on every
platform and appended take_text at offset 352. The macOS loader
callbacks now follow it: the rebased header says 23 on Apple and 22
elsewhere. The fixed contract follows: non-Apple version 22, size 360
and 45 named offsets (take_text added); Apple version 23, size 376,
vulkan_library and vulkan_extensions at 360 and 368.

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

fix(macos): storage buffer tables get descriptor sets on MoltenVK ... 9778fd0ee8

MoltenVK 1.4.2 binds a push descriptor set's resources one by one, never
through a Metal argument buffer (MVKDescriptorSet.mm pickArgumentBufferMode
returns Off for every push layout, and the pipeline names that set to
SPIRV-Cross as discrete). The SPIR-V back end declares a storage buffer
table (count > 1: Info::global_tables, the task and mesh programs'
c0+0x880 table) as one fixed-size array per typed view, all at one binding
(DefineSsbos; any global memory access uses the U32, U32x2 and U32x4
views), and SPIRV-Cross 6c09849f aliases such arrays only inside an
argument buffer. So every pushed program with a table failed: 256
"Attempting to alias same binding with a descriptor array which is not
implemented through argument buffers" errors and as many failed compute
pipelines in the first Mac start (mac-arm64-a5f2d6f9-01).

vk_vendor.h gets a fix, set_for_tables, on by default only for
VK_DRIVER_ID_MOLTENVK, with RX_VK_SET_FOR_TABLES to force it either way.
ensure_layout's push decision moves into layout_pushes(): with the fix on,
a set that has an array of storage buffers is not pushed but allocated
from the recording's pool, the path programs over the push limit already
take, where MoltenVK's sets are Metal 3 argument buffers. Every other set
is still pushed, the bindings are the same either way, and the SPIR-V,
the translator stamp and the program cache are unchanged. The vendor
fixes' log line at device creation says whether it is on, and a MoltenVK
run with MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS=0 is warned that these
programs cannot translate.

tests/test_set_for_tables.py compiles vk_draw.cpp's layout code (kPushSize
to the end of ensure_layout) on made-up programs and devices: on MoltenVK
a set with a table (compute, task, fragment) is a set, a set without one
(texture arrays and a constant buffer of count 2 included) is pushed;
ten other drivers push as before; the switch works both ways. It fails
on the base with 7 of 79 cases. tests/test_vendor_fixes.py adds a MoltenVK
device and the switch, and checks that the fix stays out of the
translation's profile and stamp. Windows and Linux: same layouts as
before; the log line gains one field.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 0c2fea2a303a5158d12ebc87bcd28467486486ef)

fix(macos): programs reading storage buffer lengths get descriptor sets on MoltenVK ... ef43dffcc8

MoltenVK 1.4.2 writes the buffer sizes SPIRV-Cross reads for OpArrayLength
in a discretely bound set only in bindDescriptorSets
(MVKCommandEncoderState.mm), never in pushDescriptorSet, and it binds every
push set discretely. So every pushed storage buffer's length read 0
whatever its range, while an ordinary set's (a Metal 3 argument buffer
with its own sizes) was exact (GPU probe,
reports/2026-11-14-null-range-probe.md). The back end measures storage
buffers in its global memory search (DefineGlobalMemoryFunctions:
native_global_bounds' candidates and every single storage buffer), so in a
pushed program no buffer ever held a global address: global stores and
atomics were dropped, the atomics returned 0, and loads the page table
does not serve read 0.

vk_vendor.h gets set_for_lengths, on by default only for
VK_DRIVER_ID_MOLTENVK, with RX_VK_SET_FOR_LENGTHS to force it either way.
The new gpu/vk/spirv_lengths.h (no Vulkan, as fallback_size_policy.h)
walks a module's words for OpArrayLength.
Each Stage gets array_length, noted beside its phis wherever the program
cache handles its SPIR-V: program_cache_save after translation (before the
program is published), a whole record read, and complete_from for a
compute program read without its code. The words are not kept anywhere a
layout could scan them later, and a light compute program's layout is made
before its code is read, so until then (array_length -1) a stage counts as
reading a length where it uses global memory: outside segmented variants,
which the cache never keeps, that is the only place the back end measures
a storage buffer. layout_pushes(p, bindings, total) then refuses a push
for any program with a length in any stage. Every other program, every
other driver, the SPIR-V, the translator stamp and the program cache are
unchanged.

The vendor fixes' log line says whether it is on, and at close one line
says how many programs it gave a set (and how many of those were decided
before their code was read).

tests/test_set_for_lengths.py builds real back end modules
(tests/set_for_lengths_ir.cpp: compute and vertex global memory with a
single storage buffer, 18 OpArrayLength each; global memory with nothing to
search; direct storage in compute, vertex and fragment stages, none), then
compiles vk_draw.cpp's layout code with their descriptors and notes:
138 layouts on MoltenVK and ten other drivers, with the switch unset, 0
and 1, stages not read yet, and the bindings equal pushed or not; plus the
renderer's scan on the same modules and on words that are not a module,
and the count kept for the log. test_vendor_fixes.py covers the new fix
on 17 devices, both ways of the switch, and its absence from the
translation's profile and stamp. The program cache fixtures
(program_cache_one_variant_test.cpp, program_cache_cleanup_test.cpp), which
compile vk_progcache.cpp's functions, include spirv_lengths.h beside
fallback_size_policy.h.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit bf5ca961c91479da13e8923387012ef6dc7fb2c7)

fix(macos): stages with more than 8 read_write textures get descriptor sets on MoltenVK ... bff8bdc326

On MoltenVK 1.4.2 a pushed set is bound outside an argument buffer
(MVKDescriptorSet.mm pickArgumentBufferMode: push layouts are Off), and
there Metal's compiler takes at most 8 read_write textures in one function:
TexelDescProbe TD5 (40 storage images and 9 storage texel buffers in one
compute stage) failed pipeline creation pushed with "number of textures
with read_write access exceeds maximum supported (8)", and worked in an
ordinary set (Metal 3 argument buffers). The device reports
maxPerStageDescriptorStorageImages 256 (MoltenVK sets
maxPerStageStorageTextureCount to its argument buffers' texture count), so
nothing in Vulkan's limits stops it.

Which descriptors count: SPIRV-Cross 6c09849f declares a storage image
(sampled 2), storage texel buffers included as texture_buffer since
MoltenVK sets texture_buffer_native, access::read_write unless the
variable is decorated NonWritable or NonReadable (spirv_msl.cpp
image_type_glsl), and it never adds those decorations itself. The eden back
end decorates none (DefineImages, DefineImageBuffers), although Info knows
is_read and is_written. So every storage image and storage texel buffer
counts, by descriptor; sampled images and uniform texel buffers do not.
The limit is per Metal function, that is per stage.

layout_pushes now refuses a push under the existing set_for_tables fix
when any stage's storage images and storage texel buffers, counted by the
bindings' descriptorCount, exceed 8. It is the same cause and remedy as a
storage buffer table (a shape a pushed set cannot take on MoltenVK, where
the pipeline fails; an ordinary set takes it), and RX_VK_SET_FOR_TABLES
covers both, so the vendor fixes' log line is unchanged. ensure_layout
records where each stage's bindings begin, so the mesh fallback's task
and mesh stages, both compute, are counted apart. The programs moved for
it are counted and logged at close (draw_layouts_report). Every other
driver, the SPIR-V, the translator stamp and the program cache are
unchanged.

tests/test_set_for_tables.py gains 55 layouts: 8 and 9 storage images,
5+3 and 5+4 images and texel buffers, 9 texel buffers, an image array of
8 and of 9, graphics stages of 8+8 (pushed) and 0+9, the fallback's task
and mesh stages of 5+5 (pushed) and 4+9, and 41 read-only textures beside
8 storage images (pushed), on MoltenVK; the 9s on the ten other drivers
(pushed); the switch both ways; and the count kept for the close. It
fails on 7b82e199. test_vendor_fixes.py follows the new call and checks
the count reaches the close's log.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 162aca1b3cce50adde9250f14b209a4e5b4c1331)

fix(macos): the shader preparation runs on every usable CPU on macOS ... a83c09b365

prepare_run's first part (every shader translated, and each compute
variant compiled for the pipeline cache) ran on half the CPUs
everywhere: prepare_cpus gives half_cpus unless the Windows process heap
is the segment heap. Half exists for the NT heap's lock that an
in-process driver compiler queued on, and for whole-PC freezes when
those compilers ran on every CPU at High priority. Neither holds on
macOS: MoltenVK converts SPIR-V to MSL in a few ms and hands every
compile to Metal's compiler service (MTLCompilerService, a launchd
service at nice 0), so the workers mostly wait on it. The Mac's first
start logged "8 workers for the shader programs (16 CPUs usable; half
the CPUs)".

prepare_workers::count takes an `every` argument (default false): each
usable CPU gets a worker, at least half_cpus and 1, at most kMaxWorkers.
kEveryCpu is true where __APPLE__ is defined, and prepare_cpus passes
it; the preparation's log line says "every one: macOS". In a synthetic
MoltenVK 1.4.2 benchmark on an M4 Max (16 CPUs, macOS 26.7.1) 16 threads
compiled 56-61 % more compute and 35-39 % more graphics pipelines a
second than 8, but only with a pipeline cache per thread; with the one
shared cache LS uses today the rate is flat from 4 to 16 threads. The
next commit gives each worker its own cache.

tests/test_prepare_every_cpu.py compiles the real prepare_workers.h and
prepare_cpus() cut from vk_progcache.cpp: on this compiler's target
prepare_cpus() gives 16 of 16 usable CPUs on macOS (8 elsewhere); count
with and without `every`; prepare_cpus with kEveryCpu forced either way.
On the base it fails: prepare_cpus() gives 8 of 16 on macOS.

Windows and Linux: unchanged (kEveryCpu false; the existing
test_prepare_workers and test_prepare_cpus cases are untouched).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 3573e736e15078554543e4740c5e2d53c719fa89)

fix(macos): a pipeline cache per preparation worker on MoltenVK ... 7adbbb0bed

MoltenVK 1.4.2 holds one mutex per VkPipelineCache across the SPIR-V to
MSL conversion and Metal's library compile (MVKPipeline.mm
getShaderLibrary, _shaderCacheLock). Every worker of the start's
preparation compiled with the one start cache, pcache, so they compiled
one pipeline at a time: the Mac's first start (mac-arm64-a5f2d6f9-01,
M4 Max) logged strict pairs of Metal compiles every ~195 ms, 5.05
compute variants a second, an estimated 33 minutes for the compute
programs alone. A synthetic benchmark on that Mac (PrepSpeed, MoltenVK
1.4.2, macOS 26.7.1): one shared cache stays at 10.5 compute and 9.6
graphics pipelines a second from 4 to 16 threads; a cache per thread,
merged after, gives 31.5 / 29.7 at 8 threads and 49-51 / 40-41 at 16.

gpu/vk/worker_caches.h: a Set of empty caches, one per worker of a
phase, that a worker enters with Scope; create() asks the shared cache
first under VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT
and compiles what it lacks with the worker's own; merge_into() merges
them into the start cache with one vkMergePipelineCaches in slot order
(MoltenVK retains each Metal library, no compile). The caches are not
externally synchronized, so a shared slot stays correct.

vk_draw.cpp:
- create_cached: before play, a worker in a phase with a set goes
  through worker_caches::create (pcache asked first, so a saved file's
  or an earlier phase's pipelines are found as before); every use of
  pcache holds pcache_mu shared, and worker_caches_merge holds it alone
  (vkMergePipelineCaches's dstCache is externally synchronized:
  vk.xml externsync without INTERNALLY_SYNCHRONIZED_MERGE). A save's
  reads of pcache's data hold it shared too.
- prepare_run (the compute warm), precompile_run, precompile_warm (both
  passes) and precompile_at_create make a set under worker_caches_on,
  enter it in their workers and merge it right after the join; the
  precompile's stragglers left running are merged as far as they got.
- precompile_run, with the caches on, sorts the notes by program
  variant and hands a variant's notes to one worker in runs of up to
  32 (worker_caches::runs/claim), so its shader libraries are compiled
  once, not by every worker that met one of its notes at the same time.
- In play, with the caches on, a compile goes into a new cache of its
  own merged into the generation's at once under the generation's lock
  (made_alone), which the asks of the generation hold shared: the asks
  keep their order and find what any thread compiled.

vk_vendor.h: worker_caches, on for VK_DRIVER_ID_MOLTENVK only, and only
with pipelineCreationCacheControl; RX_VK_WORKER_CACHES forces it either
way. Elsewhere nothing measured says a driver's cache is locked across
its compiles, and the caches would only add merges. The pipelines built,
the persisted cache's format and its stamp are the same either way.

tests/test_worker_caches.py runs vk_draw.cpp's own create_cached,
play_cache_make, worker_caches_on and worker_caches_merge and the real
header against a made-up driver whose caches lock across a compile:
four workers compile at once (without a set they cannot); pcache asked
first, nothing compiled with it; ask-only callers never compiled; caches
not externally synchronized; one merge in slot order whatever order the
slots were taken in, with no ask of pcache beside it; play's compiles
merged into the generation at once; runs and claims. The four-workers
part runs against the base's create_cached and fails there (1 of 4
compiles met the others). tests/test_pipeline_play_cache.py gets an
"alone" case, and both play-cache and cache-save harnesses the new
stand-ins (pcache_mu, worker_caches_on).

Windows and Linux: the same code paths as before (no set, one shared
cache), plus an uncontended shared lock around pcache's uses.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 2174e33f14ccce8c1635565e734773a33bc32455)

fix(macos): the worker caches make no Vulkan call from a header ... 9d733341ae

tests/test_recorder_sync.py holds every header to no recorder boundary
call: vk_work.h, included last by each renderer .cpp, turns
vkDestroyPipelineCache into a drain of RX_VK_RECORDER's packets and then
the call, and a header's calls would be wrapped or not depending on what
included it. worker_caches.h called vkCreatePipelineCache,
vkDestroyPipelineCache and vkMergePipelineCaches itself, from vk_draw.cpp
before vk_work.h.

worker_caches::Set and made_alone now take a Calls struct with the
three operations; vk_draw.cpp defines worker_cache_calls after
vk_work.h, so a set's cache destruction goes through the recorder's
boundary like every other vkDestroy* in the file. Behaviour is
otherwise the same: the same caches, made, merged and destroyed in the
same order.

tests/test_worker_caches.py and tests/pipeline_play_cache_test.cpp take
worker_cache_calls from the source and the model respectively.
test_recorder_sync now fails only as on the base (vk_vma.cpp's
vmaDestroyAllocator), and the four tests that touch the caches pass.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit aa8ecba546465f1ce65ac872ecf21d232b65cef0)

fix(macos): MoltenVK starts with an empty pipeline cache and writes none ... c586bbd154

MoltenVK 1.4.2 keeps MSL, not GPU code, in a VkPipelineCache, and
vkCreatePipelineCache with saved data compiles every stored library one
after another on the calling thread (MVKPipeline.mm readData).
pcache_init hands it all of mkw_vk_pipelines.bin, and play_files_merge
every play file, at every start. The PrepFast GPU check on the M4 Max,
with Metal's per-user cache blocked as in the runner, ran three later
starts of the same 64 pipelines (80 libraries):
- reading the one file: 5.7 s of serial compiles, 6.6 s in all;
- 16 shards read in parallel: 1.4 s;
- nothing read, pipelines compiled from SPIR-V with the worker caches:
  1.4 s.
At the game's scale the read is tens of minutes per start.

vk_vendor.h gets pcache_no_load, on for VK_DRIVER_ID_MOLTENVK only and
logged in the vendor fixes' line with worker_caches. It is the device's
default for RX_VK_PCACHE_LOAD: pcache_load_off reads the switch first
(any value, as before) and falls back to the fix, so
RX_VK_PCACHE_LOAD=1 reads the files on MoltenVK as everywhere else. With
the fix on and the switch unset or off, pcache_files_unused holds:
- pcache_init reads neither the main file nor the play files and says
  so in the log; the cache lives in memory for the run;
- nothing is saved (pcache_no_save, as RX_VK_PCACHE_LOAD=0 already
  did), and play_cache_save writes no play file and keeps the
  generation in memory: unread play files would pile up, since they
  are compacted only where they are read;
- the stamp is left alone (pcache_drop_stale returns as for any
  start that does not read the files);
- precompile_run drops RX_VK_LOAD=create's longshot_pipelines.bin.built
  marker at each start, as it does when the files were dropped: no
  cache a later start reads holds the notes, so the warm builds them
  into the in-memory cache again before loads at create ask for them.

Saving does not continue on MoltenVK because nothing reads the file or
its stamp there:
- the prepared record (prepared_for) has its own file and stamp;
- --prepare-shaders' saved cache is useful only to a start that reads
  it;
- pcache_saved_now serves graphics pipeline libraries, which MoltenVK
  does not have;
- a start with RX_VK_PCACHE_LOAD=1 makes, saves and stamps its own.
Every other driver is unchanged, RX_VK_PCACHE_LOAD=0 there included
(main file unread and unsaved, play files still merged and written).

tests/test_vendor_fixes.py checks the two cache fixes on its 16 devices
and on MoltenVK: on for MoltenVK alone, RX_VK_WORKER_CACHES forcing
the first, vendor_fixes_env leaving pcache_no_load to the files'
switch. It also checks the log line and pcache_load_off's order.
tests/test_pcache_stamp.py runs pcache_load_off, pcache_files_unused,
pcache_drop_stale and pcache_init, cut from the source, in eight starts:
other drivers unset, 0, empty and 1 as before, and MoltenVK unset, 0,
off and 1. test_pipeline_play_cache gets an "unused" case. All three
fail on aa8ecba5. tests/test_warm_bounded.py's source check of the
marker's removal takes the new condition.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 61bfbf1ae7c0966a9436ab0c556a9ee547bb3b5f)

fix(vk, macos): the renderer's threads start with a 16 MiB stack, not macOS's 512 KiB ... b12bb343f9

macOS starts a std::thread with 512 KiB of stack, where Linux starts one
with 8 MiB and Windows with longshot.exe's 8 MiB. On macOS MoltenVK
converts each shader with SPIRV-Cross on the thread that creates the
pipeline, recursing once per block of a program's control flow, and a
prepare_run worker overran its 512 KiB there (CFG::walk_from under
vkCreateComputePipelines from seed_compute, start #6, 2026-11-14).

gpu/vk/thread_stack.h: thread_stack::thread is std::thread itself off
macOS; on macOS a std::thread-like thread (construction with decayed
arguments, joinable, join, detach, native_handle, moves) started by
pthread_create with thread_stack::kBytes (16 MiB) of stack. Every
thread the renderer starts goes through it: the preparation's pools
(prepare_run, state_list_prepare, warm_libraries, precompile_at_create,
precompile_run, predict_run, warm_bounded::run), the job workers and
the serial builder, the replay, parallel-replay, presenter and
frame-generation threads, the program cache's loaders and the rest.
mkwvk_init logs the size once per start on macOS.

tests/test_thread_stack.py: no file under gpu/vk starts a thread any
other way; each kind of thread runs a recursion 2 MiB deep through the
helper, and on macOS each overflows as a std::thread (caught, no crash
report). Seven source checks follow the new spelling.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 48b49054b1c64851b3e8c974e64dc0b757b2ced3)

test(macos): one overflow message from thread_stack_test, however many threads overflow at once ... dba268cdec

The first thread whose stack overflows says so and ends the process;
the others wait in their handlers, so the message is not interleaved.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 62d0991e0cfb5402202f8f14e9eb799d5c20d262)

test: the checks that compile renderer code with its threads see thread_stack.h ... 01ffd9a938

Eight checks cut renderer functions that start threads (or copy
vk_jobs.cpp and vk_recorder.h) into fixtures of their own; they now
build with gpu/vk/thread_stack.h beside them: test_capture_copy_helpers,
test_gpu_hang_watch, test_jobs_failure, test_jobs_wait_runs_queued,
test_pipeline_cache_save, test_prepare_stall, test_present_source_crop
and test_recorder_sync.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit fd46ff431f9f62b1125582a4a3434a8cc92c551e)

fix(macos): the worker caches follow main's fetch lock (#190) and Intel's gate (#252) ... eee107e2f1

Main's #190 (f41a5c59) put a fetch lock (PcacheFetch, PcacheUse) on the pipeline cache's save and compile path, the
very path where the worker caches add the lock their merges need, and #252 (57f4eaec) put Intel's compiler gate
(IntelDriverGate) around the compiles. The worker caches now sit on top of both:

- pcache_mu, the merge lock, is taken only where the worker caches are on (pcache_use_held: MoltenVK by default).
  Elsewhere create_cached, the save's fetch and pcache_saved_now take exactly #190's locks, as on main: no new lock
  on any other driver. A play generation's lock is likewise taken only where play's compiles are merged into it
  (g->alone).
- The worker caches are never on with the fetch lock (worker_caches_on: not with pcache_fetch_lock_on, Intel's
  Windows driver or RX_VK_PCACHE_FETCH_LOCK=1): a merge reads its caches' data as a fetch does, which that lock keeps
  apart from the builds there, and the gate lets one compile at a time into Intel's compiler there anyway.
- The order of the locks: Intel's gate, then pcache_mu, then the fetch lock. The save's fetch and pcache_saved_now
  take pcache_mu before PcacheFetch; a merge takes pcache_mu alone.
- prepare_run's compute warm keeps #252's gate around its compile and, with the caches, goes through create_cached
  under it (cached_compute would take the gate a second time).
- tests: test_worker_caches checks the gating (with the caches off a pipeline is made while pcache_mu or the
  generation's lock is held alone elsewhere; with them on it waits for pcache_mu), worker_caches_on against the
  fetch lock, the warm's gate and pcache_mu ahead of PcacheFetch in the save. test_pipeline_play_cache's route case
  checks that no lock of theirs is taken off MoltenVK; pipeline_play_cache_test.cpp and pipeline_cache_save_test.cpp
  get pcache_use_held stand-ins. test_pcache_stamp's load fixture follows #321's cache_path and #190's PcacheFetch in
  pcache_init, and play_cache_save's new parameters.
- docs: #321's cache/longshot_vk_pipelines.bin in the RX_VK_WORKER_CACHES row and in vk_vendor.h, and a row for
  RX_VK_PCACHE_LOAD, whose default this PR changes on MoltenVK.

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

merge(macos): the renderer threads' 16 MiB stacks (mac/thread-stack 7707c634) under the precompile hand-off ... c19fe5a59d

The precompile hand-off starts its workers and its compile watcher through thread_stack::thread. One conflict file,
gpu/vk/vk_draw.cpp (4 blocks: the lines P31 had to resolve against main, the other way round): the include block keeps prepare_workers.h,
worker_caches.h and thread_stack.h; prepare_run's, precompile_at_create's and precompile_run's thread lines take
thread_stack::thread and keep the worker caches' merges beside them.

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

fix(vk): MoltenVK: the precompile goes on behind the game; slow compiles named; a failed compile tried once more ... 3572ba843f

On the Mac's start 12 every precompile worker was held by a Metal compile of minutes while 37,600 of
42,234 items were still to hand out, so RX_VK_PRECOMPILE_STALL_S could not apply (it waits until every
item is handed out) and the title never came. With the new vendor fix compiler_service (MoltenVK only,
RX_VK_COMPILER_SERVICE):
- the precompile hands the rest to the game once nothing has finished for the stall time, or once all
  that is left is compiles running past RX_VK_SLOW_COMPILE_S; a quarter of the workers build the rest
  behind the game, every item still built, each straggler named when it ends;
- its order: noted pipelines first, then fallbacks and computes by SPIR-V words, what an earlier run
  found slow (longshot_pipelines.bin.slow) last;
- a compile over the slow time (10 s) is named with key, variant, kind, stage and SPIR-V words while it
  runs and when it ends, and written to the slow list;
- a pipeline whose compile failed is compiled once more with a new pipeline cache (MoltenVK keeps a
  failed library in the cache it was compiled with), and said made or not made.
Every other driver: the classic worker, wait and log line as they were.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 77d4971cbdb6356d9064a44cdee923f4bde354f9)

test(vk): test_precompile_handoff: a tree without the change says each missing piece ... 2817397924

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit f9a179c08d3f9e102729ec8fe5fe923336f581b8)

docs: RX_VK_PRECOMPILE_STALL_S, RX_VK_COMPILER_SERVICE and RX_VK_SLOW_COMPILE_S ... f218f4547a

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 194a230dd959706797203501edad3b5a2331118a)

fix(vk): name a graphics compile at its precompile callers, not inside build_graphics ... 81a94014fe

test_fallback_pipeline_state compiles build_graphics cut from the source; the noted pipelines of behind_worker and precompile_warm name what they build instead.

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 528784dc5c0c293da1b692f6fd71da070a940d8b)

fix(vk): the precompile hand-off on main's Intel gate and quick builds (#252), fetch lock (#190) and game folder (#321) ... 02cb2bc35f

The hand-off was written on the macOS integration branch, before main's #190 (f41a5c59), #252 (57f4eaec) and #321
(76699aad), and before the worker caches followed them (this branch's base). What it needs on main's code:

- cached_graphics and cached_compute keep #252's gate and main's `return create_cached(guarded_*_held, ci, pl);`, and go
  through create_watched only where compiles are watched (compiles_watched: compiler_service, MoltenVK's, or
  RX_VK_SLOW_COMPILE_S set). Every other driver makes its pipelines exactly as on main, and main's own source checks
  (test_intel_compiler_gate, test_pcache_fetch_lock) read the lines they read there.
- prepare_run's compute warm: with the worker caches and watched compiles through create_watched, under the gate it holds;
  otherwise P22's create_cached or main's guarded_compute_held, as they are.
- behind_worker, the precompile's worker under compiler_service, builds a compute pipeline as the classic worker now
  does (#252): on Intel's one-at-a-time builds (serial_builds_on) without the optimizer first, the optimized build owed
  to its first dispatch (precompile_compute_quick, optimize_owed). On MoltenVK, where compiler_service is on, that never
  applies unless RX_VK_COMPUTE_SERIAL=1; it keeps the two workers' builds the same.
- test_precompile_handoff's source checks follow main's spellings: the watched and plain lines in cached_* after the gate,
  compiles_watched, the warm, the dispatch's inline build named as main spells it (p, not the integration branch's plain),
  and behind_worker's quick build.
- docs: the slow list is cache/longshot_pipelines.bin.slow since #321 moved the notes into the game folder's cache/.

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

fix(vk): under compiler_service the preparation leaves the compute pipelines to the precompile ... 87723433a3

On the Mac's cold start 14, prepare_run's compute warm kept 13 of its 16 workers on compute compiles of
122k-209k SPIR-V words for 205-274 s each. The preparation reached 278 of 38,809 programs in 430 s, and the
precompile, whose hand-off lets the title start while such compiles go on behind it, never began.

With compiler_service (MoltenVK only) the warm compiles nothing. Each compute variant is still translated and
kept by seed_compute (program_cache_save), and the state list and the prepared record follow as before. The
precompile compiles the pipelines: every kept compute program on a first start (computes_plan), in its order
and with its hand-off; one it does not take is compiled at its first dispatch. Every other driver's warm is
unchanged.

tests/test_warm_handoff.py runs prepare_run's own decision and warm_compute against stand-ins on both arches,
and pins the source chain that keeps each variant for the precompile.

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 84c32d68c536468b61af24230ea8c283c5f091ef)

fix(vk): at most four giant compiles at once in the precompile under compiler_service ... 1872ac95c2

Start 14 had 13 compute compiles of 122k-209k SPIR-V words in flight at once while the other programs went
at 0.1-0.3 a second, and Metal's compiler service aborted twice (LLVM bad_alloc).

precompile_handoff.h Giants: at most RX_VK_GIANT_COMPILES (4) compiles of more than RX_VK_GIANT_WORDS
(100,000) SPIR-V words in flight at once among behind_worker's workers, before the game and behind it. A
giant claimed while the bound is reached is deferred, never dropped, and named once with a count; its
worker takes the next item, and the deferred ones are taken first once a giant ends. A worker with nothing
else waits for them and leaves only when none is deferred. behind_worker claims with claim_below, which
never passes the end, and a worker adds its one "ran out" to next as it leaves, so the wait's
next >= total + threads still means every worker has left. The classic worker (every other driver) is
unchanged.

The precompile_handoff fixture runs the gate with blocking giants: at most 2 of 6 in flight, the small
items going on meanwhile, each deferral named once with its count, every item built once, before the game
and behind it with the hand-off.

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit f1e028c8db05ef31383fa44c05fa156984c0f6c9)

docs: RX_VK_GIANT_COMPILES and RX_VK_GIANT_WORDS; the preparation's compute pipelines under compiler_service ... 70c2a1bf48

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 8aaa2f33d51b6b6f8db335cac69639137833537e)

fix(vk): giant compiles never hold every worker of a phase ... 918fffdc0e

The bound on giant compiles in flight is now min(RX_VK_GIANT_COMPILES, workers in the phase - 1), and at
least 1. Before the hand-off the phase is the precompile's workers (16 on an M4 Max: 4); at the hand-off
precompile_run sets it to the share behind the game (4 workers: 3), so one worker there always stays on the
smaller items. Giants already in flight over the new bound finish; no more start until they are under it.
RX_VK_GIANT_COMPILES=0 is still no bound. The order line, the hand-off line and each deferral line give the
bound in use; docs/development.md says so.

The precompile_handoff fixture gains a hand-off by the stall time with three giants (4 workers: 3) and a
stuck small item holding every worker and most of the list still to hand out: behind the game, on a share
of 2, one giant at a time and the other worker on the small items, every item built once. Plus limit_for
and phase.

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit acd3a71a2717b1e1bfc83c1952932fdcf1afd9de)

test(vk): test_warm_handoff follows main's warm and dispatch (#252, #190) ... 658b854052

The fixture cuts prepare_run's warm out of vk_draw.cpp. On main the warm builds
under Intel's compiler gate (#252 IntelDriverGate) through guarded_compute_held,
with the worker caches through create_cached (#190, PrepFast) or create_watched
where compiles are watched (PrecompileStall's compiles_watched). The fixture now
has stand-ins for those; without worker caches, as there, the warm still goes to
guarded_compute_held into pcache and is counted the same way.

The source check for a dispatch's build of an unmade compute pipeline reads
main's name for the dispatch's program, p (the topic's tree had a later
rename to plain).

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>

fix(vk): behind the game no giant compile starts before the first frame; the precompile's giants and its work behind the game below the game's QoS class ... 5b1b1d834c

Run 17 (MoltenVK 1.4.2, M4 Max): the game thread's first vkQueueSubmit2 waited about four minutes in
MVKCmdBufferImageCopy::encode. The AGX driver compiled a blit program variant for the copy synchronously
(findOrCreateBlitProgramVariant -> MTLCompilerScheduler::buildRequest -> MTLXPCCompilerConnection::tryBoost ->
dispatch_sync), and its request waited on one of Metal's 16 compiler connections behind a giant compute compile
that ended only when the compiler service, crashing under 16 of them, gave up on it.

Under compiler_service (MoltenVK) only:
- Giants::hold: from the hand-off, no compile of more than RX_VK_GIANT_WORDS starts until the game has shown
  RX_VK_GIANT_HOLD_PRESENTS frames (1), or RX_VK_GIANT_HOLD_S (120 s) at most; the ones in flight finish, the
  deferred ones go first after it. Nothing is dropped.
- RX_VK_COMPILE_QOS (utility): behind the game every run, and every giant before it, is built at QoS class
  utility; the rest, which the title waits for, at the thread's own (DEFAULT, the game threads' class).
  MoltenVK dispatches each Metal compile from the calling thread to the default global queue, whose QoS is a
  fallback only, so the request carries the worker's class.

The classic worker and every other driver are unchanged; compile_qos_apply does nothing off macOS.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 4f319a0d9a658d4205d52fe25be645443764ed75)

docs: RX_VK_GIANT_HOLD_PRESENTS, RX_VK_GIANT_HOLD_S and RX_VK_COMPILE_QOS ... 448d8e06d1

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 36e04c5eb85f15398ec3a82afdef7205bd37e304)

fix(vk): a giant compile that failed is tried once more alone, not at once among the other giants ... 40edc9da95

Runs 17 and 18 (MoltenVK 1.4.2, M4 Max): Metal's compiler service aborted 13 and 7 times on an LLVM
allocation failure while it held giant compute compiles, and each abort takes every compile of that
instance with it (up to 8). A giant that came back VK_ERROR_INITIALIZATION_FAILED was compiled again
at once, with a new pipeline cache, among the giants still in flight.

Under compiler_service (MoltenVK) only, in the precompile's behind_worker: a giant's failed compile is
only said (create_watched, Retry::Later); its worker gives its place back (Giants::solo_ask) and waits
until no other giant is in flight and none is held, while no giant starts (Giants::solo), then
compiles it once more with a new pipeline cache (Retry::Fresh) and says so. Its compute_state stays
claimed meanwhile; a stop cancels its turn. Every other compile, and every other driver, as before.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit b6069bbab0719980b61f26c6b1df469f989f930a)

fix(vk): a dispatch's compute pipeline that MoltenVK's compiler service failed is built, not left out for good ... d68a6f0582

With RX_VK_COMPILER_SERVICE (MoltenVK only), the precompile goes on behind the game with three or four giant compiles in flight,
and Metal's compiler service ended under 13 and 8 compiles in starts 17 and 18. A compute pipeline a dispatch's build could not
make was failed for good: program_pick never gave its program again, and every dispatch of it was left out.

- precompile_handoff.h Board: a compile a dispatch waits for is wanted from its push until it ends; while one is, the precompile
  starts no giant (Giants::share), deferred ones included; play's own compiles never wait on the giant bound.
- A build that failed while another giant compile was in flight is handed to compute_retry_alone: tried again on a thread of its
  own, once no giant compile is in flight and with none beginning beside it, at most RX_VK_ALONE_TRIES times (2). Its
  compute_state stays 1 meanwhile, so its dispatches are left out and counted as still compiling; one not made alone either is
  failed as before.
- RX_VK_SKIP_LOG=1: each dispatch left out named with its program key and why, once per key and reason (skip_log.h).
- tests/test_loading_stall.py with tests/loading_stall_test.cpp; seg_gathers_test.cpp takes the named skips.

Every other driver: no board call (each behind compiler_service_on()); RX_VK_SKIP_LOG off unless set.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 830c1a023812449db91b6436a3406ff58e5d24e6)

test: test_loading_stall: a tree without the build's retry is a failure said, not a stop ... c564f8c175

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 40683ae53e44ba5702f2229a1ddd62cb0cd92b90)

perf(vk): RX_VK_SKIP_LOG off works out nothing for a dispatch left out ... cb73a11691

SKIP_DISPATCH and the still-compiling skip ask skip_log_on() before they work out a key or reason (compute_code_key, the
retry's lock), so every driver's skip paths cost what they did before with the log off.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 8885591d407ece67a9511a4f908d0f4bbcdfa94e)

fix(vk): a dispatch's build lets play's want go by its own scope, its failed() as it was ... 6d5f0f66db

The build's failed() captured board_on to let the want go on a throw; test_jobs_failure runs each [job]() noexcept recovery as
it stands and found one missing. BuildWant now lets the want go when the build ends, by return or throw (before failed()
runs), unless a retry alone took it over; failed() is back to what it was.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 9e1a04021849d9acf945f35400cf87151ddeb0bd)

fix(vk): one place, one count and one wording for a failed compile's tries alone ... c8f31e1a0a

The semantic merge fix for Integration 28's TitleStall (b6069bba) and
LoadingStall (8885591d) inputs. Each brought a retry alone of its own:
the precompile's failed giant queued in Giants (solo_), play's failed
dispatch build waited on the Board, with two bounds (once; and
RX_VK_ALONE_TRIES, 2) and two wordings. Merged as they were (2c4a9231),
a giant that gave its place back for its try alone (Giants::solo_ask)
stayed counted on the board it shares, so Board::giants() never came
back to 0 and no try alone of play's ever ran after it (shown on a
2c4a9231 archive: board giants 1 after the solo, play's alone_begin
not run within 2 s), and the two could run at once.

Now, with the parent's rules:
- One place: Board's ticket queue (alone_ask/alone_go/alone_again/
  alone_cancel, alone_begin for play) is the only alone slot. Giants'
  solo calls go to the board it shares (a board of its own when it
  shares none); solo_ask ends its giant on the board too. Play's tries
  go ahead of the precompile's; the precompile's also waits for TitleStall's
  first-present hold and for every compile play wants. While any try is
  queued or runs, no precompile giant starts; a giant of play's waits
  for a running try, a small compile does not.
- One count: RX_VK_ALONE_TRIES (2) tries alone per program, the
  precompile's and play's together (Board::alone_left/alone_spend by key
  and variant); used up, neither path tries again, and one line says so
  once with its key (alone_used_up). The precompile's then leaves it to
  its first dispatch, as before; 0 turns both off.
- Every try alone uses a new pipeline cache from the start
  (Retry::Fresh), play's too.
- One wording from three functions (alone_asked, alone_tried,
  alone_used_up); the deferral line names a try alone apart from play's
  want.

New tests/test_retry_alone.py and tests/retry_alone_test.cpp cover the
combined rules; test_loading_stall.py's two source needles that pinned
compute_alone_tries() as play's bound now pin alone_left. Both lanes'
fixtures pass unchanged.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit d89514202b92e65d2ef27eac9e62dce8441e4207)

fix(vk): the dispatch's want and LoadingStall's checks follow main's build (#252) ... 6907e8fda8

Main's dispatch build has Intel's worker path (#252: on_worker, made_how,
the quick first build and compute_optimize), which returns early when a
worker of Intel's compiler gate makes the pipeline. BuildWant now opens the
build, so play's want on the compile board is let go on those returns too,
not only on the ones after the compile. (On the Mac on_worker is never set:
the gate is Intel's; the scope makes the rule hold by construction.)

test_loading_stall follows main's code: the build's capture list, the serial
push with main's third argument, the dispatch's program named p (the topic's
tree had a later rename to plain), the order check against the build's own
last compute_state store (main's worker path stores above it), and the
named skips counted against main's dispatch (8; the segmented binding, not on
main, brings five more).

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>

test(vk): test_intel_quick_compute reads the dispatch's build with the compile board's capture ... 9260653dc8

Main's check (#252) finds the dispatch's build by its capture list. The build
now also captures board_on (the compile board, compiler_service only), so the
check looks for that list; what it checks inside the build is unchanged.

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>

feat(vk): read the Mac's system memory for the renderer (gpu/vk/system_memory.h) ... 00effdf7cb

Header-only, no Vulkan: the kernel's memory pressure level (kern.memorystatus_vm_pressure_level: 1
normal, 2 warning, 4 critical), the memory available without compressing or swapping anyone's pages
((vm.page_free_count + vm.page_pageable_external_count + vm.page_purgeable_count) * vm.pagesize, the
builder gate's estimate in nx2/darwin_memory.py), physical memory, swap and this process's footprint
(TASK_VM_INFO phys_footprint). The counts are in the kernel's pages: vm.pagesize, not hw.pagesize,
which is 4096 under Rosetta on an Apple silicon Mac. Read on macOS only; known is false elsewhere.

For the giant compile gate behind the game and the device-loss lines (macos/giant-mem-gate), and the
GPU budget work (macos/gpu-budget). Its checks are in tests/giant_memory_test.cpp on
macos/giant-mem-gate.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 41b04c1982f0ec40a97a1763d1c6fac46a16de3e)
(cherry picked from commit 96266f6502855309d918528e7b5c5a96d818684e)

fix(macos): on unified memory the GPU's allowance is what the Mac's RAM leaves, not Metal's working set ... de19681124

MoltenVK 1.4.2 gives Apple silicon one device-local heap the size of RAM and, through VK_EXT_memory_budget, Metal's
recommendedMaxWorkingSetSize as its budget: 53,084 MB of a 64 GB Mac, whatever else holds the RAM. Every rule that
gives memory back near the allowance (the textures' budget, the render targets' pool, the compaction) waited for that,
while the process's own CPU memory and the rest of the Mac took the same RAM. Run 22 reached 53.1 GB of GPU memory 24 s
into the save's load, wired 58 of 64 GB, critical pressure, and Metal aborted a command buffer for want of memory.

On unified memory (every heap device-local, a host-visible coherent type: unified_budget.h, Apple only) vram_usage now
answers the least of the driver's allowance; RAM less the process's CPU memory (footprint less the GPU's count) less a
reserve for the rest of the Mac (a quarter of RAM, 8 GB at least); and what the GPU holds plus what the system has
available less a headroom kept available (an eighth of RAM, 2 GB at least), read through system_memory.h at most every
100 ms. Past 90% of it the spare capture buffers are given back and not made ahead, and idle staging arenas are not
kept: each is made again when needed. A "vk: unified memory" line says the allowance and what holds the GPU's memory
(the renderer's VMA blocks, or Metal's and MoltenVK's own) on the first read and whenever either moves by 1 GB, at most
once a second; the textures' frame asks again every present (at most every 250 ms). RX_VK_UNIFIED_BUDGET=0: the
driver's allowance, as before. Every change is inside #if defined(__APPLE__); tests/test_unified_budget.py checks
that, and runs the rule with made-up heaps and RAM sizes and run 22's numbers.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit efabae733d40fd39bdff727b14cc998c2b56cd24)

fix(macos): vk_work.h stays vk_vma.cpp's last include ... f874e4ea01

The unified budget's Apple includes went after it; tests/test_recorder_sync.py requires vk_work.h last (RX_VK_RECORDER=defer
drains before the destructions below it).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit f23c9194a466c44259acf36817a249d586260c24)

fix(macos): the unified budget reads the system's memory at its first ask ... ec2573f343

Run 23 (552cc3d4) printed "the system's memory unread" on all 11 "vk: unified memory" lines and kept the driver's 53,084 MB
allowance. The system-memory read and the presents' watch were gated by now - last with last starting at INT64_MIN:
steady_clock counts from boot, so now - INT64_MIN overflowed (undefined; built, a large negative number), the gates never
opened, unified_sys.known stayed false and unified_budget::compute returned the driver's allowance. The reader itself works
in the sandbox (the giant gate's line in the same run read it).

unified_budget::Gate opens at its first ask whatever the clock reads, then at most every kReadMs (100) or kWatchMs (250);
a clock that went back opens it too. tests/unified_budget_test.cpp shows the old sum shut for good and the Gate's
openings; tests/test_unified_budget.py requires both Gates and refuses INT64_MIN or the old subtractions in vk_vma.cpp
(it fails on f23c9194).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 7009f858d1333c2ec72cc70e7d18b81c5f948b1d)

docs(macos): RX_VK_UNIFIED_BUDGET in the switch table ... ce758a263b

The unified-memory budget's off switch was named only in gpu/vk/VULKAN.md. docs/development.md's "Switches for
testing and debugging" now has its row beside RX_VK_VRAM_MB: what it turns off, the default rule and the log line.

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

merge(macos): the Mac's system memory reader (mac/gpu-budget 263e462d) under the giant compiles' memory gate ... b5016895f8

gpu/vk/system_memory.h (1326bfac, the cherry-pick of 41b04c19) comes with the
unified budget it was made for; the gate after this merge reads the same
header.

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>

fix(vk): behind the game, giant compiles wait for memory; a lost device on the Mac is said as one ... 96124f03c0

Run 21 left the title from a save with three giant compiles in flight behind the game. Each compiler
service compiling giants reached 12.7-15.1 GB; the Mac went to critical memory pressure (1% free, swap
+14 GB in 15 s), Metal aborted a command buffer for want of memory and the device was lost.

Giant compiles (MoltenVK's compiler_service only, from the hand-off on):
- a giant starts behind the game only while the kernel's memory pressure is normal and one giant's
  room is available (free + file-backed + purgeable pages; RX_VK_GIANT_ROOM_MB, unset a quarter of
  memory, 16384 MB at most, 0 off); the ones in flight finish, none is dropped: a deferred one starts
  once memory is back, or where it is first needed; a try alone waits the same way;
- no more giants in flight at once than fit beside the game's footprint in physical memory (run 21's
  36121 MB of 65536: one, not three);
- play's own giant compile waits while the pressure is critical (not at warning), still ahead of
  every giant of the precompile's;
- each pause and resume said once with the pressure level and available MB.

Device loss (log only on every platform; what changes behaviour is Apple-gated):
- a wait that comes back VK_ERROR_DEVICE_LOST is said as such, not as "timed out (done 0)"; on the Mac
  it ends the process there (device_lost), elsewhere the next submit or the hang watch does, as before;
- on the Mac, device_lost says the system memory and waits 200 ms so MoltenVK's own
  "[mvk-error] ... execution failed (code N)" line is written before the end;
- on the Mac, the slow submit and slow frame lines end with the system memory.

The Mac's memory is read through gpu/vk/system_memory.h (41b04c19, its own commit).
tests/test_giant_memory.py.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 230dde4c0498a7e4483107ed274ad965559c8fa8)

docs: RX_VK_GIANT_ROOM_MB in the switch table ... ea44f6d795

The giant compiles' memory gate reads RX_VK_GIANT_ROOM_MB (its room per giant,
a quarter of physical memory and 16384 MB at most unset, 0 for no gate), which
the topic did not document.

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>

fix(macos): the lost wait's line and end on the Mac only; vk_replay.cpp as it was elsewhere ... 4d16d199ec

The topic said a timeline wait that comes back VK_ERROR_DEVICE_LOST as a lost
device on every platform (and returned without the "timed out" line). Every
platform's part is its own change (fix/lost-wait-said, on main). Here the
waits keep their text off the Mac: wait_lost(r, what, v) is Apple-only and ends
the process at the lost wait (device_lost), as before on the Mac; the result
kept for the recordings' wait (wait_rec_result) and the early return it fed
are gone (on the Mac device_lost never returns there). system_memory.h is
included, device_lost's report and the slow frame line are changed, on the Mac
only. Off the Mac vk_replay.cpp is the text it was (unifdef -U__APPLE__:
tokens equal; one comment longer).

test_giant_memory: the waits fixture expects the Mac's line and end on the Mac
and the old lines elsewhere; source checks for every other platform's text.

Assisted-by: Claude Opus 5.5

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Merge mac/fault-contexts (#436) into mac/guest-16k ... fc1857fc3b

This PR needs the macOS fault-context PR (#436); its commits are kept as they are.
The one conflict, host/posix/win32_posix.c's Apple include block, keeps both
darwin_mem.h (the guest-memory PR's) and darwin_fault.h (#436's).

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

feat(vk): plan where an oversize guest span is cut into import segments ... 697a993cbd

A connected guest span that the views of one operation need can be larger than
one device allocation (41,747,087,360 bytes on MoltenVK 1.4.2, M4 Max). It is
then imported as disjoint, adjacent segments of at most the cap.
gpu/vk/span_segments.h (rules only, no Vulkan) chooses the cuts: multiples of
the import granularity, the fewest segments, the least cost of the views a cut
splits (gathers by their bytes, then uniform, texel and storage buffers), a
cost for moving a previous cut, and the lowest addresses on ties. It maps any
guest range onto the segments, and splits a texel view at cuts and at
maxTexelBufferElements, reporting 12-byte seams. Invalid input gets an
explicit refusal. Nothing uses it yet: vk_memory.cpp takes it later.

tests/test_span_segments.py checks it against brute force at caps of 48 KiB,
64 KiB, 96 KiB and 1 MiB with 16 KiB granularity, plus the 48 GiB example, the
512 GiB guest window and the top of the u64 range (--arch arm64 / x86_64 on
macOS).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 11e53b66ffbdddd0cfeaa7a043361a337299d855)

fix(macos): serialize guest backing and native-page watch lifetimes ... cf1f48feb2

Keep address-region and page frees owned until discard or in-place zeroing
finishes. Route guest mutations from each image to one executable-owned
registry, and pin complete imported backing through duplicate and overlapping
GPU memory lifetimes without querying the renderer under ownership locks.

Use real Mach query ranges and protections, preserve byte-exact 4 KiB guest
ownership and 64 KiB commit semantics, and handle all native watch subpages
with checked fault recovery and conservative dirty coverage. Replace racy
bulk dirty-byte reads with same-granule atomics.

Add game-free native arm64/Rosetta fixtures for two-image dispatch, actual
faults, aliases, failures, and deterministic free/reallocate/import races.
Carry prior RSS evidence rather than repeat unchanged experiments.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>

feat(vk): let the segment planner add segments that pay for themselves ... aae09e20f7

With the fewest segments, a large gathered view can be cut on every draw
although one more segment would keep it whole: a 32 GiB index extent at
[8, 40) GiB in a 48 GiB domain at the 41,747,087,360-byte cap is split by
every two-segment cut list. plan() now weighs any number of segments, each
one beyond the fewest at Weights::segment (2^32 bytes-equivalent, above a
move), and returns the least cost, then the fewest segments, then the lowest
cuts. Every cut of that plan is a mark (the first multiple of g at or above a
demand's end, or a previous cut) or ceil(next cut - cap), so the search runs
over those candidates and is exact over [k_min, k_min + min(marks,
C0 / segment)]; a least plan over 4096 segments is refused. Plan::extra
reports the added segments.

The test brute-forces the same range of segment counts, checks a DP over
every count, and adds the 32 GiB extent (three segments, nothing gathered).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 189d0636cb5e90e0d98de397d0b9676a5f8354c2)

fix(macos): retain pending watch faults across protection changes ... 79d253120a

Keep a cancelled-writable watch state so an already pending diagnostic fault
is acknowledged without rearming or changing permissions. Check the real
mapping before acknowledgement; intentional read-only/no-access stays closed.

Freeze affected watch pages once, preflight the complete native range against
Mach maximum permissions, and issue one protection operation. Preserve prior
watch states when either preflight or the native operation fails.

Exercise the real Win32 vectored dispatcher, signal-handler retention and the
next genuine watch fault. Cover permission failures both before preflight and
after a deterministic barrier, with real Mach maximum-protection changes and
no manufactured VM results, on native arm64 and Rosetta.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>

fix(macos): make the guest-memory changes Apple-only; Windows and Linux keep main's code ... 10d05689a1

The two commits before this one also changed Windows and Linux: the
dirty-page scan read its marks with byte atomics, the renderer's zeroed
guest memory was marked written, an empty range consumed no mark,
allocation failures in the scan and in the address-region bookkeeping
were fatal, hos_region_alloc refused a bad size or alignment,
hos_mark_written clamped its length, and VirtualQuery checked its
pointer and set last_error. Nobody has timed the scan there, so each of
these is now inside #if defined(__APPLE__), with main's code in the
#else. unifdef -U__APPLE__ of every host/ file this branch changes
equals main's byte for byte, and so do their preprocessed Linux and
Windows token streams. Issue #432 is the version for every platform.

test_collect_wide's fixture compiles the scan the platform builds: byte
atomics, and an empty range consuming nothing, on macOS; main's word
loads elsewhere.

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

docs(macos): describe the guest window's one owner, import pins and native-page watches ... fceb934f11

The guest-memory section still described the groundwork alone: it said
the write watch and VirtualQuery were separate work and that the
region allocator's unlock-before-discard race remained. Describe the
executable's single owner and how each image reaches it, frees that
keep their range until the bytes are gone, import pins, the real
VirtualQuery and VirtualProtect, the native-page watch and the atomic
dirty scan, that all of it is macOS only (issue #432), and the test's
two narrower modes.

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

fix(vk): scan the import table as far back as its largest live import ... e37808fba1

Every scan down vk_memory.cpp's import table by start (pool_lookup's
covering import and merge plan, bg_drain, prefetch_chunks,
import_in_background, memory_note_gpu_write and memory_guest_imported)
stopped once an import ended more than 1 GiB below its address, on the
belief that no import is larger than that. pool_lookup's own merge escape
leaves an import above 1 GiB over the smaller ones inside it ("left
overlapping"), and the device allows imports up to max_import_size: a scan
stopped at a small import inside a large one, missed the large one, and
the same bytes were imported again, two memories over the same bytes.

import_reach.h counts the live imports by span class; its bound is above
every live span, within twice the largest. imported_add and imported_take,
now the table's only ways in and out, keep the count. A scan stops only
where no import further down can reach its address, so it also stops
sooner than before when the imports are small. The covering-import checks
in pool_lookup and import_in_background look past the last import at or
below the range for the same reason.

Tests: test_import_reach.py runs the actual scans with a 4 GiB import over
a 16 MiB chunk, left by the merge escape (imports are recorded ranges: no
payload, no Vulkan, no game). Its lookup, query, note, drain, background
and prefetch cases fail on main 5e072fc8 and pass here, and a source check
keeps every change to the table in the two helpers. test_import_windows
runs pool_lookup with the helpers; test_mirror_gpu_only names the new
publication point.

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

test(vk): the readback refresh fixture runs memory_note_gpu_write with the import table's helpers ... 639ab978be

test_parallel_rb_refresh cuts memory_note_gpu_write out of vk_memory.cpp,
whose scan now stops at the live imports' reach: the fixture includes
import_reach.h, cuts live_reach, imported_add and imported_take beside it,
and puts its pool in the table through imported_add. It failed to build
at 11e9ee44 ("use of undeclared identifier 'import_reach'").

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

feat(vk): descriptors bound as pieces in the SPIR-V back end and program variants ... 68a6ea49c7

A guest span larger than one device allocation (the cap on MoltenVK/M4 Max is 41,747,087,360 bytes) is bound as
pieces: one descriptor per allocation segment, at the descriptor's own binding (reports/2026-11-14-full-range-design.md
sections 4.1-4.4). This is the shader half; the draw side (descriptors, layout, gathers) comes later.

- runtime_info.h: SegEntry {Storage|Table|TexBuf|ImgBuf, desc, pieces} and RuntimeInfo::segmented.
- Back end: a segmented storage buffer is an array of pieces at its binding (a table count * pieces, entry k's piece j
  at k * pieces + j); its loads, stores and atomics call DontInline helpers made after main, which find the piece by
  the pieces' OpArrayLength in order, with constant indices. The global memory fallbacks sum the pieces' lengths for a
  segmented descriptor's bound end and branch to its piece (single, native candidate, table written out and in the
  loop). Texel and image buffers are arrays too, their fetches, reads, writes and atomics through helpers that pick
  the piece by OpImageQuerySize, and a texel buffer's size query sums the pieces. ImageQuery was declared for every
  module already. With RuntimeInfo::segmented empty nothing new is made: the SPIR-V is byte-identical.
- vk_shader: SegSig (entries, hash) on Program, seg_sig and seg_variant; program_segmented finds or translates the
  variant of a plain program with plain's texture questions and answers and checks its descriptors are plain's;
  program_pick, mesh_program_locked, program_find_plain, loaded_variants and portable_variant keep the plain and
  segmented variants apart; every stage's RuntimeInfo::segmented comes from Program::seg.
- vk_progcache: a segmented variant is never written to the program cache nor listed among the loaded programs.
- tests/test_seg_shader.py + tests/seg_shader_ir.cpp: synthetic IR programs through the real back end, plain and
  segmented; structure checks, spirv-val (Vulkan 1.3, uniform buffer standard layout), and with --base-tree a byte
  comparison of the plain modules against an older tree. Five source-reading checks follow the new Program field and
  the atomics' new branch.

The translator stamp changes with this (eden/, vk_shader.cpp, sizeof(Program)): every program cache is rebuilt once.
Land it in the same release as the vk_api.h change that already does so.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit b7928876dab846485f667c1c934d34d25ecef035)

fix(vk): MslArrayPtr: no pointer into a storage buffer array is passed to a function ... 407a0cfc93

On MoltenVK a segmented storage program with a compare-exchange loop (an
increment, decrement or float add the device does not have) failed pipeline
creation: NullProbe revision 02's NS2, "no matching function for call",
&ssbo0_4[0u] given to a device _66 * parameter. SPIRV-Cross's MSL (6c09849f,
MoltenVK 1.4.2) passes a storage buffer pointer to a function by value, and
takes the address of the argument's expression: for an element of a buffer
array, which MSL holds as an array of pointers, that is the address of the
pointer (reports/2026-11-14-msl-arrayptr.md).

A descriptor bound as pieces now has its loops written out in the piece,
inside the segmented helper (CasLoopHere, CasStoreHere: CasLoop's loop,
attempt for attempt, its variables made first in the helper), instead of
calling the CasLoop function or write_storage_cas_loop_func with a pointer
into the pieces' array. Every other program is as before byte for byte.

Tests: test_seg_shader.py checks that no module passes a pointer into a
buffer descriptor array to a function. The two checks that cut the back
end's source follow the new loop and parameter.

Ported from macos/msl-arrayptr, where it was committed on NullShader, to the
pieces alone: here every storage access that reaches a segmented helper is
in pieces, so the loops are always written out. Left for the NullShader
change: the bound-whole branch that still calls the function with its
block, the guarded helper's cas_loop, and the tests that need NullShader or
tests/spirv_run.h (the CPU runs of the loops and of a storage buffer table,
--changed-segmented and the *.cpurun comparison).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit bd396010887afab9520181009db1b56a4cc425e3)

feat(vk): texel codecs in the SPIR-V back end and program variants ... b78e421a97

A texel buffer whose format the GPU gives no texel buffer view (MoltenVK 1.4.2 on Apple GPUs: R32G32B32_SFLOAT, the
R8G8B8 formats and the 16-bit packed ones) is read and written through an R8, R16 or R32 UINT view of the same bytes,
with the format's decode and encode in the shader (reports/2026-11-14-texel-formats-design.md section 4).

- Back end: RuntimeInfo::texel_codecs (TexelEntry: a texture or image buffer descriptor and its Shader::TexelCodec),
  honoured with Profile::support_texel_codecs only. Carrier images, per-codec decode and encode functions of integer
  operations alone (normalized components through tables of the exact floats, writes rounded to nearest even from the
  float's bits), whole-texel bounds (reads past the last texel 0, writes dropped, the size the elements over k), an
  integer format's own view read as U32 or S32 texels, and composition with the segmented piece arrays (the helpers
  take each descriptor's own image type). Typed storage accesses and atomics keep the view of their declared format:
  a codec there is refused. With no codec the SPIR-V is byte for byte as before.
- Renderer: gpu/vk/texel_codec.h, the plan shared by the variants and (next) the views; texel_codecs_on (macOS, from
  the format query, RX_VK_TEXEL_CODECS); each texel buffer's codec a variant answer (desc | Program::kTexelAnswer, so
  the program cache and the pipeline state list carry it as they are), checked by still_valid; "txcd" in the
  translator stamp when on; program cache format 2.
- Tests: tests/seg_shader_ir.cpp and tests/spirv_run.h emit every codec plain and in pieces, validate it, run its
  decode and encode on the CPU against reference conversions (every input of the 8- and 16-bit formats, random and
  boundary sets for 32-bit) and run its entry point over texel buffers in memory; the GPU probe's codec module.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 783eb1898b91d505ff22a31f337256c5047d0177)

fix(macos): a window without Vulkan extensions ends as a clean exit, as main's exit inventory asks ... f270209f99

Main's #75 classifies every host process exit (test_crash_record's
inventory, read from the source on every platform): a normal exit marks
the clean end first, a fatal one is listed as fatal. The macOS
ExitProcess(1) after hos_darwin_vulkan_capture() fails is the same kind
of exit as the SDL_CreateWindow failure just above it (a message, then
the end), so it marks the clean end the same way, and the inventory
lists display_sdl.c's second ExitProcess(1). Windows and Linux compile
the same code as before (the exit is inside #if defined(__APPLE__)).

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

Merge mac/vk-admission (#438) into mac/renderer-correctness ... 621f3762bf

Carries the vk-admission pull request's commits, which this one needs
(MkwVkHost's Apple callbacks, darwin_vulkan.h), on top of guest-16k.
host/posix/win32_posix.c: its Apple include block keeps darwin_mem.h,
darwin_fault.h and darwin_vulkan.h.

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

fix(macos): pin renderer imports through final resource ownership ... 60b3d083be

Append Apple23 full-backing import lifetime callbacks while preserving the
non-Apple21 layout. Keep buffer views move-only, release buffers before the
last memory owner unpins backing, and preserve completion-gated retirement.
Unpublished failures unwind; published roots retain process lifetime rather
than calling Vulkan from unsafe static teardown.

Check and unwind post-device startup allocations. Resolve the shared audio
shim through the executable-owned SDL service on Darwin without unresolved
weak imports or linker relaxation. Retain the existing loader/SDL behavior.

Add game-free owner, ABI, source-topology and strict-link consumers, including
both native arm64 and x86_64 routes. This slice does not claim to fix separate
host-import alias visibility or implement the final alias admission planner.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>

test(macos): cut the non-Apple Pool and import route in three more fixtures ... dcd47c89ee

044635ea gave vk_memory.cpp's Pool an Apple-only DarwinImportView member and
import_pool an Apple route (darwin_import_pool) right after its guards. It
moved test_import_buffer_binding and test_texel_buffer_ownership onto the
Windows/Linux layout (#if defined(__APPLE__) -> #if 0: the Apple owner has
its own darwin_import_lifetime_test), but three more fixtures cut the same
code and stopped compiling on macOS. Each passes at 58c5c5aa (044635ea's
parent) and fails at 044635ea:

- test_direct_buffer_writes and test_parallel_rb_refresh: their cut of
  struct Pool named DarwinImportView. They now cut Pool's Windows/Linux
  layout, the same one they compiled before.
- nx2/test_import_windows: its cut of import_pool's guards, which ends at
  the import, took in the unterminated Apple #if. It now ends at the Apple
  route, which must stay one #if just before the import; the fixture's own
  continuation models the Windows/Linux import as before.

No assertion, case or check is removed or loosened. test_parallel_rb_refresh
and test_import_windows also need the renderer-core extractions (next).

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

fix(vk): drain the recorder before startup rollback destroys the allocator ... e072777e3e

044635ea added vma_startup_rollback (vk_vma.cpp, run after a failed
replay_start), which calls vmaDestroyAllocator. vk_vma.cpp includes
vk_work.h last so that RX_VK_RECORDER=defer/thread drains before its
destructions, and every such boundary call in a vk_work.h file must be in
RX_REC_BOUNDARIES with a drain-first macro. This one was not, and
test_recorder_sync caught it ("vk_vma.cpp calls ['vmaDestroyAllocator'],
which vk_work.h does not drain before"): it passes at 58c5c5aa (044635ea's
parent) and fails at 044635ea.

Add it to the list and to vk_work.h, next to vmaDestroyBuffer and
vmaDestroyImage. With the recorder off (the default) boundary() is a
relaxed load and a branch. Rollback runs before any image or buffer exists,
so nothing should be held there today, but the allocator is no longer
destroyed while a recorder could still hold packets. The test is unchanged
(sources: 42 boundaries drained, was 41).

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

test(macos): follow main's #324 and #250 in the Darwin renderer fixture ... 8fa0934f6a

tests/test_darwin_renderer.py cuts vk_memory.cpp's code into
darwin_import_lifetime_test.cpp. Two of main's changes since this
branch's first base broke that cut on the rebase, before any check ran:

- #324 reworded the comment after imports_give_back's drain of the
  evicted pools ("(longshot) Off by default on Windows ..." is now
  "(longshot) Default by OS and vendor ..."). The cut ends at that
  comment, so it now looks for the new words. The cut code is the same
  drain loop as before.
- #250 (sparse mirrors) made retire_pool erase a retired pool from
  sparse_wanted. The fixture's stand-ins gain an empty sparse_wanted,
  beside mirror_wanted, as main declares it (std::vector<Pool*>).

No assertion, case or expected output changes.

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

test(vk): follow the moved Pool in test_mirror_gpu_only's cut ... b73b1501c7

107fda29 moves the new pool into the import table
(imported.emplace(p.lo, std::move(p))) instead of copying it.
tests/test_mirror_gpu_only.py ends its cut of pool_lookup's merge at
"imported.emplace(p.lo, p)", so it stopped with "substring not found"
(full-suite receipt full-91f9a58d: the only check that passes on main
and fails here). It now ends at the moved form. The check is the same:
the merged pool must take in the gpu_only and gpu_written marks of the
pools it absorbs before it goes into the table.

On the macOS integration branch this was hidden: renderer-core's
53b8914d rewrote the same line for its imported_add. When that pull
request rebases onto this one, its line replaces this one.

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

fix(macos): the import pin callbacks are macOS host API version 24 ... 5a831dca0a

Main's custom output size (#51) took MKWVK_API_VERSION 22 everywhere, so
the macOS loader callbacks (#438) became version 23 after take_text, and
this branch's guest_import_pin and guest_import_unpin, appended after
them, become version 24. The Apple table is now 392 bytes with the four
callbacks at 360, 368, 376 and 384; the admission contract and the
renderer startup fixture pin exactly that. Windows and Linux stay at 22.

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

fix(macos): vk_memory.cpp compiles on macOS: #324's evicted_pools declaration is not Apple's ... f66d0a87b8

Main's #324 (a4c77174) declares `extern std::deque<…> evicted_pools;` above
memory_guest_imported, which reads it on Windows and Linux. This branch
defines evicted_pools on macOS as a process-owned reference
(`auto& evicted_pools = *new std::deque<…>;`), so after the rebase onto
6c9edffe vk_memory.cpp did not compile for macOS ("redefinition of
'evicted_pools' with a different type"). The game-free fixtures cut the
functions out and never compile the whole file, so they did not see it.

The declaration is now for Windows and Linux only: on macOS
memory_guest_imported answers through darwin_guest_imported, which comes after
the definition. Windows and Linux compile the same text as before.

First made on mac/renderer-core, where this branch is merged.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 444e05c119a261b36c7c762abf9d26194b0ee417)

Merge mac/renderer-correctness (#491) into mac/renderer-core a58333bb9f

Merge fix/import-lookback (#431) into mac/renderer-core ... c6d49c67dd

# Conflicts:
#	gpu/vk/vk_memory.cpp
#	tests/test_mirror_gpu_only.py
#	tests/test_parallel_rb_refresh.py

fix(vk): join #431's import table helpers with #491's macOS Pool ... 118a66f2e7

#431 (fix/import-lookback) makes imported_add and imported_take the import
table's only ways in and out. #491 (mac/renderer-correctness) gives the
macOS Pool an import view (DarwinImportView) that owns the imported memory
and cannot be copied, defines the table on macOS as a process-owned map,
and releases imports through destroy_import. Merged, they do not build or
test on macOS:

- imported_add took a const Pool& and copied it. It now takes Pool&& and
  moves it into the table (the macOS stack's form, 53b8914d). Its callers
  already move (the merge kept #491's moves); the fixtures that call it with
  a local pool move it, or a copy where they read the pool afterwards
  (nx2/test_import_windows.py). Windows and Linux insert the same Pool at
  the same key: a move in place of a copy.
- test_import_reach.py cut the Pool and the scans with their Apple guards,
  so on macOS the fixture met DarwinImportView. It now resolves the Apple
  guards to the other side (test_vk_darwin_admission.py's select, as
  test_darwin_renderer.py does; the macOS route is that test's), cuts
  destroy_import where the source has it, and its source check does not
  count macOS's definition of the table as a change to it.
- test_darwin_renderer.py's Darwin fixture cuts live_reach, imported_add and
  imported_take (darwin_import_lifetime_test.cpp includes import_reach.h),
  and its queue-slot order check finds imported_take where the source has it.

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

fix(macos): import NOACCESS guest pages and name a missing audio service ... 01aad9ff48

RendererSliceReview findings on 044635ea, forwarded by the parent.

darwin_import_commit refused a whole import when any page in its range was
committed but NOACCESS. Darwin's VirtualQuery reports the demand-paged guest
window committed with each page's own protection, so an explicit NOACCESS or
a diagnostic watch page dropped every binding in that range to zeros, where
the pre-pin path tried the import and let the driver's VkResult decide. The
CPU protection of a committed page is CPU-side state: such pages are now left
exactly as they are and the import proceeds; only an unmapped page or a failed
query refuses. Whether MoltenVK/Metal imports a NOACCESS host range is left to
its own result; a GPU arm for the parent-released probe settles it.

waveOutOpen on macOS returned MMSYSERR_ERROR without a word when the
executable provides no hos_posix_audio_open. The lookup now names the missing
service once, on stderr; nothing else changes.

Tests: darwin_import_lifetime_test.cpp imports a range with a committed
NOACCESS page (no commit, no reprotection); test_darwin_audio_service.py
counts the line: once with the provider missing, never with it present. Both
fail on an archived 73f90266.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 9e3832639a33e22dc8672e80a64354eb729c4c48)

feat(vk): admit an operation's guest buffers before it binds them (alias isolation, macOS) ... 1bcfec58cb

Two host imports of the same bytes read stale data within one submission on MoltenVK. Under alias
isolation (set in memory_init on Apple only) every operation's guest buffers are admitted before it
binds the first, and no import is replaced while recorded work may still reach it:

- Seam: memory_admit / replay_admit on the replay thread (replay_mu, no parallel worker): draw()
  (mesh records, then its buffers once the pipeline is known), dispatch() (the upscale stand-in, then
  its buffers), the replay's signal, buffer copy, fill and uniform update, the textures of every
  copy and clear, and copy_b2t's buffer side once its texture is resolved.
- Resolver: one side-effect-free description of what each binding path binds, from the binders' own
  helpers (uniform_bind_size, storage_binding, texel_buffer_extent, buffer_extent, the *_bytes
  helpers), including the GPU unswizzle's source (texture_unswizzle_source), the temporal
  upscaler's actor motion (temporal_actor_demands) and the diagnostic readers' copies
  (RX_VK_DRAW_STATS, RX_VK_DUMP). tests/test_resolver_coverage.py holds every gpu_buffer_bind /
  gpu_buffer call site of the renderer to its resolver demand and its seam.
- Covering reuse: a range a live import holds needs nothing; on Apple a range inside a live import's
  backing becomes a new view on that memory. Backing extents count for alias conflicts.
- Handoff: end the pass, flush the uniform updates before this place, device-to-host barrier,
  submit, wait, then import (old memories retired and kept to completion, page-table changes
  deferred), host-to-device barrier.
- Cohorts: different operations whose union passes the cap get one memory each, with a handoff.
- Under batch admission the dry pass's view-making marks are skipped (its command buffer is then
  recorded in order); RX_VK_POOL_END_IMPORTED is ignored under alias isolation (it imported to
  answer a resolver's question).

Off alias isolation (Windows, Linux) nothing of this runs and every binding path is unchanged.

Tests: test_alias_admission, test_admission_handoff, test_resolver_coverage (new); the Apple
spare-backing reuse and backing-overlap cases in darwin_import_lifetime_test; extractions of
test_import_chunk_default, test_fallback_depth_hold, test_vulkan_copy_span(_gpu_compile),
test_draw_side_effects and test_vk_occlusion_queries follow the moved code, every assertion kept
(the last two also check the admission seam). test_import_reach.py's main() call is restored: the
53b8914d copy ran nothing.

Published on main 6c9edffe with #491 and #431 below it (mac/renderer-core):
- actor_reads binds main's index bytes (count << itype) for every index
  type, as main's actor_motion does. The macOS stack's copy bound nothing
  for an index type outside 0..2, which would change Windows and Linux too;
  such a draw does not reach actor_motion (bones_used refuses it when the
  draw is noted) unless its model key matches a draw of another index type,
  so that guard is left out of this macOS PR.
- vk_temporal.cpp: #59 (actor motion pairs copies by place) copies a pose
  read at its draw from the stage; the copy from the game's memory, its
  else branch, binds through actor_reads.
- vk_memory.cpp imports_give_back keeps #324's retire grace beside alias_ref.
- test_import_reach.py keeps #431's source check and prefetch case and takes
  the admission excerpts and --arch. Its main() call needed no restoring:
  #431's copy has it.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit ae1d7812c12f3e64941da0c34bb3541eb695f6db)

feat(vk): import a span past one device allocation as segments (SegMem, alias isolation) ... 46873da415

A connected guest span one operation needs that is larger than max_import_size (41,747,087,360 bytes
on MoltenVK 1.4.2, M4 Max) was left unplanned (admit_over_cap): its bindings came back empty. It is
now a segmented domain (reports/2026-11-14-full-range-design.md 2.1, 2.3, 5.3-5.5), in place of
that branch:

- memory_admit plans it as disjoint, adjacent segments where span_segments::plan cuts them (the
  operation's views and classes as demands, the domain's previous cuts kept unless moving one pays,
  priced extra segments), each an ordinary Pool of at most the cap: one import, its own page-table
  entries, mirror, write-backs and retirement. Only segments holding a demand are imported; every
  live import over their bytes is retired, after a handoff when recorded work may reach it.
- A view across a cut is never one memory: pool_lookup refuses it (counted, logged), not owed to an
  admission. gpu_span_bind (vk_internal.h SpanRef) gives its pieces, one per segment, for the
  consumers' failure branches; gpu_span_pieces and gpu_span_layout describe them binding nothing.
- Domains change only at an admission, never while parallel workers run (debug-checked with the
  design's invariants, seg_invariants); a batch past the cap is admitted as segments instead of
  being recorded in order. memory_admit loses its batch flag and AdmissionStats its splits.
- span_unused_piece: the hook the NullDesc design fills (MoltenVK has no nullDescriptor: an unused
  piece slot of a storage table cannot be null).
- import_planned retires a taken-in import only while it is still over the plan's bytes (two
  segment plans of one admission may name the same old import).

Off alias isolation nothing of this runs.

Tests: test_segmented_domains (the 48 GiB A/B case at the real cap, the priced extra segment,
injected small caps, growth with the cuts kept, a moved cut after a handoff, frozen under workers,
a refused domain reported, nothing off alias isolation; fails on the planner commit and on the
archived base); test_resolver_coverage lists gpu_span_bind's bindings and holds future callers to
a failure branch.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 9fb9b3b4a60af49e54031d9c7707cdaf71fa5117)

test(vk): follow the renderer-core merge's moved code in three extractions ... 2724ac9194

The renderer-core merge (f216d287) moved code three fixtures cut out of the
sources. ae1d7812 updated the extractions it listed; these three it missed
(its named set held no nx2/ tests, and the other two already failed on its
base for the reason the previous commit fixes). The code moved; what it does
did not change, so each fixture follows it and keeps every assertion and case:

- nx2/test_cbuf_table_extent: ae1d7812 moved uniform_range's `used` lines,
  unchanged, into uniform_used(), which the resolver shares, and
  uniform_range calls it. The test searched for those lines after
  uniform_range( (ValueError). It now cuts uniform_used's body, from the
  same `uint32_t used = index < Shader::Info::MAX_CBUFS` line, and
  uniform_range's own `used` up to the driver banks, and runs both as
  uniform_range does.
- tests/test_parallel_rb_refresh: ae1d7812 moved build_descriptors'
  bare-entry guess and binding range into storage_binding() (b.addr, b.size,
  b.bare, ...). The fixture now cuts storage_binding's guess and range and
  build_descriptors' binding from them, through memory_note_gpu_write, the
  lines it cut before. 53b8914d made memory_note_gpu_write's scan stop by
  import_reach.h's live_reach, so the fixture includes the header, cuts
  live_reach and imported_add, and adds its pool through imported_add.
- nx2/test_import_windows: pool_lookup and the code above it now read
  53b8914d's import_reach (live_reach, imported_add, imported_take) and
  ae1d7812's admission state and alias isolation globals. The fixture cuts
  them (DemandClass and AdmissionStats from vk_internal.h), with isolation
  off as on Windows and Linux and alias_conflict false (as
  tests/import_reach_test.cpp does). Its retire_pool spy and its two seeded
  imports use imported_take/imported_add, the table's only ways in and out.

The three print what they printed at 58c5c5aa.

Published on main 6c9edffe (mac/renderer-core): #431 below this branch
already cuts live_reach, imported_add and imported_take into
nx2/test_import_windows and test_parallel_rb_refresh (its rb_table.inc), so
those two keep #431's cuts and add only what follows ae1d7812: the alias
isolation globals, DemandClass and AdmissionStats, and alias_conflict's
stub; storage_binding's cut.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 64a84e4dbc10017f44cd16fc0fbd7440135ee498)

fix(vk, macos): admit a parallel batch's uniform updates in order, and keep its own updates out of its handoff ... 6368f9306a

Two findings from the renderer-core review (reports/2026-11-14-renderer-core-review.md), both in vk_replay.cpp's
parallel-batch admission. Neither path is reachable off Apple: admit_fallback and batch_admit are set only where
memory_admission_on() is true.

P2.5: a parallel replay's batch its dry pass could not know is recorded on the replay thread in order (Mode::Worker,
admit_fallback), each operation admitted as the serial replay admits it, except NOP_UPDATE_UB, whose worker branch broke out
before op_admit. Its destination is bound at the recording's end (flush_ub_updates -> gpu_write); one that needed a growth over
reached memory was refused by the guard and written on the CPU out of GPU order. The worker branch now admits it under
admit_fallback, before the update counts as passed, so a handoff there writes only the updates before it.

P3.1: a batch admitted at once whose admission hands off called admission_handoff() with rmode Serial, which wrote every listed
uniform update into the recording that ends, including the ones the batch's own dry pass had listed (from ub0). admission_handoff
takes the end of the updates to write (ub_end, default all: unchanged for every other caller), and the batch passes ub0.

Tests: tests/test_batch_admission.py (new) runs the NOP_UPDATE_UB case, op_admit, replay_admit, admission_handoff and the batch's
handoff statement cut out of the source; on bacb7c59 both of its cases fail for those reasons. tests/test_admission_handoff.py
cuts admission_handoff out by its name only (its signature gained the parameter).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 39542f89f4443e14b70fb1e46bdaa3e0e330f2ea)

fix(vk, macos): keep every byte the page table reached mapped when an admission retires imports ... ffb586ae1c

Findings P1 and P2.2 of the renderer-core review (reports/2026-11-14-renderer-core-review.md). Both are in vk_memory.cpp's
admission planner, which runs only under alias isolation (memory_admit returns at once elsewhere: macOS only).

P1, the page-table holes. A plan retires every live import it overlaps (retire_pool zeroes the import's whole range), but two plans
did not cover what they retired:
- the cohort (plan_cohort) retired the imports it overlaps and does not need without growing over them;
- a segment (seg_plan) retired an import that reaches into a segment no demand needs.
Shaders that follow the guest page table then miss on those bytes. The fix, by the rule that no byte reachable before an admission
is left without memory after it (design 5.5):
- admit_rest: the bytes of each retired import that no plan holds are planned with the first plan that retires it, imported
  exactly, before that plan's import (one that fails leaves everything as it was, as mirrors_trim does), and published after it;
  they keep the import's marks (gpu_only, gpu_written, trims, last_value) and count in the handoff's conflict test;
- seg_plan: a segment that replaces live imports makes every segment over those imports needed, to a fixpoint;
- the SegMem span takes in every live import over it, so a segment retires only imports its domain holds whole;
- the cohort's threshold is the device's import cap (max_import_size) under the admission, not kMergeMax: a merge up to the cap is
  one import (pool_lookup keeps kMergeMax: plan_import's merge_max defaults to it);
- admit_apply: a plan that is not made keeps the imports it would retire, and no later plan of the admission retires them.

P2.2, covered demands across a domain's boundary or cut. A range a live import already holds was left out of the domain: across the
domain's edge, the segment's plan retired its import and the guard then refused its binding; across a cut, one live import bound
it whole while gpu_span_pieces reported its pieces. The span's live-import take-in covers the first. For the second, a covered
range that straddles a cut seeds its domain's span (its segments are planned, the crossing import retired with the handoff the
conflict test asks for).

Tests: tests/test_admission_coverage.py with tests/admission_coverage_test.cpp (new; the admission cut out of the source, recorded
imports and page table, injected caps), cases merge-table, cohort-table, segment-table, domain-edge, covered-straddle. Each fails on
bacb7c59 for the reviewed reason (reports/CoreFix-files/repro-base-bacb7c59) and passes here on arm64 and x86_64.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit f29396c79600467b11fbb935a529a4c2511cf533)

fix(vk, macos): one view per byte of an Apple spare backing, and no endless retry of a failed view ... 0c2ace70ce

Findings P2.1 and P3.3 of the renderer-core review (reports/2026-11-14-renderer-core-review.md). The code is Apple-only
(#if defined(__APPLE__) in vk_memory.cpp's admission planner).

P2.1: covering_backing returns the owner's backing for a demand across the end of the owner's view, and the view plan was
[max(want_lo, b->lo), min(want_hi, b->hi)): (a) at the owner's own key, imported_add kept the owner, the new view was destroyed,
memory_admit returned Ready and the guard refused the binding at every admission; (b) at another key, the view overlapped the
owner (eviction of either zeroed page-table entries the other served; seg_invariants broke inside a domain). A failed
darwin_import_view looped the same way. Now:
- view_plan grows the view over every live view on the same backing it overlaps; those are retired when it is made (the same
  memory: alias_conflict excludes it, no handoff; retired views are kept until their work is done) and their gpu_only and
  gpu_written marks carried. A live import of another memory over it means no view: the range is planned as pool_lookup imports it.
- admit_apply makes the view first, then retires what it takes in, then inserts it, and checks the insertion.
- A view that fails is logged, its backing is remembered (weak_ptr) as one that takes no view, and its range is imported on its own
  (the binding, or the guard's debt and the next admission's handoff), never as a view on it again.
P3.3: admit_st.reused counts only a view that went into the table.

Tests: tests/darwin_import_lifetime_test.cpp (the real Apple import code, test_darwin_renderer.py, both arches) gains spare-cross
(a range across a one-chunk owner's end), spare-reuse-count, spare-overlap (a two-chunk owner) and spare-view-failure (the driver
refuses a second buffer on a memory). Each fails on bacb7c59 for the reviewed reason (reports/CoreFix-files/repro-base-bacb7c59)
and passes here; the fixture takes --case NAME to run one alone (the driver's --process-exit is unchanged).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 0c1d2aea03e17a3a10b0c1aa6ef69461d8d405d9)

fix(vk, macos): bg_drain publishes no background import over this epoch's retired memory or across a domain ... 3aff819a69

Finding P2.4 of the renderer-core review (reports/2026-11-14-renderer-core-review.md). Under alias isolation (macOS) bg_drain
dropped a background import only when it overlapped a live import or one sat at its start; it never asked alias_conflict, so an
import over bytes a memory retired, evicted or queued dead in the current handoff epoch still held (alias_ref) was published:
two memories over the same bytes in one epoch, the stale read alias isolation prevents. It could also publish a chunk across a
segmented domain's cut. Reachable only with the opt-in background imports (RX_VK_PREFETCH_CHUNKS, RX_VK_ASYNC_IMPORT,
RX_VK_BG_IMPORT).

Under alias isolation bg_drain now also drops (counted in st_prefetch_dropped) an import when alias_conflict holds over its
memory's bytes (on Apple its whole backing), or when it is over a segmented domain (seg_overlaps). The new branch runs only when
alias_isolation is set: off Apple the condition is unchanged. alias_conflict's and seg_overlaps' declarations move up beside the
alias isolation globals, and seg_overlaps' definition into SegMem's state block (above pool_lookup), so bg_drain (and every
fixture that cuts it out with them) sees both.

Tests: tests/admission_coverage_test.cpp gains bg-epoch (an import given back after work reached it, a background import of its
bytes), bg-domain (a background chunk across a cut after the segments were given back) and bg-elsewhere (off alias isolation,
published as before); tests/darwin_import_lifetime_test.cpp gains apple-bg-epoch (Apple's alias_conflict, real import code). The
first two and apple-bg-epoch fail on bacb7c59 for the reviewed reason (reports/CoreFix-files/repro-base-bacb7c59); all pass here
on arm64 and x86_64.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 755ac7e8757fdd30d4809ae1142e51232fae2a9e)

fix(vk, macos): admission merges no import past 1 GiB again, so mirror_make can still mirror it ... 7ce8a80966

Finding N1 of the core-fix review (reports/2026-11-14-core-fix-review.md). f29396c7 let the admission merge imports up to the
device's import cap (plan_import(..., max_import_size), and the plans' merge at max_import_size). mirror_make refuses a VRAM mirror
for any pool over 1 GiB, and mirrors are on by default for a discrete, non-GCN GPU (an Intel Mac with an RDNA Radeon, which alias
isolation also covers) and with RX_VK_MIRROR=1: such a merged pool lost its mirror, every binding in it reading host memory.

The cap was never needed for correctness once admit_rest keeps a cohort's leftover bytes mapped, so the admission's threshold is
kMergeMax again (cohort plus leftovers past it). plan_import loses the merge_max parameter that only the admission used; it, its
comment and pool_lookup's calls are as on bacb7c59. No correctness reason to keep the cap was found: a cohort and its leftovers
import the same bytes a merge would, each piece no larger than the import it came from.

Off Apple: unchanged (admit_plan runs only under alias isolation; plan_import is textually bacb7c59's again).

Tests: tests/admission_coverage_test.cpp gains merge-mirror (the seam of two live 768 MiB imports at the real cap: no import the
admission makes is larger than mirror_make's limit, which the driver reads from mirror_make itself, and every byte stays mapped).
It fails on 755ac7e8 for that reason (reports/CoreFix-files/repro2-base-755ac7e8) and passes here on arm64 and x86_64;
merge-table (the same seam: every byte mapped, one handoff) passes on both.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 9ccc7c19864991be11d4437211eecf3e430b2a7d)

fix(vk, macos): a segment keeps a crossing import's bytes as leftovers clipped at the cuts, not as whole segments ... 3e60977da0

Finding N2 of the core-fix review (reports/2026-11-14-core-fix-review.md). f29396c7's closure in seg_plan marked every segment over
an import a needed segment retires as needed, and each such segment was then imported whole (up to the device's cap, 41.7 GB of
guest address space on an M4 Max) only to keep that import's few bytes in it mapped; and when such a forced segment's import failed
after the needed one's, the crossing import was already retired.

The closure is gone: seg_plan plans only the segments the operation's ranges need. The retired imports' bytes in segments no range
needs are leftovers, as a cohort's are: admit_rest now takes segment plans too and cuts every piece that lies in a domain planned in
this admission at that domain's cuts, so each piece lies in one segment, crosses no cut and overlaps nothing (invariant 1 holds),
and costs no more than the import it came from. They are made before the segment's own import and published after it retires the
import (admit_apply, unchanged), so a failure leaves everything as it was.

Off Apple: unreachable (seg_plan and admit_rest run only from the admission, under alias isolation).

Tests: tests/admission_coverage_test.cpp gains segment-rest (a chunk across the cut into a 100 MiB segment nobody needs, retired by
the segment the operation needs: its 4 MiB there stay one import clipped at the cut, nothing else of that segment is imported, every
byte stays mapped, no import crosses a cut). It fails on 755ac7e8 for that reason (reports/CoreFix-files/repro2-base-755ac7e8) and
passes here on arm64 and x86_64; segment-table, domain-edge and covered-straddle (the other segment cases) pass on both.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 596f0ff4063da99505e7d5df789580fb4cde89f7)

fix(vk, macos): each new import over a retired import's bytes inherits its share of that import's VRAM mirror ... 4309c50216

Open item 1 of the core-fix review (reports/2026-11-14-core-fix-review.md), more reachable after N1 (9ccc7c19): with mirrors on
(a discrete, non-GCN GPU such as an Intel Mac's RDNA Radeon, or RX_VK_MIRROR=1), an import an admission retires whose bytes go to
several new imports (a cohort and that import's leftovers, or two segments over an import across their cut) handed what the GPU
wrote into its mirror and nowhere else to the first of them whose mirror was made only: mirror_make ends a retired pool's wait unless
it is trimmed, so the others' mirrors were filled from guest memory without it.

admit_apply now does what mirrors_trim does for a trim's parts:
- it counts, per import the plans retire, the new pools its bytes go to (the plans over it and its leftovers);
- a retired import with more than one, whose mirror was on (inherit_pending, set by retire_pool), is marked trimmed and counted in
  trims_waiting once the plan that retires it is made, so each new pool takes its share when its mirror is made, and trims_settle
  lets it go once every live pool over its range has its own (or after kIdleEpochs, as before);
- a leftover of an import whose mirror was on wants a mirror at once (MIRROR_WANTED, in mirror_wanted), as a trim's parts do.
trims_waiting is declared ahead of the admission region (its definition, with mirrors_trim, is unchanged).

Mirrors off (Apple Silicon's default): no pool is ever MIRROR_ON, so retire_pool sets no inherit_pending, nothing is marked and no
mirror is wanted: unchanged (the counting runs, without effect). Off Apple: unreachable (admit_apply runs only under alias isolation).

Tests: tests/admission_coverage_test.cpp gains mirror-cohort (the seam's cohort retires a mirrored import: the cohort and the leftover
both inherit, the leftover wants a mirror, trims_settle, cut out of the source, lets the old one go) and mirror-segments (two needed
segments over a mirrored import across their cut); mirror_made models mirror_make's inheritance, whose two tests the driver checks
are in mirror_make verbatim. Both fail on 596f0ff4 for the reviewed reason (reports/CoreFix-files/repro3-base-596f0ff4) and pass here
on arm64 and x86_64; mirror-off (mirrors off: nothing marked, nothing wanted) passes on both. alias_admission_test.cpp,
segmented_domains_test.cpp and darwin_import_lifetime_test.cpp get a trims_waiting stub only (no assertion changed).

Published on main 6c9edffe (mac/renderer-core): darwin_import_lifetime_test's
trims_waiting stub sits beside #491's sparse_wanted stub (main's #250).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 6aa7c2af0fb4e9d0dc57d6eeb8018aaac07ed234)

test(vk): the admission fixtures follow main's #250 sparse mirrors ... d64b26a285

Main's #250 (sparse mirrors) makes retire_pool drop a retired pool from
sparse_wanted, the pools a binding found a sparse block with no memory in.
test_alias_admission, test_segmented_domains and test_admission_coverage cut
retire_pool out of vk_memory.cpp with the admission, so their fixtures did
not compile on main 6c9edffe ("use of undeclared identifier
'sparse_wanted'"). Each gets the stub darwin_import_lifetime_test already has
(#491). No assertion changes.

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

fix(vk, macos): the actor motion's resolver follows #59: a pose read at its draw is not copied ... d792779940

Main's #59 (actor motion pairs a model's copies by place) takes a skinned
draw's pose as the draw read it (temporal_note_skinned_draw, ub_read), through
a host-visible stage, and copies the bones and origin from the game's memory
only for a draw whose pose was not read, or with no stage. actor_reads and
temporal_actor_demands (alias isolation's resolver for the upscaler's actor
motion) still demanded the bones and origin of every skinned draw: a
superset, so admissions on macOS could import or hand off for bytes nothing
binds.

pose_read_at_draw(s, k, staged) is now the one test, actor_motion's (with its
stage) and the resolver's (with the stage actor_motion takes next): the
resolver demands a draw's bones and origin only where actor_motion copies
them, and its vertices and indices always. With no stage made yet the
resolver demands the bones and origin too, since actor_motion's making of the
stage may fail. test_resolver_coverage holds both to that test.

Off alias isolation (Windows, Linux) the resolver does not run, and
actor_motion's test is the same expression as before.

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

test(vk): test_split_ub_flush follows flush_ub_updates' end parameter ... 61766e3eca

Main's #189 check reads flush_ub_updates by its signature. The admission (6e765c8d) gives it an end, the first update not
written, for a handoff in a dry-passed command buffer, defaulting to SIZE_MAX, so the check's anchor was not found and it
stopped with a ValueError. It now reads the new signature and still requires what it guarded: the writes start at
ub_first_of_recording and, with the default end every caller in maybe_split and finish_recording uses, reach the last
update (end = std::min(end, ub_updates.size())).

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

Merge mac/texel-codec (#P21) into mac/seg-contract ... 1ebb97e7f1

This PR needs the texel codec PR (#P21: texel_codec::Plan, which
texel_view_pieces takes) and the renderer-core PR (#P19, the base:
SegMem, gpu_span_bind, SpanLayout). Both are kept as they are; the
merge had no conflicts.

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

feat(vk): the segmented consumers' frozen contract (C0) ... 4c16dbc4cc

The interfaces the four segmented-consumer lanes (SegBind, SegXfer,
TexelDesc, NullShader; reports/2026-11-14-seg-consumer-plan.md section 3)
code against, frozen before they fork. Inert: no caller of anything new,
no SPIR-V, layout, push range or stream change, sizeof(Program) unchanged.

- vk_internal.h / vk_memory.cpp, SegMem's consumer interface:
  gpu_span_any() (a relaxed count of the live domains, stored in
  seg_commit; domains are kept for the run), gpu_span (gpu_buffer's
  flavour of gpu_span_bind: import buffers, no written marks, no mirror),
  SpanLayout::bind_stamp (gpu_bind_stamp(): a segment can be imported
  again with its cuts kept, so cut_gen alone never keys piece buffers),
  span_unused_piece's semantics ({null_storage, 0, 1}), and the SegArena
  API (SegArenaRef, seg_arena_take, seg_gather, seg_scatter; stub bodies
  after stream_alloc that give no room and log, SegBind's to fill).
- Review fixes in the same interface (renderer-core review P2-3, P3.2):
  every piece of gpu_span_bind carries its buffer's device address (the
  import's or the mirror's; 0 only with bufferDeviceAddress off), and its
  one-piece path stores the translated guest address, not a virtual one.
- vk_texture.h/.cpp: texel_view_pieces / texel_piece_views, stubs that
  return 1 and false (TexelDesc's to fill).
- vk_shader.h: Program::presence_words, in what was padding.
- Back end: PRESENCE_PUSH_OFFSET (88), Profile::emulate_null_descriptors,
  Bindings::presence / presence_read with the bit numbering rule.
- tests: test_resolver_coverage lists gpu_span_bind / gpu_span sites too
  (scoped to gpu/vk: gpu/render has an rx::gpu_span of its own), checks
  that gpu_span follows its own gpu_buffer, and splits SITES into
  SITES_BASE plus one block per lane. test_segmented_domains executes the
  contract (the count 0, 1, 2 -> 1 on a merge, 0; gpu_span's pieces;
  addresses with the fixture's gpu_buffer_bind returning none as the real
  one does; the bind stamp; a virtual address's guest). test_seg_shader
  accepts a base tree of this back end's generation and compares every
  module.
- docs/segmented-binding.md: the gate (every new behaviour Apple-only,
  other platforms byte-identical) and one heading per lane.

Conflict on this branch (not with main): tests/test_seg_shader.py's
docstring, against the array_pointer_calls paragraph #P20's
msl-arrayptr port added; both kept, this paragraph first.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 95fa06d4e6526601bd2e1bc88c2f8f5720855350)

Merge mac/mvk-rwtex (#P28) into mac/seg-consumers ... 2b9dd377f3

The segmented binding PR needs the MoltenVK descriptor-set fixes (#P17
storage buffer tables, #P26 storage buffer lengths; #P28 read_write
textures, which it lands after): ensure_layout's layout_pushes decides
the push, and seg-bind's counts go through it. Their commits are kept as
they are; the merge had no conflicts.

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

feat(vk): texel codecs' views, texel piece views, null-descriptor stand-ins and presence words (TexelDesc, L3) ... 74549ce92b

The renderer's half of plan section 6 (reports/2026-11-14-seg-consumer-plan.md), on B2 08cccafb:

- vk_texture.cpp texel_buffer_view(t, v, storage, plan): the plan's view (the format's own, an alias, a typed
  access's declared format, or an R8/R16/R32 UINT carrier), whole-texel ranges at most maxTexelBufferElements of
  the view's elements, plan.zero as a cached 16-byte zero view; key (format, offset, range) with the backing as
  before, every view through one cache helper (texel_view_locked).
- texel_view_pieces / texel_piece_views (C0.4): cut at a segmented domain's cuts (span_segments::texel_pieces, in
  view elements) and, on Apple, at runs of maxTexelBufferElements; each piece view on its segment's buffer (gpu_span
  after gpu_buffer); a stale count, an unbound piece, a seam or a written seam refused loudly (the element absent).
- gpu/vk/null_dummies.h (new, pure): the stand-ins' tables by view type x class x multisample, storage format, and
  the texel zero view's format from the variant's texel answer. vk_texture.cpp null_dummies_make makes them once
  (1x1 zero images, views, four samplers, texel zero views; vkGetPhysicalDeviceImageFormatProperties first; one
  clear submit), only on Apple without nullDescriptor (make_dummies).
- vk_draw.cpp: texel_views with texel_plan / texel_plan_native, P piece views for a segmented variant's entry, the
  zero view of the declared format for an absent element; sampled and storage-image stand-ins, null samplers, the
  default sampler for a real view whose sampler failed; DescWriter presence bits (C0.8 numbering), the graphics
  words kept per thread, push_presence at offset 88.
- Non-Apple, and Apple with nullDescriptor: writes byte-identical to B2 (checked against the B2 cut).

Tests: test_texel_buffer_ownership (extended), test_texel_views_plan, test_null_dummies, test_null_descriptors,
test_null_layout_push (new), SITES_TEXEL; docs: texel-buffer-formats.md (new), texel-buffer-ownership.md,
segmented-binding.md TexelDesc.

Conflict on main: tests/test_texel_buffer_ownership.py's eviction cut
ends at imports_give_back's "(longshot) Default by OS and vendor"
comment, as main's #324 reworded it ("Off by default" before).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 36fe0a1359b31095fcb8d40d3c2f502a105d6b1b)

test(vk): the texel ownership fixture names the case that failed ... 17ce0ff24c

A failed case printed only a CalledProcessError; it now prints the fixture's own FAILED line and the case.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit cb8dea7c94ef0b0c002c9102d6c78c48bc778b7e)

feat(vk): SegBind's descriptor core, gathers and arena (L1) ... 5f75a29085

On a segmented domain (macOS), vk_draw.cpp now binds storage descriptors across a segment's cut as piece arrays in the
segmented variant program_segmented makes, gathers uniform buffers and fixed-function inputs into a per-recording arena at
the pre-pass point, and fills C0's arena stubs. On Apple, unbound storage descriptors take a zero-length range of a new
64 KiB null_storage buffer (span_unused_piece set), and unbound uniform buffers take 64 KiB of zero_buffer, which loses
its STORAGE usage. Other systems keep every write, layout and push range as before.

- ensure_layout and the descriptor counts take piece counts from Program::seg; push range 88 + 4 * presence_words
- build_descriptors: single, table (k*P + j, prefix rule), bare/wide/shrink per piece; a refused array writes nothing
- uniform_range: gather queued (SegBuild), null_ubo on Apple
- draw()/dispatch(): seg_sig_of + program_segmented after the seam, always waited for; same_desc never reuses a
  gathered or stale piece set; vertex/index/indirect/mesh-args/dispatch-args gathers; index extent demanded (O9)
- pipeline_note and the compute notes skip segmented variants
- tests: test_seg_bind (new), resolver coverage SITES_BIND, and the fixtures and anchors the change moved

The next commits add test_seg_gathers, test_seg_notes, the desc_counts, push_state and vertex_bind
extensions and the docs section. (Reworded from the topic's "wip:" commit; the content is the topic's.)

Conflicts on main 6c9edffe: #252's compute-variant path in dispatch()
(program_cache_complete_ask, on_worker, made_how; compute_optimize at
the bind) meets this commit's rename of the pre-seam program to
`plain`. #252's lines are kept here as main has them, naming `p`; the
notes take SegBind's guard and #252's optimize and bind follow it.
They follow the rename in this PR's last commit, which vk_draw.cpp
needs to compile; tests/test_program_cache_one_variant.py the same.
tests/test_set_for_tables.py (#P28's read_write cases): CASES counts
both sides' cases.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit f40b77f71a47ee130cbe0df476d5e59f00fcef03)

fix(vk): a draw reusing its descriptors drops an earlier build's refusal (SegBind) ... 34df68891a

draw()'s pre-pass point cleared only the gathers an earlier build had queued when the draw reused its descriptors. The build's
lost flag stayed: a build or signature that was refused (seg_lost: no arena room, a piece array that could not be written, a
descriptor in more than 255 pieces) left its own draw out, and then every later draw that reused the previous set while a domain
existed was left out too, with no log line of its own. The whole SegBuild is now reset there (its gathered/pieces/stamp fields are
read only at the bind of a fresh build). Apple-only in effect: off alias isolation no build is ever refused.

tests/test_seg_gathers.py's "stale" case fails without it.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit a38cf86cc766d3254539965265c9bf3d56123b87)

test(vk): SegBind's gathers and notes fixtures, its parts of three checks, and its docs section ... d4865e157e

Plan 4.3 items 2, 3, 6 and 7 (reports/2026-11-14-seg-consumer-plan.md):
- tests/test_seg_gathers.py + tests/seg_gathers_test.cpp: the source's own cuts (RecordingRes and the arena with
  draw_begin_recording's reset and give-back, SegBuild, the size helpers, the bound-state caches, and draw()'s mesh-args
  rewrite, pre-pass gathers, vertex streams and indirect/indexed binds; dispatch()'s grid gather and binding) over a command
  recorder and SegProbe's domain. 76 checks: the order end_pass, barrier, copies, barrier, reader; vertex sized and WHOLE
  (clipped to the domain); direct indices; the indexed-indirect extent; records across a cut; native mesh records; the
  mesh-args rewrite per piece; a queued uniform gather; the 12-byte grid; count words in place and a straddling one left out;
  aligned arena offsets; arena made, grown, reset, given back, and full (a loud skip); nothing kept in kept_vb, vertex_set or
  last_ib; no stale refusal after a reusing draw. --base compares the common path's recorded commands with B2's cut; --json
  writes seg-gathers.json for SegBindProbe. Against B2 (--source) it builds and fails.
- tests/test_seg_notes.py: pipeline_note and dispatch()'s note lines cut out: a segmented variant makes no state_record,
  PipeNote or compute note; a plain one is noted as B2's cut is (--base).
- test_desc_counts.py, test_push_state.py, test_vertex_bind.py: --source, and SegBind's source rules (piece counts with
  seg_layout_count; the push range kPushSize + 4 * presence_words and uses_push; gathered streams and indices never reach
  vertex_bind_reuse, kept_vb, vertex_set or last_ib). Each fails against B2.
- docs/segmented-binding.md: the SegBind (L1) section.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit a0eccd31253378f8beb5963da4d4a6e5f340e670)

test(vk): test_set_for_tables reads its cut from --source ... 6e983aa6b0

The segmented single storage array's case (plan 4.3 item 5) had no negative: the check always cut its own tree. With --source
<B2 archive> it fails as required ("moltenvk.segmented_single want=set got=push").

Conflict with #P28 (read_write textures; not with main): the docstring
keeps #P28's paragraph with this usage line, and main() cuts from
--source's vk_draw.cpp with #P28's read_write count (as in the
macOS integration, Integration 17).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 5824f6828e21cf810dcceaa6be425a9224b15994)

test(vk): test_mesh_fallback's topology anchor follows draw()'s plain ... 7a498e5865

SegBind renamed draw()'s program for the bound state to `plain` (after the seam `p` is it or its segmented variant), so the
source rule "topo = pipeline_topology(p, topo);" no longer matched and the check failed in the full suite (a new failure
against B2's full run). The rule now reads `plain`; what it checks is unchanged.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 2e1eb52102ae7a889af7a0aa770f448833d36ebf)

test(vk): test_set_for_lengths' layout fixture takes SegBind's seg_layout_count and presence_words ... 8811999777

ensure_layout, which the fixture compiles from vk_draw.cpp (kPushSize
to its end), now counts each descriptor through SegBind's
seg_layout_count and grows the push range by Program::presence_words.
test_set_for_lengths (mvk-sizes) was written after SegBind's base, so
its fixture had neither, and it no longer built after the merge of
SegBind into macos/integrated (a34be2da). It gets the same stubs
SegBind gave test_set_for_tables' fixture: presence_words = 0, and a
seg_layout_count that keeps every count (its modules are plain
variants). No assertion changed.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 071c628f14ec46d0c55b1e5ef1a2941040a362aa)

feat(vk): SegXfer, the transfer consumers of a range across a segment's cut (L2) ... 6a383d426a

A guest range across a SegMem segment's cut is never one memory: gpu_buffer_bind
and gpu_buffer return it empty. Each SegXfer consumer's failure branch now binds
it piece by piece (gpu_span_bind, or gpu_span for the unswizzle's gpu_buffer
reader) after its operation's admission, and records the work per piece or
through the recording's SegArena (C0's declarations; SegBind fills the bodies):

- vk_replay.cpp: gpu_write as one vkCmdUpdateBuffer per piece (unaligned stays
  on the CPU); NOP_COPY_B2B as regions between the sides' pieces, one
  vkCmdCopyBuffer per buffer pair; NOP_CLEAR_BUF as one fill per piece.
- vk_xfer.cpp: B2T gathers the span into the arena and copies from it; T2B
  gathers in first (row padding keeps the guest's bytes), copies the image into
  the arena and scatters every byte back; bufferOffset a multiple of the texel
  block; stamp and texture_gpu_wrote over the span.
- vk_texture.cpp: the GPU unswizzle gathers its source into the arena in the
  upload command buffer, ahead of the dispatches, at the storage alignment.
- vk_temporal.cpp: the actor's bones and origin copied per piece, its vertices
  and indices gathered and read through the arena's device address.
- vk_draw.cpp: the frame dump, StatsQuery copies and mesh-indirect convert per
  piece; the mesh fallback's 8-byte indirect input gathered, by address.

No arena room is refused loudly (error log, counter), never silently. Every
path tests gpu_span_any() first: with no domain (all platforms but macOS under
alias isolation) every consumer records exactly what it did before, which the
new fixtures check against B2's recorded commands. The arithmetic is in the
new pure header gpu/vk/span_xfer.h.

Tests: tests/test_seg_xfer.py (+ seg_xfer_test.cpp), copy_b2t in
tests/test_vulkan_copy_span.py (+ copy_b2t_span_test.cpp), the gpu compile
fixture given SegMem's types, and SITES_XFER in test_resolver_coverage.py.
Docs: docs/segmented-binding.md § SegXfer.

Conflict on main 6c9edffe: vk_temporal.cpp actor_motion, #59 (actor
motion pairs copies by place): a pose read at its draw is copied from
the stage (placed), and only otherwise from the game's memory. The
piece-by-piece copy of a pose across a segment's cut goes in that
else branch, where the bones and origin are bound; the kept pose
takes #59's placed and place.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit db3c9bf0c7c9181001522991d2447321362b5724)

fix(vk): dispatch()'s compute-variant path (#252) names SegBind's pre-seam plain ... 1e1a3b3e0d

Semantic rework for main 6c9edffe, after the picks. SegBind renames the
program for the bound state to `plain` before the admission seam (after
it, `p` is that program or its segmented variant). Main's #252 added
the compute-variant path on those lines (program_cache_complete_ask,
on_worker, made_how), kept as main has it in the seg-bind pick, which
left vk_draw.cpp not compiling ("use of undeclared identifier 'p'", 7
lines). Those lines now name `plain`: the CAS and the ask, the job, the
cached pipeline, and the census and give-up after the 50 ms wait.

Behaviour is #252's: the plain program is the one read without its
code and made whole there. A segmented variant is translated, not read
from the cache, and compiled synchronously after the seam through
cached_compute, which takes #252's Intel gate itself (Windows Intel
only; segmented variants exist on macOS only). At the bind, #252's owed
optimized build and compute_optimized stay on `p`: a variant is never
built quick, so it binds its own pipeline.

The checks that read these lines follow:
test_program_cache_one_variant (its first-CAS, cached-pipeline and
complete anchors; its code_words check now looks for both names),
test_intel_compiler_gate (the ask's anchor), and test_seg_notes, whose
cut of the compute notes now ends where #252 queues the owed optimized
build (at the bind on a tree without it; its between() helper went with
the old cut). No check is weakened.

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

test(vk): the seg_gathers fixture stubs #162's rec::OwnSlot ... 03d88f59d7

Fixture follow-up for main 6c9edffe. tests/test_seg_gathers.py cuts
draw_begin_recording into its fixture, and main's #162 (the recorder
thread's own slot resets, RX_VK_RECORDER_OWN) marks the descriptor pool
reset there with a rec::OwnSlot scope, so the fixture did not build
("use of undeclared identifier 'rec'"). It gets the stub the other
fixtures that cut that function have (draw_stream_visibility_test,
recording_admission_test): a scope that does nothing. No check changed.

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

test(vk): SegXfer's fixture and resolver sites follow #59's actor motion ... 5a5f49731b

Semantic rework for main 6c9edffe. Main's #59 (actor motion pairs
copies by place) takes a pose read at its draw through a stage, and
copies the bones and origin from the game's memory only otherwise;
#P19's rework (pose_read_at_draw, shared by actor_motion and
temporal_actor_demands) makes the resolver demand them only there. The
SegXfer pick puts the per-piece pose copy in that else branch.

- tests/seg_xfer_test.cpp: the fixture's State takes #59's members
  (Skin::pose and kNoPose, pose_bytes, poses_time, Pose::placed and
  place, pose_stages, pose_stage_at, poses_read, poses_copied) and the
  <cmath> and <unordered_set> actor_motion now needs; its skins keep
  kNoPose, so its cases still take the copy from the game's memory,
  across a cut as before.
- tests/test_seg_xfer.py cuts pose_read_at_draw into the fixture too
  (when the tree has it).
- tests/test_resolver_coverage.py: SITES_XFER's four actor_motion sites
  expect the resolver's loop as SITES_BASE's do since #P19's rework
  (from pose_read_at_draw's 2 or 0), and the bones' site the same
  decision in both functions.

28 of 28 SegXfer cases and 74 binding sites in 19 functions pass again;
no expectation was dropped.

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

test(vk): SegXfer's gpu_write checks follow #329's ordered inline writes ... c22c9a9a11

Fixture follow-up for main 6c9edffe. Main's #329 (order overlapping
inline buffer updates) puts a full barrier before each vkCmdUpdateBuffer
in gpu_write, and tests that with test_inline_write_order, which cuts
gpu_write alone.

- tests/test_inline_write_order.py: SegXfer's span path in gpu_write
  calls gpu_span_any, gpu_span_bind and gpu_write_pieces; the fixture
  stubs them as they are off macOS and with no domain (gpu_span_any()
  false), so it tests #329's order as before. Its three variants keep
  their results (the barrier and the work count still caught).
- tests/test_seg_xfer.py: replay.gpu_write.common, recorded on the
  topic's base (08cccafb) without #329's barriers, is recorded again:
  the common path at this branch equals its base's (--base), on arm64
  and x86_64. The other eight common digests are unchanged.

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

diag(vk): RX_VK_LMEM_LOG names each module's private memory and each pipeline's first bind ... 1694fcb06d

Run 22's IOAccelerator memory grew 17 -> 53 GB in steps as programs ran for the first time,
with no pipeline made and the renderer's own memory flat. A program's local memory (LDL/STL)
is a Private array of the size it declares (DefineLocalMemory), which SPIRV-Cross makes a
thread array; a GPU backs it for every thread it can keep resident.

Log-only, any driver, off unless RX_VK_LMEM_LOG=1 (not in the program cache's stamp):
- gpu/vk/private_memory.h: scan() reads a module's Private, Function and Workgroup bytes, its
  largest variable with how many access chains index it with a computed value, the local size;
  a census (a line per module from RX_VK_LMEM_LOG_MIN bytes a thread, 1024; at most 2000; a
  count by size every 4096) and the first binds (once a second at most, with the driver's
  memory in use).
- vk_progcache.cpp notes every module where it notes its phis (translated and cache-read);
  vk_draw.cpp tells each game pipeline's bind (compute, graphics, mesh fallback).
- tests/test_private_memory.py: real back end modules (local memory 0-64 KB, computed and
  constant offsets, shared memory, three stages) read independently; the scan agrees on them
  and on hand-made words; census, first binds, switch; the hooks' places.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit b0d47fb30d35e41b4873843e1e6e067194bafb07)

test: the excerpt fixtures know RX_VK_LMEM_LOG's hooks ... 8a1c2abc72

The program cache fixtures excerpt vk_progcache.cpp from put_bytes to program_cache_save, which now
holds note_private_memory: they include private_memory.h, as they include spirv_lengths.h. The
fallback-pipeline and seg-xfer fixtures excerpt vk_draw.cpp functions that now call
private_memory_bound after a bind: a no-op stand-in each (the hook is log-only).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit de0ada6b2a8c08db0d16d23a7a4a135b5dfb57c7)

fix(vk): RX_VK_LMEM_LOG on main's dispatch and program cache: the bound pipeline named, the notes beside array_length ... cd13779262

On main (#252) a dispatch binds compute_optimize's pipeline once it is made, not
always p.compute_pipeline: the first-bind line now names the pipeline bound, so
an optimized pipeline's first bind is its own (Intel's quick builds on Windows;
on MoltenVK nothing is optimized and the pipeline is the same).

test_private_memory looked for each stage's private memory note after the
stage's SPIR-V words (Stage::words, which #652's precompile adds). This branch
sits on #663, which has no words: the notes follow the stage's array_length
(spirv_lengths.h) in the same three places, and the dispatch's needle reads
main's bind.

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

fix(macos): RX_VK_LMEM_LOG logs on macOS only ... f9dc41ac83

The switch was read on every platform, so a Windows or Linux player setting it got the private-memory lines too. What it
measures is Metal's private memory, and this PR is macOS's: private_memory::on() now reads RX_VK_LMEM_LOG only under
__APPLE__ and is false elsewhere, whatever the variable says. Windows and Linux compile on() as `return false;`, so every
hook returns at once there as it does with the switch unset. test_private_memory checks the gate; the docs row and the
header say macOS only.

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

merge(macos): RX_VK_LMEM_LOG's private-memory scan (mac/metal-scratch f9dc41ac, #681) into the giant compiles' memory gate (mac/giant-mem-gate 4d16d199, #669) ... 2c91cc6b52

GiantCompile2's heavy compiles are told by their local memory weight: the largest Private or Function array's access
chains times its words, read by private_memory.h's scan (#681), noted where the program cache notes a stage (#681's
note_private_memory beside it). Its gate is #669's (Giants, the memory gate, the compile board). This merge brings the two
together; #681 carries the renderer stack it is on (#663 and below).

Resolved as macos/integrated (79e2e006) has them:
- vk_shader.h Stage: array_length, words, private_bytes.
- vk_progcache.cpp, the three places a stage is noted: array_length, words, then note_private_memory.
- vk_vendor.h: set_for_tables and set_for_lengths before compiler_service (fields, vendor_fixes, the switches).
- vk_main.cpp: the vendor fixes line names set_for_tables, set_for_lengths, the worker caches and the files unread, then
  the MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS=0 note.
- vk_draw.cpp dispatch(): #681's program names (plain, p for the bound variant), its stand-in's admission and its bind's
  private_memory_bound and SegBind's grid, with #669's named skips (SKIP_DISPATCH and the still-compiling line's
  skip_named) and its Tagged compile.
- docs/development.md: the precompile's rows, then RX_VK_LMEM_LOG and RX_VK_LMEM_LOG_MIN.

The next commit names SegBind's five left-out dispatches and has the precompile's checks read the renderer's names, as
Integration's tree has them.

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

fix(vk): SegBind's left-out dispatches named, and the precompile's checks read the renderer's dispatch names, after #669 met #681 ... 5a6f21fea3

Semantic merge fix for the merge above (mac/giant-mem-gate with mac/metal-scratch), as Integration's tree has it
(LoadingStall's 830c1a02 there, written on top of SegBind):

- vk_draw.cpp dispatch(): #669's LoadingStall names every dispatch left out (SKIP_DISPATCH; RX_VK_SKIP_LOG), and its
  test_loading_stall allows no bare SKIP_HERE() there. #681 carries SegBind, whose five ways out of dispatch() were bare:
  descriptors refused as segments, the segmented variant not made, the segmented variant failed, a piece array or gather
  not made, an indirect grid across a cut not gathered. Each is now SKIP_DISPATCH with Integration's reason. With
  RX_VK_SKIP_LOG unset it is the same SKIP_HERE().
- tests/seg_gathers_test.cpp: the SKIP_DISPATCH stand-in beside its SKIP_HERE (the fixture excerpts dispatch()'s gathers).
- test_loading_stall, test_warm_handoff, test_precompile_handoff: #669's checks read main's name for the dispatch's
  program, p; #681's stack renames it plain (the bound variant stays p). They read plain now, and test_loading_stall
  counts 13 named skips in dispatch (main's eight and SegBind's five; its own comment said the five would come).

Nothing else changes on any driver.

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

test: test_private_memory looks for note_private_memory after a stage's words, as the program cache notes them once #669 met #681 ... 4f888d6d4e

Semantic merge fix for the merge of mac/giant-mem-gate (#669) with mac/metal-scratch (#681), as the integration branch has
it (79e2e006's test_private_memory.py, from b0d47fb3 there). #681's source check finds each place the program cache notes a
stage's storage-buffer length use (.array_length = …) and wants note_private_memory on the next line. #669's stack notes the
stage's SPIR-V words (.words = (uint32_t)std::min<size_t>(…, UINT32_MAX);, #652) at the same three places, and the merge put
that line between the two (array_length, words, note_private_memory, as integrated), so the check failed three times (the
wave suite at 4cc29486). It now looks after the words line, with integrated's regex and messages; everything else it checks
is unchanged.

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

fix(vk): heavy compiles run alone under Metal's compiler service; the first giant behind the game no longer waits for 16 GB ... 7d4528793e

Run 31's three giant mesh fallbacks (a 9.1-9.3 KB local memory array behind about 8,000 access chains) ended four
MTLCompilerService instances in a row when three of them shared one: the hardened service keeps every compile of one instance in
two pointer ranges of about 8 GiB together ("Failed to allocate segment from range group - out of space"). Run 35 lost the two
464k-word ones together the same way. Each was made alone, or two to an instance, in runs 18, 21, 26, 31 and 35.

- precompile_handoff.h: heavy_compile (RX_VK_HEAVY_WEIGHT, local memory weight 10,000,000: the largest Private or Function
  array's access chains times its words; RX_VK_HEAVY_WORDS, 1,000,000 SPIR-V words). Giants::next takes heavy_of: a heavy run
  starts only when no run of the precompile is in flight (every run counts until run_left) and nothing else starts while it runs;
  while the hold, play or memory keep it back the others go on, and once only the runs in flight do, they drain. The giants: 18.2M
  and 18.5M; every other module noted in runs 23-31 at most 5.4M.
- Behind the game, with no giant in flight one starts unless the memory pressure is critical (memory_lets_first_giant): run 32 held
  all 1,302 giants for its whole run for want of 16384 MB available. The room bounds the second giant and those after it.
- vk_progcache.cpp: note_local_weight, for every module over 100,000 words where the program cache notes a stage, whatever
  RX_VK_LMEM_LOG. vk_draw.cpp: the precompile's heavy table, behind_worker's run_left, the setup, deferral, begin and done lines.
- docs/development.md: the RX_VK_HEAVY_WEIGHT row.
- tests: test_giant_alone.py (new; giant_alone_test.cpp), giant_memory_test.cpp for the first-giant rule, test_loading_stall.py's
  count of held_back checks (three now).

Only MoltenVK's compiler_service path changes (behind_worker, pre->hand); the gate's 7-argument next() is as before.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit b969a0683549042c4937de78976f0b10c07ecc42)

fix(vk): the local memory weight lives in private_memory.h, so vk_progcache.cpp's cut-out fixtures build ... c5b41bb0cc

test_program_cache_cleanup and test_program_cache_one_variant cut vk_progcache.cpp's functions into fixtures of their own, which
include private_memory.h but not precompile_handoff.h: note_local_weight now calls private_memory::local_weight, and
precompile_handoff.h keeps only heavy_compile. giant_alone_test.cpp and test_giant_alone.py follow.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit b694aeb4f5a91aac40215d2e6c60fbdd81de39bb)

docs(vk): heavy_weight's comment says what probe GC-02 found ... 45bcea372f

GC-02 (reports/2026-11-15-giant-compile-2.md section 6.1): the 464k-word giants' synthetic twin made alone, after 48 other
compiles too, and one of four times their size ended every compiler service instance alone. The weight marks the giants; the
cost is control flow (the same program straight-line took a sixth of the memory). Comment only.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
(cherry picked from commit 78f3e5b3a7de083cb45f25510abf167e4d5ed6c2)

docs: RX_VK_GIANT_ROOM_MB's row says the first giant behind the game starts unless the pressure is critical ... 27753a2e2a

The commit before (macos/giant-compile-2 b969a068) changed the memory gate behind the game: with no giant compile in
flight one starts unless the system's memory pressure is critical (memory_lets_first_giant; run 32 held all 1,302
giants for want of 16384 MB available); the room bounds the second giant and those after it. Its setup line says so.
The switch's row in docs/development.md is #669's, which the topic's tree (the integration branch) did not have, so the
topic could not update it: it still said every giant waits for a normal pressure and the room. Now it says the rule
the code has. Nothing else changes.

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

fix(vk): the local memory weight is noted on macOS only, where the precompile reads it ... 694edb10a0

GiantCompile2's note_local_weight scans every module of more than 100,000 SPIR-V words where the program cache writes or reads
it (private_memory.h scan), whatever RX_VK_LMEM_LOG. Its only reader is the precompile under compiler_service, which is
Metal's compiler service (MoltenVK's driver, macOS); on Windows and Linux the scan was work with no reader, at every start's
program cache read. It is now inside #if defined(__APPLE__), as RX_VK_LMEM_LOG's own scan is (private_memory::on, #681): off
macOS nothing is scanned and Stage::local_weight stays 0, as before this branch. On macOS nothing changes.

tests/test_giant_alone.py checks the gate (the weight noted on macOS, nothing scanned elsewhere); Stage::local_weight's
comment says so.

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

mooki referenced this pull request 2026-11-15 11:56:08 +00:00

WIP: fix(macos): KosmicKrisp's compiles go through the compiler service's precompile, as MoltenVK's do #785

mooki referenced this pull request 2026-11-15 11:56:12 +00:00

WIP: fix(macos): Metal's shader cache folder asked at the host's start, before SDL's window #786

mooki referenced this pull request 2026-11-15 11:56:17 +00:00

WIP: test: giant mesh fallbacks' shape through the real SPIR-V back end (tests/giant_shape_ir.cpp) #787

mooki added the

area/renderer

kind

bug

platform/macos

priority

high

labels 2026-11-15 13:59:54 +00:00

mooki force-pushed mac/giant-compile-2 from 694edb10a0 to 99e43bd2f3 2026-11-15 15:05:37 +00:00 Compare

mooki referenced this pull request 2026-11-15 17:40:00 +00:00

WIP: fix(macos): MoltenVK's precompile and pipelines on Metal #849

mooki commented 2026-11-15 18:08:44 +00:00

Author

Member

• Copy link
• Copy Markdown

Folded into #849 (fix(macos): MoltenVK's precompile and pipelines on Metal)

Folded into #849 (fix(macos): MoltenVK's precompile and pipelines on Metal)

mooki closed this pull request 2026-11-15 18:08:45 +00:00

Some checks failed

Hide checks

CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped

Details

CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped

Details

CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped

Details

Third-party parts / The same as upstream (pull_request) Has been skipped

Details

Website / Website on Cloudflare (pull_request) Has been skipped

Details

PR description / Description follows the template (pull_request_target) Successful in 7s

Details

CI / Conventional Commit title (pull_request) Successful in 4s

Details

CI / Workflow lint (actionlint) (pull_request) Successful in 7s

Details

Guide screenshots / Guide images and local UI source review (pull_request) Failing after 6s

Details

Third-party parts / As their notes say (pull_request) Successful in 10s

Details

Pull request closed

Please reopen this pull request to perform a merge.

Sign in to join this conversation.

Reviewers

No reviewers

Labels

Clear labels   

area/accessibility

Barriers for people with disabilities

  

area/audio

Sound and music

  

area/input

Controllers, keyboard, mouse

  

area/install

Installing, updating, building from your game

  

area/menu

In-game menu and settings

  

area/renderer

Vulkan renderer, shaders, effects

  

area/saves

Save files

  

area/upscaling

DLSS, FSR, frame generation

  

beanstalk: approved @ 1697603

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ 2c5a62e

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ 4fd82b7

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ 64d6d09

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ 6f91fae

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ 70a78f9

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ 8d361dc

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ 9d8356e

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ abf2227

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ d82f202

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ e5f1e40

Set by Beanstalk for show; the farm's database is what counts

  

beanstalk: approved @ ee8ab5f

Set by Beanstalk for show; the farm's database is what counts

  

ci: approved

A maintainer approved CircleCI for this fork PR (sticky; removed after 14 quiet days)

  

good first issue

A good start for a new contributor

  

gpu/amd

AMD GPUs

  

gpu/igpu

Integrated GPUs

  

gpu/intel

Intel GPUs

  

gpu/nvidia

NVIDIA GPUs

  

help wanted

Extra hands or knowledge wanted

  

kind

bug

Something doesn't work as it should

  

kind

chore

Build, CI, dependencies, tidying

  

kind

docs

Documentation

  

kind

feature

A new feature or an improvement

  

kind

performance

Frame rate, frame time, loading, memory

  

kind

question

A question rather than a change

  

needs measurements

Waiting for before/after measurements

  

platform/linux

Affects Linux (a change for every system carries both Windows and Linux)

  

platform/macos

macOS (Apple silicon or Intel Macs)

  

platform/steam-deck

Steam Deck

  

platform/windows

Affects Windows (a change for every system carries both Windows and Linux)

  

preview

Maintainers: deploy a preview of this PR's website (read its changes first). Removed after the run.

  

priority

critical

Crashes, data loss, or blocks most players

  

priority

high

Important: next in line

  

priority

low

Nice to have

  

regression

Worked in an earlier build, broken in a newer one: highest priority, above other bugs

  

status

blocked

Waits on something else first

  

status

confirmed

Reproduced or agreed on

  

status

duplicate

Already reported or proposed

  

status

invalid

Not a problem in this project

  

status

needs-info

Waiting for more information from the reporter

  

status

wontfix

Will not be worked on

  

testing wanted

Wanted: a test on other hardware (posts a test request in #test-requests)

  

ci: approved

No labels

area/accessibility

area/audio

area/input

area/install

area/menu

area/renderer

area/saves

area/upscaling

beanstalk: approved @ 1697603

beanstalk: approved @ 2c5a62e

beanstalk: approved @ 4fd82b7

beanstalk: approved @ 64d6d09

beanstalk: approved @ 6f91fae

beanstalk: approved @ 70a78f9

beanstalk: approved @ 8d361dc

beanstalk: approved @ 9d8356e

beanstalk: approved @ abf2227

beanstalk: approved @ d82f202

beanstalk: approved @ e5f1e40

beanstalk: approved @ ee8ab5f

ci: approved

good first issue

gpu/amd

gpu/igpu

gpu/intel

gpu/nvidia

help wanted

kind

bug

kind

chore

kind

docs

kind

feature

kind

performance

kind

question

needs measurements

platform/linux

platform/macos

platform/steam-deck

platform/windows

preview

priority

critical

priority

high

priority

low

regression

status

blocked

status

confirmed

status

duplicate

status

invalid

status

needs-info

status

wontfix

testing wanted

ci: approved

Milestone

Clear milestone

No items

No milestone

Projects

Clear projects

No items

No project

Assignees

Clear assignees

No assignees

1 participant

Notifications

Subscribe

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!784

No description provided.