From 6107a002a5fb532f0b673c107c4cbe5d0d8925b4 Mon Sep 17 00:00:00 2001 From: Arthur Hanson Rasmusson Date: Mon, 16 Nov 2026 22:55:55 -0500 Subject: docs(wiki): 2026-11-16 evening status refresh - host draw chain proven end to end, guest submission is the wall - 11 wiki pages refreshed: the real frame pushes are admitted (persisted colour-target bind, draw markers inside counted runs, 40-chunk full-window replay, 128-slot ring); the beef draw lane latches a clean DS at the live-derived GS map; capture-less boots get the golden 2799-word MME pack; CALL hold/carry fire/SA re-arm fire with the latch kept across the channel recycle. - Decisive finding recorded as guest-side: 36 boots (c990-c1019) show no non-null CALL(34) draw macro from the client (interior 0x3910/0x3914 writes carry data=0x0) plus guest EGL/dri2 failures and OOM kills. - GZDoom video delivered via the guest software GL path (Mesa llvmpipe) is documented as a non-vGPU deliverable. - STATE-CURRENT.md snapshot prepended; wiki published to open-iov.org (revs 24210-24220; 68 pages audited, 0 problems). --- STATE-CURRENT.md | 61 +++++++++++++++++ wiki/.publish-manifest.json | 110 +++++++++++++++--------------- wiki/Execution-Frontier.md | 87 ++++++++++++------------ wiki/Execution-Plane.md | 48 ++++++------- wiki/FAQ.md | 45 ++++++------- wiki/Graphics-Execution.md | 157 ++++++++++++++++++++++--------------------- wiki/Host-Module.md | 46 ++++++------- wiki/OpenGL.md | 63 ++++++++++------- wiki/Physical-GPU-Backend.md | 23 ++++--- wiki/Project-Goals.md | 6 +- wiki/Project-Plan.md | 33 +++++---- wiki/Project-Status.md | 23 ++++--- wiki/System-Overview.md | 47 ++++++------- 13 files changed, 420 insertions(+), 329 deletions(-) diff --git a/STATE-CURRENT.md b/STATE-CURRENT.md index f1d8313..f18d3be 100644 --- a/STATE-CURRENT.md +++ b/STATE-CURRENT.md @@ -1,5 +1,66 @@ # Open-IOV Current State +> **Snapshot: 2026-11-16 ~22:55 (SESSION 157 continued; HEAD `a06d4b13` == +> `vgpu/master`; the working tree carries only this docs refresh; supersedes +> the 2026-11-16 ~00:35 entry below).** +> The graphics front crossed from "the `DRAW_IAB` macro executes end to end" +> to "the **host-side draw chain is proven end to end; the decisive wall is +> guest-side submission**". +> +> - **The host chain is deterministic.** The real frame pushes are admitted +> (a persisted colour-target bind carried from an earlier trusted push, +> draw markers accepted inside counted method runs, the 14.8-thousand-word +> window replayed as 40 chunks, a data-led window-start snap, a 128-slot +> candidate ring); the beef draw lane latches a **clean DS** +> (`DS-FAST2 ... ds_after=80000000`, c963) at the live-derived GS attribute +> map (maps=6, no SPH18), with the draw anchor moved after the first +> `0x3810` vertex-stream run and the raster enables emitted. Capture-less +> boots get a **golden 2799-word MME pack** from the golden library +> (`MME-GOLDEN`/`MME-PRELUDE`), and `MME-CALL-HOLD -> MME-CARRY-SAVE -> +> MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM` fires; the prelude +> latch survives the per-fire channel recycle (`MME-LATCH-KEEP`) and every +> admitted-window chunk is forwarded in order. +> - **The decisive finding is guest-side** (c990-c1019, 36 boots): the client +> never submits a non-null `CALL(34)` draw macro — every `0x3910/0x3914` +> hit is an interior method write with `data=0x0`, no CALL header exists in +> the admitted windows (`DRAW-SCAN-PRE` found=0), and those cycles logged +> guest EGL/dri2 failures and OOM kills (six missions `frames=0`). The vGPU +> path still stores nothing (`wrote=0`, `0/1025`, `px0=0`); the next work +> is guest-first — repair/verify the guest GL/EGL path and memory, then +> capture one real frame submission. +> - **GZDoom video delivered** through the guest's **software GL** path (Mesa +> llvmpipe), not the emulated GPU: four byte-verified files (22 s flight + +> 18 s orbit, 640x480/1280x960, 30 fps) at +> `https://files.vgpu.io/files/open-iov-gzdoom-20261116`. It is a +> guaranteed-quality deliverable, not a vGPU rendering claim. +> - **Host incident and recovery:** `vgsp` stuck in the UNLOADING state at +> 09:12 (a sema-service work item never completed; `refcnt=-1`, both +> `rmmod` and `insmod` blocked). An approved reboot was executed and the +> host recovered; follow-up: make the sema-service work quiesce bounded so +> a stuck item can never wedge unload again. +> - Commits since the last snapshot: eng89..eng89r (`ed8a9c6b`, `630f5a0d`, +> `d2f08383`, `42a9a97b`, `cb008b85`, `4e888f4d`, `9c09d3bf`, `60b1bf75`, +> `9731649e`, `d9645c7d`, `47a82e6a`, `ffa7e596`, `1ae572c9`, `ebacf220`, +> `a644d254`, `f0e34c4f`, `116b0ba7`, `a06d4b13`), plus the guest tooling +> `9c36fba4`; HEAD `a06d4b13` == `vgpu/master`, working tree clean before +> this refresh. +> +> CUDA front unchanged (backgrounded while graphics holds the device; its +> 10-30 status stands): `41343c63` green (`victory_mail` `VADD bad=0` + +> `STATUS OK`; `vecadd_loop` 100 launches PASS); the fresh-boot battery's red +> class is D2H-stage with release-discipline fixes staged; the SESSION 143 +> Vulkan fence regression is not re-measured. +> +> Live at check (read-only): host uptime 13 h 38 m (boot 2026-11-16 ~09:13, +> the approved recovery reboot); `vgsp` loaded (refcount 0); the campaign +> rotated its mdev from `6034deec-1bab-4ecc-b383-5608be912e18` to +> `5aafbae7-de3d-44e0-acaa-8b1d97cbdbfb` at 22:52 with a fresh QEMU cycle +> (12 GiB file-backed guest, kvmfr ivshmem); X alive (display-channel polls +> advancing); `nvidia-smi` reports no GPU (the claim is held); pstore empty; +> no Xid/Oops; no reboot initiated during the check. The open-iov.org wiki +> was refreshed alongside this snapshot (11 pages, revs 24210-24220; 68 +> pages audited, 0 problems). +> > **Snapshot: 2026-11-16 ~00:35 (SESSION 157 continued; HEAD `88d5005a` == > `vgpu/master`; working tree clean; supersedes the 2026-11-15 ~16:35 entry > below).** diff --git a/wiki/.publish-manifest.json b/wiki/.publish-manifest.json index 94d4cc9..f0b58c6 100644 --- a/wiki/.publish-manifest.json +++ b/wiki/.publish-manifest.json @@ -64,11 +64,11 @@ }, "FAQ": { "file": "FAQ.wiki", - "new_revid": 24201, - "old_revid": 24190, - "source_sha": "0eb614e09363c599", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:39Z", + "new_revid": 24212, + "old_revid": 24201, + "source_sha": "b8c5ff6fbb6df549", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:53:52Z", "title": "FAQ" }, "GMMU Multi-Tenant Protection": { @@ -127,11 +127,11 @@ }, "Graphics Execution": { "file": "Graphics-Execution.wiki", - "new_revid": 24202, - "old_revid": 24191, - "source_sha": "34cd26041ed56af4", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:39Z", + "new_revid": 24213, + "old_revid": 24202, + "source_sha": "8098340dc7ab9f35", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:53:52Z", "title": "Graphics Execution" }, "Guest Driver Lifecycle: A Field Guide": { @@ -226,11 +226,11 @@ }, "OpenGL": { "file": "OpenGL.wiki", - "new_revid": 24204, - "old_revid": 24193, - "source_sha": "f602534eaa8b1197", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:40Z", + "new_revid": 24215, + "old_revid": 24204, + "source_sha": "3b37cb8e79d35dc4", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:54:01Z", "title": "OpenGL" }, "Performance": { @@ -244,38 +244,38 @@ }, "Physical GPU Backend and Guest Wiring": { "file": "Physical-GPU-Backend.wiki", - "new_revid": 24205, - "old_revid": 24194, - "source_sha": "a76ad03eb0698087", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:41Z", + "new_revid": 24216, + "old_revid": 24205, + "source_sha": "7ef20e641634d8e2", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:54:02Z", "title": "Physical GPU Backend and Guest Wiring" }, "Project Goals": { "file": "Project-Goals.wiki", - "new_revid": 24206, - "old_revid": 24195, - "source_sha": "982fde8eab98b62f", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:41Z", + "new_revid": 24217, + "old_revid": 24206, + "source_sha": "bfe4d23f75dbc9c9", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:54:03Z", "title": "Project Goals" }, "Project Plan": { "file": "Project-Plan.wiki", - "new_revid": 24207, - "old_revid": 24196, - "source_sha": "8b97b136e3a0174e", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:42Z", + "new_revid": 24218, + "old_revid": 24207, + "source_sha": "5244de600de0129e", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:54:04Z", "title": "Project Plan" }, "Project Status": { "file": "Project-Status.wiki", - "new_revid": 24208, - "old_revid": 24197, - "source_sha": "0db90f5a36b02148", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:42Z", + "new_revid": 24219, + "old_revid": 24208, + "source_sha": "96a1beefe4fa981f", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:54:04Z", "title": "Project Status" }, "RPC Message Format": { @@ -289,11 +289,11 @@ }, "System Overview": { "file": "System-Overview.wiki", - "new_revid": 24209, - "old_revid": 24198, - "source_sha": "a2cf31484e358cc4", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:42Z", + "new_revid": 24220, + "old_revid": 24209, + "source_sha": "231c7ce3595a6865", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:54:05Z", "title": "System Overview" }, "Template:About message": { @@ -325,11 +325,11 @@ }, "The Execution Frontier": { "file": "Execution-Frontier.wiki", - "new_revid": 24199, - "old_revid": 24188, - "source_sha": "e50fe513268107dc", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:38Z", + "new_revid": 24210, + "old_revid": 24199, + "source_sha": "14a2659a1847931f", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:53:50Z", "title": "The Execution Frontier" }, "The Guest Stack and CUDASW": { @@ -343,20 +343,20 @@ }, "The Host Module (vgsp.ko)": { "file": "Host-Module.wiki", - "new_revid": 24203, - "old_revid": 24192, - "source_sha": "8d8062605fefe722", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:40Z", + "new_revid": 24214, + "old_revid": 24203, + "source_sha": "a715873cdb2312b0", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:53:53Z", "title": "The Host Module (vgsp.ko)" }, "The vGSP Execution Plane (vEP)": { "file": "Execution-Plane.wiki", - "new_revid": 24200, - "old_revid": 24189, - "source_sha": "a181986add587fd9", - "summary": "2026-11-16 status refresh (HEAD 88d5005a): DRAW_IAB mac=0x22 executes end to end (c788); TCS-off DS clean; remaining blockers = vertex buffer (eng74 VS-BLOB dumps the candidate) and render-target store/alias visibility (eng74 records the alias RT pages in WIT); stores 0", - "timestamp": "2026-11-16T05:38:38Z", + "new_revid": 24211, + "old_revid": 24200, + "source_sha": "27f9b22f9ec1b04c", + "summary": "2026-11-16 evening status refresh: host-side draw chain proven end to end; guest draw submission is the remaining wall; software-GL GZDoom video noted as non-vGPU", + "timestamp": "2026-11-17T03:53:51Z", "title": "The vGSP Execution Plane (vEP)" }, "UVM in the Guest": { diff --git a/wiki/Execution-Frontier.md b/wiki/Execution-Frontier.md index 4549f08..bfecad9 100644 --- a/wiki/Execution-Frontier.md +++ b/wiki/Execution-Frontier.md @@ -14,7 +14,7 @@ > [`../docs/04-implementation/03-execution-frontier.md`](../docs/04-implementation/03-execution-frontier.md); > the docs tree wins on disagreement. -Status: 2026-11-15, tree `master @ 88d5005a`. +Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[live]` observed; `[wip]` partial; `[wall]` current blocker; theories are labelled as such. @@ -131,24 +131,32 @@ 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 draw macro now -executes end to end** — c788 ran `DRAW_IAB` (`mac=0x22`) on a released held -window after the `MME-DRAW-MOVE` reorder, TCS-off (`45dbcdcd`) clears the DS -latch (the `0x84000420` was the synthesized TCS bind), a synthetic full-RT -viewport (`dab4a02c`) and a release chained after any GR launch -(`3481e62d`) complete the replay, and the DRAW_IAB body decodes with the -public Mesa MME toolchain (`mme_tu104_sim`: slot 34, 8 draws of 3 vertices) -— but the **vertex buffer** is not identified (no captured client push binds -the stream directly; the eng71 scan's CB-page candidate is a heuristic, and -a stale nonzero `VS0` also stores nothing) and **render-target store -visibility** is unproven (the release writes only CB/GR-context/report -pages; the big-surface alias pages do not yet populate `GUEST-WIT`); eng74 -(`88d5005a`) dumps the scanned vertex candidate (`VS-BLOB`) and records the -alias RT pages in the WIT, so both blockers are measurable next boot. The -draw does not store (`wrote=0`, `0/1025`, `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 +**window/screen pixels through the NVIDIA path**. The draw macro executes end +to end (c788 ran `DRAW_IAB` (`mac=0x22`) on a released held window after the +`MME-DRAW-MOVE` reorder; TCS-off, `45dbcdcd`, clears the DS latch; a synthetic +full-RT viewport, `dab4a02c`, and a chained release, `3481e62d`, complete the +replay; the body decodes with the public Mesa MME toolchain as 8 draws of 3 +vertices), and the **11-16 wave proved the host-side chain deterministic end +to end**: the real frame pushes are admitted (persisted colour-target bind, +draw markers inside counted runs, a 14.8-thousand-word window replayed as 40 +chunks, a 128-slot candidate ring), the beef draw lane latches a **clean DS** +(`DS-FAST2 ... ds_after=80000000`, c963) at the live-derived GS attribute map, +capture-less boots get a **golden 2799-word MME pack**, and +`MME-CALL-HOLD -> MME-CARRY-SAVE -> MME-CARRY-FIRE -> MME-PACK-REARM -> +MME-SA-REARM` fires with the prelude latch kept across the channel recycle. +The **decisive finding is guest-side**: across 36 boots (c990-c1019) the +client never submitted a non-null `CALL(34)` draw macro — every +`0x3910/0x3914` hit is an interior method write with `data=0x0`, no CALL +header exists in the admitted windows, and those cycles logged guest +EGL/dri2 failures and OOM kills. The next work is guest-first (repair and +verify the guest GL/EGL path and memory, then capture one real frame +submission), followed by the vertex/store and the window/screen present +path; the draw still does not store on the vGPU path (`wrote=0`, `0/1025`, +`px0=0`), glxgears' window is black, a synchronous window draw can wedge X, +and the per-boot X first-generation start lottery is the dominant throughput +limiter. A GZDoom video was separately delivered through the guest's +**software GL** path (Mesa llvmpipe) as a guaranteed-quality deliverable; it +is not a vGPU rendering claim. The guest Vulkan pipeline's inline-to-memory upload arm is its gap. The full picture lives on [`Graphics-Execution.md`](Graphics-Execution.md). @@ -215,29 +223,24 @@ 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 draw macro now executes end to end (c788 ran -`DRAW_IAB` `mac=0x22` on the released held window after the `MME-DRAW-MOVE` -reorder; TCS-off clears the DS latch; the synthetic viewport and the chained -release complete the replay; the body decodes with the public Mesa MME -toolchain as 8 draws of 3 vertices). The remaining blockers are the vertex -buffer (no captured client push binds the stream directly; the eng71 scan -candidate is a heuristic) and render-target store/alias visibility (the -big-surface alias pages do not yet enter `GUEST-WIT`; eng74 `88d5005a` -records them and dumps the candidate blob), 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 +captures and reaches the engine. The 11-16 wave then proved the **host-side draw chain deterministic end to +end**: the real frame pushes are admitted (a persisted colour-target bind +from an earlier trusted push, draw markers inside counted method runs, the +14.8-thousand-word window replayed as 40 chunks, a 128-slot candidate ring), +the beef draw lane latches a **clean DS** (`DS-FAST2 ... ds_after=80000000`, +c963) at the live-derived GS attribute map, capture-less boots get a +**golden 2799-word MME pack**, and +`MME-CALL-HOLD -> MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM` fires +with the prelude latch kept across the channel recycle. The **decisive +finding is guest-side**: across 36 boots (c990-c1019) the client never +submitted a non-null `CALL(34)` draw macro — every `0x3910/0x3914` hit is an +interior method write with `data=0x0`, no CALL header exists in the admitted +windows, and the same cycles logged guest EGL/dri2 failures and OOM kills. +A GZDoom video was separately delivered through the guest's **software GL** +path (Mesa llvmpipe) as a guaranteed-quality deliverable; it is not a vGPU +rendering claim. The next work is guest-first (a real draw submission), then +the vertex/store, the window/screen present, and the per-boot X +first-generation start lottery ([`Graphics-Execution.md`](Graphics-Execution.md)). ## 6. Lines of investigation (live) diff --git a/wiki/Execution-Plane.md b/wiki/Execution-Plane.md index 86a9d49..d8786dd 100644 --- a/wiki/Execution-Plane.md +++ b/wiki/Execution-Plane.md @@ -8,7 +8,7 @@ > when the two disagree, the docs tree wins. Front door: > [`../docs/README.md`](../docs/README.md). -Status: 2026-11-15, tree `master @ 88d5005a`. Tags: `[live]` proven with the +Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[live]` proven with the stock guest driver; `[gated]` implemented, default-off or parameter-gated; `[wip]` partial; `[wall]` current blocker; `[target]` named success latch; `[planned]` designed, not built. @@ -161,32 +161,26 @@ guest: push + QMD + GPFIFO entry + doorbell (BAR0 0x88704) (no method-grammar draw header; the work is macro-driven — data-block blobs plus small state pushes invoking MME macros), the recycled pushes are recovered, and the client's draw-state push opens, captures and reaches the - engine (`GR LAUNCH submitted` + OK, golden MME overlay accepted). 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 (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` - (first word `020a0481`) is fetched by both vertex slots - (`DS-IMAGE st0=st1=020a0481`; DS 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), and the held-CALL census plus the SA[34] golden fill prove the - slot-34 `DRAW_IAB` target (`client=golden=used=0x265`). **The draw macro - now executes end to end**: c788 ran `DRAW_IAB` (`mac=0x22`) on the released - held window after the `MME-DRAW-MOVE` reorder, TCS-off (`45dbcdcd`) clears - the DS latch (the `0x84000420` was the synthesized TCS bind), a synthetic - full-RT viewport (`dab4a02c`) and a chained release (`3481e62d`) complete - the replay, and the body decodes with the public Mesa MME toolchain - (`mme_tu104_sim`: 8 draws of 3 vertices). No non-black - **window/screen** frame has been produced through the NVIDIA path yet: the - remaining blockers are the vertex buffer (no captured client push binds - the stream; the eng71 scan candidate is a heuristic) and render-target - store/alias visibility (the big-surface alias pages do not yet enter - `GUEST-WIT`), so the draw does not store (`wrote=0`, `0/1025`, - `px0=0`); the window/screen present is unproven, and the per-boot binding - plus X first-generation lottery is the throughput limiter. Those are the + engine (`GR LAUNCH submitted` + OK, golden MME overlay accepted). The 11-16 wave then proved the + **host-side chain deterministic end to end**: the real frame pushes are + admitted (persisted colour-target bind, draw markers inside counted runs, a + 14.8-thousand-word window replayed as 40 chunks, a 128-slot candidate ring), + the beef draw lane latches a **clean DS** (`DS-FAST2 ... ds_after=80000000`, + c963) at the live-derived GS attribute map, capture-less boots get a + **golden 2799-word MME pack**, and `MME-CALL-HOLD -> MME-CARRY-SAVE -> + MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM` fires with the prelude + latch kept across the channel recycle. The **decisive finding is + guest-side**: across 36 boots (c990-c1019) the client never submitted a + non-null `CALL(34)` draw macro — every `0x3910/0x3914` hit is an interior + method write with `data=0x0`, no CALL header exists in the admitted + windows, and those cycles logged guest EGL/dri2 failures and OOM kills. + No non-black **window/screen** frame has been produced through the NVIDIA + path yet: the next work is guest-first (a real draw submission), then the + vertex/store and the window/screen present, with the per-boot X + first-generation lottery as the throughput limiter. A GZDoom video was + separately delivered through the guest's **software GL** path (Mesa + llvmpipe) as a guaranteed-quality deliverable; it is not a vGPU rendering + claim.Those are the named blockers. The lanes and the ladder are on [`Graphics-Execution.md`](Graphics-Execution.md). diff --git a/wiki/FAQ.md b/wiki/FAQ.md index 7c7a0a0..e64ce2f 100644 --- a/wiki/FAQ.md +++ b/wiki/FAQ.md @@ -5,7 +5,7 @@ > [`../docs/09-reference/glossary-and-faq.md`](../docs/09-reference/glossary-and-faq.md); > the docs tree wins on disagreement. -Status: 2026-11-15, tree `master @ 88d5005a`. +Status: 2026-11-16, tree `master @ a06d4b13`. ## Project and positioning @@ -52,28 +52,27 @@ minutes), captured GL sections now execute on the engine, and the direct-GL submission is fully decoded: it carries no classic draw header (the work is macro-driven; data-block blobs plus small state pushes invoking MME macros), 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` (first word `020a0481`) is fetched by both vertex slots -(`st0=st1=020a0481`), 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 replays the held window -with the calls released; the held-CALL census plus the SA[34] golden fill -prove `client=golden=used=0x265`). **The draw macro now executes end to -end**: c788 ran `DRAW_IAB` (`mac=0x22`) on a released held window after the -`MME-DRAW-MOVE` reorder, TCS-off clears the DS latch (the `0x84000420` was -the synthesized TCS bind), a synthetic viewport and a chained release -complete the replay, and the body decodes with the public Mesa MME toolchain -(8 draws of 3 vertices). Window and screen pixels are still the wall: the -remaining blockers are the vertex buffer (no captured client push binds the -stream; the eng71 scan candidate is a heuristic) and render-target -store/alias visibility (the big-surface alias pages do not yet enter the -write-witness set), so the draw never stores, glxgears' window is -black, and the per-boot binding plus X first-generation start lottery is the -throughput limiter. The +captures and reaches the engine. The 11-16 wave then proved the **host-side draw chain end to +end**: the real frame pushes are admitted (a persisted colour-target bind +carried from an earlier trusted push, draw markers inside counted method +runs, the 14.8-thousand-word window replayed as 40 chunks, a 128-slot +candidate ring), the beef draw lane latches a **clean DS** +(`DS-FAST2 ... ds_after=80000000`, c963) at the live-derived GS attribute +map, capture-less boots get a **golden 2799-word MME pack**, and +`MME-CALL-HOLD -> MME-CARRY-SAVE -> MME-CARRY-FIRE -> MME-PACK-REARM -> +MME-SA-REARM` fires with the prelude latch kept across the channel recycle. +The **decisive finding is guest-side**: across 36 boots (c990-c1019) the +client never submitted a non-null `CALL(34)` draw macro — every +`0x3910/0x3914` hit is an interior method write with `data=0x0`, no CALL +header exists in the admitted windows, and those cycles logged guest +EGL/dri2 failures and OOM kills. Window and screen pixels are still the +wall: the next work is guest-first (repair and verify the guest GL/EGL path +and memory, then capture one real draw submission), followed by the +vertex/store and the window/screen present, with the per-boot X +first-generation start lottery as the throughput limiter. A GZDoom video was +separately delivered through the guest's **software GL** path (Mesa +llvmpipe) as a guaranteed-quality deliverable — it is not a vGPU rendering +claim. The guest Vulkan pipeline runs end to end (device → command buffer → fence → readback) but frames are black. See [`OpenGL.md`](OpenGL.md), [`Vulkan.md`](Vulkan.md) and diff --git a/wiki/Graphics-Execution.md b/wiki/Graphics-Execution.md index 34b8147..4d879df 100644 --- a/wiki/Graphics-Execution.md +++ b/wiki/Graphics-Execution.md @@ -12,7 +12,7 @@ > [`../docs/04-implementation/04-real-render-walls.md`](../docs/04-implementation/04-real-render-walls.md) > (the measured walls); the docs tree wins on disagreement. -Status: 2026-11-15, tree `master @ 88d5005a`. Tags: `[live]` observed end to +Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[live]` observed end to end; `[wip]` partially built; `[wall]` current blocker; `[target]` defined success state; `[planned]` designed, not built. @@ -147,19 +147,33 @@ fidelity: toolchain (`mme_tu104_sim`): slot 34 (`0x265`) emits 8 draws of 3 vertices (`SET_VERTEX_ARRAY_START` 0..21, `DRAW_VERTEX_ARRAY` 3). A synthetic full-RT viewport (`dab4a02c`) and a release chained after any GR launch - (`3481e62d`) complete the replay. **The remaining blockers are the vertex - buffer and render-target visibility**: no captured client push binds the - vertex stream directly (no `0x1c00/0x1c04` pair outside SPH payloads), so - the `VS0` bound by the eng71 scan (`sema_gl_vs_autobind`) is a heuristic - CB-page candidate (score 8), and a nonzero stale `VS0` also stores nothing - (c811); and the release writes only CB/GR-context/report pages — the - big-surface alias pages did not populate `GUEST-WIT`, so an RT store would - be invisible. eng74 (`88d5005a`) now dumps the scanned candidate blob - (`VS-BLOB`) and records the surface-alias RT pages in the WIT, so both - blockers are measurable on the next boot. Stores still miss (`wrote=0`, - `0/1025` pages, `px0=0`). The - window/screen present is still the frontier (§6), and the pack-completion - and X-start lotteries are the throughput limiters. + (`3481e62d`) complete the replay. **The 11-16 wave then proved the host-side chain end to end.** The real + frame pushes are admitted: the colour-target bind is persisted from an + earlier trusted push (`RT-PERSIST`; the client binds the target once, not + per frame), draw markers are accepted inside counted method runs, and the + 14.8-thousand-word window is admitted and replayed as 40 chunks with a + data-led start snap (`WIN-START-SNAP`) and a 128-slot candidate ring. The + beef draw lane latches a **clean DS** (`DS-FAST2 ... ds_after=80000000`, + c963) at the live-derived GS attribute map (maps=6), with no SPH18; the + draw anchor now moves the call after the first `0x3810` vertex-stream run + and the raster enables are emitted. Capture-less boots get a **golden + 2799-word MME pack** built from the golden library (`MME-GOLDEN`, + `MME-PRELUDE`), and the chain `MME-CALL-HOLD -> MME-CARRY-SAVE -> + MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM` fires; the prelude latch + survives the per-fire channel recycle (`MME-LATCH-KEEP`) and every + admitted-window chunk is forwarded in order. **The decisive finding is + guest-side**: across 36 boots (c990-c1019) the client never submits a + non-null `CALL(34)` draw macro — every `0x3910/0x3914` hit is an interior + method write with `data=0x0`, no CALL header exists in the admitted + windows (`DRAW-SCAN-PRE` found=0), and the same cycles logged guest + EGL/dri2 failures and OOM kills, so the guest GL path was not producing a + real draw submission. A GZDoom video (four files, 22 s flight + 18 s + orbit, 640x480/1280x960, 30 fps, byte-verified) was delivered through the + guest's **software GL** path (Mesa llvmpipe) as a guaranteed-quality + deliverable — not a vGPU rendering claim. Stores on the vGPU path still + miss (`wrote=0`, `0/1025` pages, `px0=0`); the window/screen present is + still the frontier (§6), and the pack-completion and X-start lotteries + remain the throughput limiters. ## 4. The channel and object picture * **Every submission lives on a channel**: a GPFIFO ring plus engine objects, @@ -219,9 +233,12 @@ swaps, and the GR backend no longer times out (the pair-close/pair-safe DDX/ScreenInit stability walls are closed, and the direct-GL ring/USERD machinery is hardened. The MME pack completes and the draw macro runs, and the authored DS stage image is live for both vertex slots; the released - replay now executes the `DRAW_IAB` (`mac=0x22`) with a synthetic viewport, - and the next step is the vertex-buffer identity and the render-target - store/alias visibility, then the window/screen present path. + replay executes the `DRAW_IAB` (`mac=0x22`) with a synthetic viewport, and + the 11-16 wave proved the whole host chain deterministic (admission of the + real pushes, clean DS, golden pack, CALL hold, carry fire, SA re-arm). The + remaining question is now guest-side — a real non-null `CALL(34)` draw + submission — after which the vertex/store and the window/screen present + path are next. During bring-up the module also carries a **diagnostics-only mirror** for apps that spin on a shared progress word; it exists so a run can proceed while the @@ -230,53 +247,34 @@ requires it switched off, along with any external poke. ## 6. Where the frontier is (ranked walls) -1. **Direct-GL MME draw-macro execution and stores** `[wall]`. Delivery to - the lane and the multi-part program gate are closed: the submission is - fully decoded (nine NV906F entries tile one contiguous buffer; no - method-grammar draw header exists; the per-frame work is data-block blobs - plus real state pushes that invoke MME macros), the recycled pushes are - recovered by the content-gated FB-shadow and LOW-band rescues, the - client's 324-B draw-state push opens a `C597` section, is captured and - marked for the verbatim 3D lane, and reaches the engine with the golden - MME overlay (`GR LAUNCH submitted` + OK). The 2799-word pack completes - (2799/2799), the first `MME-PACK-REARM` fires (engine-global completion - plus keep-done-across-recycle), the fixed-CB region is aliased, the - released calls run macros, and `DRAW_IAB` (`mac=0x22`) executes on the 324-B - window class after a cross-lane `MME-PACK-REARM`. The **DS stage-0/1 image - is now authored and live**: a VTG SPH is written at `family+0x900` - (`SPH-AUTHOR`, first word `020a0481`) and the window's own `0x2054` slot-1 - bind is rewritten to it (`SPH-SLOT1-REWRITE`), so the DS latch reads - `st0=st1=020a0481 code=ff007321` and the DS value falls - `0x86040626 -> 0x84000420` (reproduced on two boots). The release is - host-deterministic when the pack completes: the saved-window release - carrier snapshots the held window and re-submits it with calls released - once the pack is resident (c772: `MME-CARRY-SAVE win=240 held=68` -> - `MME-CARRY-FIRE mode=release` -> synthetic `GR LAUNCH push=0x6d6d6500` -> - `MME-PACK-REARM` gen=5 -> DS `0x84000420` -> `MME-CARRY-COMPLETE`); the - held-CALL census and SA[34] golden fill settle the call and its address - (`MME-CALL-TARGET slot=34 method=0x3910 client=0x265 golden=0x265 - used=0x265`; `MME-GOLDEN sa-fill slot=34 entry=0x265`). **The draw macro - now executes end to end**: c788 ran `DRAW_IAB` (`mac=0x22`) on the released - held window after the `MME-DRAW-MOVE` reorder (`MME-FAST ... mac=0x22 - run=1`), TCS-off (`45dbcdcd`) clears the DS latch, the synthetic viewport - (`dab4a02c`) and the chained release (`3481e62d`) complete the replay, and - the body decodes with the public Mesa MME toolchain (`mme_tu104_sim`: 8 - draws of 3 vertices). **The remaining blockers are the vertex buffer and - render-target visibility**: no captured client push binds the vertex - stream directly (the eng71 scan lands a heuristic CB-page candidate, - score 8; a stale nonzero `VS0` also stores nothing), and the - big-surface alias pages do not enter `GUEST-WIT`, so an RT store would be - invisible; eng74 (`88d5005a`) dumps the scanned candidate (`VS-BLOB`) and - records the alias RT pages in the WIT for the next boot; the release - writes only CB/GR-context/report pages and stores - still miss (`wrote=0`, `0/1025`, `px0=0`). Closed on the way: the QMD-carrier theory - (refuted: no QMD bit in the entry format, no QMD magic in 256 MiB BAR1) - and RT routing (the clear targets RT0 while the window binds RT1; RT0 bind - verified 16x with correct target/geometry, still 61/61 `wrote=0`). The - `CODESRC` fault-park class is prevented by relocating a suspect program - page to the engine-mapped window-0 shadow (`17c7ed7c`; validated boot: 31 - relocations, 51 GR launches, 79 GP_GET advances, 0 `FAULT_PDE`, 0 - `WEDGE-REARM`, `backend_ok=35`). +1. **Guest draw submission and the direct-GL store** `[wall]`. The + **host-side chain is proven end to end** (2026-11-16): the real frame + pushes are admitted (persisted colour-target bind from an earlier trusted + push; draw markers accepted inside counted method runs; the 14.8-thousand- + word window admitted and replayed as 40 chunks with a data-led start snap + and a 128-slot candidate ring), the beef draw lane latches a **clean DS** + (`DS-FAST2 ... ds_after=80000000`, c963) at the live-derived GS attribute + map, capture-less boots get a **golden 2799-word MME pack** from the + golden library, and `MME-CALL-HOLD -> MME-CARRY-SAVE -> MME-CARRY-FIRE -> + MME-PACK-REARM -> MME-SA-REARM` fires with the prelude latch kept across + the per-fire channel recycle; chunks are forwarded in order. The decisive + finding of c990-c1019 (36 boots) is **guest-side**: the client never + submits a non-null `CALL(34)` draw macro — every `0x3910/0x3914` hit is an + interior method write with `data=0x0`, no CALL header exists in the + admitted windows (`DRAW-SCAN-PRE` found=0), and those cycles logged guest + EGL/dri2 failures and OOM kills, so the guest GL path was not producing a + real draw submission in that boot class. The next work is guest-first + (repair/verify the guest EGL/dri2 path and memory, only then capture one + frame's submission); `MME-CALL-ARGS slot=34 data=`, `slot34=1`, + `mac=0x22`, `VA=0xd74` and colour pages at `0x15d...` are the acceptance + receipts. Closed on the way: the QMD-carrier theory (refuted: no QMD bit + in the entry format, no QMD magic in 256 MiB BAR1), RT routing (the clear + targets RT0 while the window binds RT1; RT0 bind verified 16x with correct + target/geometry, still 61/61 `wrote=0`), and the `CODESRC` fault-park class + (suspect program page relocated to the engine-mapped window-0 shadow, + `17c7ed7c`; validated boot: 31 relocations, 51 GR launches, 79 GP_GET + advances, 0 `FAULT_PDE`, 0 `WEDGE-REARM`, `backend_ok=35`). Stores on the + vGPU path still miss (`wrote=0`, `0/1025`, `px0=0`). 2. **Window/screen present** `[wall]`. The pbuffer and off-screen frame paths are proven (`pixel=ff0000ff`, 500/500 non-black frames, captured videos), but a windowed present does not land: glxgears' window is black, the DDX @@ -344,8 +342,11 @@ requires it switched off, along with any external poke. | DS stage-0/1 image: a VTG SPH is authored at `family+0x900` and the window's own slot-1 bind rewritten to it; the DS latch reads `st0=st1=020a0481` | `[live]` | | Saved-window release carrier (held window snapshotted at `MME-CALL-HOLD` and re-submitted with calls released once the pack is resident, c772); held-CALL census + SA[34] golden fill (`client=golden=used=0x265`); synthetic full-RT viewport (`dab4a02c`); release chained after any GR launch (`3481e62d`) | `[live]` | | Per-stage SPH disable (TCS off, `45dbcdcd`) clears the DS latch (the `0x84000420` was the synthesized TCS bind) | `[live]` | -| Vertex buffer: the client's captured pushes never bind the stream directly (no `0x1c00/0x1c04` pair outside SPH payloads); the eng71 scan binds a heuristic CB-page candidate (score 8); a stale nonzero `VS0` also stores nothing (c811); eng74 `VS-BLOB` dumps the candidate for validation/rejection | `[wall]` | -| Render-target store/alias visibility: the release writes only CB/GR-context/report pages; eng74 (`88d5005a`) records the surface-alias RT pages in `GUEST-WIT` so an alias store is provable; stores `wrote=0` / `0/1025` | `[wall]` | +| Real frame pushes admitted: persisted colour-target bind from an earlier trusted push (`RT-PERSIST`), draw markers accepted inside counted method runs, 14.8-thousand-word window admitted and replayed as 40 chunks (`3D stream chunked ... -> 40 chunk(s)`), data-led start snap (`WIN-START-SNAP`), 128-slot candidate ring | `[live]` | +| Clean DS on the beef draw lane after the full-window chunking (`DS-FAST2 ... ds_after=80000000`, c963) at the live-derived GS attribute map (maps=6), no SPH18; draw anchor after the first `0x3810` and raster enables emitted | `[live]` | +| Golden 2799-word MME pack on capture-less boots (`MME-GOLDEN overlay`, `MME-PRELUDE pack ir_words=2799`); `MME-CALL-HOLD -> MME-CARRY-SAVE -> MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM` fires; prelude latch kept across the per-fire channel recycle (`MME-LATCH-KEEP`); admitted-window chunks forwarded in order | `[live]` | +| Guest draw submission: across 36 boots (c990-c1019) the client never submits a non-null `CALL(34)` draw macro — every `0x3910/0x3914` hit is an interior method write with `data=0x0`; no CALL header in the admitted windows (`DRAW-SCAN-PRE` found=0); guest EGL/dri2 failures and OOM kills in the same cycles; stores `wrote=0` / `0/1025` | `[wall]` | +| GZDoom video via the guest **software GL** path (Mesa llvmpipe): four byte-verified files (22 s flight + 18 s orbit, 640x480/1280x960, 30 fps) — a guaranteed-quality deliverable, **not** a vGPU rendering claim | `[live]` (software path) | | Pack-completion and shallow-boot lotteries gate the deterministic release (throughput limiters) | `[wip]` | | Window/screen present produces non-black window pixels | `[wall]` | | X screen-init first-generation lottery (`modeNum` parity; only an immediately-post-boot X passes DDX DMA init; dominant throughput limiter) | `[wip]` | @@ -355,18 +356,24 @@ requires it switched off, along with any external poke. ## 8. What is not claimed * No **window/screen** pixel has been produced by the emulated vGPU's 3D - pipeline yet; every screen capture so far is black. The proven non-black - frames and the videos (45.4 s and 50 s) come from the off-screen pbuffer - path (pbuffer -> sysmem -> kvmfr ivshmem -> host reader), not from a - windowed X screen capture. + pipeline yet; every vGPU screen capture so far is black. The proven + non-black frames and the videos (45.4 s and 50 s) come from the off-screen + pbuffer path (pbuffer -> sysmem -> kvmfr ivshmem -> host reader), not from + a windowed X screen capture. +* **The 2026-11-16 GZDoom video is a software-GL deliverable, not a vGPU + result.** It was rendered by Mesa llvmpipe inside the guest + (`GL_RENDERER: llvmpipe`) and captured through the same SDL hook; it exists + as a guaranteed-quality demonstration while the GPU-GL pixel path is being + worked. It must not be read as the emulated vGPU's 3D pipeline rendering + GZDoom. * Display/KMS bring-up (NvKms, `/dev/dri`, X, a real GL context) is not a rendered-frame claim. GZDoom reaching `V_Init: allocate screen` proves the client's GL init and the direct-GL GR lane, not the game loop or a - presented frame; the client's draw-state push reaches the engine, the MME - program completes and the released replay executes the draw macro - (`DRAW_IAB`, `mac=0x22`, with a synthetic viewport), but the draw's vertex - buffer is not yet identified and the render-target alias pages are not yet - WIT-visible, so the stores are still missing and the window stays black. + presented frame; the host-side chain is proven end to end (admission, + clean DS, golden pack, CALL hold, carry fire, SA re-arm), but the decisive + 11-16 finding is that the client did not submit a non-null `CALL(34)` draw + macro in the recorded boots, so the stores are still missing and the + window stays black. * The engine-zero-write (NOWRITE) campaign is not a rendering result: it and the draw census together proved the submission is macro-driven (no method-grammar draw header exists), that RT routing is not the cause, and diff --git a/wiki/Host-Module.md b/wiki/Host-Module.md index 88a0750..981c371 100644 --- a/wiki/Host-Module.md +++ b/wiki/Host-Module.md @@ -6,7 +6,7 @@ > source: [`../docs/03-architecture/06-host-module-and-hybrid-model.md`](../docs/03-architecture/06-host-module-and-hybrid-model.md); > the docs tree wins on disagreement with this page. > -> Status: 2026-11-15, tree `master @ 88d5005a`. Tags: `[live]` observed with +> Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[live]` observed with > the stock guest driver; `[wip]` demonstrated live, being productized; > `[gated]` implemented default-off behind supervised gates; `[wall]` known > blocking limit; `[target]` designed, not built; `[planned]` roadmap. @@ -137,29 +137,27 @@ client-allocated USERD resolution, foreign-USERD skip). The direct-GL submission is fully decoded (macro-driven; no classic draw header), the recycled pushes are recovered by the content-gated FB-shadow and LOW-band rescues, and the client's draw-state push opens, captures and reaches the -engine with the golden MME overlay. 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` (`SPH-AUTHOR`, first word `020a0481`) is fetched by both vertex -slots, with the window's own slot-1 bind rewritten to it -(`SPH-SLOT1-REWRITE`; DS `0x86040626 -> 0x84000420`, 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), and the held-CALL census plus the -SA[34] golden fill prove the slot-34 `DRAW_IAB` target -(`client=golden=used=0x265`). **The draw macro now executes end to end**: -c788 ran `DRAW_IAB` (`mac=0x22`) on a released held window after the -`MME-DRAW-MOVE` reorder, TCS-off (`45dbcdcd`) clears the DS latch (the -`0x84000420` was the synthesized TCS bind), a synthetic viewport -(`dab4a02c`) and a chained release (`3481e62d`) complete the replay, and the -body decodes with the public Mesa MME toolchain (`mme_tu104_sim`: 8 draws of -3 vertices). The remaining GL gap is the vertex buffer (no captured client -push binds the stream directly; the eng71 scan candidate is a heuristic) and -render-target store/alias visibility (the big-surface alias pages do not yet -enter `GUEST-WIT`), so the stores are still missing, and the window/screen -present path, which currently stays black or wedges X. +engine with the golden MME overlay. The 11-16 wave then proved the **host-side draw chain deterministic end to +end**: the real frame pushes are admitted (a persisted colour-target bind +carried from an earlier trusted push, draw markers accepted inside counted +method runs, the 14.8-thousand-word window replayed as 40 chunks, a +data-led start snap and a 128-slot candidate ring), the beef draw lane +latches a **clean DS** (`DS-FAST2 ... ds_after=80000000`, c963) at the +live-derived GS attribute map, capture-less boots get a **golden 2799-word +MME pack** built from the golden library, and `MME-CALL-HOLD -> +MME-CARRY-SAVE -> MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM` fires +with the prelude latch kept across the per-fire channel recycle +(`MME-LATCH-KEEP`); admitted-window chunks are forwarded in order. The +**decisive finding is guest-side**: across 36 boots (c990-c1019) the client +never submitted a non-null `CALL(34)` draw macro — every `0x3910/0x3914` hit +is an interior method write with `data=0x0`, no CALL header exists in the +admitted windows, and those cycles logged guest EGL/dri2 failures and OOM +kills. So the next work is guest-first (a real draw submission), then the +vertex/store and the window/screen present; the vGPU path still stores +nothing (`wrote=0`, `px0=0`) and the window stays black or wedges X. A +GZDoom video was separately delivered through the guest's **software GL** +path (Mesa llvmpipe) as a guaranteed-quality deliverable; it is not a vGPU +rendering claim. ## 6. Debug parameters diff --git a/wiki/OpenGL.md b/wiki/OpenGL.md index 4453c96..62f9a01 100644 --- a/wiki/OpenGL.md +++ b/wiki/OpenGL.md @@ -12,7 +12,7 @@ > [`../docs/03-architecture/02-guest-stack-and-cudasw.md`](../docs/03-architecture/02-guest-stack-and-cudasw.md) > (the guest stack). The docs tree wins on disagreement. -Status: 2026-11-15, tree `master @ 88d5005a`. Tags: `[live]` observed with the +Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[live]` observed with the stock guest driver; `[wip]` partial; `[wall]` current blocker; `[target]` defined success state. @@ -106,8 +106,11 @@ Rated honestly, against the milestone ladder in the plan: | DS stage-0/1 image: a VTG SPH is authored at `family+0x900` and the window's own slot-1 bind rewritten to it; the DS latch reads `st0=st1=020a0481` | `[live]` | | Saved-window release carrier (held window snapshotted at `MME-CALL-HOLD` and re-submitted with calls released once the pack is resident, c772); held-CALL census + SA[34] golden fill (`client=golden=used=0x265`); synthetic full-RT viewport (`dab4a02c`); release chained after any GR launch (`3481e62d`) | `[live]` | | Per-stage SPH disable (TCS off, `45dbcdcd`) clears the DS latch (the `0x84000420` was the synthesized TCS bind) | `[live]` | -| Vertex buffer: the client's captured pushes never bind the stream directly (no `0x1c00/0x1c04` pair outside SPH payloads); the eng71 scan binds a heuristic CB-page candidate (score 8); a stale nonzero `VS0` also stores nothing (c811); eng74 `VS-BLOB` dumps the candidate for validation/rejection | `[wall]` | -| Render-target store/alias visibility: the release writes only CB/GR-context/report pages; eng74 (`88d5005a`) records the surface-alias RT pages in `GUEST-WIT` so an alias store is provable; stores `wrote=0` / `0/1025` | `[wall]` | +| Real frame pushes admitted: persisted colour-target bind from an earlier trusted push (`RT-PERSIST`), draw markers accepted inside counted method runs, 14.8-thousand-word window admitted and replayed as 40 chunks, data-led start snap (`WIN-START-SNAP`), 128-slot candidate ring | `[live]` | +| Clean DS on the beef draw lane after the full-window chunking (`DS-FAST2 ... ds_after=80000000`, c963) at the live-derived GS attribute map (maps=6), no SPH18; draw anchor after the first `0x3810` and raster enables emitted | `[live]` | +| Golden 2799-word MME pack on capture-less boots (`MME-GOLDEN overlay`, `MME-PRELUDE pack ir_words=2799`); `MME-CALL-HOLD -> MME-CARRY-SAVE -> MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM` fires; prelude latch kept across the per-fire channel recycle (`MME-LATCH-KEEP`); admitted-window chunks forwarded in order | `[live]` | +| Guest draw submission: across 36 boots (c990-c1019) the client never submits a non-null `CALL(34)` draw macro — every `0x3910/0x3914` hit is an interior method write with `data=0x0`; no CALL header in the admitted windows (`DRAW-SCAN-PRE` found=0); guest EGL/dri2 failures and OOM kills in the same cycles; stores `wrote=0` / `0/1025` | `[wall]` | +| GZDoom video via the guest **software GL** path (Mesa llvmpipe): four byte-verified files (22 s flight + 18 s orbit, 640x480/1280x960, 30 fps) — a guaranteed-quality deliverable, **not** a vGPU rendering claim | `[live]` (software path) | | Pack-completion and shallow-boot lotteries gate the deterministic release (throughput limiters) | `[wip]` | | Window/screen present produces non-black screen pixels | `[wall]` | | X screen-init first-generation lottery (`modeNum` parity; only an immediately-post-boot X passes DDX DMA init; dominant throughput limiter) | `[wip]` | @@ -160,30 +163,44 @@ latch (the `0x84000420` was the synthesized TCS bind), a synthetic full-RT viewport (`dab4a02c`) and a release chained after any GR launch (`3481e62d`) complete the replay, and the DRAW_IAB body decodes with the public Mesa MME toolchain (`mme_tu104_sim`: slot 34, 8 draws of 3 vertices). -The remaining blockers are the **vertex buffer** (no captured client push -binds the stream directly; the eng71 scan's CB-page candidate is a heuristic, -score 8; a stale nonzero `VS0` also stores nothing (c811)) and -**render-target visibility** (the release writes only CB/GR-context/report -pages, and the big-surface alias pages do not yet populate `GUEST-WIT`), so -the stores still miss; eng74 (`88d5005a`) dumps the scanned candidate -(`VS-BLOB`) and records the alias RT pages in the WIT for the next boot; -then the window/screen present path (glxgears' window -is black and a window draw can wedge X), and the per-boot binding/X -first-generation start lottery — then the first rendered screen frame. +The 11-16 wave then proved the **host-side chain end to end**: the real +frame pushes are admitted (persisted colour-target bind from an earlier +trusted push, draw markers accepted inside counted method runs, the +14.8-thousand-word window admitted and replayed as 40 chunks with a data-led +start snap and a 128-slot candidate ring), the beef draw lane latches a +**clean DS** (`DS-FAST2 ... ds_after=80000000`, c963) at the live-derived GS +attribute map, capture-less boots get the **golden 2799-word MME pack** and +`MME-CALL-HOLD -> MME-CARRY-SAVE -> MME-CARRY-FIRE -> MME-PACK-REARM -> +MME-SA-REARM` fires, the prelude latch survives the per-fire channel recycle, +and chunks are forwarded in order. The **decisive finding is guest-side**: +across 36 boots (c990-c1019) the client never submits a non-null `CALL(34)` +draw macro — every `0x3910/0x3914` hit is an interior method write with +`data=0x0`, no CALL header exists in the admitted windows, and the same +cycles logged guest EGL/dri2 failures and OOM kills. So the next work is +guest-first: repair/verify the guest GL/EGL path and memory, capture one real +frame submission, then the vertex/store and the window/screen present path +(glxgears' window is black and a window draw can wedge X), with the per-boot +X first-generation start lottery as the throughput limiter — then the first +rendered screen frame. A GZDoom video was separately delivered through the +guest's **software GL** path (Mesa llvmpipe) as a guaranteed-quality +deliverable; it is not a vGPU rendering claim. ## 6. What is not claimed * No **window/screen** frame has rendered real pixels through the emulated - vGPU yet; every screen capture so far is black. The non-black frames and the - videos (45.4 s and 50 s) come from the off-screen pbuffer path (pbuffer -> - sysmem -> kvmfr ivshmem -> host reader), not from a windowed X screen - capture. The client's draw-state push reaches the engine, the MME program - completes and the released replay executes the draw macro (`DRAW_IAB`, - `mac=0x22`, with a synthetic viewport), but the draw's vertex buffer is not - yet identified and the render-target alias pages are not yet WIT-visible, - so the stores are still missing; a synchronous window draw can wedge X, and - X start retains a per-boot first-generation lottery. Those are the current - walls. + vGPU yet; every vGPU screen capture so far is black. The non-black frames + and the videos (45.4 s and 50 s) come from the off-screen pbuffer path + (pbuffer -> sysmem -> kvmfr ivshmem -> host reader), not from a windowed X + screen capture. The host-side chain is proven end to end (admission, clean + DS, golden pack, CALL hold, carry fire, SA re-arm), but the decisive 11-16 + finding is that the client did not submit a non-null `CALL(34)` draw macro + in the recorded boots, so the stores are still missing; a synchronous + window draw can wedge X, and X start retains a per-boot first-generation + lottery. Those are the current walls. +* **The 2026-11-16 GZDoom video is a software-GL deliverable, not a vGPU + result.** Mesa llvmpipe rendered it inside the guest; it is a + guaranteed-quality demonstration while the GPU-GL pixel path is being + worked, not evidence of the emulated vGPU's 3D pipeline. * GZDoom reaching `V_Init: allocate screen` is not a rendered-frame claim; it proves the client's GL init and the direct-GL GR lane, not the game loop or a presented frame. diff --git a/wiki/Physical-GPU-Backend.md b/wiki/Physical-GPU-Backend.md index 9d22979..cce054f 100644 --- a/wiki/Physical-GPU-Backend.md +++ b/wiki/Physical-GPU-Backend.md @@ -5,7 +5,7 @@ > guest-facing emulation. Canonical sources: [`../docs/03-architecture/08-physical-gpu-integration.md`](../docs/03-architecture/08-physical-gpu-integration.md) > and [`../docs/03-architecture/11-physical-backend-guest-wiring.md`](../docs/03-architecture/11-physical-backend-guest-wiring.md); the docs tree wins on disagreement. -Status: 2026-11-15, tree `master @ 88d5005a`. Tags: `[live]` proven with the +Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[live]` proven with the stock guest driver; `[gated]` implemented default-off; `[wip]` partially built; `[wall]` current blocker; `[target]` planned end state. @@ -109,7 +109,7 @@ FAIL a failed mutating operation parks the device in a locked fail-safe; | Host RM client and first real engine work (static config, real objects, 4 KiB CE copy) | done `[live]` | | Guest-copy forwarding, deferred release, hardware-primary copies, engine-authored relay, fault relay | verified live (seams parameterised and fail-open); the staged-transfer class is under repair `[live]` | | CUDA kernel execution (`vectorAdd` and further clients) | done `[live]` — stock guest CUDA clients (vector-add, matrix-multiply, transformer) execute on the physical engine with verified results and engine-authored completions relayed to the guest | -| Graphics method-stream execution (verbatim 3D replay, synthesized launches, direct-GL client channels) | `[wip]` — the engine retires real graphics streams, the display/KMS stack registers and X + stock GLX are green (the DDX/ScreenInit stability walls are closed, X green >10 minutes), captured GL sections execute, the direct-GL submission is fully decoded (macro-driven, no classic draw header), the client's draw-state push reaches the engine, the MME pack completes, the released replay executes `DRAW_IAB` (`mac=0x22`, c788; TCS-off DS clean, synthetic viewport, chained release), the DS stage image is authored and live for both vertex slots (`st0=st1=020a0481`), the saved-window release carrier replays the held window deterministically once the pack is resident, and the first non-black GPU-rendered frames are captured off-screen; the remaining vertex-buffer identity, the render-target store/alias visibility, the pack-completion lottery and the window/screen present are the frontier ([`Graphics-Execution.md`](Graphics-Execution.md)) | +| Graphics method-stream execution (verbatim 3D replay, synthesized launches, direct-GL client channels) | `[wip]` — the engine retires real graphics streams, the display/KMS stack registers and X + stock GLX are green (the DDX/ScreenInit stability walls are closed, X green >10 minutes), captured GL sections execute, the direct-GL submission is fully decoded (macro-driven, no classic draw header), and the 11-16 wave proved the **host-side chain deterministic end to end**: the real frame pushes are admitted (persisted colour-target bind, draw markers inside counted runs, a 14.8-thousand-word window replayed as 40 chunks, a 128-slot candidate ring), the beef draw lane latches a clean DS (`DS-FAST2 ... ds_after=80000000`, c963) at the live-derived GS attribute map, a golden 2799-word MME pack serves capture-less boots, and `MME-CALL-HOLD -> MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM` fires with the latch kept across the channel recycle; the decisive finding is guest-side (36 boots, no non-null `CALL(34)` draw macro; guest EGL/dri2 failures and OOM kills), so the next work is a real guest draw submission, then the vertex/store and the window/screen present; a GZDoom video was separately delivered through the guest's software GL path (Mesa llvmpipe, not a vGPU claim) ([`Graphics-Execution.md`](Graphics-Execution.md)) | ## 7. The execution frontier @@ -138,13 +138,18 @@ vertices), the DS stage image is authored and live for both vertex slots (`st0=st1=020a0481`; DS `0x86040626 -> 0x84000420`, two boots), and the saved-window release carrier replays the held window deterministically once the pack is resident (c772; the slot-34 -census plus the SA[34] golden fill prove `client=golden=used=0x265`), so the -remaining graphics gates are the vertex-buffer identity (no captured client -push binds the stream; the eng71 scan candidate is a heuristic), the -render-target store/alias visibility (the big-surface alias pages do not yet -enter `GUEST-WIT`), the pack-completion lottery, -the stores, the window/screen present, and the per-boot binding/X -first-generation start lottery before non-black window pixels. The remaining +census plus the SA[34] golden fill prove `client=golden=used=0x265`), so the 11-16 wave proved the **host-side chain deterministic end to end** +(admission of the real pushes, clean DS at the live-derived GS map, golden +2799-word pack, CALL hold, carry fire, SA re-arm, latch across the channel +recycle); the **decisive finding is guest-side**: across 36 boots the client +never submitted a non-null `CALL(34)` draw macro (interior `0x3910/0x3914` +writes carry `data=0x0`; no CALL header in the admitted windows), and those +cycles logged guest EGL/dri2 failures and OOM kills. The next work is +guest-first (a real draw submission), then the vertex/store, the +window/screen present, and the per-boot X first-generation start lottery +before non-black window pixels. A GZDoom video was separately delivered +through the guest's **software GL** path (Mesa llvmpipe) as a +guaranteed-quality deliverable; it is not a vGPU rendering claim. The remaining compute work is the staged-transfer class (under repair), the every-boot acceptance campaign, and per-guest execution isolation — see [`Execution-Frontier.md`](Execution-Frontier.md) and diff --git a/wiki/Project-Goals.md b/wiki/Project-Goals.md index e8c9c1c..40544ff 100644 --- a/wiki/Project-Goals.md +++ b/wiki/Project-Goals.md @@ -10,7 +10,7 @@ > [`Execution-Frontier.md`](Execution-Frontier.md) and > [`Graphics-Execution.md`](Graphics-Execution.md). -Status: 2026-11-15, tree `master @ 88d5005a`. Tags: `[live]` working with the +Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[live]` working with the stock guest driver; `[wip]` in progress; `[planned]` designed, not built; `[target]` bring-up ahead; `[non-goal]` explicitly out of scope. @@ -46,12 +46,12 @@ drivers, no license.** ## 3. Goals and their status -| Goal | What success looks like | Status (2026-11-15) | +| Goal | What success looks like | Status (2026-11-16) | |---|---|---| | Stock guest driver initialisation | The unmodified driver probes, initialises and enumerates as on bare metal (`nvidia-smi`) | `[live]` — TU104 reference platform | | Full CUDA driver-API surface | Context creation, allocation, copies, free, destroy complete with correct results | `[live]` — the driver-API smoke prints `ALL OK`; the 64-byte payload round-trips | | CUDA kernel execution on real hardware | Verified guest kernels execute on the physical GPU, with engine-authored completions waking the guest | `[live]` — vector-add, matrix-multiply and transformer clients green on fresh boots; the staged-transfer class, the every-boot acceptance campaign and per-guest isolation are in progress ([`Execution-Frontier.md`](Execution-Frontier.md)) | -| OpenGL (3D graphics) | Stock guest GL applications render real pixels through the emulated vGPU | `[wip]` — the display/KMS stack and X run, the stock NVIDIA GLX path is fully green (`glxinfo -B` rc 0, OpenGL 4.6.0 direct, `glxgears` ~520 FPS), the 2D path is green, the DDX 3D replay executes, the X DDX/ScreenInit stability walls are closed (X green >10 minutes), captured GL sections execute on the engine, the direct-GL submission is fully decoded (macro-driven, no classic draw header), the client's draw-state push reaches the engine, the MME pack completes, the released replay executes `DRAW_IAB` (`mac=0x22`, c788; TCS-off DS clean, synthetic viewport, chained release), the DS stage image is authored and live for both vertex slots (`st0=st1=020a0481`), the saved-window release carrier replays the held window deterministically once the pack is resident (slot-34 census plus SA[34] golden fill prove `client=golden=used=0x265`), and the first non-black GPU-rendered frames plus captured videos (45.4 s and 50 s) are proven off-screen; GZDoom reaches `V_Init`. Window/screen pixels remain the frontier: the vertex-buffer identity and the render-target store/alias visibility are the last named gates before window pixels, the window/screen present is unproven, the pack-completion lottery limits the release, and the per-boot binding/X first-generation lottery is the throughput limiter ([`OpenGL.md`](OpenGL.md)) | +| OpenGL (3D graphics) | Stock guest GL applications render real pixels through the emulated vGPU | `[wip]` — the display/KMS stack and X run, the stock NVIDIA GLX path is fully green (`glxinfo -B` rc 0, OpenGL 4.6.0 direct, `glxgears` ~520 FPS), the 2D path is green, the DDX 3D replay executes, the X DDX/ScreenInit stability walls are closed (X green >10 minutes), captured GL sections execute on the engine, the direct-GL submission is fully decoded (macro-driven, no classic draw header), the released replay executes `DRAW_IAB` (`mac=0x22`, c788), the DS stage image is authored and live for both vertex slots, and the first non-black GPU-rendered frames plus captured videos (45.4 s and 50 s) are proven off-screen; GZDoom reaches `V_Init`. The 11-16 wave proved the **host-side chain deterministic end to end**: real frame pushes admitted (persisted colour-target bind, draw markers inside counted runs, 40-chunk full-window replay, 128-slot candidate ring), a clean DS on the draw lane (`DS-FAST2 ds_after=80000000`, c963) at the live-derived GS map, a golden 2799-word MME pack on capture-less boots, CALL hold/carry fire/SA re-arm with the latch kept across the channel recycle. The **decisive finding is guest-side**: across 36 boots the client never submitted a non-null `CALL(34)` draw macro (interior `0x3910/0x3914` writes carry `data=0x0`; no CALL header), and the same cycles logged guest EGL/dri2 failures and OOM kills. Window/screen pixels remain the frontier: a real guest draw submission first, then the vertex/store and the window/screen present, with the X first-generation start lottery as the throughput limiter. A GZDoom video was separately delivered through the guest's software GL path (Mesa llvmpipe) — not a vGPU rendering claim ([`OpenGL.md`](OpenGL.md)) | | Vulkan | Stock guest Vulkan applications render real pixels | `[wip]` — the pipeline runs end to end (device → command buffer → fence → readback); frames are black — program delivery and program-VA mapping are the frontier ([`Vulkan.md`](Vulkan.md)) | | Windows guests (DirectX, CUDA) | A stock WDDM driver and stock D3D/CUDA applications run in Windows guests | `[target]` — not started; same emulation target ([`DirectX.md`](DirectX.md)) | | Video (NVENC/NVDEC) | Encode/decode through the emulated device | `[planned]` | diff --git a/wiki/Project-Plan.md b/wiki/Project-Plan.md index 102359f..889ca87 100644 --- a/wiki/Project-Plan.md +++ b/wiki/Project-Plan.md @@ -15,7 +15,7 @@ > [`../docs/06-portability/03-device-validation-and-porting-sequence.md`](../docs/06-portability/03-device-validation-and-porting-sequence.md); > the docs tree wins on disagreement. -Status: 2026-11-15, tree `master @ 88d5005a`. Tags: `[done]`, `[active]`, +Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[done]`, `[active]`, `[ahead]` — the plan's own state vocabulary, distinct from the goal tags. ## 1. How the plan works @@ -40,11 +40,11 @@ itself: ## 2. The phases -| Phase | What it delivers | Exit gate | State (2026-11-15) | +| Phase | What it delivers | Exit gate | State (2026-11-16) | |---|---|---|---| | **P0 — Platform** | Emulated vGPU device, GSP boot and GSP-RM emulation, stock guest driver initialisation | Driver-API smoke green (`ALL OK`) = evaluation rung 2 | `[done]` | | **P1 — First execution (compute)** | Guest CUDA kernels executing on the physical GPU, with engine-authored completions; then hardening | Verified clients + engine-authored completion = rung 3 core; hardening: staged-transfer class, every-boot acceptance, per-guest isolation | `[active]` — execution green; hardening in progress | -| **P2 — Graphics execution** | OpenGL/Vulkan draw commands executed by the physical 3D pipeline and delivered as readable pixels | The graphics ladder: M-GL1 client context-init executes; M-GL2 `glxgears` non-black; M-GL3 GZDoom GL non-black through the mdev | `[active]` — between M-GL1 and M-GL2 with M-GL2's off-screen half proven: the display/KMS and DDX replay machinery work, X + stock GLX are green, the first non-black GPU-rendered frames and videos are captured, the X DDX/ScreenInit stability walls are closed, captured GL sections execute on the engine, the direct-GL submission is fully decoded (macro-driven, no classic draw header), the client's draw-state push reaches the engine, the MME pack completes, the released replay executes `DRAW_IAB` (`mac=0x22`, c788; TCS-off DS clean, synthetic viewport, chained release), the DS stage image is authored and live for both vertex slots (`st0=st1=020a0481`), and the saved-window release carrier deterministically replays the held window once the pack is resident; the remaining walls are the vertex-buffer identity, the render-target store/alias visibility, the pack-completion lottery, the stores, the window/screen present, and the per-boot binding/X first-generation start lottery | +| **P2 — Graphics execution** | OpenGL/Vulkan draw commands executed by the physical 3D pipeline and delivered as readable pixels | The graphics ladder: M-GL1 client context-init executes; M-GL2 `glxgears` non-black; M-GL3 GZDoom GL non-black through the mdev | `[active]` — between M-GL1 and M-GL2 with M-GL2's off-screen half proven: the display/KMS and DDX replay machinery work, X + stock GLX are green, the first non-black GPU-rendered frames and videos are captured, the X DDX/ScreenInit stability walls are closed, captured GL sections execute on the engine, the direct-GL submission is fully decoded (macro-driven, no classic draw header), the released replay executes `DRAW_IAB` (`mac=0x22`, c788), and the 11-16 wave proved the host-side chain deterministic end to end (real frame pushes admitted with a persisted colour-target bind, a 40-chunk full-window replay and a 128-slot ring; a clean DS `DS-FAST2 ds_after=80000000` at the live-derived GS map; a golden 2799-word MME pack; CALL hold/carry fire/SA re-arm with the latch kept across the channel recycle). The decisive finding is guest-side: across 36 boots the client never submitted a non-null `CALL(34)` draw macro, and the same cycles logged guest EGL/dri2 failures and OOM kills; the remaining walls are a real guest draw submission, the vertex/store, the window/screen present, and the per-boot X first-generation start lottery. A GZDoom video was separately delivered through the guest's software GL path (Mesa llvmpipe) — not a vGPU rendering claim | | **P3 — Sustained and multi-tenant** | Frame rates without assistance; multiple VMs sharing the GPU with measured fairness; soak-stable operation | Graphics M-GL4 (60 fps, no forcing) and M-GL5 (two VMs, two mdevs); CUDA battery + soak; per-guest execution isolation = rungs 4/5 | `[ahead]` | | **P4 — Breadth** | Video (NVENC/NVDEC), Windows/DirectX guests, live migration, non-KVM hypervisor transports | Per-case bring-up gates plus the matrix's evidence expectations | `[ahead]` | | **P5 — Scale and portability** | New GPU generations and driver families carried forward; published performance programme | A profile + measured delta per version, validated on hardware; A/B numbers published per the measurement contract | `[ahead]` | @@ -77,15 +77,24 @@ Ranked, in dependency order: `MME-DRAW-MOVE` reorder, TCS-off (`45dbcdcd`) clears the DS latch, the synthetic viewport (`dab4a02c`) and the chained release (`3481e62d`) complete the replay, and the body decodes with the public Mesa MME - toolchain (`mme_tu104_sim`: 8 draws of 3 vertices). The named walls are - the vertex-buffer identity (no captured client push binds the stream; the - eng71 scan candidate is a heuristic, with eng74 `VS-BLOB` dumping it) and - the render-target store/alias visibility (the big-surface alias pages do - not yet enter `GUEST-WIT`; eng74 records them), the - pack-completion lottery, the stores, the window/screen present path - (glxgears' window is black and a window draw wedges X), the per-boot - binding/X first-generation start lottery (even `modeNum` required; now the - dominant throughput limiter), and then non-black window frames. + toolchain (`mme_tu104_sim`: 8 draws of 3 vertices). The 11-16 wave proved the **host-side chain deterministic end to end**: +real frame pushes admitted (persisted colour-target bind, draw markers inside +counted runs, a 14.8-thousand-word window replayed as 40 chunks, a 128-slot +candidate ring), a clean DS on the beef draw lane (`DS-FAST2 +ds_after=80000000`, c963) at the live-derived GS map, a golden 2799-word MME +pack on capture-less boots, and CALL hold/carry fire/SA re-arm with the +prelude latch kept across the channel recycle. The **decisive finding is +guest-side**: across 36 boots (c990-c1019) the client never submitted a +non-null `CALL(34)` draw macro — every `0x3910/0x3914` hit is an interior +method write with `data=0x0`, no CALL header exists in the admitted windows, +and the same cycles logged guest EGL/dri2 failures and OOM kills. The named +walls are therefore a real guest draw submission first, then the +vertex/store, the window/screen present path (glxgears' window is black and +a window draw wedges X), and the per-boot X first-generation start lottery +(even `modeNum` required; the dominant throughput limiter). A GZDoom video +was separately delivered through the guest's **software GL** path (Mesa +llvmpipe) as a guaranteed-quality deliverable; it is not a vGPU rendering +claim. Full detail: [`Graphics-Execution.md`](Graphics-Execution.md) §6. 2. **Compute hardening (P1).** The staged-transfer class (failure modes proven, diff --git a/wiki/Project-Status.md b/wiki/Project-Status.md index 78e6d12..ff067fa 100644 --- a/wiki/Project-Status.md +++ b/wiki/Project-Status.md @@ -10,7 +10,7 @@ > (the execution frontier). When this page and the docs disagree, the docs tree > wins. -Status: 2026-11-15, tree `master @ 88d5005a`. Tags: `[live]` proven with the +Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[live]` proven with the stock guest driver; `[gated]` implemented, default-off or behind supervised gates; `[wip]` partially implemented; `[wall]` current blocker; `[target]` named success state; `[planned]` designed, not built. @@ -28,7 +28,7 @@ named success state; `[planned]` designed, not built. | Physical backend on real hardware (module-owned GPU running its real GSP-RM) | `[live]` boot, RPC session, object creation, copy-engine work and GR execution proven — the verified guest CUDA kernel clients execute through this backend, and graphics method streams execute on the engine ([`Graphics-Execution.md`](Graphics-Execution.md)) | | Display and KMS on the emulated vGPU (nvidia-modeset/NvKms, `/dev/dri`, X) | `[live]` in the campaign configuration — the emulated display engine serves the guest's display push-buffer channels (notifier plus `UPDATE -> FINISHED`), nvidia-modeset/NvKms registers (`/dev/dri/card0`, `renderD128`, `fb0`), `nvidia-smi -L` enumerates and X settles. The X DDX idle-DMA/ScreenInit, USERD-latch lifetime, re-probe-thrash, Xorg kernel-mode-spin and flip-event walls were closed (X green for >10 minutes in a validated window); what remains is the per-boot **first-generation X start lottery**, which by 11-13/11-14 was the dominant throughput limiter for the graphics A/B runs (only an X started immediately after boot passes DDX DMA init; long stretches of dead starts, one green first-start boot). The display-capability seam is parameterised ([`Graphics-Execution.md`](Graphics-Execution.md)) | | Multi-tenant isolation (mdev per VM, per-context page directories) | `[wip]` device-level coexistence works — multiple mediated devices with different emulated VRAM sizes and multiple guests coexist (two guests demonstrated); per-guest execution isolation for simultaneous CUDA guests is in progress | -| OpenGL (3D graphics) | `[wip]` — the display/KMS stack registers, X and the stock NVIDIA GLX path are fully green (`glxinfo -B` returns 0 with OpenGL 4.6.0 and direct rendering; `glxgears` renders ~520 FPS with the emulated GPU's NVIDIA renderer), and the **first non-black GPU-rendered output** is proven: the pbuffer frame path produced 500/500 non-black 640x480 frames per run and captured videos (45.4 s on 2026-11-11; a 50 s 640x480 h264 capture on 2026-11-12). GZDoom reaches `V_Init: allocate screen` with its GL 4.6.0 context whenever the shared nvClip `modeNum` is even. **The direct-GL submission is now fully decoded:** no client push carries a method-grammar draw header — the channel's 9 NV906F entries tile one contiguous buffer and its per-frame work is carried as rewritten data-block blobs plus small state pushes (324/476/728 B) that invoke MME macros (the QMD-carrier hypothesis was tested and refuted). A content-gated FB-shadow rescue and a LOW-band rescue recover the recycled pushes: the client's draw-state push now opens a C597 section, is captured and marked for the verbatim 3D lane (the first direct-GL stream3d marks), and reaches the engine (`GR LAUNCH submitted`/`OK`, golden MME overlay accepted). **The MME chain now completes and executes the draw macro.** The multi-part keep-window mechanism won multi-frame windows; the part-launch poison was eliminated (the real fault was the client's own `SET_REPORT_SEMAPHORE`/`SET_NOTIFY` writes to client VAs that the host scratch page-table pool remaps — redirected to a mapped scratch slot; 49 cycles with zero poison and zero MMU faults); the 2799-word pack completes (2799/2799); engine-global completion plus keep-done-across-recycle produced the first `MME-PACK-REARM`; the fixed-CB region is aliased; and the released calls run macros through to **`DRAW_IAB` (`mac=0x22`)**. Two synthesized-prelude defects were then fixed: the SPH-BIND prelude self-destructed because an auto-dropped run broke its kept/final count (`444ae2c1`), and the stage block was silently skipped by a double-counted budget; with both fixed the prelude emits 84 words and the DS stage VAs populate (one validated boot carried the full post-REARM chain, `mac=0x22` and `DS 86040624`). **The DS stage-0/1 image is now authored and live**: a VTG SPH is written at `family+0x900` (`SPH-AUTHOR`, first word `020a0481`), the window's own later `0x2054` slot-1 bind is rewritten to the authored page (`SPH-SLOT1-REWRITE`), and the DS latch reads the authored image for both vertex slots (`DS-IMAGE st0=st1=020a0481 code=ff007321`; 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 replays the held window with the calls released; the slot-34 census and SA[34] golden fill prove `client=golden=used=0x265`). The remaining blockers are the vertex buffer (no captured client push binds the stream; the eng71 scan candidate is a heuristic, with eng74 `VS-BLOB` dumping it for validation) and render-target store/alias visibility (the big-surface alias pages do not yet enter `GUEST-WIT`; eng74 now records them), so the stores are still missing (`wrote=0`, `0/1025`, `px0=0`); the window/screen present path is unproven; and the per-boot binding lottery (the GL client usually rides the X channel in indirect mode, and X start keeps a first-generation lottery) is the throughput limiter ([`OpenGL.md`](OpenGL.md)) | +| OpenGL (3D graphics) | `[wip]` — the display/KMS stack registers, X and the stock NVIDIA GLX path are fully green (`glxinfo -B` returns 0 with OpenGL 4.6.0 and direct rendering; `glxgears` renders ~520 FPS with the emulated GPU's NVIDIA renderer), and the **first non-black GPU-rendered output** is proven: the pbuffer frame path produced 500/500 non-black 640x480 frames per run and captured videos (45.4 s on 2026-11-11; a 50 s 640x480 h264 capture on 2026-11-12). GZDoom reaches `V_Init: allocate screen` with its GL 4.6.0 context whenever the shared nvClip `modeNum` is even. **The direct-GL submission is now fully decoded:** no client push carries a method-grammar draw header — the channel's 9 NV906F entries tile one contiguous buffer and its per-frame work is carried as rewritten data-block blobs plus small state pushes (324/476/728 B) that invoke MME macros (the QMD-carrier hypothesis was tested and refuted). A content-gated FB-shadow rescue and a LOW-band rescue recover the recycled pushes: the client's draw-state push now opens a C597 section, is captured and marked for the verbatim 3D lane (the first direct-GL stream3d marks), and reaches the engine (`GR LAUNCH submitted`/`OK`, golden MME overlay accepted). **The MME chain now completes and executes the draw macro.** The multi-part keep-window mechanism won multi-frame windows; the part-launch poison was eliminated (the real fault was the client's own `SET_REPORT_SEMAPHORE`/`SET_NOTIFY` writes to client VAs that the host scratch page-table pool remaps — redirected to a mapped scratch slot; 49 cycles with zero poison and zero MMU faults); the 2799-word pack completes (2799/2799); engine-global completion plus keep-done-across-recycle produced the first `MME-PACK-REARM`; the fixed-CB region is aliased; and the released calls run macros through to **`DRAW_IAB` (`mac=0x22`)**. Two synthesized-prelude defects were then fixed: the SPH-BIND prelude self-destructed because an auto-dropped run broke its kept/final count (`444ae2c1`), and the stage block was silently skipped by a double-counted budget; with both fixed the prelude emits 84 words and the DS stage VAs populate (one validated boot carried the full post-REARM chain, `mac=0x22` and `DS 86040624`). **The DS stage-0/1 image is now authored and live**: a VTG SPH is written at `family+0x900` (`SPH-AUTHOR`, first word `020a0481`), the window's own later `0x2054` slot-1 bind is rewritten to the authored page (`SPH-SLOT1-REWRITE`), and the DS latch reads the authored image for both vertex slots (`DS-IMAGE st0=st1=020a0481 code=ff007321`; the DS value fell `0x86040626 -> 0x84000420`), reproduced on two boots. The 11-16 wave then proved the **host-side chain end to end**: the real frame pushes are admitted (a persisted colour-target bind carried from an earlier trusted push, draw markers accepted inside counted method runs, the 40-chunk full-window replay, a data-led window-start snap), the beef draw lane latches a **clean DS** (`DS-FAST2 ... ds_after=80000000`, c963, at the live-derived GS map), capture-less boots get the **golden 2799-word MME pack** (`MME-PRELUDE`, `MME-CARRY-FIRE`, `MME-PACK-REARM`, `MME-SA-REARM`), the prelude latch survives the per-fire channel recycle, and every admitted-window chunk is forwarded in order. The **decisive finding is guest-side**: across 36 boots (c990-c1019) the client never submitted a non-null `CALL(34)` draw macro — every `0x3910/0x3914` hit is an interior method write with `data=0x0`, no CALL header exists in the admitted windows, and the same cycles logged guest EGL/dri2 failures and OOM kills, so the guest GL path was not producing a real draw submission. A GZDoom video (4 files, 22 s flight + 18 s orbit, 640x480/1280x960, 30 fps, byte-verified) was delivered through the guest's **software GL** path (Mesa llvmpipe) as a guaranteed-quality deliverable; it is not a vGPU rendering claim. Window/screen pixels remain the frontier: a real guest draw submission first, then the vertex/store and the window/screen present, with the X first-generation start lottery as the throughput limiter ([`OpenGL.md`](OpenGL.md)) | | Vulkan (3D/compute) | `[wip]` — the guest Vulkan pipeline runs end to end on the emulated vGPU (device, allocation, pipeline, command buffer, fence, queue submit, readback) and the engine executes translated launches; frames are still black — program delivery and program-VA mapping are the frontier ([`Vulkan.md`](Vulkan.md)) | | DirectX / Windows guests | `[planned]` (target) — no Windows guest booted yet; the architecture is the same emulation target ([`DirectX.md`](DirectX.md)) | | Video (NVENC/NVDEC) | `[planned]` | @@ -80,13 +80,18 @@ with direct rendering, `glxgears` renders ~520 FPS); the first non-black GPU-rendered frames are proven off-screen (the pbuffer path produced a 500-frame 45.4 s video on 2026-11-11 and a 50 s capture on 2026-11-12), and GZDoom reaches its screen-allocation stage with GL 4.6.0 on an even modeNum. -The direct-GL submission is fully decoded, the MME multi-part program now -completes and the released replay executes the draw macro (`DRAW_IAB`, -`mac=0x22`, with a synthetic viewport; c788), and the DS stage image is -authored and live for both vertex slots; but windowed/screen pixels remain -the frontier (the vertex-buffer identity, the render-target store/alias -visibility and the pack-completion lottery are the next named gates, and X -start keeps a first-generation lottery) — see [`OpenGL.md`](OpenGL.md). The +The host-side draw chain is now proven end to end — admission of the real +frame pushes, a clean DS (`DS-FAST2 ds_after=80000000` on the draw lane), the +golden 2799-word MME pack, the CALL hold, the release carrier and the SA +re-arm all fire — and the decisive finding of the 11-16 wave is guest-side: +in 36 boots the client never submitted a non-null `CALL(34)` draw macro +(every `0x3910/0x3914` hit is an interior method write with `data=0x0`), and +the guest's GL path logged EGL/dri2 failures and OOM kills in that boot +class. A GZDoom video was delivered through the guest's *software* GL path +(Mesa llvmpipe) as a guaranteed-quality deliverable; it is not a vGPU +rendering claim. Windowed/screen pixels remain the frontier (a real guest +draw submission, then the vertex/store and the window/screen present, with X +start keeping a first-generation lottery) — see [`OpenGL.md`](OpenGL.md). The risc-v-gsp-rm-debugger workbench ([`Riscv-GSP-RM-Debugger.md`](Riscv-GSP-RM-Debugger.md)) is the host-side tooling used to study the firmware side of that frontier. diff --git a/wiki/System-Overview.md b/wiki/System-Overview.md index 667dfb3..65aecbe 100644 --- a/wiki/System-Overview.md +++ b/wiki/System-Overview.md @@ -7,7 +7,7 @@ > and [`../docs/03-architecture/10-interaction-and-scheduling.md`](../docs/03-architecture/10-interaction-and-scheduling.md) > for the full picture); the docs tree wins on disagreement. -Status: 2026-11-15, tree `master @ 88d5005a`. Tags: `[live]` proven with the +Status: 2026-11-16, tree `master @ a06d4b13`. Tags: `[live]` proven with the stock guest driver; `[gated]` implemented default-off; `[wip]` partial; `[wall]` current blocker; `[target]` designed end state. @@ -152,32 +152,25 @@ RPC from the guest to "firmware": client push carries a method-grammar draw header (the work is macro-driven — data-block blobs plus small state pushes invoking MME macros), the recycled pushes are recovered, and the client's draw-state push opens, - captures and reaches the engine with the golden MME overlay. 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` (first word - `020a0481`) is fetched by both vertex slots (`st0=st1=020a0481`; DS - `0x86040626 -> 0x84000420`, two boots). The release path is now - host-deterministic when the pack completes (the saved-window release - carrier replays the held window with calls released; the slot-34 census - plus SA[34] golden fill prove `client=golden=used=0x265`). **The draw macro - now executes end to end**: c788 ran `DRAW_IAB` (`mac=0x22`) on a released - held window after the `MME-DRAW-MOVE` reorder, TCS-off clears the DS latch - (the `0x84000420` was the synthesized TCS bind), a synthetic viewport and a - chained release complete the replay, and the body decodes with the public - Mesa MME toolchain (8 draws of 3 vertices). The remaining - gates are the vertex-buffer identity (no captured client push binds the - stream; the eng71 scan candidate is a heuristic) and the render-target - store/alias visibility (the big-surface alias pages do not yet enter - `GUEST-WIT`), the pack-completion lottery, the stores (`wrote=0`, `0/1025`, - `px0=0`), and the window/screen present (a window - draw can wedge X and glxgears' window is black); the per-boot binding plus - X first-generation start lottery is the dominant throughput limiter, so the - remaining gates are the vertex/store and the window/screen present - before the first non-black window frame - ([`OpenGL.md`](OpenGL.md), [`Vulkan.md`](Vulkan.md)). + captures and reaches the engine with the golden MME overlay. The 11-16 wave proved the **host-side draw chain deterministic end to + end**: the real frame pushes are admitted (a persisted colour-target bind + from an earlier trusted push, draw markers inside counted method runs, a + 14.8-thousand-word window replayed as 40 chunks, a 128-slot candidate + ring), the beef draw lane latches a **clean DS** (`DS-FAST2 ... + ds_after=80000000`, c963) at the live-derived GS attribute map, + capture-less boots get a **golden 2799-word MME pack**, and + `MME-CALL-HOLD -> MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM` fires + with the prelude latch kept across the channel recycle. The **decisive + finding is guest-side**: across 36 boots (c990-c1019) the client never + submitted a non-null `CALL(34)` draw macro (interior `0x3910/0x3914` + writes carry `data=0x0`; no CALL header in the admitted windows), and the + same cycles logged guest EGL/dri2 failures and OOM kills. The remaining + gates are a real guest draw submission, then the vertex/store and the + window/screen present; the per-boot X first-generation start lottery is + the dominant throughput limiter. A GZDoom video was separately delivered + through the guest's **software GL** path (Mesa llvmpipe) as a + guaranteed-quality deliverable; it is not a vGPU rendering claim + ([`OpenGL.md`](OpenGL.md), [`Vulkan.md`](Vulkan.md)). ## 6. Where the detail lives -- cgit v1.2.3