wiki: 2026-11-10 status refresh - guest GL draws execute on the physical GPU

Refresh STATE-CURRENT, the Main Page and the status/frontier pages: the GSP
event-IRQ fix completes swaps; the 2D path is green end-to-end; the guest's
real GL draws now forward and execute on the physical GPU (work_gr
backend_ok=9); the draw writes 0 pages because its constant-buffer (MVP)
page is unresolved and forced to the seed page; the MME front-end defer, GR
stale-wedge and the X DDX get-word/notifier completion remain. Published to
open-iov.org.

1 files changed, 50 insertions, 46 deletions

diff --git a/wiki/Graphics-Execution.md b/wiki/Graphics-Execution.md
index ffbcfaf..7771d6a 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-09, tree `master @ 21e0d611`. Tags: `[live]` observed end to
+Status: 2026-11-09, tree `master @ cb8e822b`. Tags: `[live]` observed end to
 end; `[wip]` partially built; `[wall]` current blocker; `[target]` defined
 success state; `[planned]` designed, not built.
 
@@ -89,10 +89,12 @@ fidelity:
    kick channel (`0xbfef0002`) is decoded from its ring head with its
    class-2D notification authored. The X DDX waits are fixed (class-aware
    display arm, `0x8000 -> 0` notification completion, decoded GL release
-   applied), and with GLX forced (`SDL_VIDEO_X11_FORCE_EGL=0`) the windowed
-   GL path selects `libnvidia-glcore`. What remains is the kernel-visible GL
-   present/kick completion, the DDX get-word/notifier recycle, and physical
-   dispatch of the client's draws (§6).
+   applied), forcing GLX selects `libnvidia-glcore`, and the event-IRQ fix
+   (`a478f0b4`) lets the guest service the completion, so glxgears completes
+   swaps and the guest's real GL draws now forward and execute on the
+   physical GPU (`work_gr backend_ok=9`). What remains is the constant-buffer
+   (MVP) content, the MME front-end defer and GR stale-wedge, and the DDX
+   get-word/notifier completion (§6).
 
 ## 4. The channel and object picture
 
@@ -139,10 +141,12 @@ until it posts, so the X server's mode set finishes. For the X DDX's own 2D
 push buffers, completion also requires the GPU-written engine get word to
 advance and the notifier to be recycled to `0xffff` after a kick; both are
 host-side levers now, and a diagnostic write of the get word released the
-DDX's reserve loop. For a windowed GL client the present is a kick whose
-completion the guest kernel observes by polling its per-slot
-`/dev/nvidia-modeset` fd; the host must complete the exact notifier page the
-kernel watches and signal that event, not only write the notifier memory.
+DDX's reserve loop. For a windowed GL client the present is a kick; the GSP
+event-IRQ fix now sets the RISC-V SWGEN0 IRQSTAT/IRQMASK/IRQDEST and latches
+the CPU-tree leaf, so the guest services the event and glxgears completes
+swaps. The next completion step is the constant buffer: the draw's CB page
+must be resolved and copied into the seed page so the engine produces
+fragments.
 
 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
@@ -151,32 +155,35 @@ requires it switched off, along with any external poke.
 
 ## 6. Where the frontier is (ranked walls)
 
-1. **Kernel-visible GL present completion** `[wall]`. With GLX forced the
-   windowed client uses `libnvidia-glcore`; the minimal `glxgears` then hangs
-   in the glcore kick wait: the client polls its per-slot
-   `/dev/nvidia-modeset` fd (`poll(POLLIN, 1 s)`). The host's sweep completes
-   the beef notifier memory, but the guest kernel never signals the event the
-   poll waits on. The exact notifier page the kernel watches must be
-   completed and the guest event signalled (the kick-notify executor), not
-   just the memory written.
-2. **The X DDX push-buffer completion** `[wall]`. The DDX's 2D reserve loop
+1. **The constant buffer (MVP) content** `[wall]`. The guest's GL draws now
+   execute on the physical GPU, but the engine writes 0 pages. The draw's
+   constant-buffer source is forced to the seed page because
+   `cb-copy src=0x0cd70000 ... first8=00000000 ... src=synthetic-id` reads all
+   zeros; a guest-RAM scan found no MVP matrix and the `0x3f800000` vidmem
+   hits are shader microcode immediates. With a zero MVP every vertex
+   collapses to the origin, so there are no fragments. Decode the CB-bind
+   method on the beef channel, resolve that VA through the channel VAS, and
+   copy the real page into the seed page.
+2. **Execution stability** `[wall]`. The MME front-end is busy/deferred
+   (`MME-FE-DEFER` then forced loads) and the GR channel stale-wedges
+   (`GR-STALL-stale-wedge`, recovered), so the pipeline restarts mid-frame.
+   Fixing the CB page may unstick the MME; the wedge recovery needs a durable
+   fix.
+3. **The X DDX push-buffer completion** `[wall]`. The DDX's 2D reserve loop
    exits only when the GPU-written engine get word advances (`get <= put`) and
-   the kick requires the notifier to be recycled to `0xffff` after
-   completion. A diagnostic host write released the loop; the kernel levers
-   to publish/advance the get word and recycle the notifier are next.
-3. **The X DDX footprint** `[wall]`. The DDX allocates 4 GB of system pages at
+   the kick requires the notifier to be recycled to `0xffff` after completion.
+   `sema_vas_cand_ms=1` makes X green on attempt 1, but X can still die after a
+   few forward frames into the RM-degraded state.
+4. **The X DDX footprint** `[wall]`. The DDX allocates 4 GB of system pages at
    startup; an 8 GB guest has no headroom once GZDoom's own footprint lands
    and both are OOM-killed. Current runs use a 12 GB guest; the allocation is
    a suspected emulation gap (a 512 MiB emulated VRAM falling back to a 4 GB
    sysmem allocation) to fix.
