这是可以使用我们的多个免费在线工作站之一（例如 Ubuntu Online、Fedora Online、Windows 在线模拟器或 MAC OS 在线模拟器）在 OnWorks 免费托管服务提供商中运行的命令压力
程序：
您的姓名
压力-ng - 一种加载和压力计算机系统的工具
概要
压力 [OPTION [ARG]] ...
商品描述
stress-ng 将以各种可选择的方式对计算机系统进行压力测试。 它被设计
锻炼计算机的各种物理子系统以及各种操作
系统内核接口。 stress-ng 也有广泛的 CPU 特定压力测试
练习浮点、整数、位操作和控制流。
stress-ng 最初是为了让机器努力工作并解决硬件问题
例如热溢出以及仅在系统运行时才会发生的操作系统错误
被狠狠地殴打。 谨慎使用stress-ng，因为某些测试可以使系统运行
在设计不佳的硬件上很热，也可能导致过度的系统抖动，这可能是
难以停止。
stress-ng 还可以测量测试吞吐率； 这对观察很有用
不同操作系统版本或硬件类型的性能变化。
但是，它从未打算用作精确的基准测试套件，因此
不要以这种方式使用它。
使用 root 权限运行压力 ng 将调整 Linux 系统上的内存不足设置
为了使压力源在记忆力低的情况下无法杀死，所以要明智地使用它。 和
适当的特权，stress-ng 可以允许 ionice 类和 ionice 级别
再次调整，应谨慎使用。
可以指定每种类型的压力测试要调用的进程数； 指定一个
负值或零值将选择由定义的可用处理器数量
系统配置（_SC_NPROCESSORS_CONF）。
配置
一般用途总体评估 压力 控制 opţiuni:
- 挑衅的
启用更多文件、缓存和内存激进选项。 这可能会减慢测试速度，
增加延迟并减少 bogo 操作的数量以及更改
用户时间与系统时间的平衡取决于压力源的类型
用过的。
-a N, - 全部 N
启动每个压力源的 N 个实例。 如果 N 小于零，则 CPU 的数量
online 用于实例数。 如果 N 为零，则 CPU 的数量
在系统中使用。
-b N, --退避 N
在每个压力工作进程开始之间等待 N 微秒。 这允许
随着时间的推移，增加压力测试。
- 班级 姓名
指定要运行的压力源类别。 压力源分为一种或多种
以下类：cpu、cpu-cache、设备、io、中断、文件系统、内存、
网络、操作系统、管道、调度程序和虚拟机。 一些压力源只属于一类。 为了
例如，'get' 压力源就在 'os' 类中。 其他压力源落入
不止一个类，例如，“lsearch”压力源落入“cpu”，
'cpu-cache' 和 'memory' 类，因为它练习了所有这三个类。 选择一个
特定类将运行所有属于该类的压力源，只有在运行时
使用 --sequential 选项。
-n, --试运行
解析选项，但不运行压力测试。 无操作。
-H， - 帮帮我
显示帮助。
--ignite-cpu
更改内核控制以尝试最大化 CPU。 这需要 root 权限
改变各种 /系统 界面控件。 目前这只适用于英特尔 P-State
在 Linux 上启用 x86 系统。
--ionice 类 程
指定 ionice 类（仅在 Linux 上）。 可以是空闲（默认），尽力而为，是，
实时，rt。
--ionice 级别 水平
指定 ionice 级别（仅在 Linux 上）。 对于空闲，0 是唯一可能的选项。 为了
besteffort 或实时值 0（最高优先级）到 7（最低优先级）。 看
离子(1) 了解更多详情。
-k, --保持名称
默认情况下，stress-ng 将尝试更改压力过程的名称
根据其功能； 此选项禁用此功能并保持进程
名称是父进程的名称，即stress-ng。
--日志简介
默认情况下，stress-ng 将报告程序名称、消息类型和
进程 ID 作为所有输出的前缀。 --log-brief 选项将输出消息
没有这些字段会产生一个不那么冗长的输出。
--日志文件 文件名
将消息写入指定的日志文件。
- 最大化
覆盖默认压力源设置，而是将这些设置为最大值
允许设置。 这些默认值总是可以被每个压力源覆盖
如果需要，设置选项。
--指标
应力过程执行的 bogo 操作总数。 笔记
这些不是性能或吞吐量的可靠指标，并且没有被
旨在用于任何基准测试。 指标只是一种有用的方式
观察系统在各种负载下的行为。
输出以下列信息：
柱 标题 说明
bogo ops 运行期间压力源的迭代次数。
这是衡量整体“工作”有多少的指标
在 bogo 操作中实现。
实时（秒）平均挂钟持续时间（以秒为单位）
压力源。 这是所有挂钟时间的总和
该特定压力源的实例除以
正在运行的这些压力源的数量。
usr time (secs) 运行所有用户消耗的总用户时间（以秒为单位）
压力源的例子。
sys time (secs) 运行所有系统消耗的总系统时间（以秒为单位）
压力源的例子。
bogo ops/s（实时）基于挂钟运行的每秒 bogo 操作总数
时间。 挂钟时间反映了明显的运行
时间。 一个系统上的处理器越多
工作负荷可以分配到这些上，因此
挂钟时间会减少，bogo ops 率会降低
将增加。 这本质上是“明显的”bogo
系统的操作率。
bogo ops/s (usr+sys time) 基于累积的每秒 bogo 操作总数
用户时间和系统时间。 这是真正的 bogo ops 率
系统考虑到实际时间
所有压力源的执行时间
处理器。 通常这会随着增加而减少
由于缓存争用导致更多并发压力源，
内存、执行单元、总线和 I/O 设备。
--指标简介
启用指标并仅输出非零指标。
- 最小化
覆盖默认压力源设置，而是将这些设置为最小值
允许设置。 这些默认值总是可以被每个压力源覆盖
如果需要，设置选项。
--不建议
从 0.02.26 版本开始，stress-ng 会自动调用 马德维斯(2) 随机通知
在每个 mmap 和 munmap 之前的选项，以稍微加重 vm 子系统的压力。
--no-advise 选项关闭此默认设置。
--页面输入
触摸不在核心中的已分配页面，强制将它们调回。这
是一个有用的选项，可以在使用
bigheap、mmap 和 vm 压力源。 将严重降低性能时
系统中的内存小于分配的缓冲区大小。 这使用 微核(2)
确定不在核心中的页面，因此需要触摸以对它们进行分页
早在。
--病理性的
启用已知会挂起系统的压力源。 一些压力源会很快
以这样一种方式消耗资源，即它们可以在系统崩溃之前迅速挂起系统
内核可以 OOM 杀死它们。 默认情况下不启用这些压力源，此选项
启用它们，但您可能不想这样做。 你被警告了。
--性能 使用 perf 事件测量处理器和系统活动。 仅限 Linux 和警告
空客，根据 性能事件打开(2)：“始终仔细检查您的结果！各种
广义事件具有错误的价值。”
-q, - 安静的
不显示任何输出。
-r N, - 随机的 N
启动 N 个随机压力工作者。 如果 N 为 0，则配置的处理器数量
用于 N。
--预定 调度
选择指定的调度程序（仅在 Linux 上）。 查看可用调度程序列表
使用：stress-ng --sched 其中
--调度优先级 PRIO
选择调度程序优先级（仅在 Linux 上）。 如果调度器没有
支持这一点，则选择默认优先级 0。
--顺序 N
依次运行所有压力源，默认为 60 秒。 这
要启动的每个单独压力源的实例数为 N。 如果 N 小于
大于零，则使用在线 CPU 数作为实例数。 如果
N 为零，则使用系统中的 CPU 数量。 使用 --timeout 选项
指定运行每个压力源的持续时间。
--系统日志
将输出（详细 -v 消息除外）记录到系统日志。
--临时路径 径
指定stress-ng临时目录和临时文件的路径； 默认的
path 是当前工作目录。 此路径必须具有读写权限
对于应力-ng应力过程。
-t N, - 暂停 N
N秒后停止压力测试。 还可以指定时间单位
秒、分钟、小时、天或年，后缀为 s、m、h、d 或 y。
--定时器松弛 N
将每个进程计时器的松弛时间调整为 N 纳秒（仅限 Linux）。 增加
timer slack 允许内核通过添加一些模糊性来合并定时器事件
计时器到期时间，从而减少唤醒。 相反，减少计时器
松弛会增加唤醒。 timer-slack 的值为 0 将设置系统
默认值为 50,000 纳秒。
--倍
显示所有子进程在结束时的累积用户和系统时间
压力运行。 可用 CPU 时间的利用率百分比也是
根据系统中在线 CPU 的数量计算。
--tz 从机器上的可用热区收集温度（仅限 Linux）。
一些设备可能有一个或多个热区，而其他设备可能没有。
-v， --详细
显示所有调试、警告和正常信息输出。
- 核实
运行测试时验证结果。 这并非适用于所有测试。 这会
从测试运行中检查计算或内存内容并报告给
stderr 任何意外失败。
-V, - 版
显示版本。
-X， - 排除 名单
指定要排除的一个或多个压力源的列表（即，不要运行它们）。
当一个人选择许多压力源来运行时，这对于排除特定的压力源很有用
使用 --class 选项、--sequential、--all 和 --random 选项。 示例，运行
cpu 类压力源同时排除 numa 和搜索压力源：
压力-ng --class cpu --all 1 -x numa,bsearch,hsearch,lsearch
-Y, --yaml 文件名
将收集的统计信息输出到名为“filename”的 YAML 格式文件中。
压力源 具体的 opţiuni:
--亲和力 N
启动 N 个快速改变 CPU 亲和性的工人（仅在 Linux 上）。 快速切换
CPU 亲和性会导致缓存行为不佳。
--亲和力操作 N
在 N 个 bogo 关联操作后停止关联工作人员（仅在 Linux 上）。
--亲和力兰特
随机切换 CPU 关联，而不是按顺序切换默认值。
--af-alg N
启动 N 个工人，通过散列各种大小来行使 AF_ALG 套接字域
使用 SHA1、SHA224、SHA256、SHA384、SHA512、MD4、MD5、RMD128 的随机消息，
RMD160、RMD256、RMD320、WP256、WP384、WP512、TGR128、TGR160 和 TGR192 哈希值。
（仅限 Linux）。
--af-alg-操作 N
在 N 个 AF_ALG 消息散列后停止 af-alg 工作人员。
--aio N
启动 N 个 worker，在一个线程上发出多个小型异步 I/O 写入和读取
使用 POSIX aio 接口的相对较小的临时文件。 这只会打
文件系统缓存并在发出和占用大量用户和内核时间
处理 I/O 请求。 默认情况下，每个工作进程将处理 16 个并发
I/O 请求。
--aio-ops N
在 N 个 bogo 异步 I/O 请求后停止 POSIX 异步 I/O 工作线程。
--aio-请求 N
指定每个 worker 应该发出的 POSIX 异步 I/O 请求的数量，
默认为 16； 允许 1 到 4096。
--爱醇 N
启动 N 个工作线程，使用
Linux aio 系统调用 io_设置（2） io_提交（2） io_getevents（2）和
io_销毁(2). 默认情况下，每个工作进程将处理 16 个并发 I/O
请求。
--aiol-操作 N
在 N 个 bogo 异步 I/O 请求后停止 Linux 异步 I/O 工作线程。
--aiol-请求 N
指定每个 worker 应该发出的 Linux 异步 I/O 请求的数量，
默认为 16； 允许 1 到 4096。
--apparmor N
启动 N 个工人来练习 AppArmor 界面的各个部分。 目前
需要 root 权限才能运行此特定测试。 此测试仅可用
在支持 AppArmor 的 Linux 系统上。
--apparmor-ops
在 N 个 bogo 操作后停止 AppArmor 工人。
-B N, --大堆 N
启动 N 个工作进程，通过重新分配内存来增加他们的堆。 如果内存不足
Linux 上的killer (OOM) 杀死worker 或分配失败然后分配
过程重新开始。 注意设置了worker的OOM调整
以便OOM杀手将这些工人视为第一个候选进程
杀。
--bigheap-ops N
在 N 个 bogo 分配操作完成后停止 big heap workers。
--bigheap-增长 N
指定每次迭代增加堆的内存量。 大小可以从 4K 到
64MB。 默认值为 64K。
--绑定挂载 N
启动 N 个重复将 mount / 绑定到 / 在用户命名空间内的 worker。 这个可以
快速消耗资源，导致内存不足的情况。 不要使用这个
除非你想冒险挂你的机器。
--绑定挂载操作 N
在 N bind mount bogo 操作后停止。
--brk N
启动 N 个工人，使用多个数据段一次增加一页
BRK(2)调用。 触摸每个成功分配的新页面以确保它是
驻留在记忆中。 如果出现内存不足的情况，则测试将重置
数据段到它开始之前的点并重复数据段
再次调整大小。 该过程会调整内存不足设置，以便它可以
在其他进程之前被内存不足 (OOM) 杀手杀死。 如果是
被 OOM 杀手杀死，然后它会被监控自动重新启动
父进程。
--brk-操作 N
在 N 次 bogo brk 操作后停止 brk 工人。
--brk-notouch
不要触摸每个新分配的数据段页。 这将禁用默认值
触摸每个新分配的页面，从而避免内核必然
用真实的物理内存支持页面。
--b搜索 N
启动 N 个工人，使用二进制搜索 32 位整数的排序数组
搜索(3). 默认情况下，数组中有 65536 个元素。 这是一个有用的
随机访问内存和处理器缓存的方法。
--bsearch-操作 N
在 N 个 bogo bsearch 操作完成后停止 bsearch worker。
--bsearch-大小 N
指定要搜索的数组中的大小（32 位整数的数量）。 大小可以
从 1K 到 4M。
-C N, --缓存 N
启动 N 个 worker，它们执行随机的广泛内存读写到 thrash
CPU 缓存。 代码没有智能判断CPU缓存
配置，因此在产生命中未命中读/写时可能不是最佳的
某些处理器的活动。
--缓存围栏
在每个存储操作上强制写入序列化（仅限 x86）。 这是一个无操作
非 x86 架构。
--缓存刷新
在每个存储操作上强制刷新缓存（仅限 x86）。 这是非 x86 的空操作
架构。
--缓存级别 N
指定要执行的缓存级别（1=L1 缓存，2=L2 缓存，3=L3/LLC 缓存（
默认））。 如果无法确定缓存层次结构，则内置默认值将
应用。
--缓存无关联性
在以下情况下不要更改处理器关联性 --缓存 有效。
--缓存操作 N
在 N 次 bogo 缓存 thrash 操作后停止缓存 thrash 工作器。
--缓存预取
在支持预取的架构上的下一个读取地址上强制读取预取。
--缓存方式 N
指定要执行的缓存方式的数量。 这允许整体的一个子集
要执行的缓存大小。
- 帽 N
启动 N 个工人，通过调用读取每个进程的能力 资本家（二）（Linux
只要）。
--cap-ops N
N cap bogo 操作后停止。
--chdir N
启动 N 个工作人员，使用以下命令在 8192 个目录之间更改目录 目录（2）。
--chdir-操作 N
N chdir bogo 操作后停止。
--chmod N
启动 N 个工人，通过以下方式更改文件模式位 CHMOD（2）和 修改模式(2) 在
同一个文件。 N 的值越大，对单个文件的争用就越多。
压力源将处理所有模式位的组合。
--chmod-操作 N
N chmod bogo 操作后停止。
- 时钟 N
启动 N 个工人使用时钟和 POSIX 计时器。 对于所有已知的时钟类型，这
会锻炼 时钟获取器（2） 时钟获取时间（2）和 时钟纳米睡眠(2). 对所有人
已知计时器它将创建一个 50000ns 计时器并忙于轮询它直到它到期。
这个压力源会导致频繁的上下文切换。
--时钟操作 N
在 N 个 bogo 操作后停止时钟压力工人。
- 克隆 N
启动 N 个创建克隆的 worker（通过 克隆(2) 系统调用)。 这会
快速尝试创建默认的 8192 个克隆，这些克隆立即死亡并等待
僵尸状态，直到他们被收割。 一旦达到最大克隆数
（或克隆失败，因为一个已达到允许的最大值）最旧的克隆
线程被收获，然后以先进先出的方式创建一个新的克隆，
然后重复。 为每个克隆选择一个随机克隆标志来尝试
执行不同的克隆操作。 克隆压力源是 Linux 唯一的选择。
--克隆操作 N
在 N 个 bogo 克隆操作后停止克隆压力工作者。
--克隆最大 N
尝试创建多达 N 个克隆线程。 这可能无法达到，如果系统
限制小于 N。
- 语境 N
启动运行三个线程的 N 个工作线程，这些线程使用 交换上下文（三）落实
线程到线程上下文切换。 这练习了快速的流程上下文保存和
恢复并且带宽受寄存器和内存保存和恢复速率的限制。
--上下文操作 N
在 N 个 bogo 上下文切换后停止 N 个上下文工作者。 在这个压力源中，1 bogo op
相当于 1000 次交换上下文调用。
- 拷贝文件 N
启动 N 个压力源，使用 Linux 复制文件 复制文件范围(2)系统调用。
2MB 数据块从一个文件的随机位置复制到随机
位置到目标文件。 默认情况下，文件大小为 256 MB。 数据是
每次之后同步到文件系统 复制文件范围(2) 呼叫。
--复制文件操作 N
在 N 个 copy_file_range() 调用后停止。
--复制文件字节 N
复制文件大小，默认为 256 MB。 可以以字节为单位指定大小，
KBytes、MBytes 和 GBytes 使用后缀 b、k、m 或 g。
-c N, - 中央处理器 N
启动 N 个工人通过顺序处理所有的 CPU
不同的 CPU 压力方法。 与其使用所有 CPU 压力方法，不如使用一种
可以使用 --cpu-method 选项指定特定的 CPU 压力方法。
--cpu 操作 N
在 N bogo 操作后停止 cpu 压力工人。
-l P, --cpu-负载 P
为 CPU 压力工作人员加载 P 百分比负载的 CPU。 0 实际上是一个
睡眠（空载）和 100 是满载。 加载循环被分解为计算
时间（负载%）和睡眠时间（100% - 负载%）。 精度取决于总负载
处理器和调度程序的响应能力，因此实际负载可能是
与所需负载不同。 注意bogo CPU操作的次数可能
由于某些系统采用 CPU 频率缩放，因此不会随负载线性缩放
因此更重的负载会产生更高的 CPU 频率和更大的 CPU bogo
操作。
--cpu-负载切片 S
注意 - 此选项仅在 --cpu-load 小于 100% 时有用。 CPU负载
被分成多个忙和空闲周期。 使用此选项指定
繁忙时间片的持续时间。 S 的负值指定
在空闲 CPU 之前运行的迭代（例如 -30 调用 CPU 的 30 次迭代
应力环）。 零值选择 0 到 0.5 秒之间的随机繁忙时间。
S 的正值指定空闲前运行的毫秒数
CPU（例如 100 使 CPU 忙碌 0.1 秒）。 指定小值
S 适用于较小的时间片和更平滑的调度。 将 --cpu-load 设置为
相对较低的值和 --cpu-load-slice 较大会在 CPU 之间循环
长时间的空闲和忙碌周期并使用不同的 CPU 频率。 热量
CPU的范围也是循环的，所以这是一个很好的机制来锻炼
调度程序、频率缩放和被动/主动热冷却机制。
--cpu-方法 方法
指定cpu压力方法。 默认情况下，所有的应力方法都被执行
顺序，但是如果需要，可以仅指定要使用的一种方法。
可用的cpu压力方法描述如下：
付款方式 描述
全部迭代以下所有 cpu 压力方法
阿克曼 阿克曼函数：计算 A(3, 10)，其中：
A(m, n) = n + 1 如果 m = 0;
A(m - 1, 1) 如果 m > 0 且 n = 0；
A(m - 1, A(m, n - 1)) 如果 m > 0 且 n > 0
bitops 来自 bithack 的各种位操作，即：反向位、奇偶校验
检查，位计数，四舍五入到最接近的 2 次方
callfunc 递归调用 8 个参数的 C 函数到 1024 次调用的深度
和放松
cfloat 1000 次混合浮点复杂运算的迭代
cdouble 1000 次混合双浮点复数的迭代
操作
clongdouble 1000 次混合长双浮点复数的迭代
操作
correlate 执行随机双打的 16384 × 1024 相关
crc16 在随机数据上计算 1024 轮 CCITT CRC16
decimal32 1000 位十进制浮点混合的 32 次迭代
操作（仅限 GCC）
decimal64 1000 位十进制浮点混合的 64 次迭代
操作（仅限 GCC）
decimal128 1000 位十进制浮点混合的 128 次迭代
操作（仅限 GCC）
抖动 Floyd-Steinberg 抖动 1024 位 768 × 8 随机图像
低至 1 位深度。
djb2a 128 轮散列 DJB2a（Dan Bernstein 散列使用异或
变体）在 128 到 1 个字节的随机字符串上
双精度浮点混合的双 1000 次迭代
操作
euler 使用 n = (1 + (1 ÷ n)) ↑ n 计算 e
explog 迭代 n = exp(log(n) ÷ 1.00002)
fibonacci 计算斐波那契数列 0, 1, 1, 2, 5, 8...
fft 4096 样本快速傅立叶变换
float 1000 次混合浮点运算的迭代
fnv1a 128 轮散列 FNV-1a（Fowler–Noll–Vo 散列使用异或然后
乘法变体）在 128 到 1 个字节的随机字符串上
gamma 使用极限计算 Euler-Mascheroni 常数 γ
谐波级数之差（1 + 1/2 + 1/3 + 1/4 + 1/5
... + 1/n) 和自然对数 ln(n)，n = 80000。
gcd 计算整数的 GCD
格雷计算二进制到格雷码和格雷码回二进制
0 到 65535 之间的整数
汉明在 8,4 个 262144 位数据上计算汉明 H(4) 代码。 这个
将 4 位数据转换为包含 8 个奇偶校验位的 4 位汉明码。
对于数据位 d1..d4，奇偶校验位计算如下：
p1 = d2 + d3 + d4
p2 = d1 + d3 + d4
p3 = d1 + d2 + d4
p4 = d1 + d2 + d3
河内使用递归解决方案解决 21 个圆盘的河内塔堆栈
双曲线计算 sinh(θ) × cosh(θ) + sinh(2θ) + cosh(3θ) for float, double
和长双曲正弦和余弦函数，其中 θ = 0
到 2π 以 1500 步
idct 8 × 8 IDCT（离散余弦逆变换）
int8 1000 位整数运算混合的 8 次迭代
int16 1000 位整数运算混合的 16 次迭代
int32 1000 位整数运算混合的 32 次迭代
int64 1000 位整数运算混合的 64 次迭代
int128 1000 次混合 128 位整数运算的迭代（仅限 GCC）
int32float 1000 位整数和浮点混合的 32 次迭代
操作
int32double 1000 位整数和双精度混合的 32 次迭代
浮点运算
int32longdouble 1000 位整数和长双精度混合的 32 次迭代
精度浮点运算
int64float 1000 位整数和浮点混合的 64 次迭代
操作
int64double 1000 位整数和双精度混合的 64 次迭代
浮点运算
int64longdouble 1000 位整数和长双精度混合的 64 次迭代
精度浮点运算
int128float 1000 位整数和浮点混合的 128 次迭代
操作（仅限 GCC）
int128double 1000 位整数和双精度混合的 128 次迭代
浮点运算（仅限 GCC）
int128longdouble 1000 位整数和长双精度混合的 128 次迭代
精确浮点运算（仅限 GCC）
int128decimal32 1000 位整数和 128 位小数混合的 32 次迭代
浮点运算（仅限 GCC）
int128decimal64 1000 位整数和 128 位小数混合的 64 次迭代
浮点运算（仅限 GCC）
int128decimal128 1000 位整数和 128 位小数混合的 128 次迭代
浮点运算（仅限 GCC）
jenkin Jenkin 对 128 轮 128..1 字节随机数据的整数哈希
jmp 简单的未优化比较 >、<、== 和 jmp 分支
ln2 计算 ln(2)基于系列：
1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 ...
longdouble 1000 次长双精度浮点混合迭代
操作
循环简单的空循环
matrixprod 两个 128 × 128 双浮点矩阵的矩阵乘积。 测试
在 64 位 x86 硬件上表明这提供了一个很好的组合
内存、缓存和浮点运算，可能是
用于使 CPU 热运行的最佳 CPU 方法。
nsqrt 使用 Newton-Raphson 计算长双打的 sqrt()
omega 使用有效的计算由 Ωe↑Ω = 1 定义的 omega 常数
Ωn+1 = (1 + Ωn) / (1 + e↑Ωn) 的迭代
奇偶校验使用来自 Standford Bit 的各种方法计算奇偶校验
玩弄黑客。 使用的方法是：天真的方式，天真
使用 Brian Kernigan 位计数优化的方式，
乘法、并行法和查表法（2
变化）。
phi 使用系列计算黄金比例 ϕ
pi 使用 Srinivasa Ramanujan 快速收敛算法计算 π
pjw 128 轮散列 pjw 函数对 128 到 1 个字节的随机数
字符串
prime 使用稍微查找范围 1..1000000 中的所有素数
优化的蛮力 naïve trial Division 搜索
psi 计算 ψ（斐波那契倒数常数）使用
斐波那契数列的倒数
皇后计算经典8皇后问题的所有解
电路板尺寸 1..12
rand rand() 的 16384 次迭代，其中 rand 是 MWC 伪随机数
数字生成器。 MWC 随机函数连接两个 16 位
乘以进位生成器：
x(n) = 36969 × x(n - 1) + 进位，
y(n) = 18000 × y(n - 1) + 进位 mod 2 ↑ 16
并且有大约 2 ↑ 60 的周期
rand48 16384 次迭代 德兰德48（3）和 兰德48(3)
rgb 将 RGB 转换为 YUV 并返回到 RGB (CCIR 601)
sdbm 128 轮散列 sdbm（在 SDBM 数据库和 GNU awk 中使用）
在 128 到 1 个字节的随机字符串上
使用筛法筛选 1..10000000 范围内的素数
埃拉托色尼
sqrt 计算 sqrt(rand())，其中 rand 是 MWC 伪随机数
发电机
触发计算 sin(θ) × cos(θ) + sin(2θ) + cos(3θ) for float, double and
长双正弦和余弦函数，其中 θ = 0 到 2π in 1500
步骤
union 对 C 联合中的位域混合执行整数算术。
这练习了编译器和 CPU 执行整数的能力
位域加载和存储。
zeta 计算 Riemann Zeta 函数 ζ(s) for s = 2.0..10.0
请注意，其中一些方法尝试使用在
一些现实世界的用例。 但是，代码并未针对每个人进行优化
架构基础，因此与用于手动优化的代码相比可能是次优的
一些应用程序。 他们确实试图代表在
这些用例。
--cpu-在线 N
启动 N 个工人，让随机选择的 CPU 离线和在线。 仅此 Linux
压力源需要 root 权限才能执行此操作。
--cpu-在线操作 N
离线/在线操作后停止。
--地穴 N
启动 N 个工人，使用加密 16 个字符的随机密码 地穴（3）。 该
密码使用 MD5、SHA-256 和 SHA-512 加密方法进行加密。
--加密操作 N
N 次 bogo 加密操作后停止。
--守护进程 N
启动 N 个工人，每个工人都创建一个守护进程，该守护进程在创建后立即终止
另一个守护进程等等。 这有效地通过进程表工作
没有父进程并由 init 等待的短期进程。 这个
对 init 施加压力以进行快速的孩子收割。 守护进程执行
通常混合调用以变成典型的 UNIX 守护程序，因此这人为地模仿
守护进程系统压力非常大。
--守护进程操作 N
在创建 N 个守护进程后停止守护进程。
-D N, --dentry N
启动 N 个创建和删除目录条目的工作人员。 这应该创建文件
系统元数据活动。 目录条目名称以格雷码为后缀
编码数字以尝试混淆命名空间的散列。
--dentry-ops N
在 N 次 bogo dentry 操作后停止 denty thrash 工人。
--dentry-订单 [ 前锋 | 反转 | 步幅 | 随机 ]
指定 dentries 的取消链接顺序，可以是 forward、reverse、stride 或 random 之一。
默认情况下，dentries 以随机顺序取消链接。 远期订单将取消链接
它们从头到尾，相反的顺序将从尾到头断开它们的链接，大步
order 将通过以准随机模式遍历 order 来取消它们的链接，并且
随机顺序将随机选择前进、后退或跨步顺序之一。
--dentrys N
每个 dentry 抖动循环创建 N 个 dentry，默认为 2048。
--目录 N
启动 N 个使用 mkdir 和 rmdir 创建和删除目录的 worker。
--目录操作 N
在 N 个 bogo 目录操作后停止目录 thrash 工作器。
--重复 N
启动 N 个执行任务的工人 DUP（2），然后 关闭(2) 对/dev/zero 的操作。 这
一次最大打开数是系统定义的，因此测试将运行到此
最多或 65536 个打开的文件描述符，以先到者为准。
--重复操作 N
在 N bogo open 操作后停止 dup 压力工人。
--epoll N
启动 N 个工人执行各种相关的套接字压力活动，使用
epoll_等待(2) 监视和处理新的连接。 这涉及客户端/服务器
在本地执行快速连接、发送/接收和断开连接的进程
主持人。 使用 epoll 可以有效处理大量连接，
但是，这可能会导致连接表填满并进一步阻塞
套接字连接，因此会影响 epoll bogo op 统计数据。 对于 ipv4 和 ipv6
域，多个服务器生成在多个端口上。 epoll 压力源是为了
仅限 Linux。
--epoll 域 D
指定要使用的域，默认为 unix（又名本地）。 目前ipv4、ipv6
和 unix 都支持。
--epol-port P
从套接字端口 P 开始。对于 N epoll 工作进程，端口 P 到 (P * 4) - 1 是
用于 ipv4，ipv6 域和端口 P 到 P - 1 用于 unix 域。
--epol-ops N
在 N 个 bogo 操作后停止 epoll 工人。
--eventfd N
启动 N 个读写 8 字节事件消息的父子进程
它们之间通过 eventfd 机制（仅限 Linux）。
--eventfd-操作 N
在 N 个 bogo 操作后停止 eventfd 工作人员。
--执行 N
启动 N 个工人不断地分叉执行压力然后退出的孩子
几乎立即。
--执行操作 N
在 N 个 bogo 操作后停止 exec 压力工作者。
--执行最大 P
创建执行压力-ng的P个子进程，然后等待它们退出
迭代。 默认值仅为 1； 较高的值会创建许多临时僵尸
等待收割的进程。 一个人可能会填满这个过程
表使用 --exec-max 和 --exec 的高值。
-F N, --错误定位 N
启动 N 个工人不断地分配（预分配文件空间）和 ftuncating
（文件截断）临时文件。 如果文件大于可用空间，
fallocate 会产生一个 ENOSPC 错误，这个错误会被这个压力源忽略。
--fallocate-字节 N
分配的文件大小，默认为 1 GB。 可以以单位指定大小
Bytes、KBytes、MBytes 和 GBytes 使用后缀 b、k、m 或 g。
--fallocate-ops N
在 N bogo fallocate 操作后停止 fallocate 压力工作者。
- 过错 N
启动 N 个产生次要和主要页面错误的工作程序。
--故障操作 N
在 N 个 bogo 页错误操作后停止页错误工作程序。
--fcntl N
启动 N 个执行任务的工人 控制面板(2) 用各种命令调用。 行使的
命令（如果可用）是：F_DUPFD、F_DUPFD_CLOEXEC、F_GETFD、F_SETFD、F_GETFL、
F_SETFL、F_GETOWN、F_SETOWN、F_GETOWN_EX、F_SETOWN_EX、F_GETSIG 和 F_SETSIG。
--fcntl-ops N
在 N 个 bogo fcntl 操作后停止 fcntl 工人。
--地图 N
启动 N 个工人，每个工人创建一个具有许多随机变化范围的文件，并且具有
每个工人有 4 个子进程，它们使用
FS_IOC_FIEMAP 读写控制（2）。
--fiemap-ops N
在 N fiemap bogo 操作后停止。
--fiemap-大小 N
以字节为单位指定 fiemap 文件的大小。 可以指定单位的大小
Bytes、KBytes、MBytes 和 GBytes 使用后缀 b、k、m 或 g。 更大的文件
将包含更多的盘区，在收集盘区信息时造成更大的压力。
--先进先出 N
通过传输 64 位整数来启动 N 个工作器来执行命名管道。
--fifo-ops N
在 N 个 bogo 管道写入操作后停止 fifo 工人。
--fifo-读者 N
对于每个工作人员，创建 N 个 fifo 阅读器工作人员，这些工作人员使用简单的方式读取命名管道
阻塞读取。
- 文档名称 N
启动 N 个工人，使用不同长度的文件名创建文件
包含一系列允许的文件名字符。 这将尝试查看是否可以
超过文件系统允许的文件名长度以及测试各种文件名
长度介于 1 和文件系统允许的最大值之间。
--文件名操作 N
在 N bogo 文件名测试后停止文件名工作人员。
--文件名选项 选择
根据选项“opt”使用文件名中的字符。 有效的选项是：
附加选项 描述
探测默认选项，探测文件系统以获取有效的允许字符
在文件名中并使用这些
posix 使用 The Open Group Base Specifications 指定的字符
第 7 期，POSIX.1-2008，3.278 可移植文件名字符集
ext 使用 ext2、ext3、ext4 文件系统允许的字符，
即除 NUL 和 / 之外的任何 8 位字符
- 群 N
启动 N 个工人锁定单个文件。
--flock-ops N
在 N 个 bogo 羊群操作后停止羊群压力工人。
-f N, - 叉子 N
启动 N 个工人不断地分叉立即退出的孩子。
--fork-ops N
在 N 个 bogo 操作后停止叉子压力工人。
--叉最大 P
创建 P 个子进程，然后等待它们每次迭代退出。 默认的
只是 1； 较高的值将创建许多临时僵尸进程
等待收获。 一个人可以潜在地使用高填充进程表
--fork-max 和 --fork 的值。
--fp-错误 N
启动 N 个生成浮点异常的 worker。 执行计算
强制并检查 FE_DIVBYZERO、FE_INEXACT、FE_INVALID、FE_OVERFLOW 和
FE_UNDERFLOW 异常。 还会检查 EDOM 和 ERANGE 错误。
--fp-错误操作 N
在 N bogo 浮点异常后停止。
--fstat N
在目录中启动 N 个工人 fstat'ing 文件（默认为 的/ dev).
--fstat-ops N
在 N bogo fstat 操作后停止 fstat 压力工作者。
--fstat-目录 目录
指定 fstat 的目录以覆盖 /dev 的默认值。 里面的所有文件
该目录将被反复 fstat'd。
--futex N
启动 N 个快速执行 futex 系统调用的 worker。 每个工人有两个
进程，一个 futex 服务员和一个 futex 唤醒器。 服务员拿着一个很小的
timeout 强调超时和快速轮询 futex 等待。 这是一个 Linux
特定的压力选项。
--futex-ops N
在 N bogo 成功的 futex 等待操作后停止 futex 工人。
- 得到 N
启动 N 个调用所有 get*(2) 系统调用的 worker。
--获取操作 N
在 N bogo get 操作后停止 get 工人。
--getdent N
启动 N 个递归读取目录的 worker / proc中, / dev /, / tmp目录, /系统 和 / 跑
使用 getdents 和 getdents64（仅限 Linux）。
--getdent-操作 N
在 N bogo getdent bogo 操作后停止 getdent 工人。
--getrandom N
启动 N 个工作程序，使用以下命令从 /dev/urandom 池中获取 8192 个随机字节
随机获取(2) 系统调用（仅适用于 Linux）。
--getrandom-ops N
在 N bogo get 操作后停止 getrandom 工人。
- 处理 N
启动 N 个工人来锻炼 名称_处理_地址（2）和 打开_by_handle_at(2)
系统调用。 （仅限 Linux）。
--句柄操作 N
N 处理 bogo 操作后停止。
-d N, --硬盘 N
启动 N 个工人不断地写入、读取和删除临时文件。
--hdd 字节 N
为每个硬盘进程写入 N 个字节，默认为 1 GB。 一个可以指定大小
以 Bytes、KBytes、MBytes 和 GBytes 为单位，使用后缀 b、k、m 或 g。
--硬盘选项 名单
将各种压力测试选项指定为逗号分隔的列表。 选项如下
如下：
附加选项 描述
直接尝试最小化 I/O 的缓存影响。 文件 I/O 写入是
直接从用户空间缓冲区和同步执行
也尝试转移。 为了保证同步 I/O，还
使用同步选项。
dsync 确保输出已传输到底层硬件和文件
元数据已更新（使用 O_DSYNC 打开标志）。 这是
相当于每个 写(2) 接听电话
数据同步(2). 另请参阅 fdatasync 选项。
fadv-dontneed 建议内核预计近期内不会访问数据
的未来。
fadv-noreuse 建议内核期望数据只被访问一次。
fadv-normal 建议内核没有明确的数据访问模式。
这是默认的建议假设。
fadv-rnd 建议内核期望数据的随机访问模式。
fadv-seq 建议内核期待数据的顺序访问模式。
fadv-willneed 建议内核期望在附近访问数据
的未来。
fsync 在每次写入输出后刷新所有修改过的核心数据
使用显式的设备 FSYNC(2) 呼叫。
fdatasync 类似于 fsync，但不刷新修改后的元数据，除非
需要元数据才能正确处理以后的数据读取。
这使用显式 数据同步(2) 呼叫。
iovec 使用 readv/writev 多个缓冲区 I/O 而不是读/写。
缓冲区被分解为一个，而不是 1 个读/写操作
16 个缓冲区的 iovec。
noatime 不更新文件上次访问的时间戳，这样可以减少
元数据写入。
同步确保输出已传输到底层硬件（使用
O_SYNC 打开标志）。 这相当于每个 写(2) 被
然后是调用 FSYNC(2). 另请参阅 fsync 选项。
rd-rnd 随机读取数据。 默认情况下，不回读写入的数据，
然而，这个选项会强制它被随机读回。
rd-seq 顺序读取数据。 默认情况下，不回读写入的数据，
但是，此选项将强制按顺序回读它。
syncfs 将文件元数据和数据的所有缓冲修改写入
包含硬盘工作文件的文件系统。
utimes 强制更新文件时间戳，这可能会增加元数据写入。
wr-rnd 随机写入数据。 wr-seq 选项不能同时使用
时间。
wr-seq 顺序写入数据。 如果没有写入模式，这是默认值
指定的。
请注意，其中一些选项是互斥的，例如，只能有一个
写作或阅读的方法。 此外，fadvise 标志可能是互斥的，例如
fadv-willneed 不能与 fadv-dontneed 一起使用。
--硬盘操作 N
在 N 次 bogo 操作后停止硬盘压力工人。
--硬盘写入大小 N
以字节为单位指定每次写入的大小。 大小可以从 1 字节到 4MB。
--堆排序 N
启动 N 个工作程序，使用 BSD 堆排序对 32 位整数进行排序。
--堆排序操作 N
在 N bogo heapsorts 之后停止 heapsort 压力工作者。
--堆排序大小 N
指定要排序的 32 位整数的数量，默认为 262144 (256 × 1024)。
--h搜索 N
启动 N 个工作程序，使用 搜索(3). 默认情况下，
有 8192 个元素插入到哈希表中。 这是一个有用的方法
练习访问内存和处理器缓存。
--hsearch-ops N
在 N 个 bogo hsearch 操作完成后停止 hsearch 工人。
--hsearch-大小 N
指定要插入哈希表的哈希条目数。 大小可以
从 1K 到 4M。
--iccache N
启动 N 个 worker，通过强制指令缓存来强调指令缓存
重新加载。 这是通过修改指令缓存行来实现的，导致
当我们在其中调用一个函数时，处理器重新加载它。 目前仅
已为 Intel x86 CPU 验证和启用。
--icache-ops N
在 N 个 bogo icache 操作完成后停止 icache 工作进程。
--通知 N
启动 N 个 worker 执行文件系统活动，例如创建/删除
文件/目录，移动文件等，以强调锻炼各种 inotify 事件
（仅限 Linux）。
--inotify-ops N
在 N 个 inotify bogo 操作后停止 inotify 压力工作者。
-i N, --io N
启动 N 个工人连续调用 同步(2) 将缓冲区缓存提交到磁盘。 这个
可以与 --hdd 选项结合使用。
--io操作 N
在 N 个 bogo 操作后停止 io 压力工人。
--定时器 N
启动 N 个工人来执行系统间隔计时器。 这设置了一个
生成 SIGPROF 信号的 ITIMER_PROF 计时器。 默认频率
计时器是 1 MHz，但是，Linux 内核会将其设置为不再是
jiffy 设置，因此高频 SIGPROF 信号通常是不可能的。 一种
忙循环开始 获取计时器(2) 调用消耗 CPU 并因此递减定时器
基于在 CPU 和系统时间上花费的时间。
--timer-ops N
在 N bogo 定时器 SIGPROF 信号后停止定时器压力工人。
--定时器频率 F
以 F Hz 运行计时器； 范围从 1 到 1000000 Hz。 通常最高频率是
受每秒 jiffy 滴答数的限制，因此运行在 1000 Hz 以上是
实践中难以达到。
--kcmp N
启动 N 个使用 康普(2)比较父子进程来判断
如果它们共享内核资源（仅限 Linux）。
--kcmp-ops N
在 N bogo kcmp 操作后停止 kcmp 工人。
- 钥匙 N
启动 N 个使用创建和操作密钥的工人 添加密钥（2）和 凯特尔(2). 作为
根据每个用户的限制创建了许多密钥，然后是以下 keyctl
命令在每个键上执行：KEYCTL_SET_TIMEOUT、KEYCTL_DESCRIBE、
KEYCTL_UPDATE、KEYCTL_READ、KEYCTL_CLEAR 和 KEYCTL_INVALIDATE。
--关键操作 N
在 N 次 bogo 键操作后停止键工作器。
- 杀 N
启动 N 个工人向 SIG_IGN 信号处理程序发送 SIGUSR1 终止信号。 大多数
进程时间将在内核空间结束。
--kill 操作 N
在 N bogo kill 操作后停止 kill 工人。
--日志 N
启动 N 个工人执行内核 系统日志(2)系统调用。 这将尝试
使用各种大小的读取缓冲区读取内核日志。 仅限 Linux。
--klog-ops N
在 N 次 syslog 操作后停止 klog 工作人员。
- 租 N
启动 N 个工人通过 控制面板（2）F_SETLEASE
手术。 父进程不断地锁定和解锁文件的租约，同时
用户可选择数量的子进程以非阻塞打开方式打开文件
向父级生成 SIGIO 租约中断通知。 这个压力源是
仅当 F_SETLEASE、F_WRLCK 和 F_UNLCK 支持由 控制面板（2）。
--租赁操作 N
在 N 个 bogo 操作后停止租赁工人。
--租约破坏者 N
每个租约工作者启动 N 个租约破坏者子进程。 通常一个孩子是
足以强制向父级发送许多 SIGIO 租约中断通知信号，
但是，如果需要，此选项允许指定更多子进程。
- 关联 N
启动 N 个工人创建和删除硬链接。
--链接操作 N
在 N 个 bogo 操作后停止链接压力工作人员。
--锁车 N
启动 N 个工人，快速锁定并增加 64 字节随机选择的内存
来自 16MB mmap'd 区域（仅限 Intel x86 CPU）。 这将导致缓存行未命中
和停止 CPU。
--lockbus-ops N
在 N 个 bogo 操作后停止 lockbus 工人。
--lockf N
启动 N 个使用 POSIX 随机锁定和解锁文件区域的工人
锁(3)锁紧机构。 每个工人创建一个 64K 文件并尝试保存一个
最多 1024 个并发锁，子进程也尝试持有 1024 个
并发锁。 旧锁以先进先出的方式解锁。
--lockf-ops N
在 N 个 bogo lockf 操作后停止 lockf 工人。
--lockf-非阻塞
而不是使用阻塞 F_LOCK 锁(3) 命令，使用非阻塞 F_TLOCK
命令并在锁定失败时重试。 这会产生额外的系统调用开销
和 CPU 利用率随着 lockf worker 数量的增加而增加
锁定争用。
--longjmp N
启动 N 个锻炼的工人 设置jmp（3）/长jmp(3) 通过在 longjmp 上快速循环
调用。
--longjmp-ops N
在 N 个 bogo longjmp 操作后停止 longjmp 压力工作者（1 个 bogo op 是 1000
longjmp 调用）。
--l搜索 N
启动 N 个工人，使用线性搜索 32 位整数的未排序数组
搜索(3). 默认情况下，数组中有 8192 个元素。 这是一个有用的
执行内存和处理器缓存的顺序访问的方法。
--lsearch-操作 N
在 N 个 bogo lsearch 操作完成后停止 lsearch 工作进程。
--lsearch-大小 N
将数组中的大小（32 位整数的数量）指定给 lsearch。 大小可以
从 1K 到 4M。
--malloc N
启动 N 个工人连续调用 分配（3） 卡洛克（3） 重新分配（3）和 免费（3）。
默认情况下，最多可以有 65536 个分配在任何时候处于活动状态，但这可以是
使用 --malloc-max 选项更改。 分配、重新分配和释放是
随机选择； 50% 的时间是内存分配（通过 malloc、calloc 或
realloc) 并且 50% 的时间分配是空闲的。 分配大小也是
随机，最大分配大小由 --malloc-bytes 选项控制，
默认大小为 64K。 如果工作器被 out of 杀死，它会重新启动
记忆（OOM）杀手。
--malloc-字节 N
每个分配/重新分配大小的最大值。 分配是从 1 中随机选择的
到 N 个字节。 可以以 Bytes、KBytes、MBytes 和 GBytes 为单位指定大小
使用后缀 b、k、m 或 g。 大分配大小导致内存分配器
使用 MMAP(2) 而不是使用扩展堆 BRK（2）。
--malloc-最大 N
允许的最大活动分配数。 分配是随机选择的
放置在分配槽中。 因为大约 50%/50% 在分配和
释放，通常有一半的分配槽在任何时候都在使用。
--malloc 操作 N
在 N 个 malloc bogo 操作后停止。 一个 bogo 操作与成功有关
分配（3） 卡洛克（3）或 重新分配（3）。
--malloc-阈值 N
指定 malloc 使用的阈值 MMAP（2）代替 斯布尔克(2)分配更多
记忆。 这仅在提供 GNU C 的系统上可用 马洛普特(3) 调音
功能。
- 矩阵 N
启动 N 个工作人员，对浮点值执行各种矩阵运算。 经过
默认情况下，这将一一执行所有矩阵应力方法。 一罐
使用 --matrix-method 选项指定特定的矩阵应力方法。
--矩阵操作 N
在 N 个 bogo 操作后停止矩阵压力工作者。
--矩阵方法 方法
指定矩阵应力方法。 可用的基体应力方法描述为
如下：
付款方式 描述
全部迭代以下所有矩阵应力方法
add 相加两个 N × N 矩阵
copy 将一个 N × N 矩阵复制到另一个
div 将 N × N 矩阵除以一个标量
hadamard 两个 N × N 矩阵的 Hadamard 积
frobenius 两个 N × N 矩阵的 Frobenius 积
两个 N × N 矩阵的平均算术平均值
将 N × N 矩阵乘以标量
两个 N × N 矩阵的乘积
sub 从另一个 N × N 矩阵中减去一个 N × N 矩阵
转置 N × N 矩阵
--矩阵大小 N
指定矩阵的 N × N 大小。 较小的值导致浮点数
计算吞吐量限制压力源，其中较大的值会导致缓存和/或
内存带宽限制压力源。
--会员 N
启动 N 个执行 membarrier 系统调用的 worker（仅限 Linux）。
-- 成员操作 N
在 N bogo membarrier 操作后停止 membarrier 压力工人。
--memcpy N
启动 N 个工作程序，使用以下命令将 2MB 数据从共享区域复制到缓冲区
Memcpy(3) 然后用 记住(3) 具有 3 个不同
对齐。 这将使用处理器缓存和系统内存。
--memcpy-操作 N
在 N bogo memcpy 操作后停止 memcpy 压力工作者。
--内存文件 N
启动 N 个工作程序，使用创建 256 个页面的 1024 个分配 创建memfd（2）和
截断(2) 用于分配和 MMAP(2) 将分配映射到进程中
地址空间。 （仅限 Linux）。
--memfd-操作 N
在 N 后停止 memfd-创建(2)假冒操作。
--合并排序 N
启动 N 个使用 BSD 合并排序对 32 位整数进行排序的工作程序。
--合并排序操作 N
在 N bogo 合并排序后停止合并排序压力工作者。
--合并排序大小 N
指定要排序的 32 位整数的数量，默认为 262144 (256 × 1024)。
--mincore N
启动 N 个工人，一次遍历所有内存 1 页，检查
页面映射并且也常驻在内存中使用 微核（2）。
--mincore-ops N
在 N mincore bogo 操作后停止。 一个 mincore bogo op 相当于一个 1000
微核(2)电话。
--mincore-随机
不是按顺序浏览页面，而是随机选择页面。 被选中的
地址通过将其右移一位来迭代并由 mincore 检查
直到地址小于或等于页面大小。
--mknod N
启动 N 个使用创建和删除 fifos、空文件和命名套接字的工人
mknod 和取消链接。
--mknod-ops N
在 N 个 bogo mknod 操作后停止目录 thrash 工作器。
--mlock N
启动 N 个工人，使用以下方法锁定和解锁内存映射页面 锁（2）
芒洛克（2） 麦克考尔（2）和 蒙洛克尔(2). 这是通过三个映射来实现的
连续页，然后锁定第二页，从而确保不连续
页面被锁定。 然后重复此操作，直到允许的最大 mlocks 或
最多进行 262144 个映射。 接下来，所有未来的映射都被锁定，并且
worker 尝试映射 262144 个页面，然后所有页面都被锁定，页面被锁定
未映射。
--mlock-ops N
N mlock bogo 操作后停止。
--mmap N
启动 N 个工人连续调用 MMAP（2）/蒙图(2). 初始映射是
大块（大小由 --mmap-bytes 指定）后跟伪随机 4K
解映射，然后是伪随机 4K 映射，然后是线性 4K 解映射。 笔记
如果没有，这可能会导致系统在 Linux 系统上触发内核 OOM 杀手
没有足够的物理内存和交换空间。 使用了 MAP_POPULATE 选项
在支持此功能的系统上将页面填充到内存中。 默认情况下，匿名
使用映射，但是， --mmap-file 和 --mmap-async 选项允许一个
如果需要，执行基于文件的映射。
--mmap-ops N
在 N 个 bogo 操作后停止 mmap 压力工作人员。
--mmap-异步
启用基于文件的内存映射并在每个页面上使用异步 msync'ing，请参阅
--mmap 文件。
--mmap-字节 N
为每个 mmap 压力工作者分配 N 个字节，默认为 256MB。 可以指定
大小以 Bytes、KBytes、MBytes 和 GBytes 为单位，使用后缀 b、k、m 或 g。
--mmap-文件
启用基于文件的内存映射，默认情况下在每个文件上使用同步 msync'ing
页面。
--mmap-mprotect
更改每一页内存的保护设置。 每次一个页面或一组
页面被映射或重新映射，那么这个选项将使页面只读，写-
仅、仅执行和读写。
--mmapfork N
启动 N 个工人，每个工人分出 32 个子进程，每个子进程都试图
分配一些留在系统中的空闲内存（并试图避免任何
交换）。 然后子进程提示需要分配
马德维斯(2) 然后将其设置为零并提示不再需要它
退出前 madvise。 这会产生大量的 VM 活动，大量的
缓存未命中且交换最少。
--mmapfork-ops N
在 N mmapfork bogo 操作后停止。
--mmapmany N
启动 N 个试图创建每个进程允许的最大内存的 worker
映射。 这是通过映射 3 个连续页面然后取消映射
中间页面因此将映射分成两部分。 然后重复此操作，直到
最多允许映射或最多 262144 个映射。
--mmapmany-ops N
在 N mmapmany bogo 操作后停止。
--mremap N
启动 N 个工人连续调用 MMAP（2） 重映射（2）和 蒙图(2). 最初的
匿名映射是一个大块（大小由 --mremap-bytes 指定），然后
通过重新映射到页面大小，然后迭代地将大小减半
恢复到原来的大小。 此工作程序仅适用于 Linux。
--mremap-操作 N
在 N 个 bogo 操作后停止 mremap 压力工作者。
--mremap 字节 N
最初为每个重映射压力工作分配 N 个字节，默认为 256MB。 一罐
使用后缀 b 以 Bytes、KBytes、MBytes 和 GBytes 为单位指定大小，
k、m 或 g。
--消息 N
启动 N 个不断发送和接收消息的发送方和接收方进程
使用 System V 消息 IPC。
--msg-操作 N
N 个 bogo 消息发送操作完成后停止。
--mq N 启动 N 个不断发送和接收消息的发送方和接收方进程
使用 POSIX 消息队列。 （仅限 Linux）。
--mq-ops N
N bogo POSIX 消息发送操作完成后停止。
--mq-大小 N
指定 POSIX 消息队列的大小。 默认大小是 10 条消息，大多数 Linux
系统 这是普通用户允许的最大大小。 如果给定的大小是
大于允许的消息队列大小，则发出警告并且
而是使用最大允许大小。
- 好的 N
启动 N 个 CPU 消耗工人，这些工人行使可用的 nice 水平。 每个
迭代派生出一个贯穿所有好的级别的子进程
每级运行 0.1 秒的繁忙循环，然后退出。
--不错的操作 N
在 N 个不错的 bogo 不错的循环之后停止
- 空值 N
启动 N 个工人写入 /dev/null。
--null 操作 N
在 N /dev/null bogo 写操作后停止空压力工作者。
--努玛 N
启动 N 个工人迁移压力源和一个 4MB 内存映射缓冲区
可用的 NUMA 节点。 这使用 迁移页面(2) 移动压力源
绑定（2）和 移动页面(2) 移动映射缓冲区的页面。 每次移动后，
写入缓冲区以强制通过总线进行活动，从而导致缓存未命中。
此测试将仅在启用 NUMA 和 1 个以上 NUMA 节点的硬件上运行。
--numa-ops N
在 N 次 bogo NUMA 操作后停止 NUMA 压力工作者。
--oom-管道 N
启动 N 个工人创建尽可能多的管道并练习扩展和
将管道从最大管道尺寸缩小到页面大小。 数据写入
进入管道并再次读出以填充管道缓冲区。 随着 --aggressive
模式启用时管道收缩时不读出数据，导致内核
到 OOM 过程。 运行此压力源的许多实例将迫使
由于许多大型管道缓冲区分配，内核到 OOM 进程。
--oom-管道操作 N
在 N bogo 管道膨胀/收缩操作后停止。
-o N, - 打开 N
启动 N 个执行任务的工人 open（2），然后 关闭(2) 对/dev/zero 的操作。 这
一次最大打开数是系统定义的，因此测试将运行到此
最多或 65536 个打开的文件描述符，以先到者为准。
--开放操作 N
在 N bogo 开放操作后停止开放压力工作者。
- 性格 N
启动 N 个试图设置个性并获得所有可用资源的工人
个性类型（流程执行域类型）通过 个性(2)系统
称呼。 （仅限 Linux）。
--个性操作 N
N bogo 人格操作后停止人格压力工人。
-p N, - 管道 N
启动 N 个执行大型管道写入和读取的 worker 以执行管道 I/O。
这会练习内存写入和读取以及上下文切换。 每个工人
有两个进程，一个读取器和一个写入器。
--管道操作 N
在 N 个 bogo 管道写入操作后停止管道压力工作者。
--管道数据大小 N
指定每次写入管道的字节大小（范围从 4 字节到 4096
字节）。 设置较小的数据大小会导致更多的写入被缓存在
管道，因此降低了管道编写器和管道之间的上下文切换率
读者进程。 默认大小是页面大小。
--管道尺寸 N
以字节为单位指定管道的大小（对于支持 F_SETPIPE_SZ
fcntl() 命令）。 设置较小的管道尺寸会导致管道填充和阻塞
更频繁，因此增加了管道编写器之间的上下文切换率
和管道读取器进程。 默认大小为 512 字节。
-P N, - 轮询 N
启动 N 个工作程序，通过执行零超时轮询 英寸（2） 选择（2）和
睡觉(3)电话。 这浪费了系统和用户的时间，无所作为。
--pol-ops N
在 N bogo 民意调查操作后停止民意调查压力工作人员。
--procfs N
启动 N 个从中读取文件的工作者 / proc中 并递归地从中读取文件
/过程/自我 （仅限 Linux）。
--procfs-操作 N
在 N 个 bogo 读取操作后停止 procfs 读取。 请注意，由于条目数
内核之间可能会有所不同，这个 bogo ops 指标可能非常具有误导性。
--p线程 N
启动 N 个工人，迭代地创建和终止多个 pthread（
默认为每个工作线程 1024 个线程）。 在每次迭代中，每个新创建的 pthread
等待直到工作线程创建了所有 pthread，然后它们都终止
在一起。
--pthread-ops N
在 N bogo pthread 创建操作后停止 pthread worker。
--pthread-最大 N
每个工人创建 N 个 pthread。 如果 pthread 的数量乘以
工作线程数大于允许的 pthread 的软限制，则
最大值被重新调整到允许的最大值。
--ptrace N
启动 N 个工作程序，使用
跟踪（2）。
--ptrace 操作 N
在跟踪 N 个 bogo 系统调用后停止 ptracer 工作人员。
-Q, --qsort N
启动 N 个使用 qsort 对 32 位整数进行排序的工作程序。
--qsort-ops N
在 N bogo qsorts 后停止 qsort 压力工作者。
--qsort-大小 N
指定要排序的 32 位整数的数量，默认为 262144 (256 × 1024)。
- 配额 N
启动 N 个执行 Q_GETQUOTA、Q_GETFMT、Q_GETINFO、Q_GETSTATS 和
Q_同步 配额(2) 在所有可用的基于块的文件系统上的命令。
--配额操作 N
在 N bogo quotactl 操作后停止配额压力工人。
--rdrand N
启动 N 个读取 Intel 硬件随机数生成器（Intel
Ivybridge 处理器向上）。
--rdrand-ops N
在 N 次 bogo rdrand 操作后停止 rdrand 压力工作者（1 bogo op = 2048 随机
位成功读取）。
--预读 N
启动 N 个随机查找并执行 512 字节读/写 I/O 操作的工作线程
在带有预读的文件上。 默认文件大小为 1 GB。 预读和读取是
批处理成 16 次预读，然后是 16 次读取。
--预读字节 N
设置预读文件的大小，默认为 1 GB。 一个可以指定大小
使用后缀 b、k、m 或 g 的 Bytes、KBytes、MBytes 和 GBytes 单位。
--预读操作 N
在 N 个 bogo 读取操作后停止预读压力工作者。
--重新映射 N
启动 N 个映射 512 个页面的工作人员并使用已弃用的页面重新排序这些页面
系统调用 重新映射文件页面(2). 执行几个页面重新排序：向前，
反向、随机和多页到 1 页。
--重新映射操作 N
在 N 次重新映射 bogo 操作后停止。
-R N, - 改名 N
启动 N 个工人，每个工人创建一个文件，然后反复重命名它。
--重命名操作 N
在 N 次 bogo 重命名操作后停止重命名压力工作者。
--r限制 N
启动 N 个超过 CPU 和文件大小资源限制的 worker，生成 SIGXCPU
和 SIGXFSZ 信号。
--rlimit-操作 N
在捕捉到 N bogo 资源受限的 SIGXCPU 和 SIGXFSZ 信号后停止。
--seccomp N
启动 N 个工作人员执行安全计算系统调用过滤。 每个工人
创建将短消息写入 /dev/null 然后退出的子进程。 2%
的子进程有一个禁止写入系统调用的 seccomp 过滤器
因此它被 seccomp 用 SIGSYS 杀死。 请注意，这个压力源可以
每次杀死孩子时都会生成许多审核日志消息。
--seccomp-操作 N
在 N 次 seccomp 过滤器测试后停止 seccomp 压力工作者。
- 寻找 N
启动 N 个随机查找并执行 512 字节读/写 I/O 操作的工作线程
在一个文件上。 默认文件大小为 16 GB。
--寻找操作 N
在 N bogo seek 操作后停止寻找压力工人。
--寻找拳头
在文件中打随机定位的 8K 孔，以导致更多的范围强制更多
要求寻求压力源，（仅限 Linux）。
--寻求大小 N
以字节为单位指定文件的大小。 小文件大小允许 I/O 发生在
缓存，导致更大的 CPU 负载。 大文件迫使更多的 I/O 操作
驱动器上的更多等待时间和更多 I/O。 一个可以指定大小
使用后缀 b、k、m 或 g 的 Bytes、KBytes、MBytes 和 GBytes 单位。
--扫描电镜 N
启动 N 个执行 POSIX 信号量等待和发布操作的 worker。 默认情况下，
每个工人开始一个父母和 4 个孩子，以提供一些关于
信号。 这强调快速信号量操作并产生快速上下文
交换。
--sem 操作 N
在 N 次 bogo 信号量操作后停止信号量压力工作者。
--sem-过程 N
每个工人启动 N 个子工人来提供对信号量的争用，
默认值为 4，最多允许 64 个。
--sem-sysv N
启动 N 个执行 System V 信号量等待和发布操作的 worker。 经过
默认情况下，每个工人启动一个父级和 4 个子级以提供一些争用
在信号量上。 这强调快速信号量操作并产生快速
上下文切换。
--sem-sysv-ops N
在 N bogo System V 信号量操作后停止信号量压力工作者。
--sem-sysv-procs N
每个工人启动 N 个子进程以提供对 System V 信号量的争用，
默认值为 4，最多允许 64 个。
- 发送文件 N
启动 N 个工人，将一个空文件发送到 /dev/null。 这个操作花费近
一直在内核中。 默认发送文件大小为 4MB。 发送文件
选项仅适用于 Linux。
--sendfile-操作 N
在 N 个 sendfile bogo 操作后停止 sendfile 工作人员。
--发送文件大小 S
指定每次 sendfile 调用要复制的大小。 默认大小为 4MB。 一
可以使用后缀指定以 Bytes、KBytes、MBytes 和 GBytes 为单位的大小
b、k、m 或 g。
--shm N
启动 N 个使用 POSIX 共享打开和分配共享内存对象的 worker
内存接口。 默认情况下，测试会重复创建和销毁 32
共享内存对象，每个对象的大小为 8MB。
--shm-操作 N
在 N 个 POSIX 共享内存创建和销毁 bogo 操作完成后停止。
--shm-字节 N
指定要创建的 POSIX 共享内存对象的大小。 一个可以指定
以 Bytes、KBytes、MBytes 和 GBytes 为单位的大小，使用后缀 b、k、m 或
g.
--shm-objs N
指定要创建的共享内存对象的数量。
--shm-sysv N
启动 N 个使用 System V 共享内存分配共享内存的 worker
界面。 默认情况下，测试会反复创建和销毁8个共享内存
段，每个段的大小为 8MB。
--shm-sysv-ops N
在 N 个共享内存创建和销毁 bogo 操作完成后停止。
--shm-sysv-字节 N
指定要创建的共享内存段的大小。 可以指定
大小以 Bytes、KBytes、MBytes 和 GBytes 为单位，使用后缀 b、k、m 或 g。
--shm-sysv-segs N
指定要创建的共享内存段的数量。
--signfd N
启动 N 个生成 SIGRT 信号并由子进程读取处理的 worker
使用设置的文件描述符进行处理 信号量(2). （仅限 Linux）。 这会
当所有 CPU 都满载时，会产生沉重的上下文切换负载。
--signfd-ops
在发送 N 个 bogo SIGUSR1 信号后停止 sigfd 工作人员。
--sigfpe N
启动 N 个快速导致除以零 SIGFPE 故障的 worker。
--sigfpe-操作 N
在 N 个 bogo SIGFPE 故障后停止 sigfpe 压力工作者。
--正在签署 N
启动 N 个工作人员来检查 SIGUSR1 信号是否挂起。 这个压力源面具
SIGUSR1，生成一个 SIGUSR1 信号并使用 待签(2)看信号是否
待办的。 然后它取消屏蔽信号并检查信号是否不再挂起。
--signpending-ops N
在 N bogo sigpending 挂起/未挂起检查后停止 sigpending 压力工作者。
--sigsegv N
启动 N 个快速创建和捕获分段错误的 worker。
--sigsegv-ops N
在 N 个 bogo 分段错误后停止 sigsegv 压力工作者。
--signsuspend N
启动 N 个 worker，每个 worker 产生 4 个等待 SIGUSR1 的子进程
来自父母的信号使用 信号暂停(2). 父级发送 SIGUSR1 信号到
每个孩子都在快速连续。 每次 sigsuspend 唤醒都算作一个 bogo
操作。
--sig挂起操作 N
在 N 次 bogo sigsuspend 唤醒后停止 sigsuspend 压力工作者。
--sigq N
启动 N 个使用快速发送 SIGUSR1 信号的工人 信号队列(3) 给孩子
等待信号的进程通过 信号等待信息（2）。
--sigq-ops N
在 N bogo 信号发送操作后停止 sigq 压力工人。
- 睡觉 N
启动 N 个工人，这些工人产生多个线程，每个线程执行多次睡眠
范围为 1us 到 0.1s。 这会创建多个上下文切换和计时器
中断。
--睡眠操作 N
N 次 sleep bogo 操作后停止。
--睡眠最大值 P
每个工人启动 P 个线程。 默认为 1024，允许的最大值为 30000。
-S N, - 短袜 N
启动 N 个执行各种套接字压力活动的工人。 这涉及一对
客户端/服务器进程执行快速连接、发送和接收以及
在本地主机上断开连接。
--sock 域 D
指定要使用的域，默认为 ipv4。 目前 ipv4、ipv6 和 unix 是
支持的。
--sock-nodelay
这将禁用 TCP Nagle 算法，因此数据段总是尽快发送
可能的。 这会阻止数据在传输之前被缓冲，因此
导致较差的网络利用率和更多的上下文切换
发送方和接收方。
--袜子端口 P
从套接字端口 P 开始。对于 N 个套接字工作进程，使用端口 P 到 P - 1。
--袜子操作 N
在 N 个 bogo 操作后停止套接字压力工作人员。
--sock-选项 [ 提交 | 发送消息 | 发送短信 ]
默认情况下，消息使用 提交(2). 此选项允许您指定
发送方法使用 提交（2） 发送消息（2）或 发送短信(2). 请注意，sendmmsg 是
仅适用于支持此系统调用的 Linux 系统。
--sockfd N
启动 N 个 worker，它们使用 UNIX 域套接字传递文件描述符
味精(3)辅助数据机制。 对于每个工人，一对客户端/服务器进程
创建后，服务器会在 /dev/null 上打开尽可能多的文件描述符，并且
将这些通过套接字传递给从 CMSG 数据中读取这些数据的客户端，并且
立即关闭文件。
--sockfd-ops N
在 N 个 bogo 操作后停止 sockfd 压力工作者。
--袜子对 N
启动 N 个执行套接字对 I/O 读/写的工作程序。 这涉及一对
客户端/服务器进程执行随机大小的套接字 I/O 操作。
--sockpair 操作 N
在 N 个 bogo 操作后停止套接字对压力工人。
--生成 N
启动 N 个工人使用 posix_spawn(3) 那 exec 压力-ng
然后几乎立即退出。
--spawn-ops N
在 N bogo 产卵后停止产卵压力工人。
- 拼接 N
通过管道将数据从 /dev/zero 移动到 /dev/null 而不进行任何复制
内核地址空间和用户地址空间使用 拼接(2). 这只可用
对于 Linux。
--拼接操作 N
N 次 bogo 拼接操作后停止。
--拼接字节 N
每个拼接调用传输 N 个字节，默认为 64K。 一个可以指定大小
使用后缀 b、k、m 或 g 的 Bytes、KBytes、MBytes 和 GBytes 单位。
- 堆 N
启动 N 个工人，这些工人通过使用快速导致和捕获堆栈溢出 阿洛卡（3）。
--堆栈满
默认操作是触摸每个堆栈分配的最低页面。 这个
选项通过用零填充新的堆栈分配来触及所有页面
强制分配物理页面，因此更具侵略性。
--堆栈操作 N
在 N bogo 堆栈溢出后停止堆栈压力工作者。
--str N
启动 N 个工人，在随机字符串上执行各种 libc 字符串函数。
--str-方法 函数
选择一个特定的 libc 字符串函数来强调。 可用的字符串函数
压力是：全部、索引、rindex、strcasecmp、strcat、strchr、strcoll、strcmp、
strcpy、strlen、strncasecmp、strncat、strncmp、strrchr 和 strxfrm。 看 绳子(3)
有关这些字符串函数的更多信息。 'all' 方法是默认的
并将练习所有字符串方法。
--str操作 N
在 N 个 bogo 字符串操作后停止。
- 溪流 N
启动 N 个工人根据 STREAM 松散地锻炼内存带宽压力源
“高性能计算机中的可持续内存带宽”基准测试工具
John D. McCalpin 博士此压力源分配的缓冲区至少为 4 倍
CPU L2 缓存的大小并不断执行以下轮次
大型双精度浮点数数组的计算：
操作 描述
复制 c[i] = a[i]
比例 b[i] = 标量 * c[i]
添加 c[i] = a[i] + b[i]
三元组 a[i] = b[i] + (c[i] * 标量)
由于这松散地基于 STREAM 基准代码的变体，请勿
提交基于此的结果，因为它旨在强调-ng 只是为了强调
内存和计算，不适用于 STREAM 精确调整或未调整
任何基准。 如果需要，请使用官方的 STREAM 基准测试工具
准确和标准化的 STREAM 基准。
--流操作 N
在 N 个流 bogo 操作后停止，其中一个 bogo 操作是一轮复制，
缩放、加法和三重运算。
--stream-l3-大小 N
以字节为单位指定 CPU 级别 3 缓存大小。 可以以单位指定大小
Bytes、KBytes、MBytes 和 GBytes 使用后缀 b、k、m 或 g。 如果 L3 缓存
未提供大小，那么stress-ng 将尝试确定缓存大小，并且
如果失败，则默认大小为 4MB。
-s N, - 转变 N
启动 N 个 worker，通过管道向子进程发送消息以强制上下文切换。
--切换操作 N
在 N 个 bogo 操作后停止上下文切换工作人员。
--符号链接 N
启动 N 个工人创建和删除符号链接。
--符号链接操作 N
在 N 个 bogo 操作后停止符号链接压力工作者。
--同步文件 N
启动 N 个工作程序，使用
同步文件范围(2). 执行三种同步混合，从开始到结束
文件，从文件末尾到开头，随机混合。 随机选择
使用了有效的同步类型，涵盖了 SYNC_FILE_RANGE_WAIT_BEFORE，
SYNC_FILE_RANGE_WRITE 和 SYNC_FILE_RANGE_WAIT_AFTER 标志位。
--同步文件操作 N
在 N 个 bogo 同步操作后停止同步文件工作器。
--同步文件字节 N
指定要同步的文件的大小。 可以以单位指定大小
Bytes、KBytes、MBytes 和 GBytes 使用后缀 b、k、m 或 g。
--系统信息 N
启动 N 个持续读取系统并处理特定信息的 worker。
这使用以下命令读取进程用户和系统时间 时(2)系统调用。 为了
Linux 系统，它还使用 的sysinfo(2)系统
调用以及所有已安装文件系统的文件系统统计信息
状态（2）。
--sysinfo-操作 N
在 N 个 bogo 操作后停止 sysinfo 工人。
--sysfs N
启动 N 个工作人员递归地从中读取文件 /系统 （仅限 Linux）。 这可能会导致
特定的内核驱动程序将消息发送到内核日志中。
--系统操作 N
在 N 个 bogo 读取操作后停止 sysfs 读取。 请注意，由于条目数
内核之间可能会有所不同，这个 bogo ops 指标可能非常具有误导性。
- 球座 N
通过管道将数据从写入进程移动到读取进程并移动到 /dev/null
无需使用内核地址空间和用户地址空间之间的任何复制
开球(2). 这仅适用于 Linux。
--开球 N
N bogo tee 操作后停止。
-T N, --定时器 N
启动 N 个工人以 1 MHz 的默认速率创建计时器事件（仅限 Linux）； 这个
可以创建数千个定时器时钟中断。 每个定时器事件都被捕获
由信号处理程序并计为 bogo 计时器操作。
--定时器操作 N
在 N 个 bogo 计时器事件后停止计时器压力工作者（仅限 Linux）。
--定时器频率 F
以 F Hz 运行计时器； 范围从 1 到 1000000000 Hz（仅限 Linux）。 通过选择一个
合适的频率stress-ng可以产生几十万个中断
每秒。
--定时器-兰德
选择基于定时器频率 +/- 12.5% 随机抖动的定时器频率。
这试图在计时器间隔中强制更多的可变性以使调度
不太可预测。
--定时器fd N
启动 N 个 worker，以 1 MHz 的默认速率创建 timerfd 事件（仅限 Linux）；
这可以创建数以千计的计时器时钟事件。 等待定时器事件
在定时器文件描述符上使用 选择(2)然后读并算作bogo
timerfd 操作。
--timerfd-操作 N
在 N 个 bogo timerfd 事件后停止 timerfd 压力工作者（仅限 Linux）。
--timerfd-频率 F
以 F Hz 运行计时器； 范围从 1 到 1000000000 Hz（仅限 Linux）。 通过选择一个
合适的频率stress-ng可以产生几十万个中断
每秒。
--timerfd-rand
根据定时器频率 +/- 12.5% 随机选择一个 timerfd 频率
抖动。 这试图在计时器间隔中强制更多的可变性，以使
调度不太可预测。
--tsc N
启动 N 个工作人员，每次循环迭代读取时间戳计数器 (TSC) 256 次
（假操作）。 仅在 Intel x86 平台上可用。
--tsc-ops N
在 N 个 bogo 操作完成后停止 tsc 工人。
--t搜索 N
启动 N 个工人，在二叉树上插入、搜索和删除 32 位整数
运用 搜索（3） 查找（3）和 删除(3). 默认情况下，有 65536 个随机
树中使用的整数。 这是行使随机访问的有用方法
内存和处理器缓存。
--tsearch-ops N
在 N 个 bogo 树操作完成后停止 tsearch 工作进程。
--tsearch-大小 N
指定要搜索的数组中的大小（32 位整数的数量）。 大小可以
从 1K 到 4M。
--udp N
启动 N 个使用 UDP 传输数据的 worker。 这涉及一对客户端/服务器
在本地执行快速连接、发送和接收以及断开连接的进程
主办。
--udp-域 D
指定要使用的域，默认为 ipv4。 目前 ipv4、ipv6 和 unix 是
支持的。
--udp-lite
使用 UDP-Lite (RFC 3828) 协议（仅适用于 ipv4 和 ipv4 域）。
--udp-操作 N
在 N 个 bogo 操作后停止 udp 压力工作者。
--udp-端口 P
从端口 P 开始。对于 N 个 udp 工作进程，使用端口 P 到 P - 1。 默认情况下，
使用端口 7000 以上。
--udp-洪水 N
启动 N 个工作程序，尝试使用 UDP 数据包将主机泛洪到随机端口。
数据包的 IP 地址当前未被欺骗。 这仅适用于
支持 AF_PACKET 的系统。
--udp-洪水域 D
指定要使用的域，默认为 ipv4。 目前 ipv4 和 ipv6 是
支持的。
--udp-洪水操作 N
在 N bogo 操作后停止 udp-flood 压力工人。
--取消共享 N
启动 N 个工人，每个工人分出 32 个子进程，每个子进程都执行
取消分享(2) 系统调用通过分离部分流程执行上下文。
（仅限 Linux）。
--取消共享操作 N
在 N bogo unshare 操作后停止。
-u N, --urandom N
启动 N 个工作人员阅读 /dev/urandom（仅限 Linux）。 这将随机加载内核
号码来源。
--urandom-ops N
在 N urandom bogo 读取操作后停止 urandom 压力工作者（仅限 Linux）。
--用户错误fd N
启动 N 个工人，在一个小的匿名映射上生成写页面错误
内存区域并通过用户空间故障处理来处理这些故障
userfaultfd 机制。 这将产生大量的主要页面错误和
在处理页面错误期间也会进行上下文切换。 （仅限 Linux）。
--userfaultfd-操作 N
在 N 个页面错误后停止 userfaultfd 压力工作者。
--userfaultfd-字节 N
mmap 每个 userfaultfd worker 的 N 个字节用于页面错误，默认为 16MB 一个可以
使用后缀 b 以 Bytes、KBytes、MBytes 和 GBytes 为单位指定大小，
k、m 或 g。
--utime N
启动 N 个工人更新文件时间戳。 这主要是 CPU bound 当默认
用作系统仅定期刷新元数据更改。
--utime-操作 N
在 N utime bogo 操作后停止 utime 压力工作者。
--utime-fsync
强制将每个文件时间戳更新的元数据更改刷新到磁盘。 这个
强制测试成为 I/O 绑定，并会导致许多脏的元数据写入。
--vecmath N
启动 N 个工人，对各种执行各种无符号整数数学运算
128 位向量。 向量数学运算的混合在以下内容上执行
向量：16 × 8 位、8 × 16 位、4 × 32 位、2 × 64 位。 产生的指标
通过这种组合取决于处理器架构和矢量数学优化
由编译器生成。
--vecmath-ops N
在 N bogo 向量整数数学运算后停止。
--vfork N
启动 N 个工人不断地 vforking 立即退出的孩子。
--vfork-ops N
在 N 个 bogo 操作后停止 vfork 压力工人。
--vfork-max P
创建 P 个进程，然后等待它们每次迭代退出。 默认是
只是 1; 较高的值将创建许多正在等待的临时僵尸进程
收获。 可以使用高值填充进程表
对于--vfork-max 和--vfork。
-m N, --虚拟机 N
启动 N 个工人连续调用 MMAP（2）/蒙图(2) 并写入分配的
记忆。 请注意，这可能会导致系统在 Linux 上触发内核 OOM 杀手
如果没有足够的物理内存和交换不可用的系统。
--vm-字节 N
mmap 每个 vm worker N 个字节，默认为 256MB。 可以指定单位的大小
Bytes、KBytes、MBytes 和 GBytes 使用后缀 b、k、m 或 g。
--vm-步幅 N
自 0.03.02 版起已弃用
--vm-操作 N
在 N 个 bogo 操作后停止 vm workers。
--vm-挂起 N
在取消映射内存前休眠 N 秒，默认为零秒。 指定 0
会无限等待。
--vm-保持
不要不断地取消映射和映射内存，只是继续重写它。
--vm-锁定
使用 mmap MAP_LOCKED 将映射区域的页面锁定到内存中（由于 Linux
2.5.37)。 这类似于锁定内存中描述的 锁（2）。
--vm-方法 m
指定 vm 应力方法。 默认情况下，所有的应力方法都被执行
顺序，但是如果需要，可以仅指定要使用的一种方法。 每个
vm worker 有 3 个阶段：
1. 初始化。 匿名内存映射区域设置为已知模式。
2. 锻炼。 内存以已知的可预测方式进行修改。 一些虚拟机工人改变
记忆顺序，有些使用小步或大步沿着记忆。
3.检查。 检查修改后的内存是否符合预期
结果。
名称中包含“素数”的 vm 方法的步幅为最大素数
小于 2^64，允许他们彻底遍历内存并触摸所有
位置只需一次，同时也无需接触每个位置旁边的存储单元
其他。 此策略练习缓存和页面非本地性。
由于正在使用的内存是虚拟映射的，因此无法保证
以任何特定的物理顺序接触页面地址。 这些工人不应该
用于测试所有系统的内存是否正常工作，使用工具
例如 memtest86 代替。
vm压力方法旨在以可能找到的方式锻炼记忆
内存问题并尝试强制热错误。
可用的vm压力方法描述如下：
付款方式 描述
all 迭代下面列出的所有 vm 压力方法。
按顺序翻转内存 8 次，每次只是
内存中的一位翻转（反转）。 这将有效地
在 8 次传递中反转每个字节。
galpat-0 驰骋模式零点。 这将所有位设置为 0 并翻转
只是 1 位中的 4096 为 1。然后它会检查 1 是否为
被他们的邻居或
邻居已被拉到 1。
galpat-1 驰骋模式。 这将所有位设置为 1 并翻转
只是 1 位中的 4096 为 0。然后它会检查 0 是否为
被他们的邻居或邻居拉到 1
已被拉低到 0。
灰色用连续的格雷码填充内存（这些仅
在相邻字节之间一次更改 1 位），然后
检查它们是否设置正确。
incdec 依次通过内存工作两次，第一遍
将每个字节增加一个特定值，第二个
pass 将每个字节递减回原始起始值。
每次调用的增量/减量值都会发生变化
压力源。
inc-nybble 将内存初始化为一个设定值（在每个
调用压力源）然后依次工作
通过每个字节将底部 4 位递增 1 和
前 4 位乘以 15。
rand-set 以 64 位块设置顺序处理内存
块中的字节为相同的 8 位随机值。 这
每个块的随机值变化。 检查这些值
没有改变。
rand-sum 依次将所有内存设置为随机值，然后
求和已更改的位数
原始设定值。
read64 顺序读取内存，每个 bogo 使用 32 x 64 位读取
环形。 每个循环相当于一个 bogo 操作。 这个
练习原始内存读取。
ror 用随机模式填充内存，然后按顺序填充
将 64 位内存向右旋转一位，然后检查
最终加载/旋转/存储值。
用随机模式交换 64 字节块中的填充内存。 然后
用随机选择的块交换每个 64 块。 最后，
反转交换以将块放回原始状态
放置并检查数据是否正确。 这个练习
相邻和随机内存加载/存储。
move-inv 一次依次填充内存 64 位内存
随机值，然后检查是否设置了内存
正确。 接下来，依次反转每个 64 位模式
并再次检查内存是否按预期设置。
modulo-x 填充内存超过 23 次迭代。 每次迭代开始一个
从内存和步骤开始的字节更远
以 23 字节的步幅前进。 在每个步幅中，第一个字节是
设置为随机模式，所有其他字节都设置为
逆。 然后它检查第一个字节是否包含
预期的随机模式。 这会练习缓存存储/读取
以及查看相邻单元格是否影响每个单元格
等。
prime-0 通过在非常大的内存中单步执行来迭代 8 次
主要步幅在每个字节中一次一点地清除。
然后检查是否所有位都设置为零。
prime-1 通过在非常大的内存中单步执行来迭代 8 次
主要步幅设置在每个字节中一次位。
然后检查是否所有位都设置为 XNUMX。
prime-gray-0 以非常大的基本步幅通过内存的第一步
清除每个字节中的位（基于格雷码）。
接下来，重复此操作，但清除其他 7 位。 然后检查
查看是否所有位都设置为零。
prime-gray-1 以非常大的基本步幅通过内存的第一步
在每个字节中设置位（基于格雷码）。
接下来，重复此操作，但设置其他 7 位。 然后检查
查看是否所有位都设置为 XNUMX。
rowhammer 尝试使用 rowhammer 内存强制内存损坏
压力源。 这从内存中获取两个 32 位整数并
多次强制在两个地址上刷新缓存。
众所周知，这会在某些硬件上强制进行位翻转，
特别是在较低频率的内存刷新周期中。
walk-0d 为内存中的每个字节，遍历每条数据线
将它们设置为低（而其他设置为高）并检查
写入值符合预期。 这检查是否有
数据线卡住了。
walk-1d 为内存中的每个字节，遍历每条数据线
将它们设置为高（其他设置为低）并检查
写入值符合预期。 这检查是否有
数据线卡住了。
walk-0a 在给定的内存映射中，通过一系列
通过地址线工作的特别选择的地址
查看是否有任何地址线卡在低电平。 这效果最好
使用物理内存寻址，但是，行使这些
虚拟地址也有一些价值。
walk-1a 在给定的内存映射中，通过一系列
通过地址线工作的特别选择的地址
查看是否有任何地址线卡在高位。 这效果最好
使用物理内存寻址，但是，行使这些
虚拟地址也有一些价值。
write64 使用每个 bogo 32 x 64 位写入顺序写入内存
环形。 每个循环相当于一个 bogo 操作。 这个
练习原始内存写入。 请注意，内存写入是
在每次测试迭代结束时不检查。
零一将所有内存位设置为零，然后检查是否有任何位
不是零。 接下来，将所有内存位设置为 XNUMX 并检查是否
任何位都不是一个。
--vm-填充
为内存映射填充（预错）页表； 这会给交换带来压力。
仅在支持 MAP_POPULATE 的系统上可用（自 Linux 2.5.46）。
--vm-rw N
启动 N 个工人，使用
进程_vm_writev（2）和 进程_vm_readv(2). 此功能仅支持
Linux。 仅当启用 --verify 选项时才验证内存传输。
--vm-rw-ops N
在 N 个内存读/写后停止 vm-rw 工人。
--vm-rw-字节 N
mmap 每个 vm-rw 工作器的 N 个字节，默认为 16MB。 一个可以指定大小
使用后缀 b、k、m 或 g 的 Bytes、KBytes、MBytes 和 GBytes 单位。
--vm-拼接 N
通过管道将数据从内存移动到 /dev/null，而无需在它们之间进行任何复制
内核地址空间和用户地址空间使用 虚拟拼接（2）和 拼接(2). 这个
仅适用于 Linux。
--vm-拼接操作 N
在 N bogo vm-splice 操作后停止。
--vm-拼接字节 N
每个 vmsplice 调用传输 N 个字节，默认为 64K。 一个可以指定大小
使用后缀 b、k、m 或 g 的 Bytes、KBytes、MBytes 和 GBytes 单位。
- 等待 N
启动 N 个产生两个孩子的工人； 一个旋转 暂停(2) 循环，
其他不断停止并继续第一个。 控制进程等待
通过使用 SIGCONT 的交付恢复的第一个孩子 等待进程（2）和
等待ID（2）。
--等待操作 N
在 N bogo 等待操作后停止。
--wcs N
启动 N 个工人，在其上执行各种 libc 宽字符串函数
随机字符串。
--wcs-方法 wcs函数
选择一个特定的 libc 宽字符串函数来强调。 可用字符串
强调的功能是：所有，wcscasecmp，wcscat，wcschr，wcscoll，wcscmp，wcscpy，
wcslen、wcsncasecmp、wcsncat、wcsncmp、wcsrchr 和 wcsxfrm。 “全部”方法是
默认值，将使用所有字符串方法。
--wcs-操作 N
在 N 个 bogo 宽字符串操作后停止。
--xattr N
启动 N 个 worker，它们在一个节点上创建、更新和删除一批扩展属性
文件中。
--xattr-ops N
N bogo 扩展属性操作后停止。
-y N, - 屈服 N
启动 N 个调用 计划产量(2). 这个压力源确保至少 2
每个 CPU 练习的子进程数 盾牌产量(2) 无论有多少工人
指定，从而始终确保快速上下文切换。
--yield 操作 N
在 N 后停止屈服应力工人 计划产量(2)假冒操作。
- 零 N
启动 N 个工人阅读 /dev/zero。
--零操作 N
在 N /dev/zero bogo 读取操作后停止零压力工作人员。
--zlib N
启动 N 个工作人员使用 zlib 压缩和解压缩随机数据。 每个工人
有两个进程，一个压缩随机数据并将其通过管道传输到另一个进程
解压缩数据。 这个压力源会锻炼 CPU、缓存和内存。
--zlib-ops N
在 N 次 bogo 压缩操作后停止，每次 bogo 压缩操作是一个
以最高压缩级别压缩 64K 随机数据。
--僵尸 N
启动 N 个创建僵尸进程的工人。 这将迅速尝试创建一个
默认为 8192 个子进程立即死亡并以僵尸状态等待
直到他们收获。 一旦达到最大进程数（或 fork
失败，因为一个已经达到了最大允许的孩子数）最老的
child 被收获，然后以先进先出的方式创建一个新进程，
然后重复。
--僵尸行动 N
在 N 个 bogo 僵尸操作后停止僵尸压力工作者。
--僵尸最大 N
尝试创建多达 N 个僵尸进程。 这可能无法达到，如果系统
限制小于 N。
示例
压力-ng --cpu 4 --io 2 --vm 1 --vm-bytes 1G --timeout 60s
使用 60 个 CPU 压力源、4 个 io 压力源和 2 个 vm 压力源运行 1 秒
1GB 虚拟内存。
压力-ng --cpu 8 --cpu-ops 800000
运行 8 个 CPU 压力源并在 800000 次 bogo 操作后停止。
压力-ng --sequential 2 --timeout 2m --metrics
依次运行所有压力源的 2 个同时实例，每个实例
2 分钟，最后总结性能指标。
压力-ng --cpu 4 --cpu-method fft --cpu-ops 10000 --metrics-brief
运行 4 个 FFT cpu 压力源，在 10000 次 bogo 操作后停止并生成摘要
仅用于 FFT 结果。
压力-ng --cpu 0 --cpu-method all -t 1h
在通过所有可用 CPU 工作的所有在线 CPU 上运行 CPU 压力源
压力源 1 小时。
压力-ng --all 4 --timeout 5m
运行 4 个所有压力源的实例，持续 5 分钟。
压力-ng --random 64
运行从所有可用压力源中随机选择的 64 个压力源。
压力-ng --cpu 64 --cpu-method all --verify -t 10m --metrics-brief
运行所有不同 CPU 压力源的 64 个实例并验证
计算在 10 分钟内是正确的，最后是 bogo 操作摘要。
压力-ng --sequential 0 -t 10m
一一运行所有压力源 10 分钟，实例数
每个压力源都与在线 CPU 的数量相匹配。
压力-ng --sequential 8 --class io -t 5m --times
一一运行 io 类中的所有压力源，每次 5 分钟，8
每个压力源同时运行的实例并显示整体时间利用率
运行结束时的统计数据。
压力-ng --all 0 --maximize --aggressive
同时运行所有压力源（每个 CPU 1 个实例），最大化
设置（内存大小、文件分配等）并选择最
苛刻/激进的选择。
压力-ng --random 32 -x numa,hdd,key
运行 32 个随机选择的压力源并排除 numa、hdd 和关键压力源
压力-ng --sequential 4 --class vm --exclude bigheap,brk,stack
一个接一个地运行 VM 压力源的 4 个实例，不包括 bigheap，
brk 和堆栈压力源
退出 状态
状态 描述
0 成功。
1 错误； 不正确的用户选项或压力 ng 中的致命资源问题
压力源线束（例如，内存不足）。
2 一个或多个压力源失败了。
3 由于缺乏资源，一个或多个压力源未能初始化，例如
例如 ENOMEM（无内存）和 ENOSPC（文件系统上无空间）。
使用 onworks.net 服务在线使用压力