如果一个 GPU kernel 在处理第 1024 个样本时才知道自己要读 SSD 上的哪一块数据,那么让 CPU 负责逐个请求、逐个搬运,通常很难跟上 GPU 的并行度。

但把 CPU 拿掉也不是终点。GPU 如果只看到一块裸 NVMe 盘,就还要自己解决文件名、文件大小、逻辑偏移到物理块的映射、缓存共享、崩溃一致性和并发访问。这样做虽然快,却很快会变成“每个应用都重新实现一遍文件系统”。

FAST'25 的 GeminiFS 试图在这两个极端之间找一个实际可用的折中:让主机文件系统继续负责文件管理,让 GPU 获得一份足够完成读写的文件私有元数据,并让 GPU 直接向 NVMe 提交请求。

读完论文后,我觉得 GeminiFS 最值得记住的不是某个单独的 NVMe 技巧,而是它的设计取舍:它没有把 Linux 文件系统完整搬进 GPU,而是利用机器学习工作负载“可预测、预分配、长期数据大多只读或追加写”的特点,把动态语义从热路径中拿掉。

GPU 直接访问存储,难点不只在数据搬运

先把几个经常混在一起的概念分开。

数据面和控制面

传统的 GPU 存储路径大致是:

GPU kernel 发现数据需求
        │
        ▼
CPU / 主机文件系统组织请求
        │
        ▼
NVMe 读取到主机内存或中转缓冲区
        │
        ▼
数据再进入 GPU 显存

这条路径的问题不只是多了一次拷贝。GPU 可能同时有成百上千个线程需要发起细粒度请求,而 CPU 的线程数、调度和同步能力都有限。CPU 既要解析请求,又要组织文件系统和 NVMe 操作,最后还要负责把结果交给 GPU。

因此,GPU 存储系统通常要同时缩短两个维度:

维度要回答的问题GeminiFS 的选择
数据面数据是否必须经过 CPU 内存?NVMe 直接 DMA 到 GPU 显存
控制面谁构造请求、提交队列并等待完成?GPU 线程直接提交和轮询

NVIDIA GDS 主要缩短了数据面,但请求编排仍然需要 CPU 参与。BaM 则把控制面也交给 GPU,不过它更接近“GPU 直接访问裸块设备”,并没有把传统文件系统的管理能力一起带过来。

GeminiFS 的目标可以写成一句话:

保留主机文件系统的管理边界,同时把 GPU 真正需要的文件能力复制到 GPU 端的快路径。

为什么机器学习工作负载适合这个折中

GeminiFS 并不是面向所有 POSIX 程序的通用文件系统。论文先观察了 DNN、GNN 和 LLM 的常见存储访问,然后抓住了四个特征:

  • 短期中间数据通常只在若干训练步骤内有效,不一定需要完整持久化语义。
  • 模型权重、训练输入和 KV Cache 等长期数据,往往先分配、写入或追加,之后主要以只读方式访问。
  • 很多访问模式由模型结构、数据集和训练迭代次数决定,可以提前估计。
  • 长期数据通常需要被多个 GPU 进程共享。

这四点直接决定了后面的架构:文件可以提前分配,文件的物理块映射可以提前生成,GPU 端不必处理任意目录操作和动态扩容,缓存也可以围绕共享只读数据来设计。

GeminiFS 的整体架构:主机管文件,GPU 管快路径

GeminiFS 是一个 companion file system,可以翻译成“伴生文件系统”。它不是在 GPU 上独立维护一个完整的文件系统,而是和主机文件系统共同存在:

  • 主机文件系统负责路径、目录、文件创建和删除,以及底层块的分配。
  • GVDK Helper 在文件创建时从主机内核获得物理块信息,并把 GPU 需要的元数据写进文件。
  • GPU 打开文件时,把这份元数据和映射表读进显存。
  • GPU kernel 依据这些信息把文件偏移转换为 NVMe 偏移,然后直接提交请求。

把论文中的几层关系压缩成一张图,大致是这样:

                CPU / 主机侧
