linux系统上做性能压力测试 —— 筑梦之路

这里主要使用stress 和 stress-ng。

简介

stress

1. 在常用的发行版操作系统上安装

sudo apt install stress         [on debian, ubuntu and mint]
sudo yum install stress         [on rhel/centos/fedora and rocky/almalinux]
sudo emerge -a sys-apps/stress  [on gentoo linux]
sudo apk add stress             [on alpine linux]
sudo pacman -s stress           [on arch linux]
sudo zypper install stress      [on opensuse]    
sudo pkg install stress         [on freebsd]

2. 帮助信息

stress --help
--------------------------------------------------------------------------------
`stress' imposes certain types of compute stress on your system

usage: stress [option [arg]] ...
 -?, --help         show this help statement
     --version      show version statement
 -v, --verbose      be verbose
 -q, --quiet        be quiet
 -n, --dry-run      show what would have been done
 -t, --timeout n    timeout after n seconds
     --backoff n    wait factor of n microseconds before work starts
 -c, --cpu n        spawn n workers spinning on sqrt()
 -i, --io n         spawn n workers spinning on sync()
 -m, --vm n         spawn n workers spinning on malloc()/free()
     --vm-bytes b   malloc b bytes per vm worker (default is 256mb)
     --vm-stride b  touch a byte every b bytes (default is 4096)
     --vm-hang n    sleep n secs before free (default none, 0 is inf)
     --vm-keep      redirty memory instead of freeing and reallocating
 -d, --hdd n        spawn n workers spinning on write()/unlink()
     --hdd-bytes b  write b bytes per hdd worker (default is 1gb)

example: stress --cpu 8 --io 4 --vm 2 --vm-bytes 128m --timeout 10s

note: numbers may be suffixed with s,m,h,d,y (time) or b,k,m,g (size).
对应介绍：

-c, --cpu n： 产生 n 个进程，每个进程都反复不停的计算随机数的平方根;

-i, --io n： 产生 n 个进程，每个进程反复调用 sync() 将内存上的内容写到硬盘上;

-m, --vm n： 产生 n 个进程，每个进程不断分配和释放内存;

--vm-bytes b： 指定分配内存的大小;

--vm-stride b： 不断的给部分内存赋值，让 cow(copy on write)发生;

--vm-hang n： 指示每个消耗内存的进程在分配到内存后转入睡眠状态 n 秒，然后释放内存，一直重复执行这个过程;

--vm-keep： 一直占用内存，区别于不断的释放和重新分配(默认是不断释放并重新分配内存);

-d, --hadd n： 产生 n 个不断执行 write 和 unlink 函数的进程(创建文件，写入内容，删除文件);

--hadd-bytes b： 指定文件大小;

-t, --timeout n： 在 n 秒后结束程序;

--backoff n： 等待n微妙后开始运行;

-q, --quiet： 程序在运行的过程中不输出信息;

-n, --dry-run： 输出程序会做什么而并不实际执行相关的操作;

--version： 显示版本号;

-v, --verbose： 显示详细的信息

3. 使用示例

# cpu压测

stress --cpu 8 --timeout 20

stress 消耗 cpu 资源是通过调用 sqrt() 函数（计算由 rand() 函数产生的随机数的平方根）实现。命令会产生 8 个这样的子进程不断计算，超时时间为20秒，结束后再次运行 uptime 比较平均负载

使用 top 命令查看 cpu 的状态(cpu 在用户态满负荷运转)

stress --cpu 8 -v --timeout 30s

启动 8 个 sqrt() 子进程，超时时间 30s，同时显示有关操作的详细信息

# 内存压测

stress --vm 8 --timeout 20s

产生 8 个子进程，超时时间 20s，每个进程不断分配和释放内存

stress --vm 2 --vm-bytes 2048m --vm-keep --timeout 20s

产生 2 个子进程，每个进程分配 2048m 内存

#################

–vm-keep & –vm-hang n

–vm-keep：一直占用内存，区别于不断的释放和重新分配(默认是不断释放并重新分配内存)；

–vm-hang n：指示每个消耗内存的进程在分配到内存后转入睡眠状态 n 秒，然后释放内存，一直重复执行这个过程；

–vm-keep 和 --vm-hang 都可以用来模拟只有少量内存的机器，但是指定它们时 cpu 的使用情况是不一样的

## stress --vm 2 --vm-bytes 2048m --vm-keep --timeout 20s

--vm-keep：cpu 负载高

一直在进行默认的 stride 操作，cpu user 非常高(cpu 在用户态忙碌)

## stress --vm 2 --vm-bytes 2048m --vm-hang 5 --timeout 20s

-vm-hang n：cpu 负载不高

#############

–vm-stride b

不断的给部分内存赋值，让 cow(copy on write)发生，只要指定了内存相关的选项，这个操作就会执行，默认大小为的 4096m，赋值内存的比例由参数决定

for (i = 0; i < bytes; i += stride)
    ptr[i] = ‘z’; /* ensure that cow happens. */

bytes 为消耗的总内存大小，stride 为间隔。该参数会影响 cpu：us 和 sy


单独的赋值和对比操作可以让 cpu 在用户态的负载占到 99% 以上。–vm-stride 值增大就意味着减少赋值和对比操作，这样就增加了内存的释放和分配次数(cpu在内核空间的负载)。

不指定 --vm-stride 选项就使用默认值是 4096

stress --vm 2 --vm-bytes 500m --vm-stride 64m --timeout 20s

stress --vm 2 --vm-bytes 500m --vm-stride 1024m --timeout 20s


# io压测

stress -i 8 --timeout 20s

产生 8 个进程，每个进程都反复调用 sync() 函数将内存上的内容写到硬盘上

使用 top 命令查看 cpu 的状态，sy 升高，wa(iowait) 非常高


# 磁盘压测和io

stress -d 1 --hdd-bytes 10m --timeout 20s

产生 1 个进程不断的在磁盘上创建 10m 大小的文件并写入内容

使用 top 命令查看 cpu 的状态(此时的 cpu 主要消耗在内核态)，iostat 2 输出，高 iowait，瓶颈是写磁盘


执行多个类型的任务，比如产生 4 个 cpu 进程、3 个 io 进程、2 个 256m 的 vm 进程，并且每个 vm 进程中循环分配释放内存：

stress --cpu 4 --io 3 --vm 2 --vm-bytes 256m --vm-keep --timeout 20s

stress-ng

stress-ng 完全兼容 stress, 并且在此基础上通过几百个参数，可以产生各种复杂的压力

1. 安装

sudo apt install stress-ng         [on debian, ubuntu and mint]
sudo yum install stress-ng         [on rhel/centos/fedora and rocky/almalinux]
sudo emerge -a sys-apps/stress-ng  [on gentoo linux]
sudo apk add stress-ng             [on alpine linux]
sudo pacman -s stress-ng           [on arch linux]
sudo zypper install stress-ng      [on opensuse]    
sudo pkg install stress-ng         [on freebsd]

2. 常用参数选项

-h，--help：显示帮助信息;

--version：显示版本信息；

-t,–timeout：指定程序运行结束的时间，后面直接跟数字，单位为秒；

-c,–-cpu：后面空格跟一个整数，表示测试cpu的进程数,--cpu 4 :表示生成4个worker循环调用sqrt()产生cpu压力;

-i,--io：后面空格跟一个整数，表示测试磁盘i/o的进程数， --io 4 :表示生成4个worker循环调用sync()产生io压力；

-m,--vm：后面空格跟一个整数，表示测试内存的进程数，--vm 4 :表示生成4个worker循环调用malloc()/free()产生内存压力；

-d,--hdd：后面空格直接跟数字，表示产生执行write和unlink函数的进程数，用于磁盘负载测试；

--cpu-method：指定cpu的测试方法，后面空格直接跟方法名；

--metrics：输出命令执行指标；

--vm-bytes：指定在内存测试时malloc的字节数，默认256m；

--class：指定测试类别，后面空格跟类别名；

--matrix：启用矩阵测试模式，后面空格跟矩阵模式名；

--random-seed：指定测试随机种子，后面空格跟种子名；

--sequential：启用顺序测试模式；

--hdd-bytes：指定写的字节数；

--cpu-load：cpu负载占比，后面空格直接跟数字，单位为百分比;

3. 使用示例

# cpu压测

stress-ng --cpu 4 --cpu-method matrixprod --timeout 20s

使用 4 个 cpu 进程数，进行矩阵乘法计算以进行压力测试，持续时间为20秒

stress-ng -c 2 --cpu-method pi --timeout 20s

产生 2 个 worker 做圆周率算法压力

stress-ng -c 2 --cpu-method all --timeout 20s

产生 2 个 worker 迭代使用 30 多种不同的压力算法，包括pi, crc16, fft等等

stress-ng --sock 2 --timeout 20s

产生 2 个 worker 调用 socket 相关函数产生压力

stress-ng --tsc 2 --timeout 20s

产生 2 个 worker 读取 tsc 产生压力


stress-ng --tsc 2 --taskset 0 --timeout 20s

将压力指定到特定的cpu 0上


# 内存压测

stress-ng --vm 4 --vm-bytes 512m --timeout 20s

用 4 个内存分配进程， 每次分配大小512m，分配后不释放，保持测试20秒

# io负载压测

stress-ng --io 4 --timeout 20s

使用 4 个 io 进程 ，保持测试20秒


# 磁盘io压测

stress-ng --io 4 --hdd 1 --hdd-bytes 1g --timeout 20s

使用 4 个i/o进程， 1 个写进程，每次写1g 文件块，测试20秒