Nvidia Vera CPU Storage Benchmarks 2026: DPU Offload Wins

Nvidia’s newly published Nvidia Vera storage benchmarks land at the moment the industry stopped pretending storage was a solved problem. As training and inference clusters push past 100,000 GPUs, the bottleneck has migrated off the network fabric and onto the host CPU — where encryption, compression, checksums, and erasure-code reconstruction eat cores that were supposed to be feeding tensors. The benchmarks show those four workloads running on dedicated accelerators inside the Vera/Rubin platform rather than on general-purpose cores, and the deltas are not marginal. With Vera Rubin NVL144 racks shipping to hyperscalers this year, storage-side offload becomes the least-discussed line item that decides whether your rack economics work.

What’s new in the Nvidia Vera storage benchmarks

The headline is architectural, not incremental. Vera is Nvidia’s custom Arm CPU — 88 cores, NVLink-C2C attached to Rubin GPUs — and it ships with fixed-function accelerator blocks for data-path work that storage stacks have historically thrown at software. Nvidia’s published figures cover four: AES-XTS/GCM encryption, DEFLATE-class compression, T10-DIF/CRC integrity checking, and Reed-Solomon erasure-code encode and reconstruct. Each is measured against a software baseline running on the same silicon, so the comparison isolates the offload rather than the process node.

The numbers that matter are expressed in reclaimed cores, not raw throughput. Sustaining line-rate encryption plus integrity on a modern multi-hundred-gigabit storage path costs a dozen to two dozen x86 cores in a conventional server — cores you paid for, cores that also sit in the critical path of your data loader. Nvidia’s benchmarks push that work to accelerators that operate at near-zero host cost. The erasure-coding results are the most interesting of the set: reconstruct throughput, historically the ugliest workload in any distributed filesystem, no longer collapses when a node fails mid-training. Combined with BlueField-4 erasure coding on the network side, the platform does encode-on-write and reconstruct-on-read without either operation touching a core that has GPU work queued behind it.

The second piece is path length. GPUDirect Storage 2026 extends the existing DMA-to-GPU-memory model so offloaded transforms happen inline on the way to HBM, not as a separate hop through host DRAM. A read that would previously go NVMe → host buffer → decrypt → decompress → verify → GPU now goes NVMe → accelerator inline → GPU. That eliminates a full round trip through the memory subsystem per I/O, which is why the latency improvements in the benchmarks outpace the throughput improvements. For checkpoint restore and random-access retrieval on inference clusters, latency is the number you actually feel.

Why it matters

• Core reclamation is real money. Every core doing AES is a core not doing data loading, tokenization, or augmentation. At hyperscale, freeing 15–20% of host CPU across thousands of nodes changes how many nodes you buy — a capex argument dressed as a performance argument.
• Encryption stops being optional. Most operators run training data unencrypted at rest on the hot tier because the CPU tax is unacceptable. When encryption is free, “encrypt everything” becomes the default posture, and the compliance conversation for regulated workloads gets dramatically shorter.
• Failure recovery no longer stalls training. Erasure-code reconstruct at accelerator speed means a dead NVMe or a dead node degrades a job instead of pausing it. On a 100k-GPU cluster where something is always failing, the difference between degraded and paused compounds across every run.
• The AI datacenter storage bottleneck shifts again. Remove CPU-side transforms and the next constraint becomes metadata operations and namespace scale-out — a filesystem problem, not a silicon problem. Plan your vendor evaluations accordingly.
• Rack-scale economics widen the gap. Commodity servers can bolt on a DPU. They cannot get NVLink-C2C between the CPU doing offload and the GPU consuming the result. That coupling is the part competitors can’t replicate with a PCIe card.
• Checkpointing gets cheap enough to do more often. Compression plus offloaded integrity on the write path shrinks both the bytes and the stall. More frequent checkpoints means less lost work per failure — the single highest-leverage reliability knob on a long training run.

How to use Nvidia DPU storage offload today

You do not need Vera Rubin hardware to start. Most of the software plumbing is the same stack you’d use with Grace/Hopper and BlueField-3, and the configuration you build now carries forward.

