diff options
Diffstat (limited to 'wiki/Graphics-Execution.md')
| -rw-r--r-- | wiki/Graphics-Execution.md | 92 |
1 files changed, 41 insertions, 51 deletions
diff --git a/wiki/Graphics-Execution.md b/wiki/Graphics-Execution.md index ca04b8f..1cdb15f 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 @ bb802909`. Tags: `[live]` observed end to +Status: 2026-11-09, tree `master @ df6e71bb`. Tags: `[live]` observed end to end; `[wip]` partially built; `[wall]` current blocker; `[target]` defined success state; `[planned]` designed, not built. @@ -82,20 +82,15 @@ fidelity: faults across repeated launches. This proved engine-side dispatch before the verbatim lane existed. The program itself is still a development stand-in at this rung — execution proof, not pixels. -3. **Forwarding the client's own pushes** `[wip]`. The GL client's own - channels now register, submit and retire: the direct-GL GR channel - (`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. The X DDX waits are fixed (class-aware - display arm, `0x8000 -> 0` notification completion, decoded GL release - 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=5-7`, `backend_timeout=0`) and X is - reliable, but the draw still writes 0 pages. What remains is the beef GR - ring resolution race, the fixed-CB image's zero MVP block, and the - render-target bind (§6). +3. **Forwarding the client's own pushes** `[wip]`. The X DDX channel + `0x1000014` executes its 3D replay (12 launches per cycle), the 2D path is + green, and a guest pbuffer `glClear(red)+glFinish+glReadPixels` probe + returns a real pixel (`pixel=ff0000ff`): the replay and readback machinery + works. The direct-GL client's own channel (`0xbfef0002` this cycle) opens + a C597 section but emits only 32/64-byte setup/notify kicks + (`ops_runs=0`), so its draws never reach the host; a synchronous window + draw also wedges X. That draw submission and the window/screen present are + what remains (§6). ## 4. The channel and object picture @@ -146,10 +141,11 @@ 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, and the GR backend no longer times out (the pair-close/pair-safe -replay fixes are default ON; draws retire in 3-2400 ms). The next completion -step is the beef GR ring (so the fixed-CB scan runs on every cycle) and the -CB image (its `0x80` MVP block is zero even when the scan runs), then the -render-target bind. +replay fixes are default ON; draws retire in 3-2400 ms). The DDX 3D replay +now renders and reads back a pbuffer pixel (`pixel=ff0000ff`), and the +RM write-lock holder (Xorg in the DDX vidheap scrub wait) is fixed. The next +step is the direct-GL client's draw submission/capture and the window/screen +present path. 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 @@ -158,33 +154,27 @@ requires it switched off, along with any external poke. ## 6. Where the frontier is (ranked walls) -1. **Beef GR ring resolution** `[wall]`. `0xbeef0100` (the GL client GR - channel) registers with `vas=0` before its CE siblings publish - `0xbeef0300`; the shared VAS is then registered UNVERIFIED by the 1 ms - age-out, so the ring at `0x4020000` stays `ring_pa=0` and the fixed-CB scan - (gated to the `0xbeef0000` family) never runs. The next fix is to gate the - candidate promote on *verified* rather than *known* and retry every pump - turn. -2. **The fixed-CB image MVP block** `[wall]`. Even on a cycle where the scan - runs (`r1687`), it decodes 1492 `0x3800` offsets plus 1497 `0x39c8` data - runs (1092 words) but the image's `0x80` MVP block is zero. Identified - parser bugs (subchannel bits 15:13, `0x238c` ONE_INC inline data, selector - B/C swap) are not yet applied; the MVP may live at an offset >= `0x1000` or - a selector B/C binding. With a zero MVP every vertex collapses to the - origin, so there are no fragments. -3. **The render-target bind** `[wall]`. Confirm that the replayed draw's - render target is the page `bounce copy-out` compares - (`svc_surf_prelude_capture` currently picks the last trusted bind - globally). +1. **Direct-GL draw submission/capture** `[wall]`. The GL client channel + `0xbfef0002` opens a C597 section but emits only 32/64-byte setup/notify + kicks (`ops_runs=0`; `section captured` and `GR LAUNCH` are 0). The DDX + channel `0x1000014` works (12 launches/cycle), so the gap is the + direct-GL client's submit path, not the replay machinery. +2. **Window/screen present and X stability** `[wall]`. A synchronous window + GL draw wedges X (`xwd -root` writes 0 bytes; `XGetImage` never + completes), while the pbuffer probe works. Screen capture must use the + ivshmem frame path, and the X must survive the draw. +3. **X startup / RM degradation** `[wall]`. X startup is a lottery + (`Failed to initialize DMA`, push-buffer `0x51`, occasional vmalloc + 96 GB), and X can die after forward activity; a fresh cycle clears it. 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. -5. **Non-black frames and sustained rate** `[wall]`/`[target]`. Once the beef - ring, the CB image and the render-target bind 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. +5. **Non-black screen frames and sustained rate** `[wall]`/`[target]`. Once + the direct-GL draw capture and the window/screen present 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 @@ -199,27 +189,27 @@ requires it switched off, along with any external poke. | 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=5-7`) | `[live]` | | GR backend timeouts fixed (`backend_timeout=0`; draws retire in 3-2400 ms) | `[live]` | -| CB-DIAG decodes the draw's fixed-CB stream (1492 `0x3800` offsets, 1092 words) | `[live]` | -| Beef GR channel `0xbeef0100` captures real GL draw sections | `[live]` | +| DDX 3D replay executes (`section captured` + `GR LAUNCH` on `0x1000014`, 12 launches/cycle) | `[live]` | +| First real GPU readback: pbuffer `glClear(red)+glReadPixels` -> `pixel=ff0000ff` | `[live]` | +| RM write-lock holder identified (Xorg in the DDX vidheap scrub wait) and fixed (`df6e71bb`) | `[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]` | | X server survives the run on a 12 GB guest (the DDX's 4 GB sysmem allocation forces the size) | `[live]` | -| Beef GR ring resolves deterministically; fixed-CB scan runs every cycle | `[wall]` | -| Fixed-CB image's `0x80` MVP block becomes non-zero | `[wall]` | -| Render-target bind matches the copy-out page | `[wall]` | +| Direct-GL channel `0xbfef0002` submits a captured draw (`ops_runs>0`) | `[wall]` | +| Window/screen present completes without wedging X (ivshmem frame path) | `[wall]` | +| X startup/RM stability (`0x51`, vmalloc 96 GB) | `[wall]` | | NVIDIA Vulkan ICD creates a device | `[wall]` | -| Non-black pixels from the emulated vGPU's 3D pipeline | `[wall]` | +| Non-black screen pixels from the emulated vGPU's 3D pipeline | `[wall]` | | Windows/DirectX guests | `[planned]` | ## 8. What is not claimed * 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 guest's GL draws now execute on the physical GPU, - X is reliable and glxgears completes swaps, but the frames are black. The - beef GR ring resolution, the fixed-CB image's zero MVP block and the - render-target bind are the current walls. + rendered-frame claim. The first readback pixel is a pbuffer probe, not a + window/screen frame; the direct-GL client still emits only setup/notify + kicks, and a window draw wedges X. Those 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. |