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

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

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

Ce one-liner chargera vos quatre cœurs1 à 100% :

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

Comment ça marche est assez simple, il démarre quatre boucles sans fin. Chacune d'entre elles répète l'instruction nulle (:). Chaque boucle est capable de charger un coeur de CPU à 100%.

Si vous utilisez bash, ksh93 et d'autres shells supportant des gammes, (c'est-à-dire pas dash ou plus ancien ksh), vous pouvez utiliser cette syntaxe non portable :

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

Remplacez 4 par le nombre de CPU que vous souhaitez charger s'il est différent de 4. En supposant que vous n'aviez pas de tâche de fond déjà en cours d'exécution lorsque vous avez lancé une de ces boucles, vous pouvez arrêter la génération de la charge avec cette commande :

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

En réponse au commentaire de @underscore_d, voici une version améliorée qui simplifie beaucoup l'arrêt de la charge et qui permet également de spécifier un délai d'attente (60 secondes par défaut.) Un Control-C tuera également toutes les boucles qui s'enfuient. Cette fonction shell fonctionne au moins sous bash et 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
  )
}

1Notez qu'avec les CPU supportant plus d'un thread par noyau (Hyper-threading), l'OS va distribuer la charge à tous les CPU virtuels. Dans ce cas, le comportement de la charge dépend de l'implémentation (chaque thread peut être signalé comme étant occupé à 100% ou non)…

J'ai fait un simple script python qui fait la même chose. Vous pouvez contrôler le nombre de cœurs de processeurs que vous voulez charger. L'avantage est que cela ne consommera aucune autre ressource que le processeur (je pense que l'idée de Mark Johnson consommerait beaucoup de ressources 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 quand vous avez terminé.

Voici la sortie de ma consommation cpu quand je charge 3 de mes cœurs.

Une alternative 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 distros actuelles, donc aucun paquet supplémentaire n'est nécessaire.

Démarrez deux

sha1sum /dev/zero &

commandes pour chaque noyau de votre système.

Pour arrêter

killall sha1sum

ou

kill sha1sum

J'ai développé le stress-ng, un outil de stress mis à jour qui peut mettre l'accent sur 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 à 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

Je prends généralement la suite cpuburn :

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

Remplacez 4 par le nombre de noyaux / fils HT que vous avez ou que vous voulez mettre sous tension.

Note : Cette suite met sous tension autant de surface de puce que possible en même temps, elle est programmée pour générer une dissipation de puissance maximale. J'ai dû écrire ce post une seconde fois, mais ma machine n'a pas aimé :-(

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 aussi multiplier burnP6 & pour correspondre au nombre de cœurs de votre système.

Vous pouvez exécuter cette commande autant de fois que vous le souhaitez, et elle occupera 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.

Ici vous pouvez voir un exemple de dynamique dans lequel 50% de la charge est générée sur le noyau 0 du CPU :

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

Si pxz n'est pas assez rapide (vous remarquez que xz se fait étrangler au niveau des E/S), vous pouvez fairepxz -9e /dev/zero --stdout >/dev/null

Les versions plus récentes de /dev/zero ont l'option pxz qui est un substitut de pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null.

J'ai combiné +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

Repeat dd if=/dev/zero of=/dev/null pour vos cœurs de processeurs.

Appuyez sur n'importe quelle touche pour arrêter le test.

Voici la façon dont j'utilise et il n'est pas nécessaire d'installer quoi que ce soit de plus.

Par exemple pour commencer avec 4 processus,

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

Vous pouvez changer le nombre de processus par 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 allez utiliser ce code sur plusieurs serveurs et que le nombre de CPU 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 dont vous disposez. La commande nproc fait partie des coreutils et devrait donc être utilisée sur la plupart des installations Linux.