So erstellen Sie eine CPU-Spitze mit einem Bash-Befehl

Ich möchte eine nahezu 100% ige Last auf einem Linux-Computer erstellen. Es ist ein Quad-Core-System und ich möchte, dass alle Kerne auf Hochtouren laufen. Im Idealfall würde die CPU-Auslastung eine bestimmte Zeit dauern und dann anhalten. Ich hoffe, es gibt einen Trick in Bash. Ich denke an eine Endlosschleife.

Sie können auch tun

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

Versuchen Sie, mehr davon auszuführen, um mehr Kerne zu belasten:

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

Wiederholen Sie den Befehl in den geschweiften Klammern so oft wie die Anzahl der Threads, die Sie erzeugen möchten (hier 4 Threads). Ein einfacher Enter-Treffer stoppt ihn (stellen Sie nur sicher, dass auf diesem Benutzer kein anderer DD ausgeführt wird, oder Sie töten ihn auch).

Ich benutze Stress für diese Art von Dingen. Sie können sagen, wie viele Kerne maximal genutzt werden sollen. Dadurch können auch Speicher und Festplatte belastet werden .

Beispiel für die Belastung von 2 Kernen für 60 Sekunden

stress --cpu 2 --timeout 60

Ich denke, dieser ist einfacher. Öffnen Sie das Terminal, geben Sie Folgendes ein und drücken Sie die Eingabetaste.

yes > /dev/null &

Um moderne CPUs voll auszunutzen, reicht eine Zeile nicht aus. Möglicherweise müssen Sie den Befehl wiederholen, um die gesamte CPU-Leistung zu verbrauchen.

Um all dies zu beenden, einfach ausgedrückt

killall yes

Die Idee wurde ursprünglich hier gefunden , obwohl sie für Mac-Benutzer gedacht war, aber dies sollte auch für * nix funktionieren.

Obwohl ich zu spät zur Party komme, gehört dieser Beitrag zu den Top-Ergebnissen in der Google-Suche "Load in Linux generieren".

Das als Lösung gekennzeichnete Ergebnis könnte verwendet werden, um eine Systemlast zu erzeugen. Ich bevorzuge sha1sum /dev/zeroes, eine Last auf einen CPU-Kern aufzubringen.

Die Idee ist, eine Hash-Summe aus einem unendlichen Datenstrom (z. B. / dev / zero, / dev / urandom, ...) zu berechnen. Dieser Prozess versucht, einen CPU-Kern zu maximieren, bis der Prozess abgebrochen wird. Um eine Last für mehr Kerne zu erzeugen, können mehrere Befehle miteinander verbunden werden.

z.B. eine 2-Kern-Last erzeugen: sha1sum /dev/zero | sha1sum /dev/zero

Ein Kern (ruft keinen externen Prozess auf):

while true; do true; done

Zwei Kerne:

while true; do /bin/true; done

Letzteres bringt meine beiden nur auf ~ 50% ...

Dieser wird beide zu 100% gehen lassen:

while true; do echo; done

So laden Sie 3 Kerne für 5 Sekunden:

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

Dies führt zu einer hohen Kernel (sys) -Last durch die vielen write () - Systemaufrufe.

Wenn Sie hauptsächlich Userland-CPU-Last bevorzugen:

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

Wenn Sie nur möchten, dass der Ladevorgang fortgesetzt wird, bis Sie Strg-C drücken:

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

Hier ist ein Programm , das Sie herunterladen hier

Einfach auf Ihrem Linux-System installieren

./configure
make
make install

und starten Sie es in einer einfachen Befehlszeile

stress -c 40

sqrtUm alle Ihre CPUs (wie auch immer Sie haben) mit 40 Threads zu belasten, die jeweils eine komplexe Berechnung auf einer weit verbreiteten Zahl ausführen.

Sie können sogar das Timeout des Programms definieren

stress -c 40 -timeout 10s

