Wie kann ich hohe CPU-Last auf einem Linux-Server erzeugen?

Versuchen Sie stress Es ist so ziemlich ein Äquivalent zu Windows consume.exe:

oliver$ ./stress --cpu 3
stress: info: [18472] dispatching hogs: 3 cpu, 0 io, 0 vm, 0 hdd

Sie brauchen kein zusätzliches Paket zu installieren, Ihre gute alte Shell kann das alleine tun.

Dieser Einzeiler lädt Ihre vier Cores1 zu 100%:

for i in 1 2 3 4; do while : ; do : ; done & done

Wie das funktioniert, ist ganz einfach, er startet vier Endlosschleifen. Jede dieser Schleifen wiederholt die Null-Anweisung (:). Jede Schleife ist in der Lage, einen CPU-Kern zu 100% zu laden.

Wenn Sie bash, ksh93 und andere Shells verwenden, die Bereiche unterstützen (d.h. nicht dash oder ältere ksh), können Sie diese nicht portable Syntax verwenden:

for i in {1..4}; do ...

Ersetzen Sie 4 durch die Anzahl der CPUs, die Sie laden möchten, wenn sie sich von 4 unterscheidet.

Angenommen, Sie hatten keinen Hintergrund-Job, der bereits lief, als Sie eine dieser Schleifen gestartet haben, dann können Sie die Lastgenerierung mit diesem Befehl stoppen:

for i in 1 2 3 4; do kill %$i; done

