0. 本文目的

本文主要测试一下SPDK/IOUring/libaio的性能上界。

以下数据整理自 AMD 的 SPDK 26.01 NVMe BDEV 性能报告,主要使用 4 KiB I/O。结论对应文中的硬件、队列深度和工作负载,并非所有设备的通用上限。

1. 测试环境

表 1:测试环境概要

项目配置
服务器与 CPUDell PowerEdge R7725xd,双路 AMD EPYC 9575F
内存768 GB DDR5,6400 MT/s
存储24 × 15.36 TB Micron 9550 PRO NVMe SSD
系统Ubuntu 24.04.4 LTS,Linux 6.8.0-106-generic;启用 Spectre/Meltdown 缓解措施
测试软件SPDK 26.01,fio 3.36

关键调优: 启用 Turbo Boost 和 SMT,CPU governor 设为 performance,禁用 CPU/DF C-state 与 PCIe ASPM,使用 2 MiB 大页;I/O 线程绑定到 SSD 邻近的 CPU 核心。

SSD 预处理: 每次测试前,以 128 KiB 块顺序写满整个命名空间两遍;4 KiB 纯随机写测试先运行 60 分钟,使性能进入稳态。

2. 测试用例 1:SPDK NVMe BDEV 每核 IOPS 测试

目的: 本测试用例测量 SPDK NVMe bdev 层的最大单核 IOPS。 我们使用不同的基准测试工具(SPDK bdevperf、SPDK fio bdev 插件和 SPDK NVMe perf),以了解基准测试工具本身引入的开销。由于本测试关注每核 IOPS,因此关闭或省略了延迟测量。

使用了以下随机读/写工作负载:

  • 4KiB 100% 随机读
  • 4KiB 100% 随机写
  • 4KiB 随机 70% 读、30% 写

对于每种工作负载,我们执行以下步骤:

  1. 按“测试环境”一节所述对 SSD 进行预处理。
  2. 从使用 24 块 NVMe 设备的配置开始运行每种工作负载,然后在每次后续运行中减少 SSD 数量。
    • 这展示了随着 SSD 数量增加,IOPS 如何扩展,直到达到最大每核 IOPS。
    • 从 24 块 SSD 开始并在后续运行中减少数量,可以避免在运行之间重新预处理,因为所有 SSD 都在前一次运行中处于活动状态,因此仍处于稳态。
  3. 每项测试重复三次,并报告三次运行的平均值。

表 2:SPDK NVMe BDEV IOPS 测试配置

项目说明
测试用例SPDK NVMe BDEV 每核 IOPS 测试
测试配置fio 版本:fio-3.36;NVMe SSD 数量:{1, 2, 3, 4, 5, …,24};将 SPDK_BDEV_IO_CACHE_SIZE 从 256 改为 2048(使用 bdev_set_options RPC 调用)。

Bdevperf 配置:

spdk/build/examples/bdevperf -c bdev.conf -q ${iodepth} -o ${block_size} -w ${rw} -M ${rwmixread} -t 300 -m 0 -p 0

fio 配置:

[global]
ioengine=spdk_bdev
spdk_json_conf=bdev.conf
gtod_reduce=1
direct=1
thread=1
norandommap=1
time_based=1
ramp_time=60s
runtime=300s
bs=4k
numjobs=1

随机读和混合工作负载:

rw={randread, randrw}
rwmixread={100,70}
iodepth={128, 192, 256}

随机写工作负载:

rw=randwrite
rwmixread=0
iodepth={32,64,128}

2.1 SPDK NVMe BDEV 单核吞吐量

第一项测试使用 SPDK bdevperf 执行,它是一个轻量级基准测试工具,给 I/O 路径增加的延迟极小。下列图表展示了随着 NVMe SSD 数量增加,SPDK 块层的单核 IOPS 结果。

图 1:SPDK NVMe BDEV IOPS 随 SSD 数量增加的扩展性(4KiB 随机读,1 个 CPU 核心,QD=192,使用 bdevperf 工具)

图 1:SPDK NVMe BDEV IOPS 随 SSD 数量增加的扩展性(4KiB 随机读,1 个 CPU 核心,QD=192,使用 bdevperf 工具)

图示说明:

  • 标题:SPDK NVMe BDEV IOPS。
  • 副标题:4KiB 随机读,QD=192,1 个 CPU 核心。
  • 纵轴:IOPS(千),越高越好。
  • 横轴:SSD 数量。

图 2:SPDK NVMe BDEV IOPS 随 SSD 数量增加的扩展性(4KiB 随机写,1 个 CPU 核心,QD=32,使用 bdevperf 工具)

图 2:SPDK NVMe BDEV IOPS 随 SSD 数量增加的扩展性(4KiB 随机写,1 个 CPU 核心,QD=32,使用 bdevperf 工具)

图示说明:

  • 标题:SPDK NVMe BDEV IOPS。
  • 副标题:4KiB 随机写,QD=32,1 个 CPU 核心。
  • 纵轴:IOPS(千),越高越好。
  • 横轴:SSD 数量。

图 3:SPDK NVMe BDEV IOPS 随 SSD 数量增加的扩展性(4KiB 70/30 随机读/写,1 个 CPU 核心,QD=192,使用 bdevperf 工具)

图 3:SPDK NVMe BDEV IOPS 随 SSD 数量增加的扩展性(4KiB 70/30 随机读/写,1 个 CPU 核心,QD=192,使用 bdevperf 工具)

