stress-ng 与 fio 性能测试工具使用指南

说明：系统稳定性压测与存储 I/O 基准测试完整参考手册

1、stress-ng 简介

stress-ng 是一款功能强大的系统压力测试工具，用于对 CPU、内存、I/O、内核接口等系统组件进行全方位压力测试，旨在暴露硬件故障、散热问题和内核 Bug。它包含 300 多种压力测试项（stressor），支持精确控制负载类型、工作线程数量和持续时间。

2、安装方法

各发行版安装

bash 复制代码

# Debian / Ubuntu / Linux Mint
sudo apt update && sudo apt install stress-ng

# Fedora / RHEL / CentOS / AlmaLinux
sudo dnf install stress-ng

# Arch / Manjaro / CachyOS
sudo pacman -Syu stress-ng

# 从源码编译（获取最新版本）
git clone https://github.com/ColinIanKing/stress-ng.git
cd stress-ng
make
sudo make install

验证安装

bash 复制代码

stress-ng --version
# 列出所有可用压力测试项
stress-ng --stressors

3、核心概念

stress-ng 的基本语法结构为：

bash 复制代码

stress-ng --<stressor> <num_workers> --timeout <duration> [其他选项]

概念	说明	示例
`stressor`	压力测试项，每个对应一种系统资源的压测方式	`--cpu`, `--vm`, `--hdd`, `--sock`
`workers 数量`	指定并发工作线程数；`0` 表示使用所有 CPU 核心	`--cpu 4` 启动 4 个 CPU 压力线程
`timeout`	测试持续时间，支持 s/m/h 单位	`--timeout 60s`, `-t 5m`
`class`	按类别批量运行一组 stressor	`--class cpu --seq 1`
`verify`	启用正确性校验，确保结果可复现（会降低性能）	`--verify`

4、常用参数速查

参数	说明	示例
`--cpu N`	CPU 计算压力，N 为工作线程数（0=所有核心）	`--cpu 0`
`--cpu-load P`	指定 CPU 负载百分比（需配合 --cpu）	`--cpu-load 80`
`--vm N`	虚拟内存压力测试	`--vm 2`
`--vm-bytes S`	每个 VM worker 分配的内存量（支持 % 和 G/M/K）	`--vm-bytes 4G`
`--vm-keep`	保持内存分配不释放（持续占用）	`--vm-keep`
`--hdd N`	磁盘 I/O 压力（写临时文件）	`--hdd 4`
`--hdd-bytes S`	每个磁盘 worker 写入的数据量	`--hdd-bytes 10G`
`--hdd-opts O`	磁盘 I/O 模式选项	`--hdd-opts direct`
`--io N`	I/O 系统调用压力（write/read 循环）	`--io 2`
`--sock N`	TCP 套接字压力	`--sock 4`
`--udp N`	UDP 数据包压力	`--udp 4`
`--matrix N`	浮点矩阵运算压力	`--matrix 4`
`--stream N`	内存带宽压力测试（copy/scale/add/triad）	`--stream 1`
`--timeout T`	运行时长（s/m/h）	`--timeout 60s`
`-t T`	--timeout 的简写	`-t 5m`
`--metrics-brief`	结束时输出简要统计信息	`--metrics-brief`
`--metrics`	输出详细统计信息	`--metrics`
`--verify`	对支持校验的 stressor 启用结果验证	`--verify`
`--class C`	按类别运行（cpu/vm/io/os/network/filesystem/all）	`--class cpu`
`--seq N`	顺序运行指定 class 中的所有 stressor	`--seq 1`
`--stressors`	列出所有可用 stressor	`--stressors`
`--pathological`	启用可能导致系统挂起的极端测试	`--pathological`

5、实战示例

5.1 CPU 压力测试

bash 复制代码

# 8 个 CPU 工作线程，运行 60 秒
stress-ng --cpu 8 --timeout 60s --metrics-brief

# 所有核心 100% CPU 负载，持续 5 分钟
stress-ng --cpu 0 --cpu-load 100 --timeout 5m --metrics-brief