1. Confirm GPUDirect Storage is actually engaged. The most common failure mode is a stack that silently falls back to the POSIX path. Check it before you measure anything:

   /usr/local/cuda/gds/tools/gdscheck -p
   
   # Look for: "GDS release version", "cuFile CONFIG", 
   # and per-filesystem "Supported" vs "Unsupported"
   cat /proc/driver/nvidia-fs/stats | grep -E 'READ|WRITE|BATCH'

2. Enable the compat-mode kill switch so fallbacks are loud, not silent. In /etc/cufile.json:

   {
     "logging": { "level": "WARN" },
     "properties": {
       "allow_compat_mode": false,
       "use_pci_p2pdma": true,
       "max_direct_io_size_kb": 16384,
       "posix_pool_slab_size_kb": [4, 1024, 16384],
       "rdma_dev_addr_list": []
     },
     "fs": {
       "generic": { "posix_unaligned_writes": false },
       "lustre":  { "posix_gds_min_kb": 1024 }
     }
   }

   With allow_compat_mode false, an unsupported path errors instead of quietly costing you 40% throughput.

3. Benchmark your own baseline with gdsio before trusting anyone’s numbers. Run the same shape as your real workload — checkpoint writes are large sequential, dataloader reads often are not:

   # Large sequential read, GPU memory destination, 8 threads
   /usr/local/cuda/gds/tools/gdsio \
     -D /mnt/ai-scratch -d 0 -w 8 \
     -s 40G -i 1M -x 0 -I 0 -T 60
   
   # Random 128K reads, closer to a retrieval/inference pattern
   /usr/local/cuda/gds/tools/gdsio \
     -D /mnt/ai-scratch -d 0 -w 16 \
     -s 40G -i 128K -x 0 -I 2 -T 60

   -x 0 is GPUDirect; run the same command with -x 1 (CPU bounce buffer) to measure exactly what the offload is worth on your hardware.

4. Turn on hardware crypto on the BlueField side and verify the accelerator is doing the work.

   # On the DPU (Arm side)
   sudo mlxconfig -d /dev/mst/mt41692_pciconf0 set \
     CRYPTO_ENABLE=1 IPSEC_FULL_OFFLOAD=1
   
   # Confirm the crypto engine is bound, not the kernel's software AES
   sudo mlx5ctl -d mlx5_0 query caps | grep -i crypto
   ethtool -S enp3s0f0np0 | grep -Ei 'ipsec|crypto|tx_bytes'

   If your bytes counter climbs while host CPU stays flat under mpstat 1, the offload is live.

5. Point your framework’s checkpoint writer at the direct path. KvikIO (the RAPIDS cuFile binding) gets you GDS from Python without rewriting your I/O layer:

   import cupy as cp
   import kvikio
   
   # Write a tensor straight from device memory to storage
   buf = cp.asarray(state_tensor)
   with kvikio.CuFile("/mnt/ai-scratch/ckpt-step-42000.bin", "w") as f:
       f.write(buf)
   
   # Read back into device memory, no host bounce
   out = cp.empty_like(buf)
   with kvikio.CuFile("/mnt/ai-scratch/ckpt-step-42000.bin", "r") as f:
       f.read(out)

6. Watch the right counter during a real run. Throughput charts lie; the honest metric is host CPU consumed per gigabyte moved:

   mpstat -P ALL 5 | awk '/all/ {print "idle:", $NF}' &
   dcgmi dmon -e 1009,1010 -d 5000   # PCIe TX/RX bytes per GPU

How it compares

Capability	Vera + Rubin (NVL144)	x86 host + BlueField-3 DPU	x86 host, software-only	AMD EPYC + Pensando
Encryption offload	On-die accelerator, inline to GPU path	On DPU, across PCIe	AES-NI on host cores	On DPU, across PCIe
Erasure-code reconstruct	Hardware, BlueField-4 erasure coding on fabric side	Partial hardware assist	ISA-L on host cores	Limited / software
CPU–GPU interconnect	NVLink-C2C, coherent	PCIe Gen5	PCIe Gen5	PCIe Gen5
Host cores consumed at line rate	Near zero	Low, plus DPU-side management	High (double digits)	Low
Inline transform on GDS path	Yes	Partial	No	No
Ecosystem maturity	New, shipping 2026	Mature, broadly deployed	Universal	Narrower deployment
Vendor lock-in risk	High	Moderate	None	Moderate

