fio 磁盘 I/O 压力测试入门指南

fio（Flexible I/O Tester）是 Linux 生态中最强大的磁盘 I/O 基准测试工具，由 Jens Axboe（Linux 内核 block 层维护者）开发。它不仅能模拟顺序读写、随机读写等典型负载，还支持数十种 I/O 引擎，可精确复现数据库、Web 服务器、消息队列等真实场景的磁盘行为。

本文是一份面向首次使用者的 fio 全面指南，从安装到实战报告解读，逐步深入。

安装

fio 在各大平台都有对应的安装方式。

Linux

各主流发行版的官方仓库均已收录 fio：

1
2
3
4
5
6
7
8
9

# Debian / Ubuntu
sudo apt install fio

# RHEL / CentOS / Fedora
sudo yum install fio       # RHEL 7
sudo dnf install fio       # RHEL 8+ / Fedora

# Arch Linux
sudo pacman -S fio

验证安装：

1
2

fio --version
# fio-3.36

macOS

1

brew install fio

Windows

Windows 版 fio 以预编译二进制形式发布。从 fio Releases 页面下载 fio-x.xx-x64.msi 安装包，双击安装后会自动加入 PATH。

1

fio --version

基本概念

在开始写 fio 命令之前，先理解几个磁盘 I/O 领域的核心概念——它们直接对应 fio 的参数。

顺序 vs 随机

块大小（Block Size）

一次 I/O 操作读/写的数据量，单位通常为 KB。顺序 I/O 用大块（如 1M），随机 I/O 用小块（如 4K）。

IOPS vs 吞吐量

这两个指标是磁盘性能的两面，关系为：吞吐量 = IOPS × 块大小。

随机 4K 场景下主要看 IOPS（块太小，吞吐量高不了），顺序 1M 场景下主要看吞吐量。

队列深度

操作系统同一时刻在 I/O 队列中等待处理的请求数。高队列深度模拟高并发场景。

在 fio 中由两个参数共同决定：

实际总 I/O 并发 = numjobs × iodepth。例如 --numjobs=4 --iodepth=32 表示同时最多有 128 个 I/O 请求在排队。

Direct I/O

默认情况下，Linux 的 I/O 会经过页面缓存（Page Cache），这导致测试可能是在测内存速度而非磁盘速度。--direct=1 绕过缓存，直接读写磁盘。

I/O 引擎

fio 支持多种与操作系统交互的 I/O 引擎，决定了如何将 I/O 请求下发到内核：

核心参数体系

fio 的参数分为几个大类，理解分类有助于快速找到需要的参数：

graph TD
    FIO[fio 命令] --> JOB[作业参数<br/>Job Parameters]
    FIO --> IO[I/O 参数<br/>I/O Parameters]
    FIO --> ENGINE[引擎参数<br/>Engine Parameters]
    FIO --> OUTPUT[输出参数<br/>Output Parameters]

    JOB --> J1["--name 作业名"]
    JOB --> J2["--filename 目标文件/设备"]
    JOB --> J3["--size 测试数据量"]
    JOB --> J4["--runtime 运行时长"]
    JOB --> J5["--numjobs 并发作业数"]
    JOB --> J6["--group_reporting 合并报告"]

    IO --> I1["--rw 读写模式"]
    IO --> I2["--bs 块大小"]
    IO --> I3["--iodepth 队列深度"]
    IO --> I4["--direct=1 绕过缓存"]

    ENGINE --> E1["--ioengine 引擎类型"]
    ENGINE --> E2["--sync=1 同步模式"]
    ENGINE --> E3["--fsync=1 每次写后强制刷盘"]

    OUTPUT --> O1["--output 写到文件"]
    OUTPUT --> O2["--output-format=json"]
    OUTPUT --> O3["--minimal 精简输出"]
    OUTPUT --> O4["--eta 显示进度"]

fio 命令的通用语法

