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

Ich bin gerade dabei, eine Cacti-Installation zu debuggen und möchte eine CPU-Auslastung erstellen, um meine CPU-Auslastungsdiagramme zu debuggen.

Ich habe versucht, einfach zu laufen cat /dev/zero > /dev/null, was großartig funktioniert, aber nur 1 Kern verwendet:

Gibt es eine bessere Methode zum Testen / Maximieren der Systemressourcen unter Last?

Verwandte Themen : Wie kann ich unter Windows eine hohe CPU-Last erzeugen?

Versuchen stress Es ist so ziemlich ein Äquivalent von 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 ist in der Lage, dies alleine zu tun.

Dieser One-Liner lädt Ihre vier Kerne ¹ zu 100%:

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

Wie es funktioniert ist ganz einfach, es werden vier Endlosschleifen gestartet. Jeder von ihnen wiederholt die Null-Anweisung ( :). Jede Schleife kann einen CPU-Kern zu 100% laden.

Wenn Sie verwenden bash, ksh93und andere Schalen Bereiche unterstützen, (dh nicht dashoder älter ksh), können Sie diese nicht tragbar Syntax verwenden:

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

Ersetzen Sie diese 4durch die Anzahl der CPUs, die Sie laden möchten, falls diese von abweichen 4.

Angenommen, Sie hatten bereits keinen Hintergrundjob ausgeführt, als Sie eine dieser Schleifen gestartet haben, können Sie die Ladegenerierung mit dem folgenden Befehl stoppen:

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

Beantwortet man den Kommentar von @ underscore_d, so handelt es sich um eine verbesserte Version, die das Stoppen des Ladevorgangs erheblich vereinfacht und die Angabe einer Zeitüberschreitung (Standard 60 Sekunden) ermöglicht. A Control- CBringt auch alle außer Kontrolle. Diese Shell-Funktion funktioniert mindestens unter bashund 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
  )
}

¹ _{Beachten Sie, dass bei CPUs, die mehr als einen Thread pro Kern unterstützen (Hyper-Threading), das Betriebssystem die Last an alle virtuellen CPUs verteilt. In diesem Fall ist das Ladeverhalten von der Implementierung abhängig (jeder Thread wird möglicherweise als zu 100% ausgelastet gemeldet oder nicht).} .

Ich habe ein einfaches Python-Skript erstellt, das dasselbe tut. Sie können die Anzahl der zu ladenden CPU-Kerne steuern. Das Gute daran ist, dass es keine andere Ressource als die CPU 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 aus $ python temp1.py. Sie müssen das Skript beenden, wenn Sie fertig sind.

Hier ist meine CPU-Verbrauchsleistung, wenn ich 3 meiner Kerne lade.

Ein alternativer Weg wäre

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

oder (falls nproc vorhanden ist)

openssl speed -multi $(nproc --all)

OpenSSL ist heutzutage fast immer in Distributionen verfügbar, daher werden keine zusätzlichen Pakete benötigt.

Beginnen Sie zwei

sha1sum /dev/zero &

Befehle für jeden Kern in Ihrem System.

Stoppen

killall sha1sum

oder

kill sha1sum

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 belasten möchten oder müssen.

Hinweis: Dadurch wird so viel Chipfläche wie möglich beansprucht und gleichzeitig eine maximale Verlustleistung programmiert. Ich musste diesen Beitrag ein zweites Mal schreiben, irgendwie hat es meinem Rechner nicht gefallen :-(

Sie können cpuburn auch in folgenden Sequenzen ausführen:

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

Und wenn du sie aufhalten willst:

killall burnP6

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

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 Verwendung ist ähnlich wie bei 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 Sie mit

sudo apt-get install stress-ng

Sie können diesen Befehl so oft ausführen, wie Sie möchten, 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 dynamisches Beispiel, in dem 50% Last auf CPU-Kern 0 erzeugt werden:

Sie können den Prozess gleichzeitig auf anderen Kernen ausführen.

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 verwenden:

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

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

pxzist eine parallele Implementierung von xz.

pxz -9e /dev/zero --stdout >/dev/null sollte den Trick machen, da dies ziemlich CPU-intensiv ist.

Wenn /dev/zeroes nicht schnell genug ist (Sie bemerken, dass die pxzE / A gedrosselt werden), können Sie dies tun pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Neuere Versionen von xzhaben die --threadsOption, die ein Ersatz für ist pxz.

Hier ist die Art, wie ich es benutze 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 mit der Option "-P" oben ändern.

Eine einfache Kommandozeile macht es auch:

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

Ich wollte dies zu @ jlliagres Kommentar hinzufügen, aber ich habe nicht genug Ruf. Wenn Sie diesen Code auf mehreren Servern verwenden und die CPU-Anzahl variiert, können Sie den folgenden Befehl verwenden:

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

Dadurch werden alle Kerne auf Ihrem Server verwendet, unabhängig davon, wie viele Sie haben. Der Befehl nprocist Teil von coreutils und sollte daher auf den meisten Linux-Installationen vorhanden sein.