Everpure's FlashBlade//EXA Tops MLPerf Storage v3.0 for Checkpointing and KV Cache

Storage benchmarks don't usually get engineers excited. This one should.

MLCommons just dropped MLPerf Storage v3.0 results, and Everpure's FlashBlade//EXA came out on top across both the 405B and 1.25T parameter model checkpointing categories, plus the KV cache performance tests. Unlike synthetic storage benchmarks that measure raw throughput in a vacuum, MLPerf Storage tests storage against actual AI workload patterns: checkpoint writes during training, checkpoint reads during recovery, and KV cache retrieval during inference serving.

Why does that distinction matter? Because storage has quietly become a critical path component in large-scale AI training and serving, not just a place to park data between compute steps. When a 1,024-GPU training job stalls waiting on a checkpoint write, you're burning some of the most expensive compute on the planet while it sits idle. Same story on the inference side: if KV cache retrieval can't keep pace with token generation, you're leaving throughput on the table.

Behind the Benchmark Numbers

The checkpointing results are where the scale really shows up. Running with 1,024 simulated accelerators against a 1.25T parameter model, FlashBlade//EXA hit 877.52 GiB/s write bandwidth (completing in 17.74 seconds) and 588.28 GiB/s read bandwidth (28.99 seconds), using 30 data nodes.

What's more telling than the peak number is the scaling curve. Write throughput went from 327.65 GiB/s with 10 data nodes to 877.52 GiB/s with 30 data nodes, a roughly linear relationship as node count triples. That's the kind of predictable, near-linear scaling infrastructure teams actually want to see, because it means capacity planning doesn't turn into guesswork every time a cluster grows or a model gets bigger.

On the inference side, the KV cache numbers tell a parallel story. For Llama 3.1 8B, storage-only configuration hit 85,736 tokens/second. Add memory into the mix for the same 8B workload and throughput drops to 67,642 tokens/second (worth noting this reflects a different test configuration, not a regression). Scale up to a 70B model in storage-only mode and you get 33,403 tokens/second. As inference serving increasingly leans on KV cache to avoid recomputing attention over long contexts, storage's role in the token-generation data path is only growing.

The architecture behind these numbers is arguably the more interesting story than the benchmark scores themselves. FlashBlade//EXA uses a disaggregated design that splits metadata management from data transport, two things that traditionally live together in a single storage controller and end up bottlenecking each other at scale.

In the tested configuration:

• 30 FlashBlade//EXA blades handled metadata, backed by 120 DirectFlash Modules
• 30 separate Linux/NVMe data nodes handled the actual data transport
• The combined setup delivered roughly 866 TB of usable capacity through a single unified file system
• File layout negotiation runs over NFSv4.1/pNFS over TCP
• High-speed data movement runs over NFSv3 via RDMA (RoCEv2)

The practical effect: clients negotiate where data lives via the metadata layer, then move that data directly across the network fabric rather than funneling every read and write through one centralized bottleneck. It's a similar philosophy to what you see in disaggregated storage architectures elsewhere in HPC, separate the control plane from the data plane, then scale each independently based on what's actually constrained.

That separation is also why the scaling numbers look the way they do. Adding data nodes adds data-transport bandwidth without forcing a corresponding rebuild of the metadata layer, which is usually the part of a storage system that doesn't scale gracefully.

"These results yet again demonstrate that FlashBlade//EXA delivers the highest performance and scale on the market, staying ahead of the increasing demands of AI workloads," said Rob Lee, Chief Technology and Growth Officer at Everpure. "Organizations advancing the bleeding edge of AI development need infrastructure that can deliver the utmost performance and scalability, without making tradeoffs against reliability and operational simplicity. FlashBlade//EXA stands alone in being able to deliver that."

There's a broader infrastructure narrative here too. Everpure has been repositioning itself away from being just a storage array vendor toward what it calls an Enterprise Data Cloud, a software-driven layer for managing data across increasingly heterogeneous environments. AI workloads are a useful stress test for that positioning, since they expose exactly where GPUs, networking, and storage stop being independently tunable components and start being one interdependent system. If your storage layer can't keep pace, it doesn't matter how many GPUs you've racked up.

Key Takeaways

• FlashBlade//EXA led MLPerf Storage v3.0 in checkpointing performance for both 405B and 1.25T parameter models, and in KV cache retrieval benchmarks, hitting 877.52 GiB/s write and 588.28 GiB/s read bandwidth at 1,024 simulated accelerators.
• Throughput scaled from 327.65 GiB/s to 877.52 GiB/s as data nodes went from 10 to 30, roughly linear scaling that matters more for capacity planning than any single peak number.
• KV cache throughput came in at 85,736 tokens/second for Llama 3.1 8B (storage-only), 67,642 tokens/second for 8B with memory added, and 33,403 tokens/second for a 70B storage-only workload, underscoring how much inference serving now depends on fast cache retrieval.
• The disaggregated architecture, separating metadata (30 blades, 120 DirectFlash Modules) from data transport (30 Linux/NVMe nodes), uses NFSv4.1/pNFS over TCP for layout negotiation and NFSv3 over RDMA (RoCEv2) for data movement, delivering roughly 866 TB usable capacity through a unified file system.
• For teams building or scaling AI infrastructure, the takeaway isn't just "this vendor won a benchmark." It's that storage architecture choices, particularly around metadata and data-plane separation, increasingly determine whether GPU spend translates into GPU utilization.