-4. **Physical dispatch of the GL draws** `[wall]`. The direct-GL channels
-   submit and get host-completed releases, but the forwarding path reports no
-   dispatch to the physical GR engine (`forwarded=0`); the draws are decoded
-   and host-completed, not executed on hardware.
 5. **Non-black frames and sustained rate** `[wall]`/`[target]`. Once the
-   kernel-visible present completion and the DDX get-word/notifier completion
-   land, the capture must show motion, then 60 fps in one VM with no forcing,
-   then two VMs on two mediated devices with non-black frames in both.
+   constant buffer, the MME/wedge stability and the DDX get-word/notifier
+   completion land, the capture must show motion, then 60 fps in one VM with
+   no forcing, then two VMs on two mediated devices with non-black frames in
+   both.
 
 ## 7. What is proven today
 
@@ -186,21 +193,19 @@ requires it switched off, along with any external poke.
 | Display engine serves the modeset push buffers; notifier plus `UPDATE -> FINISHED` | `[live]` (campaign configuration) |
 | nvidia-modeset/NvKms registers (`/dev/dri/card0`, `renderD128`, `fb0`); `nvidia-smi -L` enumerates | `[live]` |
 | `glxinfo` reports the emulated GPU with the NVIDIA renderer (OpenGL 4.6.0, direct rendering) | `[live]` |
-| GZDoom obtains a real GL context; windowed reaches renderer startup | `[live]` (pixels frontier) |
-| GZDoom reaches `MAP01` on Mesa llvmpipe (not the emulated vGPU path) | `[wip]` |
-| Forced GLX (`SDL_VIDEO_X11_FORCE_EGL=0`) selects `libnvidia-glcore` | `[live]` |
-| Windowed GL present/kick completion (minimal `glxgears`) | `[wall]` |
-| X server survives the GZDoom run on a 12 GB guest (the DDX's 4 GB sysmem allocation forces the size) | `[live]` |
-| GL section capture: the X server's `0xC597` stream decoded | `[live]` |
+| X server green with `sema_vas_cand_ms=1`; glxinfo 4.6.0 direct | `[live]` |
+| GSP event-IRQ fix wakes the guest poll; glxgears completes swaps | `[live]` |
+| 2D path end-to-end: accelerated X fills read back via `xwd` | `[live]` |
+| Guest's real GL draws forward and execute on the physical GPU (`work_gr backend_ok=9`) | `[live]` |
+| Beef GR channel `0xbeef0100` captures real GL draw sections | `[live]` |
+| GL section capture: the X channel's `0xC597` stream decoded | `[live]` |
 | Verbatim 3D method-stream replay retired by the engine (no MMU fault) | `[live]` |
 | Synthesized launch executes real `sm_75` SASS; Turing `V3` program header accepted | `[live]` |
-| 2D screen fills and copy-engine present ops execute | `[live]` |
-| Direct GL client: device-init gate handled, channels allocate, readback path returns clean | `[live]` |
-| Direct GL client channels submit and retire (GR `0xbeef0100`, CE `0xbeef0101`/`0xbeef0102`); DDX kick channel decoded | `[live]` |
-| Guest kernel observes the kick completion and signals the modeset event | `[wall]` |
-| NVIDIA Vulkan ICD creates a device | `[wall]` |
+| X server survives the run on a 12 GB guest (the DDX's 4 GB sysmem allocation forces the size) | `[live]` |
+| Constant-buffer (MVP) page resolves and the draw writes render-target pixels | `[wall]` |
+| MME front-end defer / GR stale-wedge stability | `[wall]` |
 | DDX push-buffer get-word publish and notifier recycle | `[wall]` |
-| Physical dispatch of the direct-GL draws (`forwarded=0`) | `[wall]` |
+| NVIDIA Vulkan ICD creates a device | `[wall]` |
 | Non-black pixels from the emulated vGPU's 3D pipeline | `[wall]` |
 | Windows/DirectX guests | `[planned]` |
 
@@ -208,11 +213,10 @@ requires it switched off, along with any external poke.
 
 * No non-black pixel has been produced by the emulated vGPU's 3D pipeline yet.
 * Display/KMS bring-up (NvKms, `/dev/dri`, X, a real GL context) is not a
-  rendered-frame claim; GZDoom reaching `MAP01` on Mesa llvmpipe is not the
-  emulated-vGPU path, and the later forced-GLX run selects `libnvidia-glcore`
-  but hangs in the present/kick wait. The kernel-visible present completion,
-  the DDX get-word/notifier completion and the physical dispatch of the GL
-  draws are the current walls.
+  rendered-frame claim; the guest's GL draws now execute on the physical GPU
+  and glxgears completes swaps, but the frames are black. The constant-buffer
+  (MVP) content, the MME/wedge stability and the DDX get-word/notifier
+  completion are the current walls.
 * No frame-rate or latency numbers: the scheduled measurement is defined
   (60 fps over 60 s, no forcing) but not yet met.
 * The `virgl`-based demo videos are a different, labelled path — not this one.