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

281

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.

Benutzer1
quelle

Antworten:

283

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

dimba
quelle
35
dd befasst sich mehr mit E / A als mit CPU-Auslastung
Fred
2
Dies funktionierte tatsächlich am besten für meine Situation. Es hat auch in Cygwin funktioniert. Aus irgendeinem Grund würden die anderen Lösungen die CPU nicht ganz anspitzen. Das Hinzufügen einer Zählung und das parallele Ausführen von vier Prozessen funktionierte perfekt. Die CPU wurde zu 100% nach oben und dann ohne Hilfe auf Null zurückgesetzt. Nur vier Codezeilen und ein "Warten".
Benutzer1
62
Lesen /dev/zeround Schreiben /dev/nullist kein sehr guter Lastgenerator - Sie müssen viele davon ausführen, um eine signifikante Last zu erzeugen. Besser so etwas zu tun dd if=/dev/urandom | bzip2 -9 >> /dev/null. /dev/urandomerfordert erheblich mehr Aufwand, um eine Ausgabe zu generieren, und erfordert bzip2viel Aufwand beim Versuch, sie zu komprimieren. Daher ist die CPU-Gesamtauslastung viel höher als "Füllen Sie einen Block mit Nullen und werfen Sie ihn dann weg".
Twalberg
4
Verwenden jobs -p | xargs killSie diese Option, um nur die von Ihnen erstellten Prozesse abzubrechen.
Marian
5
@twalberg, du solltest deinen Kommentar zu einer Antwort machen.
Aaron McDaid
362

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

David
quelle
6
Auf Fedora,sudo yum install stress
Christopher Markieta
3
Sie müssen EPELfür CentOSwget http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
Satish
4
brew install stressunter OS X. Auch aus irgendeinem Grund musste ich 8 Kerne auf einem Quad-Core-MBPr angeben
fregante
1
@ bfred.it Ihre Kerne verwenden möglicherweise Hyperthreading, wodurch sich die Anzahl der Kerne (4 physische und 4 virtuelle Kerne) effektiv verdoppelt. Sie sollten auch die virtuellen für einen Volllasttest betonen.
Mast
6
sudo apt-get install stressder Vollständigkeit halber auf Debian-basierten Systemen. Damit wurde ein Kühlmod auf dem Intel i7 NUC Kit getestet .
Onmylemon
133

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.

user1147015
quelle
7
+1 Funktioniert wie ein Zauber, danke! Erwähnenswert : Mit diesem Befehl wird maximal ein Hyperthread pro CPU-Kern ausgeführt. Eine Dual-Core-CPU (jeder Core hat 2 Threads) erhält also eine Gesamtlast von 25% pro yesBefehl (vorausgesetzt, das System war ansonsten inaktiv).
GitaarLAB
Um dies hinzuzufügen, erhöht jede Iteration dieses Befehls die CPU (Android) um 25 Prozent bis zu 4 Iterationen, und der Rest hat keine Auswirkung (selbst in Bezug auf die Taktrate).
user3188978
30

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

Mitms
quelle
Dies ist besser als dd für die CPU-Auslastung. Ich bekomme eine maximale CPU-Auslastung von 44% auf dd (6-mal) und 86% + auf sha1sum. Danke ~!
AAI
26

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
L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳
quelle
Bei Echo verlieren wir den Zugriff auf Linux. Wie kann man diesen dritten Befehl in den Hintergrund stellen?
AAI
2
Warum macht Echo alle CPU-Kerne zu 100%?
Haoyuan Ge
@HaoyuanGe Alle CPUs sind nur dann 100%, wenn "nichts" wiedergegeben wird. Ersetzen Sie das do-Echo. mit do echo "eine sehr sehr lange Saite"; <100% auf dem CPU zu sehen. Ich glaube also, dass das Echo von nichts viel weniger Sprünge und damit mehr Code zum Ausführen hat (weil while true;). Die Kerne sind zu 100% ausgelastet
TalekeDskobeDa
Wenn Sie einen Server während der Ausführung eines solchen Tests reaktionsfähig halten möchten, tun Sie dies in einer separaten Shell (einem anderen tmux / screen-Fenster oder einer ssh-Sitzung) und wiederholen Sie diese Shell zuerst, z renice 19 -p $$. B. in bash : . Die CPUs werden weiterhin maximal beansprucht, andere Prozesse werden jedoch nicht beeinträchtigt.
Walf
23

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
James Scriven
quelle
1
Ist das von tinycore möglich? xargs: ungültige Option - 'P'
conman253
nette native Option
Insign
18

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.

Fopa Léon Constantin
quelle
4
Es gibt bereits eine Antwort oben für den stressBefehl. Wie diese Antwort sagt, können Sie es einfach über yum / apt / etc. Installieren.
Asfand Qazi
1
Die Website ist nicht in gutem Zustand (503 verboten), aber auf den Repos verfügbar :)
m3nda
11
:(){ :|:& };:

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

Jeff Goldstein
quelle
13
Es hilft, wenn ich das Lesen von fork_bomb () {fork_bomb | einfacher mache fork_bomb &}; Gabelbombe
Jeff Goldstein
17
Dieser scheitert am Kriterium "Letzte festgelegte Zeit und dann Stopp";)
Marian
14
sieht aus wie ein Haufen Smileys.
Ponkadoodle
2
Diese Gabelbombe stürzte meinen Computer ab, ich musste einen harten Stromzyklus machen.
Elijah Lynn
2
Von: cyberciti.biz/faq/understanding-bash-fork-bomb WARNUNG ! Diese Beispiele können Ihren Computer zum Absturz bringen, wenn sie ausgeführt werden. "Sobald eine erfolgreiche Gabelbombe in einem System aktiviert wurde, kann der normale Betrieb möglicherweise nicht wieder aufgenommen werden, ohne das System neu zu starten. Die einzige Lösung für eine Gabelbombe besteht darin, alle Instanzen davon zu zerstören."
Elijah Lynn
11

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)

Marian
quelle
10

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
Fred
quelle
7
cat /dev/urandom > /dev/null
Evgeny
quelle
Fügen Sie auch einen Kommentar hinzu, es hilft.
Lokesh
4
#!/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
Bis auf weiteres angehalten.
quelle
4

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.

F. Hauri
quelle
3
#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done
Secko
quelle
1
Ähm nein. Schlafen ist nicht diese Art von Aufgabe, die viel CPU auf die CPU bringt:-)
Marian
2

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
Ishtiaq Ahmed
quelle
Muss es wirklich so lange dauern? Ich mag Einzeiler am liebsten für diese Art von Aufgabe…
Nikana Reklawyks
1
Die if-then-else-Klausel kann ersetzt werden durch : NUM_PROC=${1:-10}.
Thor
2

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
MirceaKitsune
quelle
Fehler "Zeile 14: Task-Set: Befehl nicht gefunden" in Ihrem Skript erhalten! irgendeine Idee?
user2912312
2

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
Dhiraj
quelle
1

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.

ZyX
quelle
1

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
knope
quelle
0

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
Joecks
quelle
0

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.

jeremysprofile
quelle
0

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
44kksharma
quelle
-1

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
GarretSidzaka
quelle