如何使用 bash 命令创建 CPU 峰值

问题描述：

我想在 Linux 机器上创建接近 100% 的负载。它是四核系统，我希望所有核心都全速运行。理想情况下，CPU 负载会持续指定的时间，然后停止。我希望 bash 中有一些技巧。我在想某种无限循环。

解决方案 1：

我对这种事情使用压力，你可以告诉它最多需要多少个核心..它也可以对内存和磁盘施加压力。

例如，对 2 个核心进行 60 秒的压力测试

stress --cpu 2 --timeout 60

解决方案 2：

您还可以

dd if=/dev/zero of=/dev/null

为了运行更多程序以将负载放在更多核心上，请尝试分叉它：

fulload() { dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null & }; fulload; read; killall dd

重复大括号中的命令，次数与要生成的线程数相同（此处为 4 个线程）。只需按 Enter 键即可停止它（只需确保此用户没有其他 dd 在运行，否则您也会将其终止）。

解决方案 3：

我认为这个更简单。打开终端并输入以下内容，然后按 Enter。

yes > /dev/null &

为了充分利用现代 CPU，一行是不够的，您可能需要重复该命令以耗尽所有 CPU 能力。

为了结束这一切，简单地说

killall yes

这个想法最初是在这里发现的，虽然它是针对 Mac 用户，但它也适用于 *nix。

解决方案 4：

尽管我迟到了，但这篇文章在谷歌搜索“在 Linux 中生成负载”时排名靠前。

标记为解决方案的结果可用于生成系统负载，我更喜欢用sha1sum /dev/zero它对 CPU 核心施加负载。

其理念是从无限数据流（例如 /dev/zero、/dev/urandom 等）计算哈希值，此过程将尝试最大化 CPU 核心，直到中止。要为更多核心生成负载，可以将多个命令一起传输。

例如生成 2 核负载：
sha1sum /dev/zero | sha1sum /dev/zero

解决方案 5：

要加载 3 个核心 5 秒：

seq 3 | xargs -P0 -n1 timeout 5 yes > /dev/null

这会导致许多 write() 系统调用导致内核（系统）负载过高。

如果你更喜欢用户空间的 CPU 负载：

seq 3 | xargs -P0 -n1 timeout 5 md5sum /dev/zero

如果您只是希望继续加载直到按下 Ctrl-C：

seq 3 | xargs -P0 -n1 md5sum /dev/zero

解决方案 6：

一个核心（不调用外部进程）：

while true; do true; done

两个核心：

while true; do /bin/true; done

但后者只能使我的两者达到~50%...

这将使两者都达到 100%：

while true; do echo; done

解决方案 7：

我也曾想过无限循环。一个看起来很怪异的循环是：

while :; do :; done

（:与 相同true，不执行任何操作并以零退出）

您可以在子 shell 中调用它并在后台运行。执行这些操作应该足够了。在休眠所需的时间后，您可以杀死它们，然后使用(提示：)$num_cores获得 PIDjobs -p`xargs`

解决方案 8：

这是一个你可以下载的程序

轻松安装在您的 Linux 系统上

./configure
make
make install

并在一个简单的命令行中启动它

stress -c 40

使用 40 个线程对所有 CPU（无论如何）进行压力测试，每个线程sqrt对随机生成的数字运行复杂的计算。

你甚至可以定义程序的超时时间

stress -c 40 -timeout 10s

与使用命令提出的解决方案不同dd，该解决方案本质上处理数据IO，因此并不会因为处理数据而真正导致系统过载。

由于需要处理计算，压力程序确实会使系统超负荷。

解决方案 9：

:(){ :|:& };:

这个 fork 炸弹将会对 CPU 造成严重破坏，并且很可能会导致你的计算机崩溃。

解决方案 10：

我会将其分成两个脚本：

无限循环.bash：

#!/bin/bash
while [ 1 ] ; do
    # Force some computation even if it is useless to actually work the CPU
    echo $((13**99)) 1>/dev/null 2>&1
done

CPU_spike.bash：

#!/bin/bash
# Either use environment variables for NUM_CPU and DURATION, or define them here
for i in `seq ${NUM_CPU}` : do
    # Put an infinite loop on each CPU
    infinite_loop.bash &
done

# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}
killall infinite_loop.bash

解决方案 11：

增加负载或消耗 CPU 100% 或 X%

sha1sum /dev/zero &

在某些系统上，这将增加 X% 的插槽负载，在这种情况下，您必须多次运行相同的命令。

然后你可以通过输入命令来查看 CPU 使用情况

top

释放负荷

killall sha1sum

解决方案 12：

cat /dev/urandom > /dev/null

解决方案 13：

如果你不想安装其他软件，你可以使用自动利用所有 CPU 核心的压缩实用程序。例如，xz：

 cat /dev/zero | xz -T0 > /dev/null

这将从 /dev/zero 获取无限的虚拟数据流，并使用系统中所有可用的核心对其进行压缩。

解决方案 14：

