SwarmIO: Towards 100 Million IOPS SSD Emulation for Next-generation GPU-centric Storage Systems

Abstract: GPU-initiated I/O has emerged as a key mechanism for achieving high-throughput storage access by leveraging massive GPU thread-level parallelism, while recent industry trends point toward SSDs optimized for ultra-high random-read IOPS. Together, these trends are enabling the emergence of IOPS-optimized, GPU-centric storage systems. Despite this momentum, no existing framework enables quantitative end-to-end evaluation of storage systems optimized for GPU-initiated I/O. While conventional SSD emulators provide a promising path toward end-to-end modeling in traditional storage systems, they face three key challenges in this GPU-centric setting: limited frontend scalability for ingesting massive request streams, high software overhead in emulating GPU-initiated I/O control and data paths, and excessive timing-model maintenance overhead at extremely high I/O request rates. We propose SwarmIO, an SSD emulator for massively parallel, GPU-centric storage. SwarmIO faithfully models IOPS-optimized SSDs at target performance levels of up to 40 MIOPS, achieving a 303.9x speedup over the state-of-the-art baseline SSD emulator under GPU-initiated I/O. We further demonstrate its utility through a vector search case study, showing that increasing SSD IOPS from 2.5 MIOPS to 40 MIOPS yields an average end-to-end speedup of up to 9.7x.

• The paper presents a scalable SSD emulator by distributing NVMe queues and accelerating data transfers using Intel DSA, achieving up to 40 MIOPS.
• It employs batched timing model updates to minimize lock contention, reducing IOPS and latency errors to under 8% and 3%, respectively.
• Empirical results in GPU-accelerated vector search illustrate up to 9.7× speedup, underscoring significant performance benefits for AI workloads.

SwarmIO: An IOPS-Scalable SSD Emulator for GPU-Centric Storage Systems

Motivation and Problem Statement

The rapid expansion of AI workloads and their associated memory footprints now demand storage systems capable of functioning as an active memory tier with performance approaching DRAM. The proliferation of GPU-centric AI—particularly in applications such as RAG, recommendation, and agentic inference—necessitates ultra-high random read IOPS, directly driven by GPU thread-level parallelism. Existing SSD emulators are insufficient for modeling these emerging ultra-high IOPS demands alongside GPU-initiated I/O, due to frontend scalability, software overhead, and timing-model maintenance bottlenecks. The lack of commercially available hardware further exacerbates the chicken-and-egg problem for evaluating next-generation SSD architectures targeting 10–100 MIOPS.

Architecture and Core Innovations

SwarmIO addresses the critical emulation bottlenecks with three architectural innovations:

Distributed, Parallelism-Aware Frontend: SwarmIO partitions NVMe queues across modular service units, each with a dispatcher and worker backed by dedicated Intel DSA engines. This distributed approach eliminates centralized dispatcher bottlenecks observed in prior frameworks (e.g., NVMeVirt), enabling scalable ingestion of request-level parallelism.

DSA-Accelerated Data Transfers: Hardware-accelerated copy offloading—using asynchronous, batched DSA descriptors—removes virtually all CPU-mediated address mapping/translation overhead (Figure 1), and efficiently pipelines both request fetching and worker-side emulation. A custom kernel-level API sustains high batch concurrency, fully utilizing available DSA bandwidth.

Figure 1: Dynamic address mapping/unmapping overhead dominates CPU thread-driven copies and is eliminated in SwarmIO via DSA acceleration.

Aggregated Timing Model Updates: Instead of sequential per-request updates, SwarmIO performs batched timing model state updates for each set of requests fetched, amortizing lock contention and serialization overhead across dispatchers.

Figure 2: High-level overview of SwarmIO’s distributed architecture combining parallel dispatchers, workers, and DSA groups for scalable IOPS.

Empirical Evaluation

SwarmIO achieves up to 40 MIOPS on current hardware (the practical DSA-limited ceiling), representing a 303.9× throughput improvement over NVMeVirt and 537× over baseline architectures following synergistic optimizations (Figure 3). IOPS error under real SSD modeling (Solidigm D7-PS1010) averages under 8%, and latency error remains below 3%, both under CPU-centric and GPU-initiated I/O.

Figure 3: Optimizations added to baseline NVMeVirt frontend—distributed architecture, DSA-accelerated fetching, and coalesced request fetching—yield exponential throughput improvements.

SwarmIO sustains consistently high throughput across a wide range of queue counts and block sizes, maintaining near-peak throughput up to 1K queues and 512-byte blocks, in alignment with anticipated SSD interface trends.

Figure 4: Sustained IOPS sensitivity to queue count and block size under GPU-initiated I/O, highlighting robust scalability up to 1K queues and optimal performance at 512-byte granularity.

Case Study: On-Disk GPU-Accelerated Vector Search

A case study using CAGRA-based on-disk vector search demonstrates the practical importance of SwarmIO for AI workloads. Scaling SSD IOPS from 2.5 MIOPS to 40 MIOPS results in up to 9.7× end-to-end speedup under large batch sizes, and shifts optimal ANNS algorithmic parameters toward wider beam searches as IOPS increases. This illustrates both the performance impact and algorithmic implications of future ultra-high IOPS SSDs in real-world GPU-centric storage scenarios.

Figure 5: End-to-end performance of CAGRA search scales with SwarmIO IOPS; higher batch sizes and search widths benefit proportionally from increased target IOPS.

Practical and Theoretical Implications

SwarmIO’s scalable approach enables quantitative evaluation of next-generation SSD architectures well before their commercial availability, guiding system and algorithm co-design for AI workloads. It exposes the architectural limits and bottlenecks of software emulators, and demonstrates that distributed frontend designs, hardware-accelerated transfers, and aggregated models are essential for emulator scalability.

On the theoretical side, SwarmIO provides an experimental platform to explore new storage-memory hierarchies, algorithmic shifts driven by IOPS, and the interplay between hardware provisioning and parallel computation. The shifting optimality of algorithm parameters under different SSD performance points highlights the need for co-evolution between storage hardware and AI methodology.

SwarmIO’s modular kernel-level design, combined with flexible DSA grouping and context management, is extensible to future accelerators and storage protocols. The framework is empirically shown to match real device performance and scale proportionally with hardware resources.

Future Perspectives

Anticipated developments include further hardware scaling (e.g., dual-socket platforms with increased DSAs) to push sustained IOPS closer to 100 MIOPS, as well as integration of emerging SSD interfaces (PCIe Gen6/Gen7). SwarmIO is positioned to inform both system-level and algorithmic innovation in GPU-centric AI platforms as memory-storage hierarchies continue to collapse and storage latency becomes a first-order constraint.

Conclusion

SwarmIO fundamentally redefines SSD emulation for GPU-centric storage systems through distributed frontend architecture, hardware-accelerated transfers, and efficient timing model updates. The framework offers accurate, scalable modeling aligned with industry roadmaps for ultra-high IOPS SSDs, allowing end-to-end AI application evaluation and emphasizing storage system design as a critical pillar for next-generation GPU infrastructure (2604.06668).