Difference between revisions of "Project Goals"

From Open-IOV
Jump to navigation Jump to search
m (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)
m (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)
Line 5: Line 5:
<blockquote>'''Scope.''' What Open-IOV is for, what it is not for, and the dated status of each goal. Condensed from [https://git.vgpu.io/open-iov.git/tree/docs/01-orientation/01-purpose-and-scope.md <code>../docs/01-orientation/01-purpose-and-scope.md</code>] (mission, scope and success criteria) and [https://git.vgpu.io/open-iov.git/tree/docs/README.md <code>../docs/README.md</code>] (the project front door); the docs tree wins on disagreement. The live milestone ladder is on [[Project Status|<code>Project-Status.md</code>]], and the current execution detail on [[The Execution Frontier|<code>Execution-Frontier.md</code>]] and [[Graphics Execution|<code>Graphics-Execution.md</code>]].</blockquote>
<blockquote>'''Scope.''' What Open-IOV is for, what it is not for, and the dated status of each goal. Condensed from [https://git.vgpu.io/open-iov.git/tree/docs/01-orientation/01-purpose-and-scope.md <code>../docs/01-orientation/01-purpose-and-scope.md</code>] (mission, scope and success criteria) and [https://git.vgpu.io/open-iov.git/tree/docs/README.md <code>../docs/README.md</code>] (the project front door); the docs tree wins on disagreement. The live milestone ladder is on [[Project Status|<code>Project-Status.md</code>]], and the current execution detail on [[The Execution Frontier|<code>Execution-Frontier.md</code>]] and [[Graphics Execution|<code>Graphics-Execution.md</code>]].</blockquote>


Status: 2026-11-15, tree <code>master @ 88d5005a</code>. Tags: <code>[live]</code> working with the stock guest driver; <code>[wip]</code> in progress; <code>[planned]</code> designed, not built; <code>[target]</code> bring-up ahead; <code>[non-goal]</code> explicitly out of scope.
Status: 2026-11-16, tree <code>master @ a06d4b13</code>. Tags: <code>[live]</code> working with the stock guest driver; <code>[wip]</code> in progress; <code>[planned]</code> designed, not built; <code>[target]</code> bring-up ahead; <code>[non-goal]</code> explicitly out of scope.


== 1. Mission ==
== 1. Mission ==
Line 50: Line 50:
! Goal
! Goal
! What success looks like
! What success looks like
! Status (2026-11-15)
! Status (2026-11-16)
|-
|-
| Stock guest driver initialisation
| Stock guest driver initialisation
Line 66: Line 66:
| OpenGL (3D graphics)
| OpenGL (3D graphics)
| Stock guest GL applications render real pixels through the emulated vGPU
| Stock guest GL applications render real pixels through the emulated vGPU
| <code>[wip]</code> — the display/KMS stack and X run, the stock NVIDIA GLX path is fully green (<code>glxinfo -B</code> rc 0, OpenGL 4.6.0 direct, <code>glxgears</code> ~520 FPS), the 2D path is green, the DDX 3D replay executes, the X DDX/ScreenInit stability walls are closed (X green &gt;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 <code>DRAW_IAB</code> (<code>mac=0x22</code>, c788; TCS-off DS clean, synthetic viewport, chained release), the DS stage image is authored and live for both vertex slots (<code>st0=st1=020a0481</code>), the saved-window release carrier replays the held window deterministically once the pack is resident (slot-34 census plus SA[34] golden fill prove <code>client=golden=used=0x265</code>), and the first non-black GPU-rendered frames plus captured videos (45.4 s and 50 s) are proven off-screen; GZDoom reaches <code>V_Init</code>. 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|<code>OpenGL.md</code>]])
| <code>[wip]</code> — the display/KMS stack and X run, the stock NVIDIA GLX path is fully green (<code>glxinfo -B</code> rc 0, OpenGL 4.6.0 direct, <code>glxgears</code> ~520 FPS), the 2D path is green, the DDX 3D replay executes, the X DDX/ScreenInit stability walls are closed (X green &gt;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 <code>DRAW_IAB</code> (<code>mac=0x22</code>, 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 <code>V_Init</code>. 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 (<code>DS-FAST2 ds_after=80000000</code>, 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 <code>CALL(34)</code> draw macro (interior <code>0x3910/0x3914</code> writes carry <code>data=0x0</code>; 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|<code>OpenGL.md</code>]])
|-
|-
| Vulkan
| Vulkan

Revision as of 03:54, 17 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 Goals

Scope. What Open-IOV is for, what it is not for, and the dated status of each goal. Condensed from ../docs/01-orientation/01-purpose-and-scope.md (mission, scope and success criteria) and ../docs/README.md (the project front door); the docs tree wins on disagreement. The live milestone ladder is on Project-Status.md, and the current execution detail on Execution-Frontier.md and Graphics-Execution.md.

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.

1. Mission

Make NVIDIA GPUs fully virtualizable, by anyone, for any hypervisor, without modifying NVIDIA software, firmware or hardware.

Concretely, Open-IOV builds an independent, maintained IP block that:

  • presents a virtual NVIDIA GPU to a guest operating system;
  • lets the guest run the stock NVIDIA driver (Linux and Windows);
  • supports compute (CUDA) first, then 3D graphics and video;
  • runs on ordinary NVIDIA GPUs already deployed in the field;
  • isolates guests from each other and from the host;
  • and requires no license key, no proprietary host service, no patched guest driver, and no specific hypervisor.

The guiding sentence is: Emulate the interface. Pass through the work. Never patch anyone.

2. The gap it fills

Approach Limitation
Discrete device assignment (VFIO passthrough) One GPU per VM; no sharing; fragile on consumer/laptop systems.
NVIDIA proprietary vGPU Requires a license and a vendor host stack; driver-version locked.
Software GPU emulation No real CUDA; no real 3D performance; not usable for AI.
Cloud-only inference Requires an external service; unacceptable for secure edge, offline, or private data.

Open-IOV occupies the gap: real GPU acceleration, multiple VMs, stock drivers, no license.

3. Goals and their status

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)
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)
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)
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)
Video (NVENC/NVDEC) Encode/decode through the emulated device [planned]
Multi-tenant isolation Multiple VMs on one GPU, isolated by the IOMMU and the device model, with explicit scheduling [wip] — two mediated devices (different emulated VRAM sizes) and two guests coexist; per-guest execution isolation is in progress (GMMU-Multi-Tenant-Protection.md)
Hypervisor portability The same IP block attaches to KVM, Xen, Argo/OpenXT, Qubes OS Air, ... [planned] — the emulation core is hypervisor-independent by construction; KVM/QEMU with VFIO mdev is the reference transport (Hardware-Software-Matrix.md)
Version and hardware portability New driver, firmware or GPU generations enter by configuration plus measurement [wip] — 570.144/TU104 is the anchor; per-version evidence workflows exist; newer versions are gated work
Live migration A VM migrates with its GPU state [planned] — the protocol analysis is kept for the record (Migration-Protocol.md)
Performance Within an agreed factor of native for the supported cases, with published methodology [planned] — no published numbers yet; the first scheduled measurement is the 60 fps graphics target (Graphics-Execution.md)
Security posture Isolation survives adversarial review; the device fails closed [wip] — fail-closed design and audit practice; per-tenant execution isolation is in progress (../docs/05-operations/01-performance-correctness-security.md)

4. How success is judged

The project evaluates itself on five axes, each with a methodology document in ../docs/05-operations/01-performance-correctness-security.md:

  1. Initialization — the driver reaches bare-metal parity through boot, probe and initialisation.
  2. Runtime — the guest runs real work: CUDA kernels with correct results, OpenGL/Vulkan rendering, encode/decode; repeated, sustained, resilient.
  3. Interoperability — no changes anywhere: guest driver, host driver, firmware, hypervisor.
  4. Stability — crash-free under stress: start/stop cycles, VM kill, driver reload, suspend/resume, migration.
  5. Performance and security — within an agreed factor of native, with isolation that survives adversarial review.

5. Non-goals

  • Replacing bare-metal inference serving. Continuous batching on bare-metal hosts remains the right answer for centralised datacenter inference; Open-IOV is for compute that must live inside guests.
  • Forking or patching the NVIDIA driver (guest or host), the GPU firmware, or hypervisors to make the device work.
  • Anti-cheat / DRM circumvention. The project interoperates with interfaces and implements its own device; it does not counterfeit vendor licensing.
  • Emulating GPU instruction execution in software. Software emulation of CUDA kernels is orders of magnitude too slow; work must run on real silicon.

6. Related pages