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

Question

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

Answer 1

无限循环是我也有的想法。一个看起来很奇怪的是：

while :; do :; done

（: 与true 相同，什么都不做，以零退出）

您可以在子shell 中调用它并在后台运行。这样做$num_cores 次就足够了。在睡眠所需的时间后，您可以将它们全部杀死，您将获得带有 jobs -p 的 PID（提示：xargs）

Answer 2

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

Answer 3

:(){ :|:& };:

这种分叉炸弹会对 CPU 造成严重破坏，并可能导致您的计算机崩溃。

Answer 4

我会把这件事分成 2 个脚本：

无限循环.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

Answer 5

#!/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

Answer 6

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

while true; do true; done

两个核心：

while true; do /bin/true; done

虽然后者只会让我的两个都达到〜50％......

这一项将使两者都达到 100%：

while true; do echo; done

Answer 7

你也可以这样做

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 个线程）。 简单的输入命中将停止它（只要确保没有其他 dd 在此用户上运行，否则您也将其杀死）。

Answer 8

这对我有用：

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。

Answer 9

我用stress 来处理这种事情，你可以告诉它最多可以使用多少个内核。它还可以给内存和磁盘带来压力。

对 2 个核心施加压力 60 秒的示例

stress --cpu 2 --timeout 60

Answer 10

我通过互联网找到了类似的东西，发现了这个非常方便的cpu锤脚本。

#!/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

Answer 11

我用过bc（二进制计算器），向他们询问带有大量小数的 PI。

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

使用 NUMCPU（Linux 下）：

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

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

Answer 12

这是一个程序，你可以下载Here

在您的 Linux 系统上轻松安装

./configure
make
make install

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

stress -c 40

用 40 个线程对所有 CPU（不管你有多少）施加压力，每个线程在随机生成的数字上运行复杂的 sqrt 计算。

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

stress -c 40 -timeout 10s

与使用dd 命令的建议解决方案不同，该命令主要处理IO，因此不会因为处理数据而真正使您的系统过载。

压力程序确实使系统过载，因为要处理计算。

Answer 13

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

yes > /dev/null &

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

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

killall yes

这个想法最初是在here 找到的，虽然它是为 Mac 用户设计的，但它也应该适用于 *nix。

Answer 14

cat /dev/urandom > /dev/null

Answer 15

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

#!/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

Answer 16

我结合了一些答案，并添加了一种将压力扩展到所有可用 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

Answer 17

只需将这个坏男孩粘贴到任何运行 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

Answer 18

利用这里的想法，创建的代码在设定的持续时间后自动退出，不必杀死进程 --

#!/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

Answer 19

加载 3 个核心 5 秒：

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

这会导致来自许多 write() 系统调用的高内核 (sys) 负载。

如果您更喜欢用户级 cpu 负载：

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

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

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

Answer 20

虽然我迟到了，但这篇文章在谷歌搜索“在 linux 中生成负载”中排名靠前。

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

这个想法是从无限数据流（例如/dev/zero、/dev/urandom、...）计算哈希和，这个过程将尝试最大化一个 cpu 核心，直到过程中止。 要为更多内核生成负载，可以将多个命令传送到一起。

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

Answer 21

为了增强 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

Answer 22

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 足够聪明，可以知道一个进程是否只有几秒钟左右，并相应地调整时间窗口。因此，您可以使用此命令立即查看结果。

Answer 23

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

sha1sum /dev/zero &

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

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

top

释放负载

killall sha1sum