1

fio [全局选项] [作业选项] --name=job1 [作业1选项] --name=job2 [作业2选项] ...

• --name 之前（或作业文件 [global] 节）的参数是全局参数，对所有作业生效
• --name=xxx 之后的参数仅对该作业生效
• 大多数参数既可以在命令行指定，也可以写在作业文件（Job File）中

第一个测试命令

从一个最简单的顺序读测试开始，逐参数理解每个选项的意义。

1

fio --name=seq-read --rw=read --bs=1m --size=1G --filename=/tmp/fio_test --direct=1 --numjobs=1 --iodepth=1

关于 --filename： 可以指定文件路径（fio 会自动创建），也可以指定裸块设备（如 /dev/sda）。操作块设备会破坏其上所有数据，务必小心。

运行示例输出

执行后，fio 会打印详细的测试统计。核心部分如下（数值为示例）：

1
2
3
4
5
6
7
8
9

seq-read: (g=0): rw=read, bs=(R) 1024KiB-1024KiB, (W) 1024KiB-1024KiB, (T) 1024KiB-1024KiB, ioengine=psync, iodepth=1
fio-3.36
Starting 1 process
...
seq-read: (groupid=0, jobs=1): err= 0: pid=12345: ...
  read: IOPS=210, BW=210MiB/s (220MB/s)(1024MiB/4876msec)
    ...
  cpu          : usr=0.50%, sys=2.31%, ctx=...
  ...

关键字段：BW=210MiB/s 表示吞吐量为 210 MiB/s，IOPS=210 表示每秒 210 个 I/O 操作（1M 块大小下，IOPS 与 MB/s 数值接近是正常的）。

常用测试模式

下面列出一组覆盖主流场景的 fio 命令，可直接复制使用（请将 /tmp/fio_test 替换为实际目标路径）。

顺序读写

顺序读写模拟大文件的连续传输，关注吞吐量指标。

顺序读：

1

fio --name=seq-read --rw=read --bs=1m --size=1G --filename=/tmp/fio_test --direct=1 --numjobs=1 --iodepth=1

顺序写：

1

fio --name=seq-write --rw=write --bs=1m --size=1G --filename=/tmp/fio_test --direct=1 --numjobs=1 --iodepth=1

随机读写

随机读写模拟数据库 OLTP、邮件服务器等场景，关注IOPS和延迟指标。

随机读（4K 块）：

1

fio --name=rand-read --rw=randread --bs=4k --size=1G --filename=/tmp/fio_test --direct=1 --numjobs=1 --iodepth=32

随机写（4K 块）：

1

fio --name=rand-write --rw=randwrite --bs=4k --size=1G --filename=/tmp/fio_test --direct=1 --numjobs=1 --iodepth=32

混合读写

--rw=randrw 表示同时进行随机读和随机写，通过 --rwmixread 控制读写比例。

70% 读 + 30% 写的混合随机负载：

1

fio --name=rand-mix --rw=randrw --rwmixread=70 --bs=4k --size=1G --filename=/tmp/fio_test --direct=1 --numjobs=4 --iodepth=32 --group_reporting

多作业并发

--numjobs 可以模拟多个进程同时读写不同文件或同一文件的不同区域：

1

fio --name=multi-job --rw=randread --bs=4k --size=1G --filename=/tmp/fio_test --direct=1 --numjobs=8 --iodepth=16 --group_reporting

此命令启动 8 个并发作业，每个 iodepth=16，总并发 I/O = 8 × 16 = 128。

按时间运行

--runtime 替代 --size 来指定运行时长，--time_based 让 fio 重复执行直到时间到：

1

fio --name=timed-test --rw=randread --bs=4k --size=1G --filename=/tmp/fio_test --direct=1 --numjobs=4 --iodepth=32 --runtime=60 --time_based --group_reporting

