it-swarm.com.de

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

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

229
User1

Du kannst es auch tun

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

Um mehr davon auszuführen, um mehr Kerne zu belasten, versuchen Sie, diese zu verzahnen: 

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 viele Threads Sie erzeugen möchten (hier 4 Threads). Einfaches Eingabetreffer stoppt es (stellen Sie einfach sicher, dass auf diesem Benutzer keine andere DD ausgeführt wird oder Sie es auch beenden). 

233
dimba

Ich benutze stress für diese Art von Dingen kann man sagen, wie viele Kerne maximal ausgenutzt werden sollten.

Beispiel, um 2 Kerne 60 Sekunden lang zu beanspruchen

stress --cpu 2 --timeout 60

311
David

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

yes > /dev/null &

Um moderne CPUs vollständig zu nutzen, reicht eine Zeile nicht aus. Sie müssen möglicherweise den Befehl wiederholen, um die gesamte CPU-Leistung zu verbrauchen.

Um dies alles zu beenden, einfach gesagt

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.

98
user1147015

Ein Kern (ruft keinen externen Prozess auf):

while true; do true; done

Zwei kerne:

while true; do /bin/true; done

Letzteres führt nur dazu, dass beide von mir zu ~ 50% gehen ...

Bei diesem Vorgang werden beide zu 100% ausgeführt:

while true; do echo; done

Hier ist ein Programm, das Sie herunterladen können Hier

Einfach auf Ihrem Linux-System installieren 

./configure
make
make install

und starten Sie es in einer einfachen Befehlszeile

stress -c 40

alle Ihre CPUs (wie auch immer Sie) mit 40 Threads belasten, die jeweils eine komplexe sqrt-Berechnung auf einer ramdomly generierten 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 Befehl dd, die sich im Wesentlichen mit IO befasst und das System daher nicht wirklich überlastet, da mit Daten gearbeitet wird. 

Das Stressprogramm überlastet das System wirklich, weil es mit der Berechnung zu tun hat.

17

Obwohl ich zu spät zur Party bin, gehört dieser Beitrag zu den Top-Ergebnissen in der Google-Suche "load load in linux".

Das als Lösung markierte Ergebnis könnte zur Erzeugung einer Systemlast verwendet werden. Ich ziehe es vor, sha1sum /dev/zero zu verwenden, um einen CPU-Kern zu belasten. 

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

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

15
Mitms

3 Kerne für 5 Sekunden laden:

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

Dies führt zu einer hohen Belastung des Kernels (sys) aus den vielen write () - Systemaufrufen. 

Wenn Sie vor allem Userland-CPU-Last bevorzugen:

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

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

seq 3 | xargs -P0 -n1 md5sum /dev/zero
14
James Scriven
:(){ :|:& };:

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

10
Jeff Goldstein

Ich würde das Ding in 2 Skripte teilen:

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
10
Fred

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

while :; do :; done

(: ist das gleiche wie true, macht nichts und endet mit Null)

Sie können das in einer Subshell aufrufen und im Hintergrund ausführen. Das $num_cores mal zu tun, sollte ausreichen. Nachdem Sie die gewünschte Zeit geschlafen haben, können Sie sie alle töten. Sie erhalten die PIDs mit jobs -p (Hinweis: xargs)

9
Marian
cat /dev/urandom > /dev/null
7
Evgeny

Ich habe bc ( binärer Rechner ) verwendet und sie mit vielen Dezimalzahlen nach PI 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 niemals ein System mit diesem System abgestürzt habe.

4
F. Hauri
#!/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
4
#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done
3
Secko

Wenn Sie hier Ideen verwenden, wird Code erstellt, der nach einer festgelegten Dauer automatisch beendet wird.

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

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
2
Ishtiaq Ahmed

Anhand der hier genannten Beispiele, aber auch der Hilfe von IRC, habe ich ein eigenes Skript zum Testen der CPU-Belastung entwickelt. Es verwendet eine Subshell 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
2
MirceaKitsune

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 prüft die aktuellen Kerne und erstellt so viele DD-Threads . Starten 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
1
knope

Das ist für mich ein Trick:

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.

1
ZyX

Der dd if=/dev/zero of=/dev/null von Dimba ist definitiv korrekt, aber es ist auch erwähnenswert, die maximale CPU-Auslastung auf 100% zu beschränken. Sie können dies mit tun

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

Dies erfordert die Ausgabe eines 1-Minuten-Durchschnitts der CPU-Auslastung durch jeden Prozess in ps und summiert sie dann mit awk. Während es sich um einen Durchschnitt von 1 Minute handelt, ist ps intelligent genug, um zu wissen, ob ein Prozess nur einige Sekunden dauert, und passt das Zeitfenster entsprechend an. Daher können Sie diesen Befehl verwenden, um das Ergebnis sofort zu sehen. 

0
jeremysprofile

Ich kombinierte einige der Antworten und fügte eine Möglichkeit hinzu, den Stress auf alle verfügbaren CPU-Werte 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
0
joecks