Difference between revisions of "FAQ"

From Open-IOV
Jump to navigation Jump to search
m (2026-11-16 status refresh (HEAD b05cd671): DRAW_IAB mac=0x22 executes end to end (c788), TCS-off DS clean, synthetic viewport, chained release; remaining blockers are the vertex buffer and render-target store/alias visibility; stores still 0)
m (2026-11-20 late status refresh: corrected beef-lane diagnosis (PBDMA fetch proven; host-side forensic spin/no-write retire was the floor); r73 beef election + r75 shadow-VTG; v1.0.0-rc1 retracted; latest acceptance red on known flake/race)
 
(6 intermediate revisions by the same user not shown)
Line 5: Line 5:
<blockquote>'''What this page is.''' The questions the project is asked most, answered honestly and with pointers to the maintained documents. Condensed from [https://git.vgpu.io/open-iov.git/tree/docs/09-reference/glossary-and-faq.md <code>../docs/09-reference/glossary-and-faq.md</code>]; the docs tree wins on disagreement.</blockquote>
<blockquote>'''What this page is.''' The questions the project is asked most, answered honestly and with pointers to the maintained documents. Condensed from [https://git.vgpu.io/open-iov.git/tree/docs/09-reference/glossary-and-faq.md <code>../docs/09-reference/glossary-and-faq.md</code>]; the docs tree wins on disagreement.</blockquote>


Status: 2026-11-15, tree <code>master @ b05cd671</code>.
Status: 2026-11-20, tree <code>master @ 3f34d58a</code>.


== Project and positioning ==
== Project and positioning ==
Line 15: Line 15:
'''Does the host driver need to be patched or replaced?''' No. In the standalone configuration the distribution driver owns the physical GPU and Open-IOV is an independent kernel module. Building NVIDIA's OpenRM modules from source is needed only for the native vGPU-management workflows, not for the QEMU/emulated path ([[Install and First Run|<code>Install-and-First-Run.md</code>]] §2).
'''Does the host driver need to be patched or replaced?''' No. In the standalone configuration the distribution driver owns the physical GPU and Open-IOV is an independent kernel module. Building NVIDIA's OpenRM modules from source is needed only for the native vGPU-management workflows, not for the QEMU/emulated path ([[Install and First Run|<code>Install-and-First-Run.md</code>]] §2).


'''Why is <code>nvidia-smi</code> working but my CUDA kernel not running?''' It probably is running: guest CUDA kernels execute on the physical GPU and verify — the vector-add, matrix-multiply and transformer clients are green on fresh boots. If a specific workload fails, the known classes are: multi-megabyte staged transfers between guest and device memory (under repair, failure modes proven), and simultaneous CUDA guests (per-guest execution isolation is in progress). This is the project's known status, not a misconfiguration — see [[Project Status|<code>Project-Status.md</code>]] and [[The Execution Frontier|<code>Execution-Frontier.md</code>]].
'''Why is <code>nvidia-smi</code> working but my CUDA kernel not running?''' It probably is running: guest CUDA kernels execute on the physical GPU and verify — the vector-add, matrix-multiply and transformer clients are green on fresh boots. If a specific workload fails, the known classes are: multi-megabyte staged transfers between guest and device memory (under repair, failure modes proven), and simultaneous CUDA guests (per-guest execution isolation is in progress). The acceptance battery gate is '''closed''' (2026-11-19): two consecutive clean-boot <code>guest-accept --cuda</code> runs printed <code>VADD n=32768 bad=0</code> + <code>STATUS OK</code>, and the live <code>t/03</code> lane is green (<code>EXPECT_CUDA_BATTERY=closed</code>), re-proven in r63 and later rounds. The latest full acceptance run (2026-11-20 19:49Z) is red on the known UVM/GR-wait lottery (<code>victory_mail rc=1</code>, 205 s); the flag stays closed and the work is to make it every-boot green. The path there fixed the CE/GR ring and pool pairing, the GR ctx-init semaphores and payload 2, the init preamble (the host-path SW methods and the <code>SET_VALID_SPAN_OVERFLOW_AREA</code> trio were resetting FECS), the inline re-rooter program page, the pa=0 fill/relocate class and the launch lottery. This is the project's known status, not a misconfiguration — see [[Project Status|<code>Project-Status.md</code>]] and [[The Execution Frontier|<code>Execution-Frontier.md</code>]].


'''Can I run OpenGL or Vulkan applications in the guest?''' Partially, and it is an active frontier. The display/KMS stack and the X server run on the emulated vGPU with the stock driver: nvidia-modeset/NvKms registers (<code>/dev/dri</code>), the stock NVIDIA GLX path is fully green (<code>glxinfo -B</code> returns 0 with OpenGL 4.6.0 direct rendering; <code>glxgears</code> renders ~520 FPS), the 2D path is green and the DDX 3D replay executes. The '''first non-black GPU-rendered output''' is proven: a pbuffer probe returns <code>pixel=ff0000ff</code>, the off-screen path produced 500/500 non-black animated frames per run, and videos were captured (45.4 s on 2026-11-11, 50 s on 2026-11-12). GZDoom reaches <code>V_Init: allocate screen</code> with its GL 4.6.0 context on an even modeNum. The X DDX idle-DMA/ScreenInit, USERD-latch, re-probe, kernel-mode-spin and flip-event walls were closed (X green &gt;10 minutes), captured GL sections now execute on the engine, and the direct-GL submission is fully decoded: it carries no classic draw header (the work is macro-driven; data-block blobs plus small state pushes invoking MME macros), the recycled pushes are recovered, and the client's draw-state push opens, captures and reaches the engine. The MME chain now completes and executes the draw macro: multi-frame keep-windows land, the 2799-word pack completes, the first <code>MME-PACK-REARM</code> fires, the fixed-CB region is aliased, and <code>DRAW_IAB</code> (<code>mac=0x22</code>) runs 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>) is fetched by both vertex slots (<code>st0=st1=020a0481</code>), and the DS value fell <code>0x86040626 -&gt; 0x84000420</code> (reproduced on 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; the held-CALL 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 a released held window after the <code>MME-DRAW-MOVE</code> reorder, TCS-off clears the DS latch (the <code>0x84000420</code> was the synthesized TCS bind), a synthetic viewport and a chained release complete the replay, and the body decodes with the public Mesa MME toolchain (8 draws of 3 vertices). Window and screen pixels are still the wall: the remaining blockers are the vertex buffer (no captured client push binds the stream; the eng71 scan candidate is a heuristic) and render-target store/alias visibility (the big-surface alias pages do not yet enter the write-witness set), so the draw never stores, glxgears' window is black, and the per-boot binding plus X first-generation start lottery is the throughput limiter. The guest Vulkan pipeline runs end to end (device → command buffer → fence → readback) but frames are black. See [[OpenGL|<code>OpenGL.md</code>]], [[Vulkan|<code>Vulkan.md</code>]] and [[Graphics Execution|<code>Graphics-Execution.md</code>]].
'''Can I run OpenGL or Vulkan applications in the guest?''' Partially, and it is an active frontier. The display/KMS stack and the X server run on the emulated vGPU with the stock driver: nvidia-modeset/NvKms registers (<code>/dev/dri</code>), the stock NVIDIA GLX path brings up on a good boot (<code>glxinfo -B</code> returns OpenGL 4.6.0 with direct rendering; the current direct-GL stack measures 0.255 FPS in <code>glxgears</code>, r64-r72, not the older ~520 FPS figure), the 2D path is green and the DDX 3D replay executes. The '''first non-black GPU-rendered output''' is proven: a pbuffer probe returns <code>pixel=ff0000ff</code>, the off-screen path produced 500/500 non-black animated frames per run, and videos were captured (45.4 s on 2026-11-11, 50 s on 2026-11-12). GZDoom reaches <code>V_Init: allocate screen</code> with its GL 4.6.0 context on an even modeNum. The X DDX idle-DMA/ScreenInit, USERD-latch, re-probe, kernel-mode-spin and flip-event walls were closed (X green &gt;10 minutes), captured GL sections now execute on the engine, and the direct-GL submission is fully decoded: it carries no classic draw header (the work is macro-driven; data-block blobs plus small state pushes invoking MME macros), the recycled pushes are recovered, and the client's draw-state push opens, captures and reaches the engine. The 11-16 wave then proved the '''host-side draw chain end to end''': the real frame pushes are admitted (a persisted colour-target bind carried from an earlier trusted push, draw markers inside counted method runs, the 14.8-thousand-word window replayed as 40 chunks, a 128-slot candidate ring), the beef draw lane latches a '''clean DS''' (<code>DS-FAST2 ... ds_after=80000000</code>, c963) at the live-derived GS attribute map, capture-less boots get a '''golden 2799-word MME pack''', and <code>MME-CALL-HOLD -&gt; MME-CARRY-SAVE -&gt; MME-CARRY-FIRE -&gt; MME-PACK-REARM -&gt; MME-SA-REARM</code> fires with the prelude latch kept across the channel recycle. The '''late-11-16 wave crossed the guest submission gap''': an offscreen SDL 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 draw window surfaced — 12068 B at push <code>0x402f9d8</code>, an op=4 <code>CALL(0)</code> to method <code>0x3800</code> (<code>imm=0xd48</code>) plus slots 44/57/58 — and is admitted, chunked and replayed verbatim. <code>CALL(0)</code> no longer wedges: eng89t resolves the immediate through client SA[0] (then golden) and elides not-resident calls to NOPs; c1026/c1027 entered the captured macro without trapping and c1027 produced the first DS with real stage data. '''On 2026-11-18 the 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, and the client's CE readback follows the copy's source VA with a generation-pinned snapshot and a with-the-copy fence (the measured ~11 s readback wait fell to 2.3-7.2 ms). Two consecutive boots read <code>GL_FRAME nonblack=291840 px0=(255,0,0)</code> and the live acceptance lane was green on that proof (<code>EXPECT_GL_PIXELS=closed</code>); the latest full run is red on the readback pin/copy race. The '''X/GLX frame rate is the open wall''': <code>glxgears</code> measures 0.255 FPS, and r72b corrected the earlier diagnosis — the PBDMA fetches the direct-GL client-ring launch (<code>h=0xbeef0100</code>, <code>push=0x400108c</code>, 59580 B) in ~1 ms and the engine writes the channel release; the floor was host-side (a 2.8 s forensic MME spin enabled by debug params, plus a ~2.45 s no-write retirement wait when the window stores 0 pages). r73's beef read-only election cuts the retire wait (1337→12 ms) and r75 mirrors the VTG program image into the win0 shadow (<code>3f34d58a</code>); the remaining blockers are the draw's zero stores plus the engine <code>Illegal Instruction Encoding</code> fault, and the X/GLX bring-up lottery (a hung GLX client blocks in <code>poll()</code> on an unsignalled dma-fence <code>sync_file</code>; a DDX channel-idle timeout kills DMA init). 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. The guest Vulkan pipeline runs end to end (device → command buffer → fence → readback) but frames are black. See [[OpenGL|<code>OpenGL.md</code>]], [[Vulkan|<code>Vulkan.md</code>]] and [[Graphics Execution|<code>Graphics-Execution.md</code>]].


'''How fast is it?''' No published numbers yet. Kernel launches execute on the physical engine; what remains unmeasured is the project's own methodology — nothing ships as a performance claim without its measurements. The first scheduled measurement is the graphics target (60 fps sustained in one VM, no forcing).
'''How fast is it?''' No published performance claim yet. Kernel launches execute on the physical engine; the one measured number is the current X/GLX floor (<code>glxgears</code> 0.255 FPS), which is a wall measurement, not a result. The first scheduled measurement is the graphics target (60 fps sustained in one VM, no forcing).


== Compatibility ==
== Compatibility ==

Latest revision as of 20:42, 20 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.

FAQ

What this page is. The questions the project is asked most, answered honestly and with pointers to the maintained documents. Condensed from ../docs/09-reference/glossary-and-faq.md; the docs tree wins on disagreement.

Status: 2026-11-20, tree master @ 3f34d58a.

Project and positioning

Is this a replacement for vLLM on bare metal? No. Continuous batching on a bare-metal host is the right answer for centralized inference, and it stays that way. Open-IOV is for compute inside guests: Linux and Windows CUDA, 3D, video, and secure edge isolation.

Does the guest driver need to be patched? No, and that is a hard project rule: no guest driver patches, no host driver patches, no firmware patches, no hypervisor patches. The guest runs the stock NVIDIA driver, unmodified.

Does the host driver need to be patched or replaced? No. In the standalone configuration the distribution driver owns the physical GPU and Open-IOV is an independent kernel module. Building NVIDIA's OpenRM modules from source is needed only for the native vGPU-management workflows, not for the QEMU/emulated path (Install-and-First-Run.md §2).

Why is nvidia-smi working but my CUDA kernel not running? It probably is running: guest CUDA kernels execute on the physical GPU and verify — the vector-add, matrix-multiply and transformer clients are green on fresh boots. If a specific workload fails, the known classes are: multi-megabyte staged transfers between guest and device memory (under repair, failure modes proven), and simultaneous CUDA guests (per-guest execution isolation is in progress). The acceptance battery gate is closed (2026-11-19): two consecutive clean-boot guest-accept --cuda runs printed VADD n=32768 bad=0 + STATUS OK, and the live t/03 lane is green (EXPECT_CUDA_BATTERY=closed), re-proven in r63 and later rounds. The latest full acceptance run (2026-11-20 19:49Z) is red on the known UVM/GR-wait lottery (victory_mail rc=1, 205 s); the flag stays closed and the work is to make it every-boot green. The path there fixed the CE/GR ring and pool pairing, the GR ctx-init semaphores and payload 2, the init preamble (the host-path SW methods and the SET_VALID_SPAN_OVERFLOW_AREA trio were resetting FECS), the inline re-rooter program page, the pa=0 fill/relocate class and the launch lottery. This is the project's known status, not a misconfiguration — see Project-Status.md and Execution-Frontier.md.

Can I run OpenGL or Vulkan applications in the guest? Partially, and it is an active frontier. The display/KMS stack and the X server run on the emulated vGPU with the stock driver: nvidia-modeset/NvKms registers (/dev/dri), the stock NVIDIA GLX path brings up on a good boot (glxinfo -B returns OpenGL 4.6.0 with direct rendering; the current direct-GL stack measures 0.255 FPS in glxgears, r64-r72, not the older ~520 FPS figure), the 2D path is green and the DDX 3D replay executes. The first non-black GPU-rendered output is proven: a pbuffer probe returns pixel=ff0000ff, the off-screen path produced 500/500 non-black animated frames per run, and videos were captured (45.4 s on 2026-11-11, 50 s on 2026-11-12). GZDoom reaches V_Init: allocate screen with its GL 4.6.0 context on an even modeNum. The X DDX idle-DMA/ScreenInit, USERD-latch, re-probe, kernel-mode-spin and flip-event walls were closed (X green >10 minutes), captured GL sections now execute on the engine, and the direct-GL submission is fully decoded: it carries no classic draw header (the work is macro-driven; data-block blobs plus small state pushes invoking MME macros), the recycled pushes are recovered, and the client's draw-state push opens, captures and reaches the engine. The 11-16 wave then proved the host-side draw chain end to end: the real frame pushes are admitted (a persisted colour-target bind carried from an earlier trusted push, draw markers inside counted method runs, the 14.8-thousand-word window replayed as 40 chunks, a 128-slot candidate ring), the beef draw lane latches a clean DS (DS-FAST2 ... ds_after=80000000, c963) at the live-derived GS attribute map, capture-less boots get a golden 2799-word MME pack, and MME-CALL-HOLD -> MME-CARRY-SAVE -> MME-CARRY-FIRE -> MME-PACK-REARM -> MME-SA-REARM fires with the prelude latch kept across the channel recycle. The late-11-16 wave crossed the guest submission gap: an offscreen SDL 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 draw window surfaced — 12068 B at push 0x402f9d8, an op=4 CALL(0) to method 0x3800 (imm=0xd48) plus slots 44/57/58 — and is admitted, chunked and replayed verbatim. CALL(0) no longer wedges: eng89t resolves the immediate through client SA[0] (then golden) and elides not-resident calls to NOPs; c1026/c1027 entered the captured macro without trapping and c1027 produced the first DS with real stage data. On 2026-11-18 the pixel gate closed (b5a68b9a): the first clear/CALL(0)-bearing window is archived and replayed, the engine clear stores red on the guest surface, and the client's CE readback follows the copy's source VA with a generation-pinned snapshot and a with-the-copy fence (the measured ~11 s readback wait fell to 2.3-7.2 ms). Two consecutive boots read GL_FRAME nonblack=291840 px0=(255,0,0) and the live acceptance lane was green on that proof (EXPECT_GL_PIXELS=closed); the latest full run is red on the readback pin/copy race. The X/GLX frame rate is the open wall: glxgears measures 0.255 FPS, and r72b corrected the earlier diagnosis — the PBDMA fetches the direct-GL client-ring launch (h=0xbeef0100, push=0x400108c, 59580 B) in ~1 ms and the engine writes the channel release; the floor was host-side (a 2.8 s forensic MME spin enabled by debug params, plus a ~2.45 s no-write retirement wait when the window stores 0 pages). r73's beef read-only election cuts the retire wait (1337→12 ms) and r75 mirrors the VTG program image into the win0 shadow (3f34d58a); the remaining blockers are the draw's zero stores plus the engine Illegal Instruction Encoding fault, and the X/GLX bring-up lottery (a hung GLX client blocks in poll() on an unsignalled dma-fence sync_file; a DDX channel-idle timeout kills DMA init). 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. The guest Vulkan pipeline runs end to end (device → command buffer → fence → readback) but frames are black. See OpenGL.md, Vulkan.md and Graphics-Execution.md.

How fast is it? No published performance claim yet. Kernel launches execute on the physical engine; the one measured number is the current X/GLX floor (glxgears 0.255 FPS), which is a wall measurement, not a result. The first scheduled measurement is the graphics target (60 fps sustained in one VM, no forcing).

Compatibility

Will it support Windows guests? Yes, it is a target: same architecture, measured bring-up. No Windows guest has been booted on the emulated vGPU yet; the Windows/DirectX path (WDDM, nvlddmkm, Direct3D) is described on DirectX.md. Hardware-Software-Matrix.md lists the support ladder.

Can I run several VMs on one GPU? That is a core design goal: one mediated device per VM, IOMMU isolation, and explicit scheduling at the GPU's memory-management unit. Multi-tenant maturity depends on the scheduling and isolation work tracked in the project's known-unknowns document.

Does it support Xen / Qubes OS Air / Argo / OpenXT? Designed for them. The emulation core is hypervisor-independent by construction; the transport backends are on the roadmap. KVM/QEMU with VFIO mdev is the reference transport today.

What about MIG? MIG is a hardware partitioning mechanism; the project's scheduling policy can use it where available. It is part of the multi-tenancy work.

Which GPUs are supported? Turing TU104 is the reference platform. Other generations are targets or experimental combinations — see Hardware-Software-Matrix.md for the exact ladder and what each status means.

Legal and licensing

How is this legal / license-clean? Open-IOV's own code is BSD-3-Clause (GPL-2.0 for the kernel modules that link GPL-only kernel exports); NVIDIA's software is used unmodified and is not redistributed. The project interoperates with the interfaces rather than relicensing anything. Details: the repository LICENSE and the legal reference in docs/09-reference/.

Can my company use this commercially? Yes, under BSD-3-Clause (kernel modules GPL-2.0), with no fee. Co-development is welcome — see HAAEEP-and-Collaboration.md.

Contributing

Where do I report bugs or ask for help? Open an issue in the repository with a reproduction and the standard captures (host dmesg, guest dmesg, guest lspci -vvv, guest driver parameters). A reproduction plus logs is worth more than a description.

How do I contribute support for my GPU / driver / hypervisor? Start from Hardware-Software-Matrix.md and the portability workflow in the repository. The deliverable is a profile plus evidence from the project's evaluation ladder.

How do I debug the firmware side? The risc-v-gsp-rm-debugger workbench runs GSP firmware in a RISC-V virtual machine with hooks, watchpoints and recorded sessions — Riscv-GSP-RM-Debugger.md.