# 浮点矩阵运算压力测试
stress-ng --matrix 0 --timeout 60s --metrics-brief

# 指定 80% CPU 负载（非全负载）
stress-ng --cpu 0 --cpu-load 80 --timeout 2m --metrics-brief

5.2 内存压力测试

bash 复制代码

# 分配 4GB 内存进行压力测试，持续 5 分钟
stress-ng --vm 2 --vm-bytes 4G --vm-keep --timeout 5m --metrics-brief

# 在所有核心上分配 80% 的系统内存
stress-ng --vm 0 --vm-bytes 80% --timeout 2m --metrics-brief

# 内存带宽压力测试（Stream 风格）
stress-ng --stream 1 --timeout 60s --metrics-brief

# 页面换入测试（模拟内存不足场景）
stress-ng --vm 2 --vm-bytes 2G --mmap 2 --mmap-bytes 2G --page-in --timeout 60s

5.3 磁盘 I/O 压力测试

bash 复制代码

# 4 个磁盘 worker 顺序写 10GB 文件
stress-ng --hdd 4 --hdd-bytes 10G --timeout 600s --metrics-brief

# 随机写 + 直接 I/O（绕过页缓存）
stress-ng --hdd 4 --hdd-opts direct --timeout 120s --metrics-brief

# 文件系统 I/O 综合（读写 + 创建/删除文件）
cd /tmp  # 确保有 50GB 以上可用空间
stress-ng --class filesystem --seq 1 --timeout 10m --metrics-brief

5.4 网络与 OS 压力测试

bash 复制代码

# TCP + UDP 套接字压力测试（10 分钟）
sudo stress-ng --sock 4 --udp 4 --timeout 10m --metrics-brief

# 进程调度与上下文切换压力
stress-ng --class os --seq 1 --timeout 10m --metrics-brief

# IPC 通信压力（管道 + 消息队列 + 信号量）
stress-ng --pipe 8 --msg 4 --sem 4 --timeout 10m --metrics-brief

# CPU 缓存压力测试（L1/L2/LLC）
stress-ng --cache 0 --l1cache 0 --llc-cache 0 --timeout 10m --metrics-brief

5.5 综合压力测试

bash 复制代码

# CPU + 内存 + I/O 组合压力测试
stress-ng --cpu 4 --vm 2 --io 2 --timeout 2m --metrics-brief

# 全系统综合压力测试（30 分钟，需密切监控温度）
sudo stress-ng --class all --seq 1 --timeout 30m --metrics-brief

# CPU + 内存 + I/O 分类别顺序运行（每个 30 秒）
stress-ng --class cpu --class vm --class io --seq 1 --timeout 30s --metrics-brief

# 新硬件验收完整流程
# 步骤1: 基础 CPU 功能
stress-ng --cpu 1 --timeout 30s --metrics-brief
# 步骤2: 内存稳定性
stress-ng --vm 2 --vm-bytes 4G --timeout 300s --metrics-brief
# 步骤3: 磁盘耐久性
stress-ng --hdd 4 --hdd-bytes 10G --timeout 600s --metrics-brief

6、压力测试分类速查

类别 (class)	常用 stressor	典型场景
`cpu`	`--cpu`, `--matrix`, `--bitops`, `--crc32`, `--zlib`	CPU 稳定性、散热验证
`vm` / 内存	`--vm`, `--bigheap`, `--brk`, `--mmap`, `--stack`, `--stream`	内存稳定性、带宽测试
`io` / 文件系统	`--hdd`, `--aio`, `--dir`, `--dentry`, `--lockf`	磁盘耐久性、文件系统压力
`os` / 调度	`--switch`, `--yield`, `--futex`, `--timer`, `--signal`, `--pipe`, `--affinity`	调度器压力、上下文切换
`network`	`--sock`, `--udp`, `--tcp`, `--dccp`	网络栈稳定性
`all`	所有 class 的 stressor	全面系统压力测试

查看各类别下具体有哪些 stressor：

bash 复制代码