图示说明:

  • 标题:SPDK NVMe BDEV IOPS。
  • 副标题:4KiB 随机读/写,QD=192,1 个 CPU 核心。
  • 纵轴:IOPS(千),越高越好。
  • 横轴:SSD 数量。

2.2 Bdevperf 与 fio 的每核 IOPS 结果对比

SPDK 提供了 bdevperf 基准测试工具,该工具仅包含定义基本工作负载和收集有限指标所需的最少功能。fio 在定义工作负载、扩展测试和收集详细性能数据方面提供了丰富得多的功能,但这种灵活性带来了更高的开销。本测试比较了 bdevperf 与使用 SPDK bdev 插件的 fio 的每核 IOPS。

表 3:每核 IOPS 性能;SPDK fio bdev 插件与 SPDK bdevperf 对比(块大小=4KiB,1 个 CPU 核心)

工作负载SPDK fio bdev 插件(IOPS,千)SPDK bdevperf(IOPS,千)性能提升
4KiB 随机读,QD=192,8 块 SSD7514.9211160.3348%
4KiB 随机写,QD=32,24 块 SSD6112.9910122.5766%
4KiB 70/30 随机读/写,QD=192,12 块 SSD5891.6110766.8483%

当被测系统每核能够提供数百万 IOPS 时,基准测试开销就十分重要。在此环境中,开销较低的 SPDK bdevperf 工具提供的每核 IOPS 比 fio 最多高 83%。

2.3 NVMe BDEV 与轮询模式驱动的每核 IOPS 对比

这部分测试比较了 SPDK NVMe bdev 层与 SPDK NVMe 轮询模式驱动的吞吐量。SPDK 块层提供了额外功能,但这些功能引入了可测量的开销。对于随机读工作负载,bdev 层提供的每核 IOPS 比更底层的轮询模式驱动低约 58%。对于随机写工作负载,差距则小得多。该比较使用 SPDK bdevperf 和 nvmeperf 执行。

表 4:SPDK NVMe Bdev 与 SPDK NVMe PMD 的每核 IOPS 对比(块大小=4KiB,1 个 CPU 核心)

工作负载SPDK Bdevperf(IOPS,千)SPDK Nvmeperf(IOPS,千)性能提升
4KiB 随机读,QD=256,8 块 SSD11,467.5318,115.9558%
4KiB 随机写,QD=32,24 块 SSD10,122.5710,460.223%

2.4 结论

  1. 对于随机读工作负载,与使用 SPDK NVMe 块设备模块相比,SPDK NVMe 轮询模式驱动提供的 IOPS 高 58%。
  2. 对于随机读工作负载,在 NVMe SSD 数量增加到 3 块之前,性能呈线性扩展,达到约 700 万 IOPS。在此之后,扩展变为非线性,并在使用 13 块 SSD 时达到约 1180 万 IOPS 的峰值。
  3. 对于随机写工作负载,性能一直线性扩展至 24 块 NVMe SSD,达到约 1010 万 IOPS。
  4. 对于 70/30 随机读/写工作负载,性能一直线性扩展至 12 块 SSD,达到约 1080 万 IOPS。

3. 测试用例 2:SPDK NVMe BDEV I/O 核心数扩展

目的: 本测试用例展示了为 I/O 处理分配更多 CPU 核心时,NVMe bdev 吞吐量如何扩展。 测试中使用的 CPU 核心数从 1 增加到 2、3、4、5、6、8、10 和 12。

测试工作负载:

  • 4KiB 100% 随机读
  • 4KiB 100% 随机写
  • 4KiB 随机 70% 读、30% 写

表 5:SPDK NVMe BDEV I/O 核心数扩展性测试

项目说明
测试用例测试 SPDK NVMe BDEV I/O 核心数扩展性测试
测试配置CPU 核心数:1, 2, 3, 4, 5, 6, 8, 10, 12;NVMe SSD 数量:测试中每个 CPU 核心对应 8 块,最多 24 块 NVMe SSD;NUMA 优化:选择用于测试的 CPU 时,使其与 NVMe 驱动器在平台 NUMA 节点间的分布相匹配。

Bdev perf 配置:

spdk/build/examples/bdevperf --json bdev.conf \
    -q ${QD} -o 4096 -w randrw -M ${MIXREAD} \
    -t 300 -m ${CORE_MASK} -p ${PRIMARY_CORE}

3.1 结果

表 6:SPDK NVMe BDEV I/O 核心数扩展性测试(QD=192 时的 4KiB 100% 随机读 IOPS;QD=32 时的 4KiB 100% 随机写 IOPS;QD=192 时的 4KiB 70/30 随机读/写 IOPS)

IOPS 单位:千。

CPU 核心数NVMe SSD 数量随机读,QD=192随机写,QD=3270/30 随机读/写,QD=192
1810,954.075,358.8810,608.60
21621,699.648,131.8220,991.29
32432,480.4410,183.4831,266.99
42439,209.5110,553.6839,744.37
52443,417.1710,457.1244,562.07
62450,088.8710,467.5549,155.86
82455,274.9610,633.3652,186.72
102456,218.37N/A52,799.65
122457,819.93N/A53,847.02

图 4:SPDK NVMe BDEV I/O 核心数扩展性(QD=192 时的 4KiB 100% 随机读 IOPS;QD=32 时的 4KiB 100% 随机写 IOPS;QD=192 时的 4KiB 70/30 随机读/写 IOPS)

图 4:SPDK NVMe BDEV I/O 核心数扩展性(QD=192 时的 4KiB 100% 随机读 IOPS;QD=32 时的 4KiB 100% 随机写 IOPS;QD=192 时的 4KiB 70/30 随机读/写 IOPS)