Auf den Kommentar von @underscore_d antwortend, hier ist eine verbesserte Version, die das Stoppen der Last sehr vereinfacht und die es auch erlaubt, einen Timeout anzugeben (Voreinstellung 60 Sekunden. Diese Shell-Funktion funktioniert mindestens unter bash und ksh.

# Usage: lc [number_of_cpus_to_load [number_of_seconds] ]
lc() {
  (
    pids=""
    cpus=${1:-1}
    seconds=${2:-60}
    echo loading $cpus CPUs for $seconds seconds
    trap 'for p in $pids; do kill $p; done' 0
    for ((i=0;i<cpus;i++)); do while : ; do : ; done & pids="$pids $!"; done
    sleep $seconds
  )
}

1Hinweis: Bei CPUs, die mehr als einen Thread pro Kern unterstützen (Hyper-Threading), wird das Betriebssystem die Last an alle virtuellen CPUs verteilen. In diesem Fall ist das Lastverhalten implementierungsabhängig (jeder Thread kann als zu 100% ausgelastet oder nicht ausgelastet gemeldet werden).

Ich habe ein einfaches Python-Skript erstellt, das dasselbe tut. Sie können die Anzahl der CPU-Kerne, die Sie laden wollen, kontrollieren. Das Gute daran ist, dass es außer der CPU keine weiteren Ressourcen verbraucht (ich denke, Mark Johnsons Idee würde eine Menge I/O-Ressourcen verbrauchen, was hier unerwünscht ist)

from multiprocessing import Pool

def f(x):
    # Put any cpu (only) consuming operation here. I have given 1 below -
    while True:
        x * x

# decide how many cpus you need to load with.
no_of_cpu_to_be_consumed = 3

p = Pool(processes=no_of_cpu_to_be_consumed)
p.map(f, range(no_of_cpu_to_be_consumed))

Führen Sie dieses Skript einfach vom Terminal $ python temp1.py aus. Sie müssen das Skript beenden, wenn Sie fertig sind.

Hier ist die Ausgabe meines CPU-Verbrauchs, wenn ich 3 meiner Cores lade.

Eine Alternative wäre

openssl speed -multi $(grep -ci processor /proc/cpuinfo)

oder (wenn nproc vorhanden ist)

openssl speed -multi $(nproc --all)

OpenSSL ist auf heutigen Distributionen fast immer vorhanden, so dass keine zusätzlichen Pakete benötigt werden.

Starten Sie zwei Befehle

sha1sum /dev/zero &

für jeden Kern in Ihrem System.

Zum Stoppen von

killall sha1sum

oder

kill sha1sum

Ich habe stress-ng entwickelt, ein aktualisiertes Stress-Tool, das eine Vielzahl von Aspekten eines Linux-Systems hervorheben kann. Weitere Informationen finden Sie unter http://kernel.ubuntu.com/~cking/stress-ng/

Die Benutzung ist ähnlich wie stress

$ stress-ng --cpu 4 --vm 2 --fork 8 --switch 4 --timeout 1m
stress-ng: info: [32254] dispatching hogs: 4 cpu, 8 fork, 4 switch, 2 vm
stress-ng: info: [32254] cache allocate: default cache size: 8192K

Installieren mit

sudo apt-get install stress-ng

Normalerweise nehme ich die cpuburn-Suite:

sudo apt-get install cpuburn
for i in {1..4}; do burnK7 & done

Ersetzen Sie 4 durch die Anzahl der Kerne / HT-Threads, die Sie haben oder betonen wollen.

Hinweis: Dadurch wird so viel Chipfläche wie möglich gleichzeitig beansprucht, es ist so programmiert, dass es maximale Verlustleistung erzeugt. Ich musste diesen Beitrag ein zweites Mal schreiben, irgendwie gefiel er meiner Maschine nicht :-(

Sie könnten auch cpuburn in Sequenzen machen:

burnP6 & burnP6 & burnP6 & burnP6 & 
[1] 28520
[2] 28521
[3] 28522
[4] 28523

Und wenn Sie sie stoppen wollen:

killall burnP6

Sie könnten auch burnP6 & multiplizieren, um die Anzahl der CPU-Kerne auf Ihrem System anzupassen.

Sie können diesen Befehl so oft ausführen, wie Sie wollen, und er nimmt jedes Mal einen anderen Kern ein:

$ CORES=1
$ for i in `seq 1 $CORES`; do cat /dev/zero > /dev/null &
> done
[1] 8388

https://github.com/GaetanoCarlucci/CPULoadGenerator

ziemlich einfache und wissenschaftliche Lösung.

Hier sehen Sie ein Dynamik-Beispiel, bei dem 50% Last auf CPU-Kern 0 erzeugt wird:

Sie können den Prozess gleichzeitig auf anderen Kernen laufen lassen.

pxz ist eine parallele Implementierung von xz.

pxz -9e /dev/zero --stdout >/dev/null sollte den Zweck erfüllen, da dies recht rechenintensiv ist.

Wenn /dev/zero nicht schnell genug ist (Sie stellen fest, dass pxz E/A gedrosselt wird), können Sie pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Neuere Versionen von xz haben die Option --threads, die ein Ersatz für pxz ist.

Ich habe +jlliagre und +ecabuk kombiniert.

#!/bin/bash
lc() {
    nowMs=$(date +%s)
    (
        pids=""
        cpus=${1:-1}
        seconds=${2:-60}
        echo "[$(date)] loading $cpus CPUs for $seconds seconds"
        echo "[$(date)] Expected completion: [$(date --date=@$(expr $nowMs + $seconds))]"
        trap 'for p in $pids; do kill $p; done' 0
        for ((i=0;i<cpus;i++)); do
            sha1sum /dev/zero &
            pids="$pids $!";
        done
        sleep $seconds
    )
    echo "[$(date)] Done"
}

lc $@

Sie können:

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 dd if=/dev/zero of=/dev/null für Ihre CPU-Kerne.

Drücken Sie eine beliebige Taste, um den Test zu beenden.

So benutze ich es und es ist nicht nötig, etwas extra zu installieren.

Zum Beispiel mit 4 Prozessen zu beginnen,

nproc | xargs seq | xargs -n1 -P4 md5sum /dev/zero

Sie können die Anzahl der Prozesse durch die obige Option “-P” ändern.

Eine einfache Befehlszeile tut es auch:

x="x" ; while : ; do x=$x$x ; echo -n "." ; done

Ich wollte dies dem Kommentar von @jlliagre hinzufügen, aber ich habe nicht genug Ansehen. Wenn Sie diesen Code auf mehreren Servern verwenden wollen und die Anzahl der CPUs variiert, können Sie den folgenden Befehl verwenden:

for ((i=1; i<=`nproc --all`; i++)); do while : ; do : ; done & done

Dies wird alle Kerne auf Ihrem Server nutzen, unabhängig davon, wie viele Sie haben. Der Befehl nproc ist Teil von Coreutils und sollte daher auf den meisten Linux-Installationen vorhanden sein.