# 列出所有 stressor
stress-ng --stressors

# 查看 CPU 相关 stressor
stress-ng --class cpu?

# 查看内存相关 stressor
stress-ng --class vm?

# 查看支持 verify 校验的 stressor
stress-ng --verifiable

7、最佳实践与注意事项

危险警告

stress-ng 可能使系统达到极限状态，长时间高负载运行可能导致硬件损坏（尤其是散热不足时）。务必在运行测试时监控温度、电压和系统稳定性。

运行时监控

强烈建议在运行 stress-ng 时同时使用以下工具进行监控：

bash 复制代码

# 实时监控 CPU/内存/进程（终端1）
htop

# 实时监控温度传感器（终端2）
watch -n 1 sensors

# 实时监控内核日志（终端3）
sudo dmesg -w

# 或使用 GUI 工具
hardinfo          # 系统信息与基准测试 GUI
gnome-system-monitor  # GNOME 系统监视器

实用技巧

先用短时间测试（如 30 秒）验证命令正确性，再延长运行时间。

使用 --metrics-brief 获取测试结束后的统计摘要。

使用 --verify 对支持校验的 stressor 进行结果验证，适用于硬件验收。

磁盘测试前确保有足够的磁盘空间（建议 >50GB）。

在 /tmp 或专用目录下运行磁盘测试，避免影响系统分区。

8、fio 简介

fio（Flexible I/O Tester）是由 Jens Axboe 开发的专业 I/O 基准测试工具，能够精确模拟各种 I/O 负载模式。它支持多种 I/O 引擎、灵活的负载参数配置，是评估存储设备性能的事实标准。与 stress-ng 的"压力测试"定位不同，fio 更专注于精确测量 I/O 性能指标（吞吐量、IOPS、延迟）。

9、安装方法

bash 复制代码

# Ubuntu / Debian
sudo apt-get update && sudo apt-get install fio

# CentOS / RHEL
sudo yum install fio

# Fedora
sudo dnf install fio

# Arch Linux
sudo pacman -S fio

# 从源码编译（获取最新版本）
git clone https://github.com/axboe/fio.git
cd fio
./configure
make
sudo make install

# Windows: 从 GitHub Releases 下载 MSI 安装包
# https://github.com/axboe/fio/releases

验证安装

bash 复制代码

fio --version
# 查看可用的 I/O 引擎
fio --enghelp

libaio 依赖

在 Linux 上若要使用 libaio I/O 引擎（最常用的异步 I/O 引擎），需安装 libaio 开发包：sudo apt install libaio-dev（Debian/Ubuntu）或 sudo dnf install libaio-devel（RHEL/Fedora）。

10、核心概念

fio 的工作方式是：用户编写一个 Job 文件描述 I/O 负载，fio 解析后按照配置生成线程/进程执行 I/O 操作。一个 Job 从上到下包含以下基本维度：

维度	说明	关键参数
I/O 类型	读写模式：顺序/随机、读/写/混合	`rw`, `readwrite`
块大小	每次 I/O 操作的数据块大小	`bs`, `blocksize`
I/O 总量	测试读写的数据总量	`size`
I/O 引擎	底层 I/O 提交方式	`ioengine`
队列深度	异步 I/O 的并发队列深度	`iodepth`
目标文件/设备	测试的目标文件路径或裸设备	`filename`
并发数	同时运行的线程/进程数	`numjobs`
运行时长	测试持续时间	`runtime`, `time_based`

11、关键参数详解

11.1 I/O 模式参数（rw）

参数值	说明
`read`	顺序读
`write`	顺序写
`randread`	随机读
`randwrite`	随机写
`rw`	混合顺序读写（默认 50/50）
`randrw`	混合随机读写（默认 50/50）
`trim` / `randtrim`	TRIM 操作（SSD）

11.2 I/O 引擎参数（ioengine）

