wiki: 2026-11-09 evening refresh - X DDX waits fixed; GZDoom reaches MAP01 on llvmpipe

Refresh Project Status, Graphics Execution, OpenGL, Execution Frontier,
Execution Plane, Physical GPU Backend, Host Module, System Overview,
Project Goals, Project Plan and the FAQ, plus STATE-CURRENT and the Main
Page: the X DDX waits (class-aware display arm, 0x8000->0 notification
completion, decoded GL release) are fixed; GZDoom reaches MAP01 on Mesa
llvmpipe; the NVIDIA renderer path, the DDX get-word/notifier completion,
the DDX 4 GB sysmem footprint and physical dispatch of the GL draws are
the pixel walls. Published to open-iov.org.

1 files changed, 49 insertions, 26 deletions

diff --git a/wiki/Graphics-Execution.md b/wiki/Graphics-Execution.md
index 59196d5..cba9732 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 @ 4acc81e8`. Tags: `[live]` observed end to
+Status: 2026-11-09, tree `master @ e342bd0f`. Tags: `[live]` observed end to
 end; `[wip]` partially built; `[wall]` current blocker; `[target]` defined
 success state; `[planned]` designed, not built.
 
@@ -87,9 +87,12 @@ fidelity:
    (`0xbeef0100`) and its CE siblings (`0xbeef0101`/`0xbeef0102`) are
    discovered, their rings and releases are decoded, and the X server's DDX
    kick channel (`0xbfef0002`) is decoded from its ring head with its
-   class-2D notification authored. What remains is completing the GLX
-   context-creation handshake and the client's kick-slot wait (§6), not
-   making the pushes readable.
+   class-2D notification authored. The X DDX waits are fixed (class-aware
+   display arm, `0x8000 -> 0` notification completion, decoded GL release
+   applied), and GZDoom reached `MAP01` once the DDX push-buffer loop was
+   unblocked. What remains is the renderer backend path (NVIDIA Vulkan ICD or
+   forced GLX), the DDX get-word/notifier completion, and physical dispatch
+   of the client's draws (§6).
 
 ## 4. The channel and object picture
 
@@ -105,10 +108,12 @@ fidelity:
 * **Display and modeset** `[live]`. The guest's modeset path is served by an
   emulated display engine: the display push-buffer channels (core `0xc57d`,
   window `0xc57e`, immediate/window `0xc57b`) are registered, their push
-  buffers parsed, and the notifier/`UPDATE` completion authored. This is what
-  lets nvidia-modeset/NvKms register (`/dev/dri`), X settle and GLX clients
-  obtain a real GL context. The display-capability seam is parameterised in
-  the campaign configuration.
+  buffers parsed, and the notifier/`UPDATE` completion authored. The arm is
+  class-aware (the window class has no NOTIFY bit; a bound notifier is the
+  arm), and the X DDX's `0x8000 -> 0` notification completion is authored.
+  This is what lets nvidia-modeset/NvKms register (`/dev/dri`), X settle and
+  GLX clients obtain a real GL context. The display-capability seam is
+  parameterised in the campaign configuration.
 * **Cells of state**: 3D streams are long—hundreds of method words per draw —
   and mix state binds (viewport, render target, ZS, blend/ROP), program and
   constant binds, vertex/index streams and draw-issuing methods. The capture
@@ -130,7 +135,11 @@ there.
 
 For the display path, completion is the notifier write and `UPDATE ->
 FINISHED`; a completion event deferred by the reply path is force-retried
-until it posts, so the X server's mode set finishes.
+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.
 
 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
@@ -139,21 +148,29 @@ requires it switched off, along with any external poke.
 
 ## 6. Where the frontier is (ranked walls)
 
-1. **The X GLX context-creation completion** `[wall]`. With the UVM
-   channel-pool and direct-GL submission walls closed, the X server spins in
-   its RM ioctl path (`_nv018351rm`) while a GL client's GLX context request
-   waits on the X reply. The X DDX's own channels and the GLX reply are the
-   current named objects. (Fullscreen GZDoom's client-triggered mode set can
-   still wedge X; the campaign path is a settled X plus windowed GZDoom.)
-2. **The client kick-slot word** `[wall]`. The GL client polls a kick-slot GPU
-   address for its completion; the RM notifier page is a different object, so
-   the completion must be authored at the client's kick-slot address.
-3. **Non-black frames** `[wall]`. Once the GLX context completes and the
-   client's kick wait resolves, the capture must show motion; every frame
-   captured so far is black.
-4. **Sustained frame rate, and two VMs** `[target]`. The defined end state:
-   60 fps in one VM with no forcing, then two VMs on two mediated devices
-   with non-black frames in both.
+1. **The renderer backend path** `[wall]`. GZDoom's default Vulkan backend
+   fails at `vkCreateDevice` in the NVIDIA Vulkan ICD, and the default
+   OpenGL/EGL path falls back to Mesa (`llvmpipe`). The campaign is forcing
+   GLX (`SDL_VIDEO_X11_FORCE_EGL=0`) so the client uses the NVIDIA GL stack;
+   the first NVIDIA-path frame is gated here.
+2. **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
+   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
+   NVIDIA renderer path 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
 
@@ -164,13 +181,17 @@ requires it switched off, along with any external poke.
 | 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]` |
+| 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]` |
 | 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]` |
-| X GLX context-creation completion and the client kick-slot word | `[wall]` |
+| NVIDIA Vulkan ICD creates a device, or forced GLX reaches glcore | `[wall]` |
+| DDX push-buffer get-word publish and notifier recycle | `[wall]` |
+| Physical dispatch of the direct-GL draws (`forwarded=0`) | `[wall]` |
 | Non-black pixels from the emulated vGPU's 3D pipeline | `[wall]` |
 | Windows/DirectX guests | `[planned]` |
 
@@ -178,7 +199,9 @@ 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; the GLX context-creation and kick-slot completions are
+  rendered-frame claim; GZDoom reaching `MAP01` on Mesa llvmpipe is not the
+  emulated-vGPU path either. The NVIDIA renderer path, the DDX
+  get-word/notifier completion and the physical dispatch of the GL draws 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.