图示说明:

  • 标题:4KiB Bdevperf 核心数扩展性能。
  • 纵轴:IOPS(千),越高越好。
  • 横轴:使用的 CPU 核心数。
  • 图例:随机读,QD=192;随机写,QD=32;70/30 随机读/写,QD=192。

3.2 结论

  1. 对于 4 KiB 随机读工作负载,当 I/O 核心数增加到 3 个 CPU 核心之前,IOPS 几乎呈线性扩展。超过 3 个核心之后,扩展变为非线性,并在使用 12 个 CPU 核心时达到 5782 万 IOPS 的峰值,这接近此测试环境的理论最大值。
    • a. 当我们将 bdevperf 的 I/O 线程绑定到 SSD 邻近的本地 CPU 核心时,在 6、8 和 10 个 I/O 核心的情况下,IOPS 吞吐量提升了 5–6%。
  2. 对于 4 KiB 70/30 随机读/写工作负载,IOPS 在增加到 4 个 I/O 核心之前几乎呈线性扩展。超过 4 个核心之后,扩展变为非线性,并在使用 12 个 CPU 核心时达到 5385 万 IOPS 的峰值。该结果超出了这些 NVMe SSD 在此工作负载下的预期吞吐量;我们怀疑这是由于预处理不完善所致,其影响会随时间推移逐渐消退。不过,这些结果是可重复的,仍然展示了 SPDK 在 I/O 核心数增加时的强大扩展性。
  3. 对于 4 KiB 随机写工作负载,IOPS 在增加到 3 个 CPU 核心之前呈线性扩展,并达到约 1050 万 IOPS 的峰值。吞吐量受到 NVMe SSD 而非 CPU 核心的限制。因此,增加 I/O 核心并未提高 IOPS。

4. 测试用例 3:SPDK NVMe BDEV 延迟

本测试用例考察 SPDK NVMe bdev 层的延迟特征,并将其与 Linux 内核 NVMe 块层进行比较。我们使用 SPDK fio bdev 插件而不是 bdevperf,因为它提供更详细的延迟指标。fio 针对一块 NVMe 驱动器上的单个块设备运行了 15 分钟。目标是使用直方图和汇总指标比较延迟随时间变化的一致性。Linux 内核块层也提供 I/O 轮询,以减少上下文切换、中断传递延迟和中断处理程序调度等开销。因此,本节比较了 SPDK、Linux libaio,以及启用轮询的 Linux io_uring 的延迟。

测试工作负载:

  • 4KiB 100% 随机读
  • 4KiB 100% 随机写

表 7:SPDK NVMe BDEV 延迟测试

项目说明
测试用例测试 SPDK NVMe BDEV 延迟测试
测试配置Fio 版本:fio-3.36;CPU 核心数:1;NVMe SSD 数量:1
SPDK NVMe 驱动配置ioengine=spdk_bdev
Linux 内核默认配置(libaio)ioengine=libaio
Linux 内核 io_uringioengine=io_uring

Linux 内核 io_uring:系统 NVMe 块设备配置

echo 0 > /sys/block/nvme0n1/queue/iostat
echo 0 > /sys/block/nvme0n1/queue/rq_affinity
echo 2 > /sys/block/nvme0n1/queue/nomerges
echo -1 > /sys/block/nvme0n1/queue/io_poll_delay

fio 配置(公共部分):

[global]
direct=1
thread=1
time_based=1
norandommap=1
group_reporting=1

rw={randread | randwrite}
bs=4096
runtime=900
ramp_time=120
numjobs=1
log_avg_msec=15
write_lat_log=/tmp/tc3_lat.log

fio 配置(SPDK 专用部分):

[global]

ioengine=spdk_bdev
spdk_conf=/tmp/bdev.conf

[filename0]
iodepth=1
cpus_allowed=0
filename=Nvme0n1

fio 配置(Linux 内核公共部分):

[global]

ioengine={libaio | io_uring}

[filename0]
iodepth=1
cpus_allowed=0
filename=/dev/nvme0n1

fio 配置(Linux 内核 io_uring 专用部分):

[global]
fixedbufs=1
hipri=1
registerfiles=1
sqthread_poll=1

Linux 块层在完成队列上实现 I/O 轮询。轮询能够消除上下文切换开销、IRQ 传递开销以及 IRQ 处理程序调度开销。

图 5:通过轮询优化 Linux 块层 I/O。

图 5:通过轮询优化 Linux 块层 I/O。

图示说明:

标注含义
IRQIRQ(中断请求)
Polling轮询
Application perceived I/O latency应用程序感知到的 I/O 延迟
syscall系统调用
BIO stackBIO 栈
Device driver设备驱动
CSCS(上下文切换)
Sleep睡眠
ISRISR(中断服务例程)
Wake唤醒
Command execution命令执行
Are you done ?完成了吗?
Gain收益

此外,Linux 块 I/O 轮询提供了一种降低 CPU 负载的机制。在经典轮询模型中,CPU 自旋等待命令完成,并占用一个 CPU 核心 100% 的资源。还存在一种自适应混合轮询,它让 I/O 轮询线程睡眠约为命令执行时间一半的时长,从而降低 CPU 负载;但必须在 I/O 完成之前提前唤醒轮询线程,并预留足够的上下文切换时间。本文档的测试没有使用混合轮询模式。

图 6:Linux 块 I/O 经典轮询与混合轮询的延迟分解。

图 6:Linux 块 I/O 经典轮询与混合轮询的延迟分解。