引擎	说明	适用场景
`sync`	同步 read/write	基本测试、兼容性好
`libaio`	Linux 异步 I/O（AIO）	最常用，配合 direct=1 测裸性能
`io_uring`	Linux 新一代异步 I/O	内核 5.1+，性能更优
`mmap`	内存映射文件	模拟内存映射 I/O 场景
`splice`	Linux splice 系统调用	零拷贝 I/O 测试
`posixaio`	POSIX 异步 I/O	跨平台兼容
`sg`	SCSI Generic	直接对块设备发 SCSI 命令
`psync`	预注册同步 I/O	减少文件描述符开销

11.3 其他常用参数

参数	说明	示例
`bs`	块大小（单次 I/O 数据量）	`bs=4k`, `bs=128k`
`bsrange`	块大小范围（随机取值）	`bsrange=4k-64k`
`size`	测试文件总大小	`size=1G`, `size=10G`
`direct`	是否绕过页缓存（O_DIRECT）	`direct=1`（推荐）
`iodepth`	异步 I/O 队列深度	`iodepth=32`
`numjobs`	并发工作线程数	`numjobs=4`
`runtime`	测试运行时长（秒）	`runtime=60`
`time_based`	按时间运行（而非按数据量）	`time_based`
`group_reporting`	按组汇总输出结果	`group_reporting`
`rwmixread`	混合读占比（%）	`rwmixread=70`（70% 读）
`filename`	目标文件/设备路径	`filename=/dev/sdb`
`name`	Job 名称标识	`name=randwrite`
`stonewall`	Job 之间顺序执行（屏障）	`stonewall`
`offset`	测试起始偏移量	`offset=100M`
`loops`	重复运行次数	`loops=5`
`verify`	写入后验证数据完整性	`verify=crc32c`
`output-format`	输出格式	`output-format=json`

12、命令行示例

12.1 基本测试命令

bash 复制代码

# 随机写测试（4K 块大小，1GB 文件，libaio 引擎，绕过缓存）
fio --name=randwrite \
    --filename=/tmp/testfile \
    --size=1G \
    --bs=4k \
    --rw=randwrite \
    --ioengine=libaio \
    --iodepth=32 \
    --direct=1 \
    --runtime=60 \
    --time_based \
    --group_reporting

# 随机读测试（4K 块，测 IOPS）
fio --name=randread \
    --filename=/tmp/testfile \
    --size=1G \
    --bs=4k \
    --rw=randread \
    --ioengine=libaio \
    --iodepth=32 \
    --direct=1 \
    --runtime=60 \
    --time_based

# 顺序写测试（128K 块，测吞吐量）
fio --name=seqwrite \
    --filename=/tmp/testfile \
    --size=1G \
    --bs=128k \
    --rw=write \
    --ioengine=libaio \
    --iodepth=32 \
    --direct=1

# 顺序读测试（128K 块，测吞吐量）
fio --name=seqread \
    --filename=/tmp/testfile \
    --size=1G \
    --bs=128k \
    --rw=read \
    --ioengine=libaio \
    --iodepth=32 \
    --direct=1

12.2 混合读写测试

bash 复制代码

fio --name=mixed_rw \
    --filename=/tmp/testfile \
    --size=1G \
    --bs=4k \
    --rw=randrw \
    --rwmixread=70 \
    --ioengine=libaio \
    --iodepth=32 \
    --direct=1 \
    --numjobs=4 \
    --runtime=120 \
    --time_based \
    --group_reporting

12.3 裸设备测试

危险操作

对裸设备（如 /dev/sdb）进行写测试会破坏设备上的所有数据！确保选择了正确的设备，并已备份重要数据。

bash 复制代码

# 随机读 IOPS 测试（裸设备）
sudo fio --name=dev_randread \
    --filename=/dev/nvme0n1 \
    --bs=4k \
    --rw=randread \
    --ioengine=libaio \
    --iodepth=32 \
    --direct=1 \
    --numjobs=4 \
    --runtime=60 \
    --time_based \
    --group_reporting \
    --readonly

