[ benchmarks — live-fired receipts · no simulations ]
Park freezes a running CUDA workload — process tree, RAM, and VRAM — into one signed artifact. Wake restores it anywhere in seconds, byte-exact. The cold-start chart below is the market's own baseline: loading a 753B-class model from scratch.
The market's headline is “21.7× faster to first token” (61 s restore vs 22 min cold). Here are our receipts against the same 22-minute baseline — per workload class, because a multiplier without its workload class is marketing, not a benchmark.
Cold start (753B-class, disk → VRAM)
22 min
1× baseline
Market restore claim (their number)
61 s
21.7×
runaii Park — engine warm restore (KV cache live in VRAM)
17–21 s
62–77×
runaii Park — container wake
2.3–9 s
146× and up
The engine row is the wedge: park the warm inference engine itself — KV cache and all — instead of replaying conversations to rebuild warmth. Restore ms/GB at torch-image scale: a 5.6 GiB rootfs's first-generation delta backup runs in 17.8 s (~315 MB/s).
Every row is a live-fired drill on real GPU hardware — park measured on a loaded workload, wake measured after the process tree was killed and the box wiped. Failed runs are kept in our internal register too; the ladder below is the passing state of the art, one rung per capability.
| Drill | Workload | Park | Wake | Proof |
|---|---|---|---|---|
| D18b | docker-managed GPU container · 1 GiB VRAM canary | 13 s | 9 s | VRAM sha identical after kill + wipe |
| D19 | runc-managed CUDA workload · 2 GiB VRAM | 16.0 s | 7.6 s | 9/9 asserts, canary byte-exact |
| D19b | torch 2.14 image (5.6 GiB rootfs) · 2 GiB torch canary | ~30 s | ~25 s | allocator pool alive, canary byte-exact |
| D17c | user session + fs-delta — cross-VM | — | 4.7 s | 4/4 on a different physical box |
| D18-cross | docker + GPU container — cross-VM, from object storage alone | — | 24 s | 8/8, disk wiped on the target |
| D-skew | dump on driver 580.178.04 → wake on 580.173.02 | — | — | 8/8 byte-exact through the older driver |
| D20 | REST migrate → wake, same VM (the product path) | 26.8 s | 12.5 s | workload counter continues across death |
| D20 live migration | prefetch + wake on a second machine — the live flip | — | 22.7 s (prefetch 4.3 s) | canary byte-exact from the foreign GPU, counter 29→31 |
| D22 | KERNEL-LAUNCH survival — pre-loaded CUDA modules, same-arch control | 16 s | 9 s | launches CONTINUE post-restore (the first kernel receipt — every earlier proof was memcpy-only) |
| D22 | H100-native park/wake (Hopper sm90) | 15 s | 7 s | byte-exact canary, kernel launches alive on H100 |
| D23 | CROSS-ARCH migration — park on RTX PRO 6000 (Blackwell sm120), wake on H100 (Hopper sm90), different boxes and driver builds — CR-LITE exec-bridge | — | 6 s | 17/17: counters CONTINUE across the arch hop (5→10, kernel cell 15→30), canary byte-exact at the original virtual address, fresh cuInit on Hopper |
| D24 | MULTI-GPU cross-arch — 2× RTX6000 (g4x2) ⇄ 2× H100 (h100x2), both directions, driver-identical (580.173.02) | 16 s | 10 s | 2/2 children ALL-OK both ways: per-child pid preserved (7→7, 8→8), per-child fixed VA + canary rehydrated, counters continue (k_cell 18→39/15→33 fwd, 15→33/15→30 rev) — plus the PTX up-JIT receipt (sm_90 module loads rc=0 on sm120) |
| D25 | THE DOWNGRADE CONSEQUENCE — 32 GiB child vs an occupied 96 GB GPU: fit gate refuses → gate bypassed fails LOUD (bridge OOM, forensics written, artifact intact) → remediated → byte-exact wake | 203 s | refused → forced-fail → PASS | Gate: 'child 0 holds 32.0 GiB frozen device memory, GPU 0 has only 14.4 GiB free (another process is using this GPU)' → forced: 'bridge cuMemCreate failed: CUresult 2 (out of memory)' → after freeing: counter 5→10, k_cell 15→30, fixed VA, canary rehydrated, 32 GiB re-upload in 1.494 s — plus the TP=8 topology refusal (a single process sharded across 8 GPUs cannot wake on 1) |
| D26 | INVOKEAI v5 (the last catalog app) — the w5 lane's first foreign real-app roundtrip, plus a park fired INTO a live generation; spot-reclaimed mid-drill, artifacts outlived the hardware | 31 s (idle) / 5.3 GiB mid-render | 34 s (VRAM state refilled: 3015 MiB idle / 3611 MiB mid-render) | Post-wake generation PIXEL_DIFF 0 of 786432 — byte-exact vs the parked process's own last render (a process RESTART is only pixel-exact: the wake is strictly stronger than a restart); the mid-generation park's session RESUMED and completed its 1024²/500-step render after the wake; the 2.7 GB model + DB + gallery ride the artifact via the fs-delta bind roots. Five lane walls live-found + fixed (pre-cuInit device-node conversion, mknod umask, docker-exec invisibility to runc checkpoint, the restored-container re-park stdio mount, the secrets-gate doc-literal class) |
Spot-preemption rung: park completes in 23.2 s on a 2 GiB workload inside the 120 s preemption notice a spot GPU gives you — the artifact is durable off-box (65.9 s full-durability window at 24 GiB), so the preemption can't kill your state even when it kills the machine.
“Restored” is a claim anyone can type. Every drill above is forced to prove it the same way — the check is the product:
1 · Canary
Before freeze: workload writes known bytes to VRAM at recorded virtual addresses, plus filesystem and process-tree witnesses.
2 · Freeze
Park drains GPU state and the whole process tree into one signed artifact (HMAC over the manifest; untrusted bytes never execute).
3 · Kill
The original is destroyed — process killed, container removed, VRAM wiped. No courtesy state survives.
4 · Wake
Restore on the same box, or a different one from the artifact alone (driver skew allowed down-contract, never up).
5 · Prove
The restored workload re-reads the canary at the original addresses. Byte-exact means sha256 identical — not “approximately resumed.”
Not zero-downtime
Hibernation-grade: there is a real park→wake gap (seconds). Nothing on the market does seamless GPU migration either — we publish our gap instead of hiding it.
Cross-arch, receipted both ways
The NVIDIA checkpoint API itself refuses foreign architectures — receipted live: the process tree and files restore, the CUDA context answers “operation not supported” (equally true of anyone riding that API). Our CR-LITE exec-bridge goes around the gate: the workload quiesces to portable bytes, parks under plain CRIU, wakes on the other architecture and rebuilds its context natively — receipted sm120 → sm90 with counters continuing (17/17), the reverse direction too (sm90 → sm120, where the stale sm_90 module loads natively — PTX up-JIT), and multi-GPU (2× RTX6000 ⇄ 2× H100, both directions, per-child pid and counters intact). The honest limit: the bridge is a contract the workload opts into, not a transparent drop-in for arbitrary processes — and the 8× / B200 rungs are receipted as capacity-blocked (quota/stockout), not yet as passing.
Not a sandbox
Park is a state layer: it preserves and moves GPU workloads. Isolation is someone else's race — we can be the state layer underneath it.
Driver floor, not driver indifference
Wake targets must meet a driver-version contract (major-version floor). Skew receipts run down-contract; there is no up-contract magic.
Honest limits, registered
Multi-process CUDA owners that hold the context in a child don't ride yet; sockets with unread buffered data skip+close at freeze; semaphore VALUEs aren't carried (proven non-fatal for vLLM/sglang-class engines).
One signed artifact. $0 idle. Wake anywhere byte-exact. Try the $0-idle calculator in the console — the math is the pitch.