--time_based 不指定时，fio 完成 --size 的数据量后立刻退出。加上后，fio 会循环执行直到 --runtime 到期——这更适合长时间稳定性测试。

Job File 作业文件

当参数超过四五行时，命令行变得难以维护。fio 支持将所有参数写入 .fio 作业文件，可读性和复用性都更好。

基本语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

[global]
# 全局参数，对所有作业生效
ioengine=libaio
direct=1
size=1G
filename=/tmp/fio_test
group_reporting=1

[seq-read]
rw=read
bs=1m
numjobs=1
iodepth=1

[seq-write]
rw=write
bs=1m
numjobs=1
iodepth=1

[rand-read-4k]
rw=randread
bs=4k
numjobs=4
iodepth=32

[rand-write-4k]
rw=randwrite
bs=4k
numjobs=4
iodepth=32

保存为 benchmark.fio，执行：

1
2
3
4
5
6
7
8

# 运行所有作业
fio benchmark.fio

# 只运行指定作业
fio --section=rand-read-4k benchmark.fio

# 运行多个指定作业（逗号分隔）
fio --section=seq-read,rand-read-4k benchmark.fio

完整示例：通用磁盘基准测试

下面是一个可直接使用的完整作业文件，覆盖了磁盘评测的四项核心指标：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

; disk_bench.fio —— 磁盘综合基准测试

[global]
ioengine=libaio
direct=1
size=2G
filename=/tmp/fio_test
group_reporting=1

[seq-read-1m]
rw=read
bs=1m
numjobs=1
iodepth=1

[seq-write-1m]
rw=write
bs=1m
numjobs=1
iodepth=1

[rand-read-4k]
rw=randread
bs=4k
numjobs=4
iodepth=32

[rand-write-4k]
rw=randwrite
bs=4k
numjobs=4
iodepth=32

1
2

bs=4k
bs 4k

输出报告解读

fio 的输出报告非常详尽。以下逐段解释关键字段的含义。

基本信息区

1

seq-read: (g=0): rw=read, bs=(R) 1024KiB-1024KiB, (W) 1024KiB-1024KiB, (T) 1024KiB-1024KiB, ioengine=psync, iodepth=1

• g=0：该作业所属的组编号（对应 --group_reporting 的合并粒度）
• bs=(R)：实际使用的读块大小范围（最小值-最大值）
• ioengine=psync：使用的 I/O 引擎

核心指标区

1

read: IOPS=210, BW=210MiB/s (220MB/s)(1024MiB/4876msec)

延迟（Latency）区

这是判断磁盘响应速度的核心数据：

1
2
3

lat (usec): min=1234, max=56789, avg=2156.78, stdev=423.45
lat (msec): min=1, max=57, avg=2.16, stdev=0.42
clat (usec): min=1150, max=56123, avg=2080.12, stdev=410.23

一般关注 clat——它代表磁盘硬件本身处理 I/O 的耗时，去除了操作系统调度的影响。

百分位延迟

1
2
3
4
5
6

clat percentiles (usec):
 |  1.00th=[ 1400],  5.00th=[ 1556], 10.00th=[ 1608], 20.00th=[ 1720],
 | 30.00th=[ 1768], 40.00th=[ 1824], 50.00th=[ 1864], 60.00th=[ 1936],
 | 70.00th=[ 1992], 80.00th=[ 2096], 90.00th=[ 2280], 95.00th=[ 2544],
 | 99.00th=[ 4128], 99.50th=[ 5088], 99.90th=[ 8768], 99.95th=[11328],
 | 99.99th=[23680]

这是衡量磁盘服务质量的最重要指标：

JSON 输出

fio 支持将结果输出为 JSON 格式，方便自动化分析和绘图：

1
2

fio --name=test --rw=read --bs=1m --size=1G --filename=/tmp/fio_test --direct=1 \
    --output=result.json --output-format=json

解析示例（Python）：

1
2
3
4
5
6
7
8
9
10

