Difference between revisions of "The Execution Frontier"
m (2026-11-15 status refresh: DS stage image authored+live (st0=st1=020a0481; DS 0x86040626->0x84000420, two boots); draw-issue mac=0x22 and stores remain; X start lottery limits the run rate) |
m (2026-11-15 (evening) status refresh: saved-window release carrier deterministic (c772), slot-34 census + SA[34] golden fill (0x265), release-window reorder landed but unexercised; the remaining blocker is call order; pack-completion lottery; DS 0x84000420 and stores remain) |
||
| Line 5: | Line 5: | ||
<blockquote>'''What this page is.''' The state of guest-facing execution: the chain that must fire for a stock guest CUDA kernel to run on the physical GPU, what has been proven about it, how we know, and where the leading edge is now. The chain fires end to end: verified guest CUDA clients execute on the physical GPU and wake up correctly; the leading edge is now breadth and hardening. A '''parallel graphics frontier''' (OpenGL/Vulkan execution) shares the same submission machinery at a different execution layer — [[Graphics Execution|<code>Graphics-Execution.md</code>]], [[OpenGL|<code>OpenGL.md</code>]], [[Vulkan|<code>Vulkan.md</code>]]. It is evidence-led: every statement carries a live observation, a decompilation finding, or a clearly labelled theory. Condensed from [https://git.vgpu.io/open-iov.git/tree/docs/04-implementation/03-execution-frontier.md <code>../docs/04-implementation/03-execution-frontier.md</code>]; the docs tree wins on disagreement.</blockquote> | <blockquote>'''What this page is.''' The state of guest-facing execution: the chain that must fire for a stock guest CUDA kernel to run on the physical GPU, what has been proven about it, how we know, and where the leading edge is now. The chain fires end to end: verified guest CUDA clients execute on the physical GPU and wake up correctly; the leading edge is now breadth and hardening. A '''parallel graphics frontier''' (OpenGL/Vulkan execution) shares the same submission machinery at a different execution layer — [[Graphics Execution|<code>Graphics-Execution.md</code>]], [[OpenGL|<code>OpenGL.md</code>]], [[Vulkan|<code>Vulkan.md</code>]]. It is evidence-led: every statement carries a live observation, a decompilation finding, or a clearly labelled theory. Condensed from [https://git.vgpu.io/open-iov.git/tree/docs/04-implementation/03-execution-frontier.md <code>../docs/04-implementation/03-execution-frontier.md</code>]; the docs tree wins on disagreement.</blockquote> | ||
Status: 2026-11-15, tree <code>master @ | Status: 2026-11-15, tree <code>master @ a03a68ea</code>. Tags: <code>[live]</code> observed; <code>[wip]</code> partial; <code>[wall]</code> current blocker; theories are labelled as such. | ||
== 1. The chain that should fire == | == 1. The chain that should fire == | ||
| Line 89: | Line 89: | ||
=== A parallel frontier: 3D graphics === | === A parallel frontier: 3D graphics === | ||
Graphics execution shares this page's submission and completion machinery but runs a different engine workload. The display and GL stacks now run end to end in the guest: the emulated display engine serves the modeset push buffers, nvidia-modeset/NvKms registers (<code>/dev/dri</code>), X settles, and the stock NVIDIA GLX path is fully green (<code>glxinfo -B</code> returns 0 with OpenGL 4.6.0 and direct rendering; <code>glxgears</code> renders ~520 FPS). The X DDX waits are fixed and its 3D replay executes; the '''first non-black GPU-rendered output''' landed: a pbuffer probe returns <code>pixel=ff0000ff</code>, the off-screen path produced 500/500 non-black 640x480 frames per run and captured videos (45.4 s on 2026-11-11, a 50 s capture on 2026-11-12), and GZDoom reaches <code>V_Init: allocate screen</code> with its GL 4.6.0 context when the shared nvClip <code>modeNum</code> is even. The X side of the path was hardened in the 11-12/11-13 wave (DDX idle-DMA/ScreenInit, USERD-latch, re-probe, kernel-mode spin and flip-event walls closed; X green for more than 10 minutes), captured GL sections now execute on the engine, and the direct-GL submission is fully decoded: no client push carries a method-grammar draw header — the work is macro-driven (data-block blobs plus small state pushes invoking MME macros) — and the recycled pushes are now recovered, so the client's draw-state push opens a <code>C597</code> section, captures, and reaches the engine with the golden MME overlay. The MME chain then advanced from the multi-part gate to '''draw-macro execution''': multi-frame keep-windows land, the part-launch poison is eliminated (the client's own <code>SET_REPORT_SEMAPHORE</code>/<code>SET_NOTIFY</code> writes to remapped client VAs were the real fault; they are redirected to a mapped scratch slot), the 2799-word pack completes (2799/2799), the first <code>MME-PACK-REARM</code> fires, the fixed-CB region is aliased, and <code>DRAW_IAB</code> (<code>mac=0x22</code>) runs with the SPH-BIND prelude intact (84 words) and the DS stage VAs populated. The '''DS stage-0/1 image is now authored and live''': a VTG SPH at <code>family+0x900</code> (<code>SPH-AUTHOR</code>, first word <code>020a0481</code>) is what both vertex slots fetch (<code>DS-IMAGE st0=st1=020a0481 code=ff007321</code>), the window's own later slot-1 bind is rewritten to it, and the DS value fell <code>0x86040626 -> 0x84000420</code> (reproduced on two boots). What is missing is '''window/screen pixels through the NVIDIA path''': the | Graphics execution shares this page's submission and completion machinery but runs a different engine workload. The display and GL stacks now run end to end in the guest: the emulated display engine serves the modeset push buffers, nvidia-modeset/NvKms registers (<code>/dev/dri</code>), X settles, and the stock NVIDIA GLX path is fully green (<code>glxinfo -B</code> returns 0 with OpenGL 4.6.0 and direct rendering; <code>glxgears</code> renders ~520 FPS). The X DDX waits are fixed and its 3D replay executes; the '''first non-black GPU-rendered output''' landed: a pbuffer probe returns <code>pixel=ff0000ff</code>, the off-screen path produced 500/500 non-black 640x480 frames per run and captured videos (45.4 s on 2026-11-11, a 50 s capture on 2026-11-12), and GZDoom reaches <code>V_Init: allocate screen</code> with its GL 4.6.0 context when the shared nvClip <code>modeNum</code> is even. The X side of the path was hardened in the 11-12/11-13 wave (DDX idle-DMA/ScreenInit, USERD-latch, re-probe, kernel-mode spin and flip-event walls closed; X green for more than 10 minutes), captured GL sections now execute on the engine, and the direct-GL submission is fully decoded: no client push carries a method-grammar draw header — the work is macro-driven (data-block blobs plus small state pushes invoking MME macros) — and the recycled pushes are now recovered, so the client's draw-state push opens a <code>C597</code> section, captures, and reaches the engine with the golden MME overlay. The MME chain then advanced from the multi-part gate to '''draw-macro execution''': multi-frame keep-windows land, the part-launch poison is eliminated (the client's own <code>SET_REPORT_SEMAPHORE</code>/<code>SET_NOTIFY</code> writes to remapped client VAs were the real fault; they are redirected to a mapped scratch slot), the 2799-word pack completes (2799/2799), the first <code>MME-PACK-REARM</code> fires, the fixed-CB region is aliased, and <code>DRAW_IAB</code> (<code>mac=0x22</code>) runs with the SPH-BIND prelude intact (84 words) and the DS stage VAs populated. The '''DS stage-0/1 image is now authored and live''': a VTG SPH at <code>family+0x900</code> (<code>SPH-AUTHOR</code>, first word <code>020a0481</code>) is what both vertex slots fetch (<code>DS-IMAGE st0=st1=020a0481 code=ff007321</code>), the window's own later slot-1 bind is rewritten to it, and the DS value fell <code>0x86040626 -> 0x84000420</code> (reproduced on two boots). The release path is now host-deterministic when the pack completes: the saved-window release carrier snapshots the held window and re-submits it with the calls released once the pack is resident (c772 end to end: save 240/68 -> fire -> synthetic <code>GR LAUNCH 0x6d6d6500</code> -> <code>MME-PACK-REARM</code> -> DS <code>0x84000420</code>), and the held-CALL census plus the SA[34] golden fill prove the <code>DRAW_IAB</code> call and its target are present (<code>MME-CALL-TARGET slot=34 method=0x3910 client=0x265 golden=0x265 used=0x265</code>). What is missing is '''window/screen pixels through the NVIDIA path''': the blocker is '''call order''' — the saved 728-B state window places the slot-34 run after the <code>0x33/0x39</code> setup, so the last <code>0x39</code> latches DS <code>0x84000420</code> and the MFE never reaches CALL(34) (c780), while the 324-B DRAW window places it first and ran <code>mac=0x22</code> (c716). A release-window reorder (<code>a03a68ea</code>) is landed but unexercised, and pack completion is still a per-boot lottery (poisoned pack-part; no pump pass after the carry arm; carry-armed-never-fired). The DS still carries the stage type/context bits (SPH5/SPH10/SPH18), so the draw does not store (<code>wrote=0</code>, <code>px0=0</code>); the window/screen present path is unproven, glxgears' window is black, and a synchronous window draw wedges X on some boots. The per-boot binding and X first-generation start lottery are now the dominant throughput limiter. The guest Vulkan pipeline's inline-to-memory upload arm is its gap. The full picture lives on [[Graphics Execution|<code>Graphics-Execution.md</code>]]. | ||
No breadth beyond these is claimed: Windows guests, migration and performance numbers remain planned. | No breadth beyond these is claimed: Windows guests, migration and performance numbers remain planned. | ||
| Line 147: | Line 147: | ||
'''Issue C — per-guest execution isolation.''' Multiple mediated devices with different emulated VRAM sizes and multiple guests coexist at the device level (two guests demonstrated); per-guest execution isolation for simultaneous CUDA guests is in progress. | '''Issue C — per-guest execution isolation.''' Multiple mediated devices with different emulated VRAM sizes and multiple guests coexist at the device level (two guests demonstrated); per-guest execution isolation for simultaneous CUDA guests is in progress. | ||
'''Issue D — the graphics pixel frontier.''' The display/KMS stack and the GL client now run end to end (NvKms registers, X settles, the stock GLX path is fully green with glxinfo 4.6.0 and ~520 FPS glxgears, the DDX 3D replay executes, the X DDX/ScreenInit stability walls are closed with X green >10 minutes, captured GL sections execute on the engine, the first non-black GPU-rendered frames and videos are captured off-screen, and the direct-GL ring/USERD machinery is substantially hardened); the direct-GL submission is fully decoded (macro-driven; no method-grammar draw header in any push), the recycled pushes are recovered, and the client's draw-state push opens, captures and reaches the engine. The MME chain now completes and executes the draw macro: multi-frame keep-windows land, the 2799-word pack completes, the first <code>MME-PACK-REARM</code> fires, the fixed-CB region is aliased, and <code>DRAW_IAB</code> (<code>mac=0x22</code>) runs with the SPH-BIND prelude intact and the DS stage VAs populated. The '''DS stage-0/1 image is now authored and live''' (a VTG SPH at <code>family+0x900</code>, fetched by both vertex slots as <code>st0=st1=020a0481</code>; DS fell <code>0x86040626 -> 0x84000420</code>, reproduced on two boots) | '''Issue D — the graphics pixel frontier.''' The display/KMS stack and the GL client now run end to end (NvKms registers, X settles, the stock GLX path is fully green with glxinfo 4.6.0 and ~520 FPS glxgears, the DDX 3D replay executes, the X DDX/ScreenInit stability walls are closed with X green >10 minutes, captured GL sections execute on the engine, the first non-black GPU-rendered frames and videos are captured off-screen, and the direct-GL ring/USERD machinery is substantially hardened); the direct-GL submission is fully decoded (macro-driven; no method-grammar draw header in any push), the recycled pushes are recovered, and the client's draw-state push opens, captures and reaches the engine. The MME chain now completes and executes the draw macro: multi-frame keep-windows land, the 2799-word pack completes, the first <code>MME-PACK-REARM</code> fires, the fixed-CB region is aliased, and <code>DRAW_IAB</code> (<code>mac=0x22</code>) runs with the SPH-BIND prelude intact and the DS stage VAs populated. The '''DS stage-0/1 image is now authored and live''' (a VTG SPH at <code>family+0x900</code>, fetched by both vertex slots as <code>st0=st1=020a0481</code>; DS fell <code>0x86040626 -> 0x84000420</code>, reproduced on two boots). The release is host-deterministic when the pack completes: the saved-window release carrier re-submits the held window with the calls released (c772), and the held-CALL census plus SA[34] golden fill prove the slot-34 <code>DRAW_IAB</code> address (<code>client=golden=used=0x265</code>). The remaining blocker is call order: the 728-B state window places the slot-34 run after the <code>0x33/0x39</code> setup, so the <code>0x39</code> DS latch pre-empts it (c780), while the 324-B DRAW window places it first and ran <code>mac=0x22</code> (c716); the reorder <code>a03a68ea</code> is landed but unexercised, and pack completion is still a per-boot lottery. The DS stage type/context bits (SPH5/SPH10/SPH18) remain after the call, so the draws still do not store. glxgears' window is black, a window draw wedges X on some boots, and the per-boot binding plus X first-generation start lottery is the dominant throughput limiter ([[Graphics Execution|<code>Graphics-Execution.md</code>]]). | ||
== 6. Lines of investigation (live) == | == 6. Lines of investigation (live) == | ||
| Line 155: | Line 155: | ||
# '''Per-guest execution isolation''' — build from the device-level coexistence to isolation for simultaneous CUDA guests. | # '''Per-guest execution isolation''' — build from the device-level coexistence to isolation for simultaneous CUDA guests. | ||
# '''Hold the acceptance battery''' — vector-add, matrix-multiply and the transformer kernel; each entry is accepted only on its own verification output (<code>bad=0</code> + <code>STATUS OK</code>). | # '''Hold the acceptance battery''' — vector-add, matrix-multiply and the transformer kernel; each entry is accepted only on its own verification output (<code>bad=0</code> + <code>STATUS OK</code>). | ||
# '''The graphics pixel frontier''' — the DS stage image is authored and live for both vertex slots; next | # '''The graphics pixel frontier''' — the DS stage image is authored and live for both vertex slots, and the saved-window release carrier now replays the held window deterministically when the pack completes; next exercise the release-window reorder so the slot-34 <code>DRAW_IAB</code> call runs before the setup calls and stores (<code>wrote>0</code>) at the bound render target, then clear the DS stage type/context bits, make the window/screen present land, and reduce the per-boot binding/X start lottery so the proven off-screen frames become window pixels; the lanes, the walls and the milestone ladder are on [[Graphics Execution|<code>Graphics-Execution.md</code>]]. | ||
== 7. Theories, resolved == | == 7. Theories, resolved == | ||
Revision as of 21:34, 15 November 2026
An absence of critical technical documentation has historically slowed growth and adoption of developer ecosystems for GPU virtualization.
This CC-BY-4.0 licensed content can either be used with attribution, or used as inspiration for new documentation, created by GPU vendors for public commercial distribution as developer documentation.
Where possible, this documentation will clearly label dates and versions of observed-but-not-guaranteed behaviour vs. vendor-documented stable interfaces/behaviour with guarantees of forward or backward compatibility.
The Execution Frontier
What this page is. The state of guest-facing execution: the chain that must fire for a stock guest CUDA kernel to run on the physical GPU, what has been proven about it, how we know, and where the leading edge is now. The chain fires end to end: verified guest CUDA clients execute on the physical GPU and wake up correctly; the leading edge is now breadth and hardening. A parallel graphics frontier (OpenGL/Vulkan execution) shares the same submission machinery at a different execution layer —
Graphics-Execution.md,OpenGL.md,Vulkan.md. It is evidence-led: every statement carries a live observation, a decompilation finding, or a clearly labelled theory. Condensed from../docs/04-implementation/03-execution-frontier.md; the docs tree wins on disagreement.
Status: 2026-11-15, tree master @ a03a68ea. Tags: [live] observed; [wip] partial; [wall] current blocker; theories are labelled as such.
1. The chain that should fire
A guest CUDA launch becomes a method stream in a push buffer, referenced by a GPFIFO ring entry, announced by a doorbell. The host emulation decodes it and forwards an equivalent method stream to a real channel owned by the module's resource-manager session. The hardware front-end fetches and executes the methods, the launch descriptor (QMD) is materialised and read by the GR engine, the grid is dispatched to the SMs, and completion is published as semaphores the guest waits on.
guest: builds launch + method stream
GPFIFO entry + doorbell
-> host: doorbell trap, decode, rebuild forward stream,
prewrite QMD, ring/USERD, doorbell
-> front-end: fetch GPFIFO entry (ring cursor advances)
-> front-end: execute methods (object bind, cache ops, report sem)
-> front-end: install inline QMD into the descriptor buffer
-> GR engine: read QMD through the channel's page tables
-> context switch loads the channel context (FECS/ucode)
-> GR: dispatch grid to the SMs
-> engine authors release semaphore + channel semaphore
-> host polls release, relays to guest; CUDA wakes
| # | Stage | State |
|---|---|---|
| 1 | Guest builds launch + method stream | [live] observed (stock driver, unmodified)
|
| 2 | GPFIFO entry + doorbell | [live] observed
|
| 3 | Host decode + forward stream + QMD prewrite + ring/USERD | [live] observed
|
| 4 | Front-end fetches the ring entry | [live] observed (ring cursor advances)
|
| 5 | Front-end executes methods | [live] observed (object bind, cache ops, report semaphore)
|
| 6 | Inline-QMD install (descriptor materialised) | [live] observed
|
| 7 | Engine reads the QMD | [live] observed
|
| 8 | Context switch loads the channel context | [live] context validity at dispatch is ruled in
|
| 9 | GR dispatches the grid to the SMs | [live] observed (the guest's results verify)
|
| 10 | Engine authors release + channel semaphore | [live] engine-authored releases relay to the guest
|
| 11 | Host relays completion; guest wakes | [live] the guest's synchronisation waits resolve
|
One-line summary: the whole chain is live; the leading edge is now breadth and hardening — the large-buffer staged-transfer class, reproducibility across boots, and per-guest execution isolation.
2. Where the leading edge is
A stock, unmodified guest CUDA program executes its kernels on the physical GPU and verifies its results. On fresh boots the vector-add client (victory_mail) prints VADD n=32768 bad=0 + STATUS OK, the matrix-multiply client (victory_matmul) prints MATMUL n=256 bad=0 + STATUS OK, and a transformer kernel prints dh=256 seq=64 bad=0, FFN4 layers=4 bad=0 + STATUS OK. The executing engine is the physical GPU under the module's own real GSP-RM session; the host CUDA bridge is not part of this path. Engine-authored completions relay to the guest and its synchronisation waits resolve.
The leading edge has moved from the launch chain itself — it fires — to breadth and hardening around it:
- The staged-transfer class. Multi-megabyte transfers between guest memory and device memory are under repair: some large multi-chunk clients still mis-verify, with the failure modes proven (a release applied before the op it owes, a ledger-vs-writer page divergence, and a readback racing a writeback).
- Reproducibility across boots. Two defects landed and were fixed: the boot-poisoning defect (under the driver's status-queue mode the emulation read the wrong queue cursor, so under load the reply ring could desynchronise and the first CUDA client would fail) and a ring-block ownership defect that could stall the first client after a reboot. Green clients reproduce across fresh boots; a formal every-boot campaign remains.
- Per-guest execution isolation. Multiple mediated devices with different emulated VRAM sizes and multiple guests already coexist at the device level (two guests demonstrated); per-guest execution isolation for multiple simultaneous CUDA guests is in progress.
A parallel frontier: 3D graphics
Graphics execution shares this page's submission and completion machinery but runs a different engine workload. The display and GL stacks now run end to end in the guest: the emulated display engine serves the modeset push buffers, nvidia-modeset/NvKms registers (/dev/dri), X settles, and the stock NVIDIA GLX path is fully green (glxinfo -B returns 0 with OpenGL 4.6.0 and direct rendering; glxgears renders ~520 FPS). The X DDX waits are fixed and its 3D replay executes; the first non-black GPU-rendered output landed: a pbuffer probe returns pixel=ff0000ff, the off-screen path produced 500/500 non-black 640x480 frames per run and captured videos (45.4 s on 2026-11-11, a 50 s capture on 2026-11-12), and GZDoom reaches V_Init: allocate screen with its GL 4.6.0 context when the shared nvClip modeNum is even. The X side of the path was hardened in the 11-12/11-13 wave (DDX idle-DMA/ScreenInit, USERD-latch, re-probe, kernel-mode spin and flip-event walls closed; X green for more than 10 minutes), captured GL sections now execute on the engine, and the direct-GL submission is fully decoded: no client push carries a method-grammar draw header — the work is macro-driven (data-block blobs plus small state pushes invoking MME macros) — and the recycled pushes are now recovered, so the client's draw-state push opens a C597 section, captures, and reaches the engine with the golden MME overlay. The MME chain then advanced from the multi-part gate to draw-macro execution: multi-frame keep-windows land, the part-launch poison is eliminated (the client's own SET_REPORT_SEMAPHORE/SET_NOTIFY writes to remapped client VAs were the real fault; they are redirected to a mapped scratch slot), the 2799-word pack completes (2799/2799), the first MME-PACK-REARM fires, the fixed-CB region is aliased, and DRAW_IAB (mac=0x22) runs with the SPH-BIND prelude intact (84 words) and the DS stage VAs populated. The DS stage-0/1 image is now authored and live: a VTG SPH at family+0x900 (SPH-AUTHOR, first word 020a0481) is what both vertex slots fetch (DS-IMAGE st0=st1=020a0481 code=ff007321), the window's own later slot-1 bind is rewritten to it, and the DS value fell 0x86040626 -> 0x84000420 (reproduced on two boots). The release path is now host-deterministic when the pack completes: the saved-window release carrier snapshots the held window and re-submits it with the calls released once the pack is resident (c772 end to end: save 240/68 -> fire -> synthetic GR LAUNCH 0x6d6d6500 -> MME-PACK-REARM -> DS 0x84000420), and the held-CALL census plus the SA[34] golden fill prove the DRAW_IAB call and its target are present (MME-CALL-TARGET slot=34 method=0x3910 client=0x265 golden=0x265 used=0x265). What is missing is window/screen pixels through the NVIDIA path: the blocker is call order — the saved 728-B state window places the slot-34 run after the 0x33/0x39 setup, so the last 0x39 latches DS 0x84000420 and the MFE never reaches CALL(34) (c780), while the 324-B DRAW window places it first and ran mac=0x22 (c716). A release-window reorder (a03a68ea) is landed but unexercised, and pack completion is still a per-boot lottery (poisoned pack-part; no pump pass after the carry arm; carry-armed-never-fired). The DS still carries the stage type/context bits (SPH5/SPH10/SPH18), so the draw does not store (wrote=0, px0=0); the window/screen present path is unproven, glxgears' window is black, and a synchronous window draw wedges X on some boots. The per-boot binding and X first-generation start lottery are now the dominant throughput limiter. The guest Vulkan pipeline's inline-to-memory upload arm is its gap. The full picture lives on Graphics-Execution.md.
No breadth beyond these is claimed: Windows guests, migration and performance numbers remain planned.
3. How we know (observables and their limits)
| Observable | What it proves | What it does not prove |
|---|---|---|
Client verification output (bad=0 + STATUS OK)
|
the guest executed its kernel and verified its results | by itself, which engine produced the results |
| Engine-authored release relayed to the guest | the engine executed the launch and the relay works | nothing about other launches |
| The guest's synchronisation wait resolving | completion reached the guest through the relay | nothing about other launches |
| Ring entry consumed; ring cursor advances | the front-end is alive and fetching | not engine execution — front-end signals are necessary but not sufficient |
| Reproduction across fresh boots | the path is not a lucky boot | no "every boot" claim yet while re-measurement is in progress |
| No GR fault recorded | the engine did not raise this error | silence is not health: a skipped launch is silent by construction |
Consequence: acceptance is verified guest results plus the engine-authored release; a green run counts as progress only when it reproduces across fresh boots.
4. What is exonerated (do not relitigate)
- Context validity at dispatch — the channel's context is valid when the launch is submitted (instance flag set).
- The descriptor destination window mapping — installed in the engine's table view at submit.
- Front-end fetch and control-block alignment — the entry is consumed with the host control block at offset 0.
- The shared context-buffer one-shot rule — traced to a shared per-GPU buffer already initialised in the same cycle; not the dispatch delta.
- Parenting/TSG for the fetch — both variants fetch identically.
- The copy-engine path — CE-class work, releases and fault relay are live (default off); the GR path is separate.
- The descriptor-gate line of investigation (the old T1–T4 theories) — the inline-descriptor install, the engine read, the dispatch, the engine-authored release and the guest wake-up are all observed; closed by observation.
- The old boot-poisoning defect — root-caused to the status-queue consumption cursor and fixed.
5. The clear issues (ranked)
Issue A — the staged-transfer class. Multi-megabyte transfers between guest memory and device memory are under repair: some large multi-chunk clients still mis-verify, with the failure modes proven and named.
Issue B — every-boot reproducibility (acceptance campaign). The boot-poisoning defect and the post-reboot ring-block ownership defect were root-caused and fixed, and green clients reproduce on fresh boots; the formal every-boot acceptance campaign is the remaining work.
Issue C — per-guest execution isolation. Multiple mediated devices with different emulated VRAM sizes and multiple guests coexist at the device level (two guests demonstrated); per-guest execution isolation for simultaneous CUDA guests is in progress.
Issue D — the graphics pixel frontier. The display/KMS stack and the GL client now run end to end (NvKms registers, X settles, the stock GLX path is fully green with glxinfo 4.6.0 and ~520 FPS glxgears, the DDX 3D replay executes, the X DDX/ScreenInit stability walls are closed with X green >10 minutes, captured GL sections execute on the engine, the first non-black GPU-rendered frames and videos are captured off-screen, and the direct-GL ring/USERD machinery is substantially hardened); the direct-GL submission is fully decoded (macro-driven; no method-grammar draw header in any push), the recycled pushes are recovered, and the client's draw-state push opens, captures and reaches the engine. The MME chain now completes and executes the draw macro: multi-frame keep-windows land, the 2799-word pack completes, the first MME-PACK-REARM fires, the fixed-CB region is aliased, and DRAW_IAB (mac=0x22) runs with the SPH-BIND prelude intact and the DS stage VAs populated. The DS stage-0/1 image is now authored and live (a VTG SPH at family+0x900, fetched by both vertex slots as st0=st1=020a0481; DS fell 0x86040626 -> 0x84000420, reproduced on two boots). The release is host-deterministic when the pack completes: the saved-window release carrier re-submits the held window with the calls released (c772), and the held-CALL census plus SA[34] golden fill prove the slot-34 DRAW_IAB address (client=golden=used=0x265). The remaining blocker is call order: the 728-B state window places the slot-34 run after the 0x33/0x39 setup, so the 0x39 DS latch pre-empts it (c780), while the 324-B DRAW window places it first and ran mac=0x22 (c716); the reorder a03a68ea is landed but unexercised, and pack completion is still a per-boot lottery. The DS stage type/context bits (SPH5/SPH10/SPH18) remain after the call, so the draws still do not store. glxgears' window is black, a window draw wedges X on some boots, and the per-boot binding plus X first-generation start lottery is the dominant throughput limiter (Graphics-Execution.md).
6. Lines of investigation (live)
- Repair the staged-transfer class — the green clients stay the regression battery and must remain green throughout.
- Complete the every-boot acceptance campaign — demonstrate the fixed boot path across a defined run of fresh boots before claiming boot-to-boot reproducibility.
- Per-guest execution isolation — build from the device-level coexistence to isolation for simultaneous CUDA guests.
- Hold the acceptance battery — vector-add, matrix-multiply and the transformer kernel; each entry is accepted only on its own verification output (
bad=0+STATUS OK). - The graphics pixel frontier — the DS stage image is authored and live for both vertex slots, and the saved-window release carrier now replays the held window deterministically when the pack completes; next exercise the release-window reorder so the slot-34
DRAW_IABcall runs before the setup calls and stores (wrote>0) at the bound render target, then clear the DS stage type/context bits, make the window/screen present land, and reduce the per-boot binding/X start lottery so the proven off-screen frames become window pixels; the lanes, the walls and the milestone ladder are onGraphics-Execution.md.
7. Theories, resolved
The descriptor-gate theories (T1–T4) are resolved and are not kept as open: the inline-descriptor install, the engine's QMD read, the grid dispatch, the engine-authored release and the guest wake-up are all directly observed, so the launch chain they questioned is proven end to end. The remaining work is engineering (staged transfers, an every-boot acceptance campaign, per-guest isolation, the graphics pixel frontier), each with an acceptance signal named before the work.
8. Claim discipline
- Engine-authored release is the acceptance signal for execution — now observed end to end; the guest's own verification (
bad=0+STATUS OK) is the guest-side acceptance signal. - Front-end signals are necessary but not sufficient. Ring cursor and front-end method execution can be front-end-authored; they never substitute for the engine-authored release.
- Silence is not health. No fault recorded does not mean no fault occurred.
- Emulator verdicts are instruction/memory-level. They bound behaviour, never timing or device environment.
- A green run counts only when it reproduces across fresh boots.
- A wall is closed only by an acceptance signal, named before the experiment.
9. Related pages
Project-Status.md— the project-level ladder.CUDA-Userspace-Driver.md— the guest-side client path.Physical-GPU-Backend.md— the backend the work is forwarded to.Graphics-Execution.md— the parallel graphics frontier (OpenGL/Vulkan), sharing this machinery.Execution-Plane.md— the execution layer's design.Introduction-to-GMMU.md— page tables, QMDs and the engines.../docs/04-implementation/03-execution-frontier.md— the canonical, continuously-updated version with the full evidence tables.