Korean national R&D project · 2026 – 2028

Feed the GPUs.
Not the CPU.

GPUFlow is an ultra-high-bandwidth parallel storage software stack built around an accelerator-initiated, zero-copy data path, so that data moves from NVMe to GPU memory without passing through host CPUs or system memory, and expensive accelerators stop waiting on I/O.

Program AI Cloud Competitiveness Enhancement Period Apr 2026 – Dec 2028 Lead Gluesys + 6 research partners
200GB/s
Sequential read per storage node
140GB/s
Sequential write per storage node
≤5%
Host CPU spent on storage I/O
Top‑3
IO500 target ranking
The problem

AI has become data-bound. The I/O path hasn't caught up.

Multimodal models push training sets into the petabytes, and LLM serving now streams KV-cache on every request. GPUs got faster, but the path that feeds them still detours through the CPU.

Today · CPU-centric I/O

NVMe→ Kernel / page cache→ Host DRAM bounce buffer→ TCP/IP→ GPU HBM

Multiple memory copies, context switches, and interrupt overhead. Latency stacks up and GPUs sit idle.

GPUFlow · Accelerator-initiated I/O

NVMe (SPDK)→ RDMA / RoCEv2 · DPU offload→ GPUDirect P2P DMA→ GPU HBM

User-space, kernel-bypass, zero-copy, with a CXL memory tier for hot KV-cache and metadata.

  • The memory wallEvery byte bound for a GPU is copied through host memory at least once, and often more than once.
  • Mixed AI trafficLarge sequential training reads (elephant flows) collide with checkpoints and KV-cache loads (mouse flows), and general-purpose filesystems treat them all the same.
  • Inference latencySlow KV-cache loading raises time-to-first-token and leaves accelerators starved.
  • Operational blind spotsWhen GPU utilization drops, it is hard to tell whether storage, network, or scheduling is to blame.
Technology

Nine core technologies, one GPU-centric data service

GPUFlow combines an end-to-end direct data path, hardware offload, and AI-driven storage intelligence to serve the AI factory's repeated train → infer cycle.

01 · Data path

GPUDirect zero-copy I/O

GPUs pull storage data directly over RDMA, through both POSIX and object (S3) interfaces, with cuFile/cuObject-compatible drivers.

CPU-mediated copies → direct GPU path
02 · Availability

Sub-30-second failover

Distributed mirroring and an automated DR controller keep training running through component or site failures.

Long service outages → RTO ≤ 30 s
03 · Intelligence

AI-powered storage resources

eBPF-based telemetry and access-pattern models predict load and faults, then re-place data and resources ahead of demand.

Static placement → predictive optimization
04 · Cloud native

Unified VM + container storage

One storage stack serves virtual machines and Kubernetes pods on the same nodes, with CSI-driven dynamic provisioning and non-disruptive rebalancing.

Single-runtime storage → heterogeneous runtimes
05 · Offload

DPU-accelerated data processing

NVMe-oF/RDMA, encryption, compression, and checksums are offloaded to a domestic FPGA-based DPU, with UEC-ready congestion control.

CPU-bound protocol stacks → DPU offload
06 · Observability

Workload-aware diagnosis

Correlates GPU idle time with storage and network latency to explain why GPUs starve, from cluster view down to a single volume.

Infrastructure-only monitoring → bottleneck root cause
07 · Validation

Internationally certified performance

Performance is proven through IO500 and MLCommons MLPerf Storage, together with a new benchmark for AI inference storage.

In-house benchmarks → global certification
08 · Memory

CXL metadata acceleration

A CXL memory tier with ghost caching, batched metadata handling, and contention-aware asynchronous I/O scheduling.

Metadata stalls → microsecond-scale access
09 · Inference

KV-cache & framework integration

PyDAOS bindings pass PyTorch/CuPy tensors to storage without conversion, a vLLM connector, and an adaptive GPUDirect/host-staging path selector.

Format conversion → native tensor I/O
GPUFlow‑COREZero-copy, accelerator-attached parallel storage engine
GPUFlow‑ACCELCXL/DPU I/O acceleration & compute offload module
GPUFlow‑ManagerWorkload-aware tiering & unified management platform
GPUFlow‑HCIHyper-converged compute, network & storage with a CXL memory pool
GPUFlow‑SYSIntegrated HW + SW appliance for AI factories
Architecture

Five layers, one end-to-end path

From GPU/HBM on the AI factory nodes down to sharded NVMe on the storage nodes, each layer removes a hop or offloads a cost and reports what it sees to a single control plane.