图示说明:

标注含义
Classic Polling经典轮询
Hybrid Polling混合轮询
Application perceived I/O latency应用程序感知到的 I/O 延迟
syscall系统调用
BIO stackBIO 栈
Device driver设备驱动
Are you done ?完成了吗?
Command execution命令执行
CPU load reductionCPU 负载降低
CSCS(上下文切换)
Sleep睡眠
Wake唤醒
Timer IRQ定时器 IRQ
ISRISR(中断服务例程)

表格和图表中的数据比较了使用 SPDK bdev,与使用 Linux 块层 I/O 模型 libaio 和启用轮询模式的 io_uring 执行各种 4KiB 工作负载时的 I/O 延迟。

4.1 平均延迟与尾延迟对比

表 8:SPDK bdev 与 Linux 内核延迟对比(4KiB 随机读,QD=1,运行时间=900s)

延迟指标(usec)SPDK Fio BDEV 插件Linux 内核(libaio)Linux 内核(io_uring)
平均值58.1060.2958.59
P9066.0568.1067.07
P9967.0769.1268.10
P99.9984.1483.8084.14
标准差5.715.765.70
平均提交延迟0.090.790.00
平均完成延迟58.0159.5058.55

表 9:SPDK bdev 与 Linux 内核延迟对比(4KiB 随机写,QD=1,运行时间=900s)

延迟指标(usec)SPDK Fio BDEV 插件Linux 内核(libaio)Linux 内核(io_uring)
平均值9.4212.0710.79
P909.4111.5410.82
P9910.0112.1811.46
P99.9984.4887.5587.55
标准差1.121.361.26
平均提交延迟0.110.820.00
平均完成延迟9.3111.2510.75

图 7:SPDK bdev 与 Linux 内核延迟对比(4KiB 随机读)

图 7:SPDK bdev 与 Linux 内核延迟对比(4KiB 随机读)

图示说明:

  • 标题:4KiB 随机读延迟。
  • 分类:Linux 内核(io_uring);Linux 内核(libaio);SPDK Fio BDEV 插件。
  • 图例:P99.99;P99;P90;平均值。

图 8:SPDK bdev 与 Linux 内核延迟对比(4KiB 随机写)

图 8:SPDK bdev 与 Linux 内核延迟对比(4KiB 随机写)

图示说明:

  • 标题:4KiB 随机写延迟。
  • 分类:Linux 内核(io_uring);Linux 内核(libaio);SPDK Fio BDEV 插件。
  • 图例:P99.99;P99;P90;平均值。

4.2 Linux 内核 libaio 直方图

图 9:Linux 内核(默认 libaio)4KiB 随机读平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图 9:Linux 内核(默认 libaio)4KiB 随机读平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图示说明:

  • 标题:Linux 内核(Libaio)延迟直方图。
  • 副标题:4KiB 随机读。
  • 纵轴:频数。
  • 横轴:延迟(纳秒)。

图 10:Linux 内核(默认 libaio)4KiB 随机写平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图 10:Linux 内核(默认 libaio)4KiB 随机写平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图示说明:

  • 标题:Linux 内核(Libaio)延迟直方图。
  • 副标题:4KiB 随机写。
  • 纵轴:频数。
  • 横轴:延迟(纳秒)。

4.3 Linux 内核 io_uring 直方图

图 11:Linux 内核(io_uring 轮询)4KiB 随机读平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图 11:Linux 内核(io_uring 轮询)4KiB 随机读平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图示说明:

  • 标题:Linux 内核(io_uring)延迟直方图。
  • 副标题:4KiB 随机读。
  • 纵轴:频数。
  • 横轴:延迟(纳秒)。

图 12:Linux 内核(io_uring 轮询)4KiB 随机写平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图 12:Linux 内核(io_uring 轮询)4KiB 随机写平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图示说明:

  • 标题:Linux 内核(io_uring)延迟直方图。
  • 副标题:4KiB 随机写。
  • 纵轴:频数。
  • 横轴:延迟(纳秒)。

4.4 SPDK fio Bdev 直方图

图 13:SPDK BDEV NVMe 4KiB 随机读平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图 13:SPDK BDEV NVMe 4KiB 随机读平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图示说明:

  • 标题:SPDK FIO BDEV 延迟直方图。
  • 副标题:4KiB 随机读。
  • 纵轴:频数。
  • 横轴:延迟(纳秒)。

图 14:SPDK BDEV NVMe 4KiB 随机写平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图 14:SPDK BDEV NVMe 4KiB 随机写平均延迟直方图(QD=1,运行时间=900s,fio,采样间隔=15msec)

图示说明:

  • 标题:SPDK FIO BDEV 延迟直方图。
  • 副标题:4KiB 随机写。
  • 纵轴:频数。
  • 横轴:延迟(纳秒)。

4.5 性能与不断增加的队列深度之间的关系

目的: 本节比较了在单个 NVMe SSD 上使用单个 CPU 核心、将队列深度从 1 增加到 512 时,SPDK、启用轮询的 Linux io_uring,以及 Linux libaio 的 IOPS 和平均延迟。

表 10:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机读,1 块 NVMe SSD,1 个 CPU 核心,numjobs=1)