# 顺序写吞吐量测试（裸设备，会覆盖数据！）
sudo fio --name=dev_seqwrite \
    --filename=/dev/nvme0n1 \
    --bs=128k \
    --rw=write \
    --ioengine=libaio \
    --iodepth=32 \
    --direct=1 \
    --runtime=60 \
    --time_based \
    --group_reporting

13、Job 文件示例

对于复杂的多场景测试，使用 Job 文件是最佳方式。Job 文件使用 INI 风格语法，支持全局参数继承和多个 Job 段定义。

13.1 完整 SSD 评估 Job 文件

html 复制代码

; 全局参数（所有 job 段继承）
[global]
ioengine=libaio
iodepth=32
direct=1
group_reporting
time_based
runtime=60
; 测试文件路径
filename=/tmp/fio_testfile
; 测试文件大小（建议 > 系统内存以减少缓存影响）
size=10G

; 1. 4K 随机读（测 IOPS）
[randread-4k]
rw=randread
bs=4k
numjobs=4

; 2. 4K 随机写（测写入 IOPS）
[randwrite-4k]
stonewall
rw=randwrite
bs=4k
numjobs=4

; 3. 128K 顺序读（测读取带宽）
[seqread-128k]
stonewall
rw=read
bs=128k
numjobs=1

; 4. 128K 顺序写（测写入带宽）
[seqwrite-128k]
stonewall
rw=write
bs=128k
numjobs=1

; 5. 混合随机读写 70/30（模拟数据库负载）
[mixed-randrw]
stonewall
rw=randrw
rwmixread=70
bs=4k
numjobs=4

bash 复制代码

# 运行 job 文件
fio ssd_bench.fio

# 只查看命令（不执行）
fio --showcmd ssd_bench.fio

# 以 JSON 格式输出结果（便于脚本解析）
fio --output-format=json ssd_bench.fio

# 将结果输出到文件
fio --output=result.txt ssd_bench.fio

13.2 NVMe 企业级测试 Job 文件

html 复制代码

[global]
ioengine=io_uring
direct=1
time_based
runtime=120
group_reporting
; 裸设备路径（谨慎！）
filename=/dev/nvme0n1
size=100%

; 随机读 IOPS（高队列深度，多线程）
[randread-iops]
rw=randread
bs=4k
iodepth=128
numjobs=16

; 随机写 IOPS
[randwrite-iops]
stonewall
rw=randwrite
bs=4k
iodepth=128
numjobs=16

; 带宽测试（大块顺序读写）
[seqread-bw]
stonewall
rw=read
bs=1M
iodepth=32
numjobs=4

; 延迟测试（低队列深度，单线程）
[randread-latency]
stonewall
rw=randread
bs=4k
iodepth=1
numjobs=1

13.3 数据库负载模拟

html 复制代码

[global]
ioengine=libaio
direct=1
time_based
runtime=300
group_reporting
filename=/data/mysql/testfile
size=20G

; 模拟 OLTP 随机读写（8K 块，混合读写）
[oltp-workload]
rw=randrw
rwmixread=75
bs=8k
iodepth=16
numjobs=8

; 模拟日志写入（顺序写，64K 块）
[wal-write]
stonewall
rw=write
bs=64k
iodepth=1
numjobs=1

14、输出结果解读

fio 运行结束后会输出详细的性能报告，以下是关键字段解读：

bash 复制代码

randwrite-4k: (groupid=0, jobs=4): err= 0: pid=12345: Thu Sep  3 10:00:00 2026
  write: IOPS=152.3k, BW=594.9MiB/s (624.0MB/s)(34.5GiB/60003msec)
  slat (usec):  min=2, avg=4.15, max=8934
  clat (usec):  min=10, avg=817.34, max=524288
     lat (usec):  min=13, avg=822.65, max=524295

  lat (usec) :
    2.00th percentile: [  500]
   50.00th percentile: [  780]
   95.00th percentile: [ 1600]
   99.00th percentile: [ 3200]
   99.90th percentile: [ 8000]

  CPU utilization: usr=0.12%, sys=15.78%, ctx=9823401