import json

with open("result.json") as f:
    data = json.load(f)

for job in data["jobs"]:
    read = job["read"]
    print(f"IOPS: {read['iops']}, BW: {read['bw_bytes'] / 1024 / 1024:.1f} MiB/s")
    print(f"clat avg: {read['clat_ns']['mean'] / 1000:.1f} us")
    print(f"clat P99: {read['clat_ns']['percentile']['99.000000'] / 1000:.1f} us")

实战场景

场景一：SSD 性能评估

评估一块新 SSD 的理论性能天花板，使用大 iodepth 充分挖掘 SSD 的并行潜力：

1
2
3
4
5

# 顺序读/写 —— 测吞吐量上限
fio --name=seq-read --rw=read --bs=1m --size=2G --filename=/dev/nvme0n1 --direct=1 --numjobs=1 --iodepth=32

# 随机读/写 4K —— 测 IOPS 上限
fio --name=rand-read --rw=randread --bs=4k --size=2G --filename=/dev/nvme0n1 --direct=1 --numjobs=4 --iodepth=32 --group_reporting

严重警告： 对块设备（/dev/nvme0n1）执行 --rw=write 会永久擦除数据。评估写入性能时务必确认设备上没有需要的数据，或使用 --filename 指定一个普通文件。

场景二：NAS 网络存储测试

测试 NAS / SMB / NFS 挂载点的读写性能：

1
2
3
4

# 假设 NAS 已挂载到 /mnt/nas
fio --name=nas-seq-read --rw=read --bs=1m --size=1G --filename=/mnt/nas/fio_test --direct=1 --numjobs=1 --iodepth=32

fio --name=nas-rand-read --rw=randread --bs=4k --size=1G --filename=/mnt/nas/fio_test --direct=1 --numjobs=8 --iodepth=32 --group_reporting

网络存储的性能还受网络延迟影响，可以对比不同 numjobs 和 iodepth 组合下的变化趋势。

场景三：模拟数据库 OLTP 负载

数据库典型的 I/O 模式：随机 8K 读写混合 + 高 iodepth + 数据持久化（fsync）。

MySQL / PostgreSQL 类 OLTP 写负载模拟：

1
2
3
4
5
6
7
8
9
10
11
12

[oltp-write]
rw=randrw
bs=8k
rwmixread=0
size=2G
filename=/tmp/fio_db_test
ioengine=libaio
direct=1
iodepth=32
numjobs=4
fsync=1
group_reporting=1

fsync=1 会显著降低性能，但也更贴近真实数据库写入场景。如果去掉 fsync=1，测出的写入速度可能偏高 10~100 倍，但对数据库性能评估没有参考价值。

场景四：对比启用/禁用缓存

快速验证 Direct I/O 和缓冲 I/O 的差异：

1
2
3
4
5

# 带缓存（默认）
fio --name=cached --rw=randread --bs=4k --size=512M --filename=/tmp/fio_test --numjobs=4 --iodepth=32 --group_reporting

# 直接 I/O（绕过缓存）
fio --name=direct --rw=randread --bs=4k --size=512M --filename=/tmp/fio_test --direct=1 --numjobs=4 --iodepth=32 --group_reporting

通常带缓存的 IOPS 会高出几个数量级——这就是为什么性能测试务必使用 --direct=1。

参数速查表

总结

fio 的学习路径可以概括为：

1. 用最简单的 --rw=read --bs=1m --size=1G 跑一次，看懂输出
2. 加入 --direct=1，理解缓存对测试结果的影响
3. 引入 --iodepth 和 --numjobs，理解并发对 IOPS 的提升
4. 使用 Job File 管理复杂测试组合，避免命令行过长
5. 关注 clat 和百分位延迟，而非只看平均延迟

参考链接

• fio GitHub 仓库
• fio 官方文档（How-To）
• fio man page
• Linux I/O Stack 图解