Im Gegensatz zu der vorgeschlagenen Lösung mit dem ddBefehl, der sich im Wesentlichen mit IOIhrem System befasst und es daher nicht wirklich überlastet, weil er mit Daten arbeitet.

Das Stressprogramm überlastet das System wirklich, weil es sich mit Berechnungen befasst.

:(){ :|:& };:

Diese Gabelbombe wird die CPU zerstören und wahrscheinlich Ihren Computer zum Absturz bringen.

Eine Endlosschleife ist die Idee, die ich auch hatte. Ein freaky aussehender ist:

while :; do :; done

( :ist das gleiche wie true, tut nichts und geht mit Null)

Sie können das in einer Subshell aufrufen und im Hintergrund ausführen. Diese $num_coresZeiten zu tun sollte ausreichen. Nach der gewünschten Zeit schlafen Sie sie alle töten, um die PIDs mit erhalten jobs -p(Tipp: xargs)

Ich würde das Ding in 2 Skripte aufteilen:

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

Ich habe bc( binärer Taschenrechner ) verwendet und sie nach PI mit vielen Dezimalstellen gefragt.

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

mit NUMCPU (unter Linux):

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

Diese Methode ist stark, scheint aber systemfreundlich zu sein , da ich noch nie ein System mit dieser Methode zum Absturz gebracht habe.

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

Ich ging durch das Internet, um so etwas zu finden und fand dieses sehr praktische CPU-Hammer-Skript.

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

Anhand der hier genannten Beispiele, aber auch der Hilfe des IRC, habe ich mein eigenes CPU-Stresstestskript entwickelt. Es verwendet eine Unterschale pro Thread und die Endlosschleifentechnik. Sie können auch die Anzahl der Threads und die Zeitdauer interaktiv angeben.

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

Wenn Sie hier Ideen verwenden und Code erstellen, der nach einer festgelegten Dauer automatisch beendet wird, müssen Sie keine Prozesse beenden.

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

Das macht einen Trick für mich:

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

und es verwendet nichts außer Bash.

Um die Antwort von dimba zu verbessern und etwas steckbareres bereitzustellen (weil ich etwas Ähnliches brauchte). Ich habe Folgendes mit dem dd-Ladekonzept geschrieben: D.

Es überprüft die aktuellen Kerne und erstellt so viele dd-Threads. Start und Ende der Kernlast mit 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

Ich habe einige der Antworten kombiniert und eine Möglichkeit hinzugefügt, den Stress auf alle verfügbaren CPUs zu skalieren:

#!/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's dd if=/dev/zero of=/dev/nullist definitiv richtig, aber es ist auch erwähnenswert, zu überprüfen, ob die CPU auf 100% ausgelastet ist. Sie können dies mit tun

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

Dies fordert die ps-Ausgabe eines 1-Minuten-Durchschnitts der CPU-Auslastung durch jeden Prozess an und summiert sie dann mit awk. Während es sich um einen 1-Minuten-Durchschnitt handelt, ist ps klug genug, um zu wissen, ob ein Prozess nur einige Sekunden gedauert hat, und passt das Zeitfenster entsprechend an. Mit diesem Befehl können Sie das Ergebnis sofort anzeigen.

um die Last zu erhöhen oder die CPU zu 100% zu verbrauchen

sha1sum /dev/zero &

Dann können Sie die CPU-Auslastung durch Eingabe des Befehls anzeigen

top

um die Last freizugeben

killall sha1sum

Fügen Sie diesen bösen Jungen einfach in die SSH oder Konsole eines Servers ein, auf dem Linux ausgeführt wird. Sie können die Prozesse manuell beenden, aber ich schalte den Server einfach schneller aus, wenn ich fertig bin.

Bearbeiten: Ich habe dieses Skript so aktualisiert, dass es jetzt über eine Timer-Funktion verfügt, sodass die Prozesse nicht abgebrochen werden müssen.

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