QDSPDK IOPSSPDK 平均延迟(usec)Linux 内核(libaio)IOPSLinux 内核(libaio)平均延迟(usec)Linux 内核(io_uring 轮询)IOPSLinux 内核(io_uring 轮询)平均延迟(usec)
117,1525816,5696017,05159
234,4565833,2696034,19758
468,8195866,3446068,15659
8137,05358131,74161135,18359
16271,22059258,98062265,27560
32529,83760489,72965510,72663
641,008,55463597,075107945,79268
1281,822,78470597,1252141,504,18585
2562,455,507104595,4304301,987,999129
5122,456,238208596,6138582,214,990231

图 15:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机读,1 块 NVMe SSD,1 个 CPU 核心,numjobs=1)

图 15:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机读,1 块 NVMe SSD,1 个 CPU 核心,numjobs=1)

图示说明:

  • 标题:队列深度增加时的平均延迟和 IOPS。
  • 副标题:4KiB 随机读,1 块 NVMe SSD。
  • 左纵轴:IOPS,越高越好。
  • 右纵轴:平均延迟(usec,越低越好)。
  • 横轴:队列深度。
  • 图例:SPDK IOPS;Linux 内核(libaio)IOPS;Linux 内核(io_uring 轮询)IOPS;SPDK 平均延迟(usec);Linux 内核(libaio)平均延迟(usec);Linux 内核(io_uring 轮询)平均延迟(usec)。

表 11:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机写,1 块 NVMe SSD,1 个 CPU 核心,numjobs=1)

QDSPDK IOPSSPDK 平均延迟(usec)Linux 内核(libaio)IOPSLinux 内核(libaio)平均延迟(usec)Linux 内核(io_uring 轮询)IOPSLinux 内核(io_uring 轮询)平均延迟(usec)
1103,563983,1131291,57411
2151,22313145,37414144,99914
4383,35010286,18114319,58612
8797,26110516,99315581,31114
161,237,27212602,51426995,71716
321,555,93420602,569531,404,35123
641,640,86739606,6531051,623,10739
1281,642,83178608,3272101,674,83476
2561,703,205150607,2844211,685,945152
5121,708,936299600,0268531,698,960301

图 16:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机写,1 块 NVMe SSD,1 个 CPU 核心,numjobs=1)

图 16:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机写,1 块 NVMe SSD,1 个 CPU 核心,numjobs=1)

图示说明:

  • 标题:队列深度增加时的平均延迟和 IOPS。
  • 副标题:4KiB 随机写,1 块 NVMe SSD。
  • 左纵轴:IOPS,越高越好。
  • 右纵轴:平均延迟(usecs),越低越好。
  • 横轴:队列深度。
  • 图例:SPDK IOPS;Linux 内核(libaio)IOPS;Linux 内核(io_uring 轮询)IOPS;SPDK 平均延迟(usec);Linux 内核(libaio)平均延迟(usec);Linux 内核(io_uring 轮询)平均延迟(usec)。

4.6 结论

  1. 通过轮询完成事件而不是依赖中断,同时降低了延迟和延迟变化。
  2. 对于随机读和随机写,SPDK NVMe Bdev 的平均延迟分别比 Linux 内核 libaio 最多低 3.63% 和 21.98%。
  3. 对于随机读和随机写工作负载,SPDK NVMe Bdev 的平均延迟分别比 Linux 内核 io_uring 最多低约 0.83% 和 12.75%。
  4. 对于 QD=1 的 4KiB 随机写工作负载,频数分桶非常窄,因此决定以 100ns 作为 x 轴的区间单位来呈现结果。
  5. 对于 4 KiB 随机读工作负载,三种引擎在 QD 增加到 32 之前都呈线性扩展。在此之后:
    • a. SPDK NVMe bdev 的扩展在 QD=128 时变为非线性,并在 QD=256 时达到峰值,约为 246 万 IOPS,使 NVMe 驱动器饱和。
    • b. 内核 io_uring 的扩展在 QD=128 时变为非线性,并在 QD=512 时达到约 221 万 IOPS,接近使 NVMe 驱动器饱和。
    • c. 内核 libaio 在 QD=64 时达到约 597k IOPS 的峰值。超过该点后继续增加队列深度,并未提高吞吐量。
  6. 对于 4 KiB 随机写工作负载,libaio 在 QD 增加到 8 之前呈线性扩展,之后仅略有增加,最终在约 608k IOPS 时使 CPU 核心饱和。io_uring 和 SPDK 在 QD 增加到 16 之前呈线性扩展。超过这些点之后,随着 NVMe 驱动器在约 170 万 IOPS 时接近饱和,扩展变为非线性。
  7. 随机写工作负载的结果超过了该 NVMe SSD 的能力(约 437K IOPS),这可能是由不完善的预处理过程造成的,其影响会随时间推移逐渐消退。不过,这些结果是可重复的,并展示了 SPDK 随队列深度增加而具备的高扩展性。

5. 测试用例 4:不同队列深度下的 IOPS 与延迟

目的: 执行本测试用例是为了了解运行 SPDK 与内核 NVMe 块层时,不同队列深度下吞吐量与延迟之间的权衡。

表中的结果表示 SPDK 和 Linux 内核 NVMe 块层的 IOPS 性能和平均延迟。我们限制 SPDK 和 Linux NVMe 块层使用相同数量的 CPU 核心。

测试工作负载:

  • 4KiB 100% 随机读
  • 4KiB 100% 随机写
  • 4KiB 随机 70% 读、30% 写

表 12:不同队列深度下的 SPDK NVMe BDEV 延迟测试配置

项目说明
测试用例测试不同队列深度下的 SPDK NVMe BDEV 延迟测试
测试配置fio 版本:fio-3.36;CPU 核心数:12;NVMe SSD 数量:24

Linux 内核 io_uring NVMe 块设备配置:

echo 0 > /sys/block/nvme0n1/queue/iostat
echo 0 > /sys/block/nvme0n1/queue/rq_affinity
echo 2 > /sys/block/nvme0n1/queue/nomerges
echo -1 > /sys/block/nvme0n1/queue/io_poll_delay

fio 配置(公共部分):

[global]
direct=1
thread=1
time_based=1
norandommap=1
group_reporting=1

rw={randread | randwrite | randrw}
rwmixread={100 | 0 | 70}
bs=4096
runtime=240
ramp_time=60
numjobs=1

fio 配置(SPDK 专用部分):

[global] ioengine=spdk_bdev
spdk_conf=/tmp/bdev.conf

[filename0]
iodepth={2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}*
cpus_allowed=0
filename=Nvme0n1
filename=Nvme1n1

[filename1]
iodepth={2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}*
cpus_allowed=1
filename=Nvme2n1
filename=Nvme3n1
[…]

[filename11]
iodepth={2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}*
cpus_allowed=11
filename=Nvme20n1
filename=Nvme21n1

* —— 测试中实际使用的 iodepth 参数值;该值乘以作业节中 filename 对象的数量,以实现所需的每块 NVMe SSD 队列深度(例如,此处 QD=256 表示每块 SSD 的 QD=128)。

fio 配置(Linux 内核公共部分):

[global]
ioengine={libaio | io_uring}

[filename0]
iodepth={2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}*
cpus_allowed=0
filename=/dev/nvme0n1
filename=/dev/nvme1n1

[filename1]
iodepth={2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}*
cpus_allowed=1
filename=/dev/nvme2n1
filename=/dev/nvme3n1
[…]

[filename11]
iodepth={2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}*
cpus_allowed=11
filename=/dev/nvme20n1
filename=/dev/nvme21n1

* —— 测试中实际使用的 iodepth 参数值;该值乘以作业节中 filename 对象的数量,以实现所需的每块 NVMe SSD 队列深度(例如,此处 QD=256 表示每块 SSD 的 QD=128)。

fio 配置(Linux 内核 io_uring 专用部分):

[global]
fixedbufs=1
hipri=1
registerfiles=1
sqthread_poll=1

5.1 4KiB 随机读结果

表 13:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机读,24 块 NVMe SSD,12 个 CPU 核心)

QDSPDK IOPS(百万)SPDK 平均延迟(usec)Linux 内核(libaio)IOPS(百万)Linux 内核(libaio)平均延迟(usec)Linux 内核(io_uring 轮询)IOPS(百万)Linux 内核(io_uring 轮询)平均延迟(usec)
10.4158.170.4060.570.4059.50
20.8357.870.7960.460.8159.34
41.6557.931.5760.901.6059.74
83.2958.203.1061.853.1760.32
166.4958.855.7866.256.1062.75
3212.6460.396.56116.9610.7871.09
6423.7863.966.55234.3115.8496.85
12841.7072.246.55468.8918.94162.11
25652.27114.026.54938.9923.26264.07
51250.61238.706.581,867.1421.83562.79

图 17:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机读,24 块 NVMe SSD,12 个 CPU 核心)

图 17:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机读,24 块 NVMe SSD,12 个 CPU 核心)

图示说明:

  • 标题:IOPS 与平均延迟。
  • 副标题:4KiB 随机读,24 块 NVMe SSD,12 个 CPU 核心。
  • 纵轴:IOPS(百万),越高越好。
  • 横轴:平均延迟(µsec),越低越好。
  • 图例:SPDK Fio Bdev IOPS;Linux 内核(libaio);Linux 内核(io_uring 轮询)。
  • 数据点标注:QD=32、QD=64、QD=128、QD=256、QD=512;即对应的队列深度。

5.2 4KiB 随机写结果

表 14:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机写,24 块 NVMe SSD,12 个 CPU 核心)

QDSPDK IOPS(百万)SPDK 平均延迟(usec)Linux 内核(libaio)IOPS(百万)Linux 内核(libaio)平均延迟(usec)Linux 内核(io_uring 轮询)IOPS(百万)Linux 内核(io_uring 轮询)平均延迟(usec)
12.469.521.8312.992.1311.09
23.6312.983.4113.953.4413.76
48.6010.886.0615.666.8113.91
815.9011.536.4329.6811.0817.18
1625.0714.446.4459.4613.9827.36
3230.8823.396.44119.0616.3846.76
6433.0944.856.47237.2217.4887.76
12834.9885.946.45476.2318.42166.69
25636.99163.766.45952.5918.08340.00
51236.17323.396.321,944.0915.96769.84

图 18:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机写,24 块 NVMe SSD,12 个 CPU 核心)。

图 18:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 随机写,24 块 NVMe SSD,12 个 CPU 核心)。

图示说明:

  • 标题:IOPS 与平均延迟。
  • 副标题:4KiB 随机写,24 块 SSD,12 个 CPU 核心。
  • 纵轴:IOPS(百万),越高越好。
  • 横轴:平均延迟(usec),越低越好。
  • 图例:SPDK Fio Bdev IOPS;Linux 内核(libaio)IOPS;Linux 内核(io_uring 轮询)IOPS。
  • 数据点标注:QD=16、QD=32、QD=64、QD=128、QD=256;即对应的队列深度。

5.3 4KiB 随机 70%/30% 读/写结果

表 15:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 70/30 随机读/写,24 块 NVMe SSD,12 个 CPU 核心)