GPU cluster & clientAI factory train / infer nodes
GPUDirect I/O library + GPU path selector cuFile / cuObject-compatible drivers PyTorch DataLoaderPOSIX FUSE adapter MPI-IO / HDF5Py KV-cache bindervLLM KV module CXL KV-cache & metadata cache
Parallel storage engineStorage nodes
SPDK / RDMA user-space I/ONVMe sharding Network erasure codingParallel RPC (CaRT) Key-Value-Array & S3 modelsWORM integrity Self-healing & auto-rebalanceReal-time replication Multi-tenant QoS & RBACContainer CSI
Network & DPU accelerationRDMA / RoCEv2 fabric
NVMe-oF / RDMA DPU offloadInline encryption & compression RoCE congestion controlUEC transport layer Multipath adaptive routing
Operations & intelligenceUnified control plane
eBPF workload telemetryWorkload inference Fault-pattern predictionNPU-based optimization HCI controlReal-time GPU data-path bottleneck UX Open API
Validation & certificationTestbed & benchmarks
IO500MLPerf Storage AI inference storage benchmarkIntegrated CI/CD HW/SW compatibility matrixE2E test automation

Workload-aware placement

  1. Training reads: elephant flows striped over sharded NVMe at full bandwidth
  2. Checkpoints: POSIX/HDF5 with prioritized synchronous replication
  3. KV-cache: object/KV path with a CXL hot tier for low TTFT
  4. Metadata: CXL ghost cache and batched requests

Design principles

  1. No CPU on the data path
  2. POSIX and object, natively
  3. Offload what hardware does better
  4. Measure it, explain it, certify it
Console

See the whole path, from GPU to storage

The GPUFlow console puts GPUs, cache tiers, the network/DPU fabric, and parallel storage in one view. It shows where GPUs wait on data, explains why, and predicts the next bottleneck before it happens.

Monitor

Overview · Workload Lens · End-to-End Path · Bottleneck Analyzer · Tiering & Cache · Storage Fabric · Agent Console

Manage

Nodes & Cluster · Policies · Tenants, Volumes & QoS · Alerts & Events · Access & Audit

Verify

KPI Scorecard that tracks the project's ten quantitative targets

Open the interactive console → Concept mockup with simulated scenario data. Controls change only the page state. The production dashboard is being developed by OnlinePowers on telemetry from the consortium partners.
Consortium

Seven organizations, each owning a layer

Industry, a national research institute, a standards and certification body, and two universities work in a shared joint-research space with quarterly integration reviews.

Gluesys

Lead organization · Industry

Overall project lead, system architecture, core parallel-storage engine, integration, and commercialization. Builds on Gluesys's commercial parallel storage products for HPC and AI.

Client layer
  • GPUDirect Storage client module
  • POSIX / S3 GPU acceleration
  • CXL-based filesystem cache
Storage layer
  • Elephant-flow parallel processing
  • Non-disruptive scale-out & rebalancing
  • Automatic recovery, per-project isolation
Ops & validation
  • Unified management tool, RBAC
  • SmartNIC compute offload
  • Integrated validation & GPU-cloud pilots
clientstorageoperationsvalidation

KETI

Research institute

Korea Electronics Technology Institute: cloud-native resource management and AI-driven autonomous storage operation.

  • WORM storage for training-data integrity & versioning
  • Kubernetes-based storage control & cloud-native deployment
  • AI workload inference, NPU-based optimization, HCI control
storageoperations

MangoBoost

Industry · DPU

Data-processing-unit (DPU) hardware and software for storage and network offload.

  • NVMe-oF storage protocol offload
  • RoCEv2 congestion-control optimization
  • Transport encryption & compression offload, UEC adoption
storagenetwork

OnlinePowers

Industry · UI/UX

Integrated monitoring and operations experience for AI infrastructure.

  • AI workload monitoring
  • Unified management UI & GPUFlow dashboard
  • Large-scale telemetry visualization (Canvas/WebGL)
operations

TTA

Standards & certification

Telecommunications Technology Association: test methodology, a large-scale testbed, and international certification.

  • IO500 international certification
  • MLPerf Storage / training performance evaluation
  • Inference-storage evaluation metrics & benchmark
validation

Seoul National University

University

Multi-tier I/O profiling and adaptive CXL memory management.

  • CXL-based KV-cache acceleration cache
  • CXL-based metadata acceleration cache
  • Contention-aware I/O scheduling
client

Sogang University

University