#!/bin/bash
duration=120    # seconds
instances=4     # cpus
endtime=$(($(date +%s) + $duration))
for ((i=0; i<instances; i++))
do
    while (($(date +%s) < $endtime)); do :; done &
done

解决方案 15：

我已经使用过bc（二进制计算器），要求他们计算带有大量小数的圆周率。

$ for ((i=0;i<$NUMCPU;i++));do
    echo 'scale=100000;pi=4*a(1);0' | bc -l &
    done ;\n    sleep 4; \n    killall bc

使用 NUMCPU（在 Linux 下）：

$ NUMCPU=$(grep $'^processor    *:' /proc/cpuinfo |wc -l)

这种方法很强大，但似乎对系统很友好，因为我从来没有用这种方法导致系统崩溃。

解决方案 16：

#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done

解决方案 17：

您可以尝试测试加密算法的性能。

openssl speed -multi 4

解决方案 18：

我通过互联网寻找类似的东西，并找到了这个非常方便的 CPU hammer 脚本。

#!/bin/sh

# unixfoo.blogspot.com

if [ $1 ]; then
    NUM_PROC=$1
else
    NUM_PROC=10
fi

for i in `seq 0 $((NUM_PROC-1))`; do
    awk 'BEGIN {for(i=0;i<10000;i++)for(j=0;j<10000;j++);}' &
done

解决方案 19：

使用此处提到的示例，以及 IRC 的帮助，我开发了自己的 CPU 压力测试脚本。它使用每个线程一个子 shell 和无限循环技术。您还可以以交互方式指定线程数和时间量。

#!/bin/bash
# Simple CPU stress test script

# Read the user's input
echo -n "Number of CPU threads to test: "
read cpu_threads
echo -n "Duration of the test (in seconds): "
read cpu_time

# Run an endless loop on each thread to generate 100% CPU
echo -e "E[32mStressing ${cpu_threads} threads for ${cpu_time} seconds...E[37m"
for i in $(seq ${cpu_threads}); do
    let thread=${i}-1
    (taskset -cp ${thread} $BASHPID; while true; do true; done) &
done

# Once the time runs out, kill all of the loops
sleep ${cpu_time}
echo -e "E[32mStressing complete.E[37m"
kill 0

解决方案 20：

利用这里的想法，创建在设定的时间后自动退出的代码，不必终止进程——

#!/bin/bash
echo "Usage : ./killproc_ds.sh 6 60  (6 threads for 60 secs)"

# Define variables
NUM_PROCS=${1:-6} #How much scaling you want to do
duration=${2:-20}    # seconds

function infinite_loop {
endtime=$(($(date +%s) + $duration))
while (($(date +%s) < $endtime)); do
    #echo $(date +%s)
    echo $((13**99)) 1>/dev/null 2>&1
    $(dd if=/dev/urandom count=10000 status=none| bzip2 -9 >> /dev/null) 2>&1 >&/dev/null
done
echo "Done Stressing the system - for thread $1"
}


echo Running for duration $duration secs, spawning $NUM_PROCS threads in background
for i in `seq ${NUM_PROCS}` ;
do
# Put an infinite loop
    infinite_loop $i  &
done

解决方案 21：

这对我来说是一个窍门：

bash -c 'for (( I=100000000000000000000 ; I>=0 ; I++ )) ; do echo $(( I+I*I )) & echo $(( I*I-I )) & echo $(( I-I*I*I )) & echo $(( I+I*I*I )) ; done' &>/dev/null

它除了 bash 之外什么都不用。

解决方案 22：

为了增强 dimba 的答案并提供更多可插入的内容（因为我需要类似的东西）。我使用 dd 加载概念编写了以下内容 :D

它将检查当前核心，并创建相应数量的 dd 线程。使用Enter启动和结束核心加载

#!/bin/bash

load_dd() {
    dd if=/dev/zero of=/dev/null
}

fulload() {
    unset LOAD_ME_UP_SCOTTY
    export cores="$(grep proc /proc/cpuinfo -c)"
    for i in $( seq 1 $( expr $cores - 1 ) )
      do
    export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd | ')"
  done
        export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd &')"
    eval ${LOAD_ME_UP_SCOTTY}
}

echo press return to begin and stop fullload of cores
  read
  fulload
  read
  killall -9 dd

解决方案 23：

Dimba 的dd if=/dev/zero of=/dev/null说法绝对正确，但同样值得一提的是，验证是否将 CPU 使用率最大化到 100%。你可以这样做

ps -axro pcpu | awk '{sum+=$1} END {print sum}'

这要求 ps 输出每个进程 1 分钟内的 CPU 使用率平均值，然后使用 awk 将它们相加。虽然这是 1 分钟的平均值，但 ps 足够智能，可以知道进程是否只运行了几秒钟，并相应地调整时间窗口。因此，您可以使用此命令立即查看结果。

解决方案 24：

