Comment puis-je produire une charge de processeur élevée sur un serveur Linux?

Je suis actuellement en train de déboguer une installation Cacti et je souhaite créer une charge de processeur pour déboguer mes graphiques d'utilisation du processeur.

J'ai simplement essayé de courir cat /dev/zero > /dev/null, ce qui fonctionne très bien mais n'utilise qu'un seul noyau:

Existe-t-il une meilleure méthode de test / utilisation maximale des ressources système sous charge?

Connexe: Comment puis-je générer une charge de processeur élevée sous Windows?

Essayez stress c'est à peu près l'équivalent de Windows consume.exe:

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

Nul besoin d'installer un paquet supplémentaire, votre bon vieux shell est capable de le faire seul.

Ce one-liner chargera vos quatre noyaux ¹ à 100%:

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

Comment ça marche est assez simple, il commence quatre boucles sans fin. Chacun d'eux répète l'instruction null ( :). Chaque boucle est capable de charger un cœur de processeur à 100%.

Si vous utilisez bash, ksh93et d' autres coquilles supportant des gammes, (c. -à- pas dashou plus ksh), vous pouvez utiliser cette syntaxe non portable:

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

Remplacez-le 4par le nombre de CPU que vous souhaitez charger si différent de 4.

En supposant qu'aucune tâche en arrière-plan ne soit en cours d'exécution lorsque vous avez lancé l'une de ces boucles, vous pouvez arrêter la génération de charge à l'aide de cette commande:

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

Répondant au commentaire de @ underscore_d, voici une version améliorée qui simplifie beaucoup l'arrêt du chargement et qui permet également de spécifier un délai d'attente (60 secondes par défaut). A Control- Csupprimera également toutes les boucles en fuite. Cette fonction shell fonctionne au moins sous bashet 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
  )
}

¹ _{Notez qu'avec les processeurs prenant en charge plusieurs threads par cœur (Hyper-threading), le système d'exploitation distribue la charge à tous les processeurs virtuels. Dans ce cas, le comportement de la charge dépend de la mise en œuvre (chaque thread peut être signalé comme étant occupé à 100% ou non).} .

J'ai fait un script python simple qui fait la même chose. Vous pouvez contrôler le nombre de cœurs de processeur que vous souhaitez charger. La bonne chose à ce propos est qu’elle ne consommera aucune autre ressource que le processeur. (Je pense que l’idée de mark johnson consomme beaucoup de ressources d’E / S, ce qui n’est pas souhaitable ici.)

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

Il suffit de lancer ce script depuis le terminal $ python temp1.py. Vous devez tuer le script lorsque vous avez terminé.

Ici, c’est ma sortie de consommation de CPU lorsque je charge 3 de mes cœurs.

Une autre solution serait

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

ou (si nproc est présent)

openssl speed -multi $(nproc --all)

OpenSSL est presque toujours présent sur les distributions actuelles, donc aucun paquet supplémentaire n'est nécessaire.

Commencer deux

sha1sum /dev/zero &

commandes pour chaque cœur de votre système.

Arrêter

killall sha1sum

ou

kill sha1sum

Je prends habituellement la suite cpuburn:

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

Remplacez 4 par le nombre de cœurs / fils HT que vous avez ou voulez stresser.

Remarque: Cela sollicite autant que possible la zone de copeaux en même temps. Il est programmé pour générer une dissipation de puissance maximale. J'ai dû écrire ce billet une seconde fois, ma machine ne l'aimait pas du tout :-(

Vous pouvez aussi faire cpuburn en séquences:

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

Et quand vous voulez les arrêter:

killall burnP6

Vous pouvez également multiplier burnP6 &pour correspondre au nombre de cœurs de processeur de votre système.

J'ai développé stress-ng, un outil de stress mis à jour qui peut mettre en évidence un large éventail d'aspects d'un système Linux. Pour plus d'informations, voir http://kernel.ubuntu.com/~cking/stress-ng/

L'utilisation est similaire au 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

Installer avec

sudo apt-get install stress-ng

Vous pouvez exécuter cette commande autant de fois que vous le souhaitez, et cela nécessitera un noyau différent à chaque fois:

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

https://github.com/GaetanoCarlucci/CPULoadGenerator

solution assez simple et scientifique.

Vous pouvez voir ici un exemple de dynamique dans laquelle 50% de la charge est générée sur le cœur de processeur 0:

Vous pouvez exécuter le processus sur d'autres cœurs en même temps.

J'ai combiné les deux + jlliagre et + ecabuk.

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

Vous pouvez utiliser:

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

Répétez l'opération dd if=/dev/zero of=/dev/nullpour vos cœurs de processeur.

Appuyez sur une touche pour arrêter le test.

pxzest une implémentation parallèle de xz.

pxz -9e /dev/zero --stdout >/dev/null devrait faire l'affaire, car c'est assez intensif en cpu.

Si /dev/zeron’est pas assez rapide (vous remarquez que l’ pxzE / S est étranglé), vous pouvez le faire. pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Les nouvelles versions de xzont l' --threadsoption qui se substitue à pxz.

Voici comment je l'utilise et il n'y a pas besoin d'installer quoi que ce soit d'autre.

Par exemple, pour commencer avec 4 processus,

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

Vous pouvez modifier le nombre de processus à l'aide de l'option "-P" ci-dessus.

Une simple ligne de commande le fait aussi:

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

Je voulais ajouter ceci au commentaire de @ jlliagre, mais je n'ai pas assez de réputation. Si vous utilisez ce code sur plusieurs serveurs et que le nombre de processeurs varie, vous pouvez utiliser la commande suivante:

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

Cela utilisera tous les cœurs de votre serveur, quel que soit le nombre de vos cœurs. La commande nprocfait partie de coreutils et devrait donc l'être sur la plupart des installations Linux.