web-dev-qa-db-fra.com

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 essayé d'exécuter simplement cat /dev/zero > /dev/null, ce qui fonctionne très bien mais n'utilise qu'un seul noyau:

enter image description here

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

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

performancedebianbenchmarking
154
Der Hochstapler

Essayez stress C'est à peu près l'équivalent du code Windows consume.exe:

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

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

Ce one-liner chargera vos quatre noyaux1 à 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’entre eux répète l’instruction null (:). Chaque boucle est capable de charger un cœur de processeur à 100%.

Si vous utilisez bashname__, ksh93 et d’autres shells prenant en charge des plages, vous pouvez utiliser cette syntaxe non portable: dashou old kshname__):

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

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

En supposant que vous n’ayez déjà exécuté aucune tâche d’arrière-plan 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-C va tuer toutes les boucles en fuite aussi. Cette fonction Shell fonctionne au moins sous bashet kshname__.

# 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 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 occupé à 100% ou non)..

90
jlliagre

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 d’exécuter ce script à partir du 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.

Script temp1.py creates three processes (PIDs - 9377, 9378, 9379) which load 3 of my cores

19
Pushpak Dagade

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.

13
rkosegi

Commencer deux

sha1sum /dev/zero &

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

Arrêter

killall sha1sum

ou

kill sha1sum
8
ecabuk

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 faire correspondre le nombre de cœurs de processeur de votre système.

7
ce4

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 à 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
6
Colin King

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
3
Christian Mann

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:

 enter image description here

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

2
user

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 dd if=/dev/zero of=/dev/null pour vos cœurs de processeur.

Appuyez sur une touche pour arrêter le test.

1
Lyma Lyma

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 $@
1
TJR

Une simple ligne de commande le fait aussi:

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

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 nproc fait partie de coreutils et devrait donc figurer sur la plupart des installations Linux.

0
AndreasKralj

pxz est une implémentation parallèle de xz.

pxz -9e /dev/zero --stdout >/dev/null devrait faire l'affaire, car cela nécessite beaucoup de ressources processeur.

Si /dev/zero n'est pas assez rapide (vous remarquez que pxz reçoit des E/S limitées), vous pouvez faire pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Les versions les plus récentes de xz ont l'option --threads, qui remplace pxz.

0
styrofoam fly