┌────────────────────────────────────────┐
│ 主机文件系统                           │
│ 目录、文件生命周期、块分配              │
│            │                           │
│            ├── GVDK Helper:生成文件内元数据 │
│            │                           │
│            └── SNVMe:创建并注册 GPU 队列   │
└────────────┼───────────────────────────┘
             │ 共享 NVMe 控制器与 DMA 映射
             ▼
┌────────────────────────────────────────┐
│ GPU / 显存侧                            │
│ libGemini → 元数据缓存 / 页缓存          │
│     → GPU kernel 构造 NVMe 命令           │
│     → GPU 轮询完成队列                    │
└────────────────┼───────────────────────┘
                 │ PCIe P2P DMA
                 ▼
             NVMe SSD

论文把这套系统拆成三项关键设计:

  1. GVDK:把必要的文件私有元数据嵌入文件,避免 GPU 每次请求都回到 CPU 查映射。
  2. SNVMe:扩展主机 NVMe 驱动,让 CPU 和 GPU 都能为同一个设备建立 I/O 队列。
  3. GPU-specific page cache:在显存中管理可共享、可预取、能承受 GPU 并行度的页缓存。

libGemini 则把这三部分封装成接近 open/read/write 的接口,避免应用开发者直接处理队列、DMA 地址和元数据布局。

GVDK:把文件系统元数据放进文件本身

为什么不直接把 EXT4 搬到 GPU

文件系统之所以复杂,很大一部分复杂度来自动态元数据:inode、目录、extent tree、日志、块分配、时间戳和一致性控制。把这些都放进 GPU,会遇到两个问题:

  • GPU 需要执行大量带分支和状态维护的控制逻辑,这不是 GPU 最擅长的工作。
  • CPU 和 GPU 都可能修改元数据,双方必须持续同步,反而把 CPU 重新拉回 I/O 热路径。

GeminiFS 的做法是先限制问题:GPU 访问的文件由主机侧提前创建,并且按预估大小预分配块。这样,GPU 端不需要在每次追加写时重新申请物理块,也不需要维护目录和全局 inode 状态。

主机文件系统仍然是文件生命周期的权威来源,GPU 只拿一份“这个文件如何读写”的局部视图。

GPU 端到底需要哪些元数据

论文把文件私有元数据嵌入文件的第一个块,主要包括:

  • 文件类型和访问模式;
  • 文件大小和 I/O block size;
  • 文件逻辑块到 NVMe 物理块的映射;
  • L1、L2 两级映射表;
  • 已使用块信息和 block bitmap;
  • dirty bitmap 的 NVMe 地址。

目录、路径组织和其他面向主机管理的元数据不放进 GPU 端。GPU 只需要完成几件事:检查访问是否合法、把文件偏移翻译成 NVMe 偏移、提交读写请求,以及在需要时刷新修改过的数据和元数据。

这正是“伴生”的含义:GPU 端不是另一个完整的 namespace,而是主机文件系统中某个文件的高速访问视图。

两级映射如何完成地址翻译

EXT4 的 extent tree 对 CPU 很自然,但把完整的 extent 解析逻辑放进 GPU,会带来很多分支和随机访问。GeminiFS 在文件创建阶段让主机内核完成这部分工作,然后把结果展开成更适合 GPU 读取的两级表。

GVDK 的结构可以简化为:

文件第一个区域
┌──────────────────────────────────────────┐
│ Header / 文件私有元数据                   │
│ Dirty Bitmap                              │
│ L1 Table:每项指向一个 L2 Table            │
│ L2 Table:每项指向一个数据块的 NVMe offset │
│ Data Blocks                               │
└──────────────────────────────────────────┘

假设一个文件偏移被拆成 m = (m1, m2, m3):

  • m1 用来索引 L1 表,找到对应的 L2 表;
  • m2 用来索引 L2 表,找到目标数据块的 NVMe offset;
  • m3 是数据块内部的偏移。

所以一次地址翻译就是:

