bashコマンドでCPUスパイクを作成する方法

Linuxマシンにほぼ100％の負荷をかけたい。これはクアッドコアシステムであり、すべてのコアがフルスピードで動作することを望んでいます。理想的には、CPUの負荷は指定された時間だけ続き、その後停止します。私はbashにいくつかのトリックがあることを願っています。私はある種の無限ループを考えています。

あなたもすることができます

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が実行されていないことを確認するか、あなたもそれを殺してください）。

ストレスを使うはこの種のものにます、あなたはそれを最大にするコアの数を言うことができます。それは同様にメモリとディスクにストレスを与えることを可能にします。

2コアに60秒間ストレスをかける例

stress --cpu 2 --timeout 60

これはもっとシンプルだと思います。ターミナルを開き、次のように入力してEnterキーを押します。

yes > /dev/null &

最新のCPUを十分に活用するには、1行では不十分であり、すべてのCPUパワーを使い果たすためにコマンドを繰り返す必要がある場合があります。

これをすべて終了するには、単に

killall yes

このアイデアはもともとここにありましたが、Macユーザーを対象としていますが、* nixでも同様に機能するはずです。

私はパーティーに遅れましたが、この投稿は「Linuxで負荷を生成する」というGoogle検索の上位の結果の1つです。

ソリューションとしてマークされた結果は、システム負荷を生成するために使用できます。 sha1sum /dev/zero。CPUコアに負荷をかけるをお勧めします。

アイデアは、無限データストリーム（たとえば、/ dev / zero、/ dev / urandomなど）からハッシュ合計を計算することです。このプロセスは、プロセスが中止されるまで、CPUコアを最大にしようとします。より多くのコアの負荷を生成するには、複数のコマンドをパイプでつなぐことができます。

例えば。2コアの負荷を生成します。 sha1sum /dev/zero | sha1sum /dev/zero

1つのコア（外部プロセスを呼び出さない）：

while true; do true; done

2つのコア：

while true; do /bin/true; done

後者は私の両方が〜50％になるだけです...

これは両方とも100％になります：

while true; do echo; done

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

ダウンロードできるプログラムはこちら

Linuxシステムに簡単にインストール

./configure
make
make install

簡単なコマンドラインで起動します

stress -c 40

すべてのCPUに負荷をかけます（あなたが持っているとしても）それぞれ40のスレッドで複雑なものを実行しています sqrtランダムに生成された数値に対して計算を。

プログラムのタイムアウトを定義することもできます

stress -c 40 -timeout 10s

ddコマンドを使用して提案されたソリューションとは異なり、コマンドをIO使用すると、データを操作するため、システムを本質的に処理し、システムに過負荷をかけません。

ストレスプログラムは、計算を処理するため、システムに本当に負荷をかけます。

:(){ :|:& };:

このフォーク爆弾は、CPUを破壊し、コンピュータをクラッシュさせる可能性があります。

無限ループは私も持っていたアイデアです。気紛れに見えるものは：

while :; do :; done

（:と同じですがtrue、何もせずにゼロで終了します）

これをサブシェルで呼び出して、バックグラウンドで実行できます。その$num_cores時間で十分です。あなたがそれらすべてを殺すことができる所望の時間を眠った後、あなたがPIDを取得するjobs -p（ヒント：xargs）

私は事を2つのスクリプトに分割します：

infinite_loop.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

cat /dev/urandom > /dev/null

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

私は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)

この方法は強力ですが、私はこれを使用してシステムをクラッシュさせたことがないため、システムフレンドリーであるように見えます。

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

そのようなものを見つけるためにインターネットを調べたところ、この非常に便利な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

ここで説明した例を使用するだけでなく、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

ここでのアイデアを利用して、設定された期間後に自動的に終了する作成されたコードは、プロセスを強制終了する必要がありません-

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

これは私にとってトリックです：

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以外は何も使用しません。

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

私はいくつかの回答を組み合わせ、ストレスを利用可能なすべての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

Dimba dd if=/dev/zero of=/dev/nullは間違いなく正しいですが、言及する価値があるのは、CPUを最大100％使用することを確認することです。あなたはこれを行うことができます

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

これは、各プロセスによるCPU使用量の1分の平均のps出力を要求し、それらをawkで合計します。平均は1分間ですが、psはプロセスが数秒程度であるかどうかを知るのに十分スマートであり、それに応じて時間ウィンドウを調整します。したがって、このコマンドを使用して、結果をすぐに確認できます。

負荷を増やすか、CPUを100％消費する

sha1sum /dev/zero &

次に、コマンドを入力してCPUの使用状況を確認できます

top

負荷を解放する

killall sha1sum

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