QDSPDK IOPS(百万)SPDK 平均延迟(usec)Linux 内核(libaio)IOPS(百万)Linux 内核(libaio)平均延迟(usec)Linux 内核(io_uring 轮询)IOPS(百万)Linux 内核(io_uring 轮询)平均延迟(usec)
10.5443.980.5246.420.5345.36
21.0644.961.0147.401.0346.26
42.0446.841.9349.721.9748.49
83.8349.853.4854.973.6452.57
167.0254.415.8265.786.2761.04
3212.2662.266.39119.969.0884.44
6419.2979.006.37240.8311.66131.54
12829.52102.916.36482.8414.65209.63
25637.36160.876.39961.7917.56349.88
51240.15301.006.381,925.5216.97724.06

图 19:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 70/30 随机读/写,24 块 NVMe SSD,12 个 CPU 核心)

图 19:队列深度增加时的性能;SPDK NVMe BDEV、Linux 默认 libaio 与 Linux io_uring 轮询对比(4KiB 70/30 随机读/写,24 块 NVMe SSD,12 个 CPU 核心)

图示说明:

  • 标题:IOPS 与平均延迟。
  • 副标题:4KiB 70/30 随机读/写,24 块 SSD,12 个 CPU。
  • 纵轴:IOPS(百万),越高越好。
  • 横轴:平均延迟(µsec),越低越好。
  • 图例:SPDK Fio Bdev IOPS;Linux 内核(libaio);Linux 内核(io_uring 轮询)。
  • 数据点标注:QD=32、QD=64、QD=128、QD=256、QD=512;即对应的队列深度。

5.4 结论

  1. 对于随机读工作负载,SPDK NVMe BDEV fio 插件在 QD=256 时达到最高约 5227 万 IOPS。这低于测试用例 2 中使用 bdevperf 测得的 5782 万 IOPS,因为这项基于 fio 的测试被限制为使用 12 个 CPU 核心。
  2. 对于 4 KiB 随机写工作负载,SPDK NVMe bdev fio 插件的 IOPS 在 QD 增加到 8 之前几乎呈线性扩展。超过该点之后,扩展变为非线性,并在 QD=256 时达到 3699 万 IOPS 的峰值。
    • i. Linux io_uring 的 IOPS 在 QD 增加到 8 之前也几乎呈线性扩展。超过该点之后,扩展变为非线性,并在 QD=128 时达到 1842 万 IOPS 的峰值;在此之后,随着队列深度进一步增加,性能开始下降。
    • ii. Linux libaio 的 IOPS 在 QD 增加到 4 之前几乎呈线性扩展,达到 606 万 IOPS。超过 QD=4 之后,收益很小,性能在 QD=64 时达到 647 万 IOPS 的峰值。
  3. 对于 4 KiB 70/30 随机读/写工作负载,SPDK NVMe bdev fio 插件在 QD=512 时达到最高 4015 万 IOPS。这低于测试用例 2 中使用 bdevperf 测得的约 5300 万 IOPS,而且该工作负载在所测试的队列深度范围内尚未达到峰值 IOPS。我们怀疑增加 I/O 核心可能会提高 IOPS。
  4. 随机写工作负载的结果超出了这 24 块 NVMe SSD 的能力(约 1060 万 IOPS),这可能是由不完善的预处理过程造成的,其影响会随时间推移逐渐消退。不过,这些结果是可重复的,仍然展示了 SPDK 随 I/O 请求增加而具备的高扩展性。
  5. Linux libaio 使用 12 个 CPU 核心达到最高约 650 万 IOPS,并未使平台的 NVMe 吞吐量饱和。随机读在 QD=32 时、随机写在 QD=8 时、70/30 随机读/写工作负载在 QD=32 时达到峰值性能。超过这些队列深度之后,IOPS 没有提高,但延迟增加了。
  6. Linux io_uring 的峰值性能为:随机读在 QD=256 时达到 2326 万 IOPS,随机写在 QD=128 时达到 1842 万 IOPS,70/30 随机读/写工作负载在 QD=256 时达到 1756 万 IOPS。测试期间,htop 显示 io_uring 总共使用了 24 个 CPU 核心:12 个用于 fio,12 个用于提交队列轮询。因此,我们测得 io_uring 的每核 IOPS 最高约为 97 万,而 SPDK NVMe bdev fio 插件的每核 IOPS 最高约为 436 万。《提交队列轮询》博客进一步介绍了 io_uring 如何在此模式下消除系统调用。

6. 总结

  1. 使用 SPDK bdevperf 基准测试工具的 SPDK NVMe BDEV 块层,在启用 Turbo Boost 的单个 AMD EPYC™ 9575F CPU 核心上,最多可提供 1180 万 IOPS。
  2. SPDK NVMe BDEV 的 IOPS 仅使用 6 个 CPU 核心就可扩展至 5009 万,使用 12 个 CPU 核心时最高可达 5782 万(启用 Turbo Boost 的 AMD EPYC™ 9575F CPU 核心)。
  3. 对于 4KiB 小块,SPDK NVMe BDEV 在 QD=1 时的延迟低于 Linux 内核 NVMe 块层。
    • a. 与 Linux libaio 相比,SPDK bdev 的随机读延迟最多低 3.63%,随机写延迟最多低 21.98%。
    • b. 与 Linux io_uring 相比,SPDK bdev 的随机读延迟约低 0.83%,随机写延迟约低 12.75%。
  4. SPDK NVMe BDEV Fio 在队列深度为 256、使用 12 个 CPU 核心时,最高达到 5227 万 IOPS,平均延迟约为 114 usec。在相同的 fio 工作负载下,Linux io_uring 实际使用 24 个核心(12 个 fio 线程加 12 个提交队列轮询线程)时,最高达到 2326 万 IOPS,而 Linux libaio 最高达到 658 万 IOPS。