awk是一种编写长时间运行的循环的好方法，该循环受 CPU 限制，不会产生大量的内存流量或系统调用，也不会使用任何大量内存或污染缓存，因此它会以最小的量减慢其他核心的速度。（stress或者stress-ng如果您安装了，也可以这样做，如果您使用简单的 CPU 压力方法。）

awk 'BEGIN{for(i=0;i<100000000;i++){}}'   # about 3 seconds on 4GHz Skylake

这是一个计数循环，因此您可以让它在有限的时间后自行退出。（Awk 使用 FP 数字，因此由于舍入，2^54可能无法达到这样的限制i++，但这比几秒钟到几分钟所需的限制要大得多。）

要并行运行它，请使用 shell 循环在后台启动它 n 次

for i in {1..6};do awk 'BEGIN{for(i=0;i<100000000;i++){}}' & done

######     6 threads                      each running about 3 seconds

$ for i in {1..6};do awk 'BEGIN{for(i=0;i<100000000;i++){}}' & done
[1] 3047561
[2] 3047562
[3] 3047563
[4] 3047564
[5] 3047565
[6] 3047566
$              # this shell is usable.
(wait a while before pressing return)
[1]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[2]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[3]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[4]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[5]-  Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[6]+  Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
$

我曾经perf观察过它对 CPU 施加了什么样的负载：它每个时钟周期运行 2.6 条指令，因此对于共享同一物理核心的超线程来说，它并不是最友好的。但它的缓存占用空间非常小，即使在 L1d 缓存中缓存未命中率也可以忽略不计。并且strace会显示它在退出之前不会进行任何系统调用。

$ perf stat -r5 -d awk 'BEGIN{for(i=0;i<100000000;i++){}}'

 Performance counter stats for 'awk BEGIN{for(i=0;i<100000000;i++){}}' (5 runs):

          3,277.56 msec task-clock                #    0.997 CPUs utilized            ( +-  0.24% )
                 7      context-switches          #    2.130 /sec                     ( +- 12.29% )
                 1      cpu-migrations            #    0.304 /sec                     ( +- 40.00% )
               180      page-faults               #   54.765 /sec                     ( +-  0.18% )
    13,708,412,234      cycles                    #    4.171 GHz                      ( +-  0.18% )  (62.29%)
    35,786,486,833      instructions              #    2.61  insn per cycle           ( +-  0.03% )  (74.92%)
     9,696,339,695      branches                  #    2.950 G/sec                    ( +-  0.02% )  (74.99%)
           340,155      branch-misses             #    0.00% of all branches          ( +-122.42% )  (75.08%)
    12,108,293,527      L1-dcache-loads           #    3.684 G/sec                    ( +-  0.04% )  (75.10%)
           217,064      L1-dcache-load-misses     #    0.00% of all L1-dcache accesses  ( +- 17.23% )  (75.10%)
            48,695      LLC-loads                 #   14.816 K/sec                    ( +- 31.69% )  (49.90%)
             5,966      LLC-load-misses           #   13.45% of all LL-cache accesses  ( +- 31.45% )  (49.81%)

           3.28711 +- 0.00772 seconds time elapsed  ( +-  0.23% )

对 x86 CPU 上的其他超线程最“友好”的是像这样的 C 程序，它只pause在循环中运行一条指令。（或者可移植地，运行的 Rust 程序std::hint::spin_loop。）就操作系统的进程调度程序而言，它停留在用户空间中（与系统调用不同yield()），但在硬件中它不会占用太多资源，让另一个逻辑核心拥有多个周期的前端。

#include <immintrin.h>
int main(){                    // use atoi(argv[1])*10000ULL as a loop count if you want.
    while(1) _mm_pause();
}

解决方案 25：

我结合了一些答案，并添加了一种将压力扩展到所有可用 CPU 的方法：

#!/bin/bash

function infinite_loop { 
    while [ 1 ] ; do
        # Force some computation even if it is useless to actually work the CPU
        echo $((13**99)) 1>/dev/null 2>&1
    done
}

# Either use environment variables for DURATION, or define them here
NUM_CPU=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
PIDS=()
for i in `seq ${NUM_CPU}` ;
do
# Put an infinite loop on each CPU
    infinite_loop &
    PIDS+=("$!")
done

# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}

# Parent kills its children 
for pid in "${PIDS[@]}"
do
    kill $pid
done

解决方案 26：

只需将此错误粘贴到任何运行 Linux 的服务器的 SSH 或控制台中即可。您可以手动终止进程，但我完成后会关闭服务器，这样速度更快。

编辑：我已经更新此脚本，现在具有计时器功能，因此无需终止进程。

read -p "Please enter the number of minutes for test >" MINTEST && [[ $MINTEST == ?(-)+([0-9]) ]]; NCPU="$(grep -c ^processor /proc/cpuinfo)";  ((endtime=$(date +%s) + ($MINTEST*60))); NCPU=$((NCPU-1)); for ((i=1; i<=$NCPU; i++)); do while (($(date +%s) < $endtime)); do : ; done & done