指标	含义	关注点
`IOPS`	每秒 I/O 操作数	随机小块测试的核心指标
`BW`	带宽（吞吐量）	顺序大块测试的核心指标
`slat`	提交延迟（submission latency）	I/O 提交到内核的耗时
`clat`	完成延迟（completion latency）	内核完成 I/O 的耗时
`lat`	总延迟（slat + clat）	端到端 I/O 延迟
`50th / 95th / 99th`	延迟百分位数	P99 延迟反映尾延迟，对延迟敏感型负载重要
`usr / sys`	CPU 用户态/内核态利用率	sys 过高可能表明 I/O 路径开销大

输出格式技巧

使用 --output-format=json 获取机器可读的 JSON 结果，便于在脚本中解析和对比多次测试结果。使用 --minimal 获取简洁的分号分隔格式，适合 CSV 导入。

15、stress-ng 与 fio 对比

对比维度	stress-ng	fio
核心定位	系统稳定性压力测试	存储 I/O 性能基准测试
主要目标	暴露硬件故障、散热问题、内核 Bug	精确测量吞吐量、IOPS、延迟
测试范围	CPU、内存、磁盘、网络、OS（300+ stressor）	专注存储 I/O（文件系统/裸设备）
配置方式	命令行参数为主	Job 文件为主，命令行可选
输出指标	bogo ops/s（压力测试统计）	IOPS、BW、延迟分布（精确性能数据）
适用场景	新硬件验收、稳定性测试、散热验证	存储选型、性能调优、容量规划
平台	Linux（主要）	Linux、Windows、FreeBSD、Solaris 等

16、组合使用场景

场景一：新服务器硬件验收

bash 复制代码

# 第一步：CPU 稳定性（24 小时烤机）
stress-ng --cpu 0 --timeout 24h --metrics-brief

# 第二步：内存稳定性（12 小时）
stress-ng --vm 0 --vm-bytes 90% --vm-keep --timeout 12h --metrics-brief

# 第三步：全系统综合压力（6 小时）
sudo stress-ng --class all --seq 1 --timeout 6h --metrics-brief

# 第四步：存储基准性能
fio --name=ssd_bench \
    --filename=/dev/nvme0n1 \
    --bs=4k \
    --rw=randread \
    --ioengine=libaio \
    --iodepth=32 \
    --direct=1 \
    --numjobs=4 \
    --runtime=300 \
    --time_based \
    --group_reporting \
    --readonly

场景二：存储性能对比

bash 复制代码

# 测试 SSD（随机 4K 读 IOPS）
fio --name=ssd_test \
    --filename=/dev/sdb \
    --bs=4k --rw=randread \
    --ioengine=libaio --iodepth=32 --direct=1 \
    --numjobs=4 --runtime=60 --time_based \
    --group_reporting --readonly --output=ssd_result.json \
    --output-format=json

# 测试 NVMe（同样参数）
fio --name=nvme_test \
    --filename=/dev/nvme0n1 \
    --bs=4k --rw=randread \
    --ioengine=libaio --iodepth=32 --direct=1 \
    --numjobs=4 --runtime=60 --time_based \
    --group_reporting --readonly --output=nvme_result.json \
    --output-format=json

# 比较两个 JSON 结果中的 IOPS 和延迟

场景三：系统负载下存储性能

bash 复制代码

# 终端1: 用 stress-ng 制造 CPU + 内存负载
stress-ng --cpu 4 --vm 2 --vm-bytes 4G --vm-keep --timeout 300s --metrics-brief &

# 终端2: 同时运行 fio 测存储性能
fio --name=under_load \
    --filename=/tmp/fio_test \
    --size=1G \
    --bs=4k --rw=randrw \
    --ioengine=libaio --iodepth=32 --direct=1 \
    --numjobs=2 --runtime=240 --time_based \
    --group_reporting

# 对比无负载时的 fio 结果，分析负载对 I/O 性能的影响

参考文档

stress-ng 官方文档：man stress-ng 或访问 GitHub 仓库

fio 官方文档：man fio 或访问 fio 文档站