7. SPDK 块设备层简介

7.1 SPDK 轮询模式驱动

NVMe PCIe 驱动通常是操作系统内核的一部分,应用程序通过系统调用与之交互。SPDK 采用了不同的方法:它将 NVMe 设备从内核 NVMe 驱动解绑,转而将其绑定到用户态 NVMe 驱动。这使用户态应用程序能够直接访问设备及其队列。

SPDK NVMe 驱动是一个可以直接链接到应用程序中的 C 库,用于与 NVMe SSD 之间进行直接、零拷贝的数据传输。它是完全被动的:不创建任何线程,仅在响应应用程序的函数调用时执行工作。该库通过将 PCI BAR 映射到本地进程并执行 MMIO 操作来控制 NVMe 设备。SPDK NVMe 驱动也是异步的。它将 I/O 请求作为一个 NVMe 提交队列条目提交,并在命令完成之前立即返回。随后,应用程序必须对每个具有未完成 I/O 的队列对轮询完成事件,才能接收到完成回调。

7.2 SPDK 块设备层

SPDK 还以用户态库的形式提供完整的块存储栈,执行许多与操作系统块存储栈相同的功能。SPDK 块设备层通常称为 bdev,是一个 C 库,旨在成为传统内核存储栈中位于设备驱动之上的块存储层的用户态等价实现。

bdev 模块提供了一个抽象层,为不同类型的块存储设备提供通用 API。应用程序可以使用这些 API 枚举并认领 SPDK 块设备,然后执行读、写和 unmap 等异步 I/O 操作,而无须知道底层设备是本地 NVMe SSD、Ceph RBD 设备,还是由 malloc 内存支持的 RAM 磁盘。SPDK NVMe bdev 模块既可以为本地 PCIe 连接的 NVMe 设备创建块设备,也可以为通过 NVMe-oF 导出的远程设备创建块设备。

在本报告中,我们对本地 PCIe 连接的 NVMe 设备所使用的 bdev 层的性能与效率进行了基准测试。我们还通过多种工作负载展示了 SPDK 方法的优势,包括用户态轮询、异步 I/O,以及减少上下文切换开销。

7.3 FIO 集成

SPDK 提供了一个 fio 插件,用于与 Flexible I/O 基准测试工具集成。为本地连接的 PCIe NVMe bdev 生成配置文件的最快方法,是使用 gen_nvme.sh 脚本及其 --json-with-subsystems 选项,如图 20 所示。

[user@localhost spdk]$ sudo scripts/gen_nvme.sh --json-withsubsystems | jq
{
  "subsystems": [
    {
      "subsystem": "bdev",
      "config": [
        {
          "method": "bdev_set_options",
          "params": {
            "bdev_io_pool_size": 65535,
            "bdev_io_cache_size": 2048,
            "bdev_auto_examine": true
          }
        },
        {
          "method": "bdev_nvme_attach_controller",
          "params": {
            "trtype": "PCIe",
            "name": "Nvme0",
            "traddr": "0000:1a:00.0"
          }
        },
        [...]
        {
          "method": "bdev_nvme_attach_controller",
          "params": {
            "trtype": "PCIe",
            "name": "Nvme23",
            "traddr": "0000:df:00.0"
          }
        }
      ]
    }
  ]

图 20:NVMe bdev 配置文件示例

通过设置 ioengine=spdk_bdev,并添加值指向 NVMe bdev 配置文件的 spdk_json_conf 参数,将 SPDK bdev 加入 fio 作业文件。

图 21 中的 fio 配置文件示例展示了如何定义多个 fio 作业,并为每个作业分配 NVMe bdev。每个作业还绑定到一个 CPU 核心,该核心与该作业将访问的 NVMe SSD 位于同一个 NUMA 节点上。

最后,要使用 bdev fio 插件,请在运行 fio 时指定 LD_PRELOAD。

LD_PRELOAD=<path to spdk repo>/build/fio/spdk_bdev fio <fio job file>

占位符说明:<path to spdk repo> 为“SPDK 仓库路径”;<fio job file> 为“fio 作业文件”。

[global]
direct=1
thread=1
time_based=1
norandommap=1
group_reporting=1
ioengine=spdk_bdev
spdk_json_conf=/tmp/bdev.conf
rw=randread
rwmixread=70
bs=4096
numjobs=1
runtime=300
ramp_time=60

[filename0]
iodepth=192
cpus_allowed=16
filename=Nvme0n1
filename=Nvme4n1
filename=Nvme8n1
filename=Nvme12n1
filename=Nvme16n1
filename=Nvme20n1

[filename1]
iodepth=192
cpus_allowed=32
filename=Nvme1n1
filename=Nvme5n1
filename=Nvme9n1
filename=Nvme13n1
filename=Nvme17n1
filename=Nvme21n1

[filename2]
iodepth=192
cpus_allowed=80
filename=Nvme2n1
filename=Nvme10n1
filename=Nvme11n1
filename=Nvme14n1
filename=Nvme18n1
filename=Nvme22n1

[filename3]
iodepth=192
cpus_allowed=112
filename=Nvme3n1
filename=Nvme7n1
filename=Nvme11n1
filename=Nvme15n1
filename=Nvme19n1
filename=Nvme23n1

图 21:SPDK Fio BDEV 配置文件示例

参考资料