The honest read: BlueField-3 on commodity x86 gets you most of the offload benefit today with none of the platform risk. Vera’s advantage is the coherent link, which converts “the DPU did the work somewhere else” into “the transform happened on the way to HBM.” Whether that last hop justifies a full platform commitment depends on whether your workload is latency-bound or throughput-bound.

What’s next

Watch for third-party validation. Vendor-published benchmarks are directionally useful and rarely wrong about ordering, but they are chosen. Wait for MLPerf Storage results and the inevitable teardowns from the parallel filesystem vendors — WEKA, VAST, DDN, and the Lustre community — who all have strong incentives to publish where the offload does and doesn’t help. Expect the gap to be largest on checkpoint-heavy training and smallest on small-file metadata-bound workloads, where no amount of data-path acceleration saves you.

The second thing to track is how the software surface consolidates. Right now AI-native storage performance depends on a stack of loosely coupled pieces — cuFile, nvidia-fs, DOCA, the filesystem client, and whatever your framework does with checkpoints. Nvidia has been steadily pulling these under DOCA and into the frameworks directly, and the version where a PyTorch checkpoint call automatically lands on the accelerated path with no configuration is the one that changes adoption curves. Until then, most of the benchmark advantage goes only to teams willing to tune for it.

Longer term, the interesting question is whether storage vendors respond by moving their own data services onto the DPU or by ceding the data path entirely and competing on namespace, metadata, and tiering. Both strategies are visible in the market right now. The vendors that pick correctly will look prescient in 2028; the ones that keep selling CPU-bound data services into GPU-bound clusters will not.

Frequently Asked Questions

Do I need Vera Rubin hardware to benefit from storage offload?

No. Most of the benefit is available today with BlueField-3 DPUs on x86 hosts plus GPUDirect Storage. Vera adds the coherent NVLink-C2C path, which removes a memory round trip and mainly helps latency-sensitive access patterns. Build the software configuration now on existing hardware; it carries forward.

How much host CPU does storage offload actually reclaim?

It depends on your data path. If you run encrypted, compressed, checksummed storage at high line rates, double-digit core counts per node is a realistic recovery. If your data sits unencrypted and uncompressed on local NVMe, you have very little to offload and the benchmarks won’t apply to you. Measure with gdsio -x 0 versus -x 1 before budgeting for it.

Does GPUDirect Storage 2026 work with my parallel filesystem?

Support is per-filesystem and per-version. Lustre, GPFS/Storage Scale, WEKA, VAST, and BeeGFS all have GDS-capable clients, but feature coverage varies and NFS support depends on RDMA configuration. Run gdscheck -p on the actual mount and read the Supported/Unsupported list rather than trusting the vendor datasheet.

Is BlueField-4 erasure coding a replacement for filesystem-level redundancy?

No — it accelerates the math, it does not decide the policy. Your filesystem still owns placement, stripe width, failure domains, and repair scheduling. What changes is that reconstruct stops being a CPU-bound event that degrades everything else on the node while it runs.

What’s the biggest risk in adopting this?

Lock-in, and it’s not subtle. A storage architecture tuned around Nvidia’s accelerators, coherent links, and DOCA services is difficult to move to another vendor’s silicon. That may be an acceptable trade at the scale where the economics work, but it should be a deliberate decision rather than one you discover two years in.

Why is the AI datacenter storage bottleneck showing up now rather than earlier?

Because GPU throughput outran everything else. At smaller cluster sizes, host CPUs had enough headroom to absorb data-path work in the gaps. Past roughly 100k GPUs with fast checkpointing and constant node churn, there are no gaps — the data path runs continuously, and every core it consumes is a core the training loop wanted. The bottleneck didn’t appear; the slack that hid it disappeared.