文件偏移 m
   │
   ├── m1 → L1[m1] → 某个 L2 表
   ├── m2 → L2[m2] → 物理数据块的 NVMe offset
   └── m3 → 物理数据块内部偏移

打开文件时,映射表会被缓存到 GPU 显存,后续 G_read 或 G_write 就可以在 GPU 上完成偏移转换,不必为了每个请求调用主机文件系统。

这是一种很典型的“用空间换控制流”的设计。论文给出的代价是:物理块为 4 KB、每个物理块的 NVMe offset 使用 8 字节时,映射信息大约带来 0.2% 的容量开销。换来的好处是 GPU 不再需要理解主机文件系统的复杂索引结构。

预分配是关键前提,不是实现细节

GVDK 的物理映射能稳定工作,靠的是文件提前分配和生命周期受控。假如主机文件系统在 GPU 使用过程中随意扩容、迁移或重排文件块,GPU 显存里的映射就可能失效。

因此,GVDK 更像是“为 GPU I/O 准备的预分配文件格式”,而不是给任意动态文件提供通用的物理地址抽象。论文也承认这一点:对于不可预测的工作负载,后续计划采用 file pre-allocation 和运行时批量填充槽位,而不是让 GPU 端支持任意动态分配。

dirty bitmap 和一致性边界

GVDK 还为每个文件维护 dirty bitmap。每一位对应一个文件页,GPU 写入数据后设置对应标记,之后再把 bitmap 刷回存储。

它解决的是“哪些页被 GPU 修改过”的记录问题,但不能自动把 GeminiFS 变成完整的 POSIX 一致性实现。libGemini 把同步责任暴露给应用,通过 G_sync 让修改过的数据和元数据持久化。

这里有一个容易被论文摘要带过去的边界:GeminiFS 提供的是面向特定 GPU 工作负载的持久化路径,不是一个支持任意并发更新、任意崩溃场景和完整 POSIX 语义的文件系统。

SNVMe:为什么还需要改 NVMe 驱动

有了文件内映射,GPU 还不能立刻向 SSD 发命令。原因很直接:传统 Linux NVMe 驱动默认由 CPU 建立和管理控制器队列,GPU 并没有自己的 I/O submission queue 和 completion queue。

标准 NVMe 初始化在做什么

主机侧通常会经历以下过程:

  • 创建一对 Admin Submission Queue 和 Completion Queue,用于管理控制器;
  • 查询控制器和 namespace 的能力;
  • 创建若干 I/O queue pairs,并通过 admin 命令注册给控制器;
  • 把 namespace 注册成主机的块设备,交给块层和文件系统使用。

如果只是在 GPU 端重新实现一套完整 NVMe 驱动,工作量很大,而且容易让 GPU 进程独占整块设备。GeminiFS 的判断是:GPU 不需要理解控制器的全部管理语义,只需要能正确地创建 I/O 队列、提交读写命令和轮询完成结果。

SNVMe 做了两处核心修改

GeminiFS 的 CPU/GPU Shared NVMe Driver,简称 SNVMe,仍然依托主机 NVMe 驱动,但增加了 GPU 所需的能力。

第一处是 GPU buffer 管理。

创建 GPU I/O 队列后,SNVMe 需要让 NVMe 设备能够看见这些位于 GPU 显存中的队列。论文描述的路径包括:

  • 通过 GPU 驱动固定队列所在的 GPU memory pages;
  • 使用 nvidia_p2p_get_pages_persistent 建立持久映射;
  • 使用 nvidia_p2p_dma_map_pages 把 GPU 虚拟地址转换成设备可用的 DMA 地址。

于是,NVMe 控制器看到的 SQ/CQ 虽然位于 GPU 显存,但仍然可以按照 NVMe 协议访问。

第二处是 GPU I/O queue 的注册。

GeminiFS 在标准控制器初始化前预先分配 GPU 队列,记录队列数量和深度;随后在创建 I/O queue 的阶段,把这些位于 GPU 显存的队列一并注册到控制器。

