Difference between revisions of "Project Plan"

From Open-IOV
Jump to navigation Jump to search
m (2026-11-09 wiki refresh: display/KMS bring-up (NvKms, /dev/dri, GL 4.6), direct-GL channel submissions, current X/GLX completion wall)
m (2026-11-18 late status refresh: CUDA CE push page + fresh-CE walk seed fixed; the wall is now the guest-side UVM page-tree-init push; GL pixel gate held; checkpoint 5b23a983 noted)
 
(17 intermediate revisions by the same user not shown)
Line 5: Line 5:
<blockquote>'''Scope.''' The sequence of work: the phases, the gates that close them, what comes next, and how the plan itself is maintained. This is the ''roadmap'' view — [[Project Goals|<code>Project-Goals.md</code>]] says what the project is for, [[Project Status|<code>Project-Status.md</code>]] says where it stands today, and this page says in what order the remaining work happens and what must be true before each step. Canonical sources: the compute milestone ladder in [https://git.vgpu.io/open-iov.git/tree/docs/04-implementation/03-execution-frontier.md <code>../docs/04-implementation/03-execution-frontier.md</code>], the graphics ladder in [https://git.vgpu.io/open-iov.git/tree/docs/04-implementation/05-graphics-execution-plan.md <code>../docs/04-implementation/05-graphics-execution-plan.md</code>], the five-rung evaluation ladder in [https://git.vgpu.io/open-iov.git/tree/docs/05-operations/01-performance-correctness-security.md <code>../docs/05-operations/01-performance-correctness-security.md</code>], and the porting sequence in [https://git.vgpu.io/open-iov.git/tree/docs/06-portability/03-device-validation-and-porting-sequence.md <code>../docs/06-portability/03-device-validation-and-porting-sequence.md</code>]; the docs tree wins on disagreement.</blockquote>
<blockquote>'''Scope.''' The sequence of work: the phases, the gates that close them, what comes next, and how the plan itself is maintained. This is the ''roadmap'' view — [[Project Goals|<code>Project-Goals.md</code>]] says what the project is for, [[Project Status|<code>Project-Status.md</code>]] says where it stands today, and this page says in what order the remaining work happens and what must be true before each step. Canonical sources: the compute milestone ladder in [https://git.vgpu.io/open-iov.git/tree/docs/04-implementation/03-execution-frontier.md <code>../docs/04-implementation/03-execution-frontier.md</code>], the graphics ladder in [https://git.vgpu.io/open-iov.git/tree/docs/04-implementation/05-graphics-execution-plan.md <code>../docs/04-implementation/05-graphics-execution-plan.md</code>], the five-rung evaluation ladder in [https://git.vgpu.io/open-iov.git/tree/docs/05-operations/01-performance-correctness-security.md <code>../docs/05-operations/01-performance-correctness-security.md</code>], and the porting sequence in [https://git.vgpu.io/open-iov.git/tree/docs/06-portability/03-device-validation-and-porting-sequence.md <code>../docs/06-portability/03-device-validation-and-porting-sequence.md</code>]; the docs tree wins on disagreement.</blockquote>


Status: 2026-11-09, tree <code>master @ 4acc81e8</code>. Tags: <code>[done]</code>, <code>[active]</code>, <code>[ahead]</code> — the plan's own state vocabulary, distinct from the goal tags.
Status: 2026-11-18, tree <code>master @ 5b23a983</code>. Tags: <code>[done]</code>, <code>[active]</code>, <code>[ahead]</code> — the plan's own state vocabulary, distinct from the goal tags.


== 1. How the plan works ==
== 1. How the plan works ==
Line 24: Line 24:
! What it delivers
! What it delivers
! Exit gate
! Exit gate
! State (2026-10-30)
! State (2026-11-18, late)
|-
|-
| '''P0 — Platform'''
| '''P0 — Platform'''
Line 39: Line 39:
| OpenGL/Vulkan draw commands executed by the physical 3D pipeline and delivered as readable pixels
| 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 <code>glxgears</code> non-black; M-GL3 GZDoom GL non-black through the mdev
| The graphics ladder: M-GL1 client context-init executes; M-GL2 <code>glxgears</code> non-black; M-GL3 GZDoom GL non-black through the mdev
| <code>[active]</code> — between M-GL1 and M-GL2; the display/KMS and direct-GL channel work is live; the X GLX completion and first rendered frame are the walls
| <code>[active]</code> — 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 <code>DRAW_IAB</code> (<code>mac=0x22</code>, 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 <code>DS-FAST2 ds_after=80000000</code> 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 late-11-16 wave crossed the guest submission gap: an offscreen EGL/GBM shim gives GZDoom a real NVIDIA GL context without Xorg/DDX, and the real op=4 <code>CALL(0)</code> <code>0x3800</code> draw (12068 B at push <code>0x402f9d8</code>) is admitted and replayed; <code>CALL(0)</code> executes its captured macro without trapping (eng89t), and c1027 reached the first DS with real stage data. '''2026-11-18: the GL pixel gate closed''' (<code>b5a68b9a</code>): the first clear/CALL(0)-bearing window is archived and replayed, the engine clear stores red on the guest surface, the readback fence is delivered with the copy (11.03-11.05 s measured down to 2.3-7.2 ms), and the CE D2H copy's source VA is adopted as the readback surface; two consecutive boots read <code>GL_FRAME nonblack=291840 px0=(255,0,0)</code> and live <code>t/04</code> is green (<code>EXPECT_GL_PIXELS=closed</code>). The remaining walls are the '''window/screen present''', X start speed and the boot lottery; the per-draw MME macro body is a research path, no longer on the pixel critical path. 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'''
| '''P3 — Sustained and multi-tenant'''
Line 63: Line 63:
Ranked, in dependency order:
Ranked, in dependency order:


# '''Graphics pixels (P2).''' The client and display stacks execute; the named walls are the X GLX context-creation completion (<code>_nv018351rm</code> plus the X DDX/GLX reply), the client kick-slot word, then non-black frames. Full detail: [[Graphics Execution|<code>Graphics-Execution.md</code>]] §6.
# '''Graphics pixels (P2).''' The client and display stacks execute, X and the stock GLX path are fully green (<code>glxinfo -B</code> rc 0, ~520 FPS <code>glxgears</code>), the X DDX/ScreenInit stability walls are closed (X green &gt;10 minutes), the DDX 3D replay runs, the first non-black GPU-rendered frames and videos are captured off-screen, captured GL sections execute on the engine, the direct-GL submission is fully decoded (macro-driven; no method-grammar draw header), and the client's draw-state push reaches the engine with the golden MME overlay. The MME pack then completes and <code>DRAW_IAB</code> (<code>mac=0x22</code>) executes with the SPH-BIND prelude intact and the DS stage VAs populated. The '''DS stage-0/1 image is now authored and live''' (a VTG SPH at <code>family+0x900</code>, first word <code>020a0481</code>; the window's own slot-1 bind is rewritten to it; DS <code>0x86040626 -&gt; 0x84000420</code>, 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, and the slot-34 census plus the SA[34] golden fill prove <code>client=golden=used=0x265</code>. '''The draw macro now executes end to end''': c788 ran <code>DRAW_IAB</code> (<code>mac=0x22</code>) on the released held window after the <code>MME-DRAW-MOVE</code> reorder, TCS-off (<code>45dbcdcd</code>) clears the DS latch, the synthetic viewport (<code>dab4a02c</code>) and the chained release (<code>3481e62d</code>) complete the replay, and the body decodes with the public Mesa MME toolchain (<code>mme_tu104_sim</code>: 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 (<code>DS-FAST2 ds_after=80000000</code>, 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 '''late-11-16 wave crossed the guest submission gap''': an offscreen EGL/GBM shim gives GZDoom a real NVIDIA GL context without Xorg/DDX (<code>GL_RENDERER: NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2</code>, <code>GL_VERSION: 4.6.0 NVIDIA 570.144</code>; no llvmpipe), and the real op=4 <code>CALL(0)</code> <code>0x3800</code> draw (12068 B at push <code>0x402f9d8</code>, slots 44/57/58) is admitted and replayed; <code>CALL(0)</code> executes its captured macro without trapping (eng89t resolves the immediate through client SA[0]/golden and elides not-resident calls), and c1027 reached the first DS with real stage data. '''The GL pixel gate then closed on 2026-11-18''' (<code>b5a68b9a</code>) without the per-draw macro body: the host archives and replays the first clear/CALL(0)-bearing window, the engine clear stores red on the guest surface, and the readback follows the CE copy's source VA with a generation-pinned snapshot and a with-the-copy fence (11.03-11.05 s measured down to 2.3-7.2 ms). Two consecutive boots read <code>GL_FRAME nonblack=291840 px0=(255,0,0)</code>, live <code>t/04</code> is green, and <code>EXPECT_GL_PIXELS=closed</code>. The named walls are therefore the '''window/screen present path''' (glxgears' window is black and a window draw can wedge X), X start speed, and the boot lottery. 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|<code>Graphics-Execution.md</code>]] §6.
# '''Compute hardening (P1).''' The staged-transfer class (failure modes proven, fixes in flight); the every-boot acceptance campaign; per-guest execution isolation. Detail: [[The Execution Frontier|<code>Execution-Frontier.md</code>]].
# '''Compute hardening (P1).''' The current work unit is the guest-side UVM page-tree-init push: <code>UVM_REGISTER_GPU</code> holds the UVM parents mutex while waiting for a tracking value the emulation never completes, and the push's channel is not registered with us (a boot-dependent race; checkpoint <code>5b23a983</code> adds TSG engine inheritance but is not yet CUDA-validated). After that: the staged-transfer class, the every-boot acceptance campaign, per-guest execution isolation. Detail: [[The Execution Frontier|<code>Execution-Frontier.md</code>]].
# '''The visible sequence after these''': first non-black frame → 60 fps in one VM with no forcing → two VMs on two mdevs → the CUDA battery 15/15 plus a soak → video → Windows.
# '''The visible sequence after these''': first non-black window/screen frame (the guest GL readback gate is already closed) → 60 fps in one VM with no forcing → two VMs on two mdevs → the CUDA battery 15/15 plus a soak → video → Windows, then tag v1.0.0 and package source + binary tarballs.
# '''Then P4/P5 row by row''': each item ships with its own gate, profile and evidence, and only then moves in the matrix.
# '''Then P4/P5 row by row''': each item ships with its own gate, profile and evidence, and only then moves in the matrix.


Recently closed, as evidence the gates work: the boot-poisoning defect and the post-reboot client-stall defect (compute reproducibility); the display/KMS bring-up (NvKms registers, X settles, GL 4.6 and a real GZDoom GL context); the UVM channel-pool tracker; the direct-GL GR release and CE ring discovery; the X DDX kick-channel decode; and the guest Vulkan pipeline running end to end.
Recently closed, as evidence the gates work: the boot-poisoning defect and the post-reboot client-stall defect (compute reproducibility); the display/KMS bring-up (NvKms registers, X settles, GL 4.6); the UVM channel-pool tracker; the direct-GL ring/release and CE-ring discovery; the X DDX kick-channel decode and its three wait fixes (class-aware display arm, <code>0x8000 -&gt; 0</code> notification completion, decoded GL release applied); the GSP event-IRQ fix that completes swaps; the X DMA-init fix (<code>ebf3130f</code>); the GR backend timeout fix (<code>backend_timeout=0</code>); the 2D path end-to-end; the DDX 3D replay and the first non-black GPU-rendered frames with captured videos (the ring-ledger scrub release, <code>f6184ac3</code>); the direct-GL ring/VAS and USERD hardening (verified page-directory discovery, eager push pins, client-allocated USERD resolution); the full green X/GLX path (<code>glxinfo -B</code> rc 0, ~520 FPS <code>glxgears</code>); the guest adapter-init regression (<code>RMInstLoc</code> lost to a kernel-cmdline override) and its fix; the emulated FB/GART sizing traps (FB info in KB, GART 256 MiB) that removed the 4 GiB guest-allocation class; and the guest Vulkan pipeline running end to end; the acceptance suite with explicit gate flags (<code>1615f3cd</code>); the GL pixel gate (a stock guest <code>glReadPixels</code> reads a non-black engine-rendered frame, live <code>t/04</code>, 2026-11-18, re-verified on the later rounds); the 124 B UVM CE push-page class (<code>e5507958</code>); and the fresh-CE ring-walk seed (<code>d992c23b</code>).


== 4. The gates ==
== 4. The gates ==

Latest revision as of 03:25, 19 November 2026

An absence of critical technical documentation has historically slowed growth and adoption of developer ecosystems for GPU virtualization.

This CC-BY-4.0 licensed content can either be used with attribution, or used as inspiration for new documentation, created by GPU vendors for public commercial distribution as developer documentation.

Where possible, this documentation will clearly label dates and versions of observed-but-not-guaranteed behaviour vs. vendor-documented stable interfaces/behaviour with guarantees of forward or backward compatibility.

Project Plan

Scope. The sequence of work: the phases, the gates that close them, what comes next, and how the plan itself is maintained. This is the roadmap view — Project-Goals.md says what the project is for, Project-Status.md says where it stands today, and this page says in what order the remaining work happens and what must be true before each step. Canonical sources: the compute milestone ladder in ../docs/04-implementation/03-execution-frontier.md, the graphics ladder in ../docs/04-implementation/05-graphics-execution-plan.md, the five-rung evaluation ladder in ../docs/05-operations/01-performance-correctness-security.md, and the porting sequence in ../docs/06-portability/03-device-validation-and-porting-sequence.md; the docs tree wins on disagreement.

Status: 2026-11-18, tree master @ 5b23a983. Tags: [done], [active], [ahead] — the plan's own state vocabulary, distinct from the goal tags.

1. How the plan works

Five rules shape every phase below, and they are the project's contract with itself:

  1. Every milestone has a gate and an acceptance signal, named before the work starts. A wall is closed only by its acceptance signal — not by an intention, a decompiler reading, or a lucky run.
  2. The evaluation ladder is the spine. A platform advances initialization → runtime start → execution → sustained → multi-tenant, and nothing claims a rung it has not reached and reproduced.
  3. Correctness before speed; no number without methodology. Performance claims carry their harness, versions and A/B baseline.
  4. Default-off until validated. New mechanisms land behind parameters (the forwarding and graphics seams today) and graduate only after their gate passes; graduation replaces the knob with documented configuration.
  5. No patches anywhere, and profiles over rewrites. Guest drivers, host drivers, firmware and hypervisors stay stock; a new driver, firmware or GPU enters the plan as a profile plus a measured delta.

2. The phases

Phase What it delivers Exit gate State (2026-11-18, late)
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 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 late-11-16 wave crossed the guest submission gap: an offscreen EGL/GBM shim gives GZDoom a real NVIDIA GL context without Xorg/DDX, and the real op=4 CALL(0) 0x3800 draw (12068 B at push 0x402f9d8) is admitted and replayed; CALL(0) executes its captured macro without trapping (eng89t), and c1027 reached the first DS with real stage data. 2026-11-18: the GL pixel gate closed (b5a68b9a): the first clear/CALL(0)-bearing window is archived and replayed, the engine clear stores red on the guest surface, the readback fence is delivered with the copy (11.03-11.05 s measured down to 2.3-7.2 ms), and the CE D2H copy's source VA is adopted as the readback surface; two consecutive boots read GL_FRAME nonblack=291840 px0=(255,0,0) and live t/04 is green (EXPECT_GL_PIXELS=closed). The remaining walls are the window/screen present, X start speed and the boot lottery; the per-draw MME macro body is a research path, no longer on the pixel critical path. 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]

The phases overlap on purpose: the graphics workstream is what unblocks P3's first exit gate, and portability work starts from whichever hardware becomes available (P5 runs across the whole plan).

3. Where the plan stands, and what is next

Ranked, in dependency order:

  1. Graphics pixels (P2). The client and display stacks execute, X and the stock GLX path are fully green (glxinfo -B rc 0, ~520 FPS glxgears), the X DDX/ScreenInit stability walls are closed (X green >10 minutes), the DDX 3D replay runs, the first non-black GPU-rendered frames and videos are captured off-screen, captured GL sections execute on the engine, the direct-GL submission is fully decoded (macro-driven; no method-grammar draw header), and the client's draw-state push reaches the engine with the golden MME overlay. The MME pack then completes and DRAW_IAB (mac=0x22) executes 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; the window's own slot-1 bind is rewritten to it; 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 the calls released, and the slot-34 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 the released held window after the 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 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 late-11-16 wave crossed the guest submission gap: an offscreen EGL/GBM shim gives GZDoom a real NVIDIA GL context without Xorg/DDX (GL_RENDERER: NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2, GL_VERSION: 4.6.0 NVIDIA 570.144; no llvmpipe), and the real op=4 CALL(0) 0x3800 draw (12068 B at push 0x402f9d8, slots 44/57/58) is admitted and replayed; CALL(0) executes its captured macro without trapping (eng89t resolves the immediate through client SA[0]/golden and elides not-resident calls), and c1027 reached the first DS with real stage data. The GL pixel gate then closed on 2026-11-18 (b5a68b9a) without the per-draw macro body: the host archives and replays the first clear/CALL(0)-bearing window, the engine clear stores red on the guest surface, and the readback follows the CE copy's source VA with a generation-pinned snapshot and a with-the-copy fence (11.03-11.05 s measured down to 2.3-7.2 ms). Two consecutive boots read GL_FRAME nonblack=291840 px0=(255,0,0), live t/04 is green, and EXPECT_GL_PIXELS=closed. The named walls are therefore the window/screen present path (glxgears' window is black and a window draw can wedge X), X start speed, and the boot lottery. 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 §6.
  2. Compute hardening (P1). The current work unit is the guest-side UVM page-tree-init push: UVM_REGISTER_GPU holds the UVM parents mutex while waiting for a tracking value the emulation never completes, and the push's channel is not registered with us (a boot-dependent race; checkpoint 5b23a983 adds TSG engine inheritance but is not yet CUDA-validated). After that: the staged-transfer class, the every-boot acceptance campaign, per-guest execution isolation. Detail: Execution-Frontier.md.
  3. The visible sequence after these: first non-black window/screen frame (the guest GL readback gate is already closed) → 60 fps in one VM with no forcing → two VMs on two mdevs → the CUDA battery 15/15 plus a soak → video → Windows, then tag v1.0.0 and package source + binary tarballs.
  4. Then P4/P5 row by row: each item ships with its own gate, profile and evidence, and only then moves in the matrix.

Recently closed, as evidence the gates work: the boot-poisoning defect and the post-reboot client-stall defect (compute reproducibility); the display/KMS bring-up (NvKms registers, X settles, GL 4.6); the UVM channel-pool tracker; the direct-GL ring/release and CE-ring discovery; the X DDX kick-channel decode and its three wait fixes (class-aware display arm, 0x8000 -> 0 notification completion, decoded GL release applied); the GSP event-IRQ fix that completes swaps; the X DMA-init fix (ebf3130f); the GR backend timeout fix (backend_timeout=0); the 2D path end-to-end; the DDX 3D replay and the first non-black GPU-rendered frames with captured videos (the ring-ledger scrub release, f6184ac3); the direct-GL ring/VAS and USERD hardening (verified page-directory discovery, eager push pins, client-allocated USERD resolution); the full green X/GLX path (glxinfo -B rc 0, ~520 FPS glxgears); the guest adapter-init regression (RMInstLoc lost to a kernel-cmdline override) and its fix; the emulated FB/GART sizing traps (FB info in KB, GART 256 MiB) that removed the 4 GiB guest-allocation class; and the guest Vulkan pipeline running end to end; the acceptance suite with explicit gate flags (1615f3cd); the GL pixel gate (a stock guest glReadPixels reads a non-black engine-rendered frame, live t/04, 2026-11-18, re-verified on the later rounds); the 124 B UVM CE push-page class (e5507958); and the fresh-CE ring-walk seed (d992c23b).

4. The gates

Each gate's full text lives in its canonical document; this is the map:

Gate What must be true Where it is defined
Rung gate The previous rung is green and reproducible for this platform before the next is claimed Evaluation ladder
Execution gate Engine-authored release plus verified guest results, reproduced across fresh boots Execution frontier
Graphics gate Milestone definitions: capture shows motion, no forcing, no diagnostic mirror, renderer is the NVIDIA driver Graphics plan (§C)
Performance gate A/B ratios from the published harness; no absolute numbers; variance and run counts reported Measurement contract
Portability gate Profile fields recorded, firmware/device pairing hashed, first-touch differences explained, supervised physical validation done Porting sequence + matrix
Isolation gate Fail-closed enforcement; fairness measured before any multi-tenant claim Security document
Security gate Adversarial review before multi-tenant or production claims Security document

5. Workstreams (always on)

Workstream What it does Entry point
Correctness and acceptance The regression battery, battery-first ordering, regression gates Execution-Frontier.md
Graphics execution The execution lanes, capture/decode, the M-GL ladder Graphics-Execution.md
Performance measurement Microbenchmarks first, then the A/B corpus, then structural optimisation Performance.md
Portability and versions Profiles, measured deltas, the validation sequence; new driver/firmware families behind a review gate Hardware-Software-Matrix.md
Developer tooling The firmware workbench: recorded sessions as evidence, offline-first investigation of walls Riscv-GSP-RM-Debugger.md
Security and isolation Threat model, audits, fail-closed posture ../docs/05-operations/01-performance-correctness-security.md
Documentation and evidence Docs tree canonical; dated status; replayable evidence for every claim ../docs/README.md

6. Contributing to the plan

  • The unit of contribution is a profile plus evidence, evaluated through the five-rung ladder — see "Adding a new combination" in Hardware-Software-Matrix.md and the porting sequence document.
  • Nasty bugs (non-reproducible, cross-subsystem, blocking a gate) get a tracked issue in the repository; ordinary work stays in the live handoffs.
  • Support claims are made only by recording hardware + driver + firmware + rung + date in the matrix with the evidence bundle behind them.

7. How this plan is maintained

The plan is a living sequence, not a dated roadmap: each milestone's gate is owned by its canonical document, the current state is tracked on Project-Status.md, and the plan changes only when a gate is named and its evidence rules are written down. When a wall closes, the canonical doc is updated first and the site pages follow on the next refresh.

8. Related pages