GPU-direct I/O paths and LLM-serving storage optimization.

  • GPUDirect I/O library, dual-path I/O scheduling
  • KV-cache object data model
  • AI-driven data-path optimization algorithms
client
Demand organizations KISTI (Korea Institute of Science and Technology Information), national supercomputing & AI infrastructure KT Cloud, AI data-center operator
Targets

What "done" looks like

Final-year quantitative goals, measured with public benchmarks wherever possible.

Bandwidth & performance
≥200GB/s

Sequential read per node

Average per-node bandwidth for elephant-flow workloads.

IO500 ior-easy-read
≥140GB/s

Sequential write per node

Average per-node bandwidth for elephant-flow workloads.

IO500 ior-easy-write
≥40GiB/s

LLM checkpoint read per node

Large-language-model training checkpoint load.

MLPerf Storage · checkpointing
≥20GiB/s

LLM checkpoint write per node

Large-language-model training checkpoint save.

MLPerf Storage · checkpointing
≥20%

I/O performance uplift

Over the best-performing comparable domestic commercial storage.

Comparative benchmark
≤5%

Host CPU for storage I/O

Through GPUDirect Storage, RDMA offload, and storage-side compute.

CPU utilization under load
Operations & availability
≤30s

Remote recovery time (RTO)

Failover to the DR site without stopping AI training.

Failover drill
≤200ms

AI-powered engine feedback

Response latency after a fault or efficiency event is detected.

Event-to-action latency
≥6

Storage isolation techniques

Multi-tenant isolation of space, performance, and access.

Feature verification
✓

Cloud-native provisioning

Kubernetes orchestration and IaC-based deploy, scale-out, and recovery.

Automation test
International certification
IO500
World Top-3 IO500 certificationHigh-bandwidth I/O performance on the official IO500 list
ML
MLCommons MLPerf StorageCertified checkpoint read/write throughput for AI training
Journey

From architecture to production

The work is staged so that each year builds on a verified foundation, ending in field deployment at the demand organizations.

Y1
Apr – Dec 2026

Integrated architecture & foundations

  • End-to-end GPUFlow data-path architecture
  • Parallel filesystem core structure
  • RDMA / NVMe-oF transport path analysis
  • Baseline AI-workload performance validation
TRL 4 → 5
Y2
2027

Workload-aware integration & prototype

  • GPU-aware data-path control
  • AI-specific I/O scheduling
  • Kubernetes-based automation
  • Integrated system prototype
TRL 5 → 6
Y3
2028

Field validation, production-grade

  • Pilots at KISTI and KT Cloud
  • 200 GB/s-per-node validation
  • IO500 and MLPerf Storage submissions
  • Product-level stability, reference sites
TRL 6 → 7
→
2029 onward

Commercialization & adoption

  • GPUFlow commercial product release
  • National AI data-center programs
  • Public, CSP, and enterprise markets
  • Global OEM / ODM partnerships

Built in the open

Consortium software is published under the gpuflow-io GitHub organization under the Apache License 2.0, so results can be freely used, modified, and redistributed, with an explicit patent grant.

We will also hold at least one open-source community event or technical seminar every year with partner associations and user groups.

Open-source goalYear 1Year 2Year 3
Public repositories3710
Commits2060100
Contributors51220
Outreach events–12

Part of a full-stack AI cloud

GPUFlow is the storage pillar among sibling projects in the same national program. Together they form a reference architecture for Korean AI cloud infrastructure, connected through shared interfaces, joint demos, and exchange of I/O profiling data.

Network fabric · RoCEv2 low-latency transport GPU orchestration · workload-aware scheduling GPU virtualization · partitioning & multi-tenant isolation GPUFlow · core data-path platform
Projects

Open-source software from GPUFlow

Repositories released as GPUFlow results. Each one is usable on its own today and will be integrated into the full GPUFlow stack over the course of the project.

gluesys/daos-operator

Gluesys · Go · Apache-2.0 · v0.1.0 · API v1alpha1
First release

Run DAOS on Kubernetes. It is the cloud-native deployment and provisioning layer for the GPUFlow storage engine.

  • OperatorManages the DAOS system, pools, and containers through DaosSystem, DaosPool, and DaosContainer resources, plus host preparation, telemetry, and a Grafana dashboard
  • CSI driverMounts a DAOS container as a ReadWriteMany volume
  • S3 gatewayServes a pool over the S3 protocol
  • KV-cache referencevLLM + LMCache using a DAOS container as the KV cache
helm install daos-operator oci://ghcr.io/gluesys/charts/daos-operator \
  --namespace daos-system --create-namespace
storageoperations