GPU 侧的完成处理不使用主机中断,而是由 GPU thread polling CQ。提交队列的高吞吐实现借用了 BaM 的思路,让很多 GPU 线程能够并发写入 SQ、敲 doorbell,并轮询完成队列。

所以这里并不是“GPU 接管了整个 NVMe 控制器”,而是:CPU 仍然负责设备级初始化和管理,GPU 获得了自己的 I/O 队列和数据访问权。

控制面缩短以后,文件系统语义由谁提供

这一点是 GeminiFS 和裸块设备方案的分界线:

  • SNVMe 只解决“怎么把 GPU 命令送到 NVMe”;
  • GVDK 解决“这个文件偏移对应哪个物理块”;
  • libGemini 解决“应用如何用接近文件接口的方式调用它们”;
  • 主机文件系统仍然负责路径、文件创建、预分配和生命周期。

几层职责没有被混成一个 GPU 端的大型内核,这也是 GeminiFS 能够控制复杂度的原因。

GPU 页缓存:照搬 CPU page cache 反而会出问题

GPU 页缓存的目标很直白:数据一旦进入 HBM,后续访问应该尽量利用 GPU 内部带宽,而不是每次都走 PCIe 和 NVMe。

但 GPU 页缓存和 CPU 页缓存有两个本质差异。

多进程共享不能依赖普通进程内存

GeminiFS 运行在 GPU 非特权用户态,缓存只能分配在具体 GPU 进程的显存空间里。如果多个进程同时打开同一个文件,简单做法会给每个进程复制一份缓存,浪费显存,也会让缓存一致性变得复杂。

论文把缓存管理放进 SNVMe 的主机模块:

  • 第一个进程打开文件时,分配 GPU 显存并建立持久映射;
  • 主机侧记录该文件对应的 page cache;
  • 后续进程通过 GPU IPC memory handle 获取同一份显存缓存的指针。

论文举例提到 CUDA 的 cuIpcGetMemHandle 和持久 GPU page mapping。这里的重点不是某个 CUDA API,而是把“缓存物理存储”和“进程访问句柄”分离:多个进程共享同一份页缓存,而不是各自维护一套副本。

GPU 并行度让锁竞争更严重

CPU 页缓存常见的锁粒度和链表结构,在 GPU 上不一定合适。成千上万个 GPU thread 同时缺页时,如果每个 thread 都争抢全局锁,缓存本身就会变成瓶颈。

GeminiFS 做了两层处理。

按 warp 获取页面,而不是按 thread 获取。

同一个 warp 中的线程通常具有相近的访问行为。把页面获取粒度提升到 warp,可以把大量 thread 级别的竞争压缩到 warp 级别。论文用 Ampere 架构举例:即使有成千上万个 warp,某一时刻真正竞争执行控制流的数量仍然受 SM 和 warp scheduler 数量限制。

用哈希表加双向链表维护缓存。

  • 哈希表负责文件页到显存页的常数时间查找;
  • 对引用数为零的页面,再用哈希表和双向链表维护候选淘汰集合;
  • 页面重新被命中时,从零引用集合中常数时间移除;
  • 页面释放后重新加入链表尾部,长期未访问的页面逐渐移动到头部。

它不追求一个复杂的全局替换策略,而是优先缩短临界区,降低锁竞争。

预取和页大小是必须调的参数

GeminiFS 的页缓存不是一个固定策略,而是暴露了较大的调参空间:

参数调大后的主要效果可能的代价
cache capacity能容纳更多热点数据占用更多 HBM
page size同一 warp 涉及的页数减少,锁竞争降低访问不连续时可能读入更多无用数据
prefetch pages更容易填满 NVMe 队列,适合顺序访问随机访问会增加无效 I/O

论文的微基准很能说明这套设计的意图:关闭预取时,读写带宽只有理论内存带宽的 30.2% 和 28%;打开预取后,读写性能分别提高约 2.4 倍和 2.34 倍,接近峰值。

在 128 个 warp 的测试中,页缓存读写带宽约为 658.1 GB/s 和 641.2 GB/s;页大小从 4 KB 增加到 1 MB 后,读写带宽都接近 120 GB/s 的 kernel memory copy 上限。

这些数字不是说 NVMe 能跑到几百 GB/s,而是说明:一旦数据已经在显存中,页缓存管理逻辑没有明显挡住 HBM 内部的并行带宽。 单个 NVMe 设备的带宽仍然只有几个 GB/s,真正的瓶颈通常在存储侧。

libGemini:把底层复杂度藏在一组小 API 后面

GeminiFS 没有试图实现完整 POSIX,而是提供一组足够覆盖 GPU 训练和推理场景的接口:

// host side
int Geminifs_init(char *dev_path, char *GPU_ids, int Q_num);
dev_fd G_open(char *path, uint16_t flag,
              uint64_t cache_capacity, int page_size);
int G_close(dev_fd fd);

// device side
int G_read(dev_fd fd, void *buf,
           uint64_t offset, size_t nbyte);
int G_write(dev_fd fd, void *buf,
            uint64_t offset, size_t nbyte);
int G_sync(dev_fd fd);

一条典型使用路径是:

  1. CPU 调用 Geminifs_init,指定 NVMe 设备、GPU ID 和每个 GPU 要创建的 I/O queue 数量。
  2. CPU 调用 G_open,主机侧准备 GVDK 文件,读取文件元数据,建立映射表缓存和页缓存。
  3. GPU kernel 调用 G_read 或 G_write,在 GPU 端检查范围、完成地址翻译,并提交 NVMe 请求。
  4. 对模型权重、KV Cache 或检查点等写入数据调用 G_sync,把修改过的数据和元数据刷新到存储。
  5. 主机侧关闭文件并释放对应的 GPU 资源。

这组 API 的价值不在于名字像 POSIX,而在于应用不需要处理以下细节:

  • GPU 队列如何分配和注册;
  • GPU 显存如何转换为 NVMe DMA 地址;
  • 文件逻辑偏移如何变成物理块地址;
  • 页缓存如何共享、预取和淘汰;
  • GPU 线程如何轮询完成队列。

论文明确选择了“不做完整 POSIX”。原因也很现实:很多目标数据是只读的,训练中间数据即使写入磁盘,也未必需要传统数据库式的强一致语义;而主机文件系统的元数据不由 GPU 读写路径修改。

这里顺带记录一个论文阅读时容易略过的小问题:表 2 把主机侧的释放接口写成 G_close,但后面的 File Close 段落又把 CPU-side 接口称为 G_sync。按上下文看,作者想表达的是“同步修改并释放资源”这一组 close 语义,实际使用时应以实现代码为准,而不能只照抄论文中的命名。

实验结果:文件语义的成本到底有多大

实验环境

论文的主要实验环境是:

  • 64 核 Intel Xeon 5416S;
  • 512 GB 主机内存;
  • Ubuntu 20.04,Linux 5.15;
  • 80 GB HBM 的 GPU,论文引用的是 NVIDIA Ampere 架构资料;
  • Intel Optane P5800X NVMe,挂载 EXT4;
  • 主机侧分配 64 个 I/O queue pairs,GPU 侧分配 32 个。

论文把 GeminiFS 和三类方案对比:

  • GPUfs:CPU-centric,并且具有文件接口;
  • GDS:CPU 负责编排,数据可以直接到 GPU;
  • BaM:GPU-centric,但测试中按裸 NVMe 设备访问,不提供文件系统语义。

为了观察控制面差异,第一组实验使用 4 KB I/O,并关闭 GeminiFS 页缓存。

4 KB I/O:GPU 线程越多,CPU 越容易成为瓶颈

论文报告的主要结果如下:

对比论文报告的结果解释
GeminiFS vs GPUfs平均带宽约为 GPUfs 的 7.33 倍;1024 个线程时达到 NVMe 峰值GPU 可以直接提交请求,避免 CPU 线程争用
GeminiFS vs GDS1~16 个线程时 GDS 带宽约高 57%;128~512 个线程时 GeminiFS 带宽约为 GDS 的 6.2 倍少量线程时 CPU 频率更高;并行度上来后 CPU 编排成为瓶颈
GeminiFS vs BaM带宽平均低约 4.6%,延迟高约 4.8%GeminiFS 多了元数据解析和逻辑地址到物理地址的转换
4 KB 平均延迟 vs GPUfs不同线程数下减少约 79.6%~90.9%缩短了主机控制面和数据路径
1024 个线程时 vs GDSGeminiFS 延迟约为 GDS 的 17%GPU 的高并行度没有转化成 CPU 请求争用

这组结果里最重要的不是“GeminiFS 比所有方案都快”,而是它展示了不同并行度下的拐点:

  • 低并行度时,GDS 可以利用高频 CPU 快速组织请求;
  • 高并行度、小 I/O 时,CPU 组织请求的能力开始跟不上 GPU;
  • BaM 作为裸块设备路径仍然略快,说明文件语义确实有成本,但 GeminiFS 把这个成本控制在相对有限的范围内。

换句话说,GeminiFS 没有消灭文件系统开销,而是把地址翻译和元数据解析提前到可控的位置,再让 GPU 以足够高的并行度摊薄它。

页缓存实验说明“缓存策略”本身也是系统设计

在内存复制替代 NVMe 访问的微基准中,论文观察到:

  • 不预取时,页缓存读写带宽分别只有理论 kernel copy 带宽的 30.2% 和 28%;
  • 预取后,读写性能分别提升约 2.4 倍和 2.34 倍;
  • warp 数从 1 增加到 128 时,读写带宽增长到约 658.1 GB/s 和 641.2 GB/s;
  • 页大小增大到 1 MB 时,读写带宽接近 120 GB/s 的内存复制上限。

这说明 GPU 页缓存不能只问“有没有缓存”,还要问:

  • 缺页时一次拉多少页;
  • 一个 warp 访问的页面是否能合并;
  • 页大小是否和访问局部性匹配;
  • 锁和元数据访问是否压过了实际数据搬运。

对于顺序读写和可预测训练数据,预取会非常有效;对于随机访问,过大的页和过度预取则可能把 NVMe 带宽浪费在无用数据上。

LLM 训练:真正的收益来自大量小 I/O

论文最后用 GPT2-124M 训练测试激活值卸载和检查点写入。实验使用 batch size 64,运行 3 个训练 step,每个 step 包含一次 forward、一次 backward,并在每一步写 checkpoint。表中给出的存储访问规模是:

数据大小访问方式
Model weights238 MB读写
Checkpoint每步 713 MB追加式顺序写
Activation57.96 GB读写

在不卸载 activation、只比较 checkpoint 优化时,GeminiFS 的总运行时间相比 native、DLRover-RM 和 GDS 分别减少 25%、12% 和 10%;checkpoint 写入时间分别减少 85%、75% 和 59%。

启用 activation offloading 后,GeminiFS 相比 native 和 GDS 的训练时间分别减少 94.5% 和 91%。论文还指出,和完全把 activation 留在 HBM 中相比,卸载后的训练时间大约增加 4 倍;如果把多个 NVMe 设备并入系统,理论上可以继续接近只使用 DRAM 的方案。

这个实验很能说明 GeminiFS 的定位:它不是为了让一次大块顺序读快一点,而是为了让 GPU 自己处理大量细粒度、可并行的存储访问,避免每个小 I/O 都经过 CPU。

不过这里也有一个需要标出来的阅读细节:论文正文称实验模型是“GPT2-124M”,随后又写成“1.5 billion parameters”。模型名称和参数量并不一致,二者至少有一处是笔误。因此,实验趋势可以参考,但不宜把这组数字当成完全无歧义的模型规模描述。

我认为 GeminiFS 真正做对了什么

它把“文件系统”拆成了管理面和访问面

传统文件系统把目录、元数据、块分配和数据读写整合在一起。GeminiFS 则把它们拆开:

  • 管理面继续留在主机文件系统;
  • 访问面复制一份 GPU 必需的局部信息;
  • 两边通过文件内元数据和预分配建立稳定连接。

这不是简单地把 CPU 路径搬到 GPU,而是重新定义了“GPU 需要的文件系统最小集合”。

它把动态问题变成了初始化问题

动态分配、复杂索引、目录遍历和控制器管理都很难放进 GPU 热路径。GeminiFS 通过初始化阶段完成:

  • 主机预分配文件空间;
  • 主机生成物理块映射;
  • 建立 GPU NVMe 队列;
  • 创建共享页缓存;
  • 把元数据和映射表读进显存。

运行阶段只剩下范围检查、地址翻译、命令提交和完成轮询。对于可预测的训练和推理负载,这是很划算的交换。

它没有为了“通用”而牺牲快路径

GeminiFS 明确不支持完整 POSIX,不提供任意动态文件操作,也没有把所有一致性语义都强行塞进 GPU。这个决定可能让它看起来不够通用,但正是它能在 4 KB 高并发 I/O 中接近 BaM 的原因。

从系统设计角度看,这是一种很熟悉、也很有效的做法:把通用性留在慢路径,把工作负载确定的部分压缩进快路径。

边界在哪里:它不是 GPU 版 EXT4

读到这里,最容易产生的误解是“GeminiFS 已经解决了 GPU 文件系统”。更准确的说法应该是:它为一类 GPU 工作负载提供了一个文件形状的直连 I/O 层。

它的边界至少包括以下几项:

  • 依赖预分配和稳定映射。 任意动态扩容、碎片整理和复杂文件生命周期都不是它的目标。
  • 不提供完整 POSIX 语义。 read/write/sync 足够支撑论文中的训练与推理场景,但不等于完整的目录、权限、锁和一致性模型。
  • 并发修改模型有限。 论文重点是长期只读或追加写数据;主机和多个 GPU 进程同时以通用方式修改同一文件,需要更严格的协议。
  • 部署侵入性较强。 需要修改或扩展 NVMe 内核驱动,并依赖 GPU peer memory、DMA 映射和特定硬件能力。
  • 多 GPU 仍是后续工作。 论文计划通过逻辑切分文件实现并行读写,再用 RAID 聚合多块 NVMe 来满足多 GPU 带宽需求。
  • 不可预测访问仍需要额外方案。 论文提出未来用预分配槽位和批量分配来覆盖这类负载,但这说明当前设计的核心假设仍然是“可以提前知道大致访问需求”。

另外,论文提到可以对文件内元数据做完整性检查,也可以通过只提供预编译库来隐藏底层细节。但这更接近工程上的防护措施,不能和完整的主机文件系统权限隔离、安全模型直接画等号。

总结:GeminiFS 是一条 GPU I/O 快路径

GeminiFS 的整体思路可以压缩成下面四句话:

  1. 主机文件系统继续管理文件和物理空间,不把完整的文件系统状态搬进 GPU。
  2. GVDK 把 GPU 必需的私有元数据和物理块映射嵌入文件,打开时缓存到显存。
  3. SNVMe 让 CPU 和 GPU 为同一个 NVMe 设备建立各自的 I/O 队列,GPU 直接提交并轮询请求。
  4. GPU 页缓存用共享显存、warp 级获取、常数时间容器和可调预取,把 HBM 带宽真正利用起来。

所以,GeminiFS 的核心不是“让 GPU 变成一个更快的 CPU 文件系统”,而是把文件系统中稳定、可预先计算的部分提取出来,给 GPU 构造一条足够像文件、又足够接近裸设备的访问路径。

如果工作负载是大模型权重、训练输入、KV Cache、检查点或可预测的中间数据,这个取舍很有吸引力;如果工作负载需要任意文件操作、强一致并发更新和复杂权限语义,那么它更像一个需要谨慎集成的专用加速层,而不是主机文件系统的替代品。

参考资料