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

162

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:

entrez la description de l'image ici

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?

Der Hochstapler
la source
1
est-il possible d'exécuter plusieurs instances catsimultanément?
Nate Koppenhaver le
@NateKoppenhaver: Oui, cela semble possible lorsque vous les enroulez dans des screensessions. Mais je préférerais une solution plus sophistiquée si possible.
Der Hochstapler le
1
Hé, j'ai toujours utilisé cat /dev/random > /dev/null. Devinez /dev/zerofonctionne aussi. :-)
oKtosiTe
8
@oKtosiTe cat / dev / random a pour effet secondaire de réduire l'entropie dans / dev / random. Il y a des moments où vous avez besoin de conserver l'entropie, je n'aurais pas cela pour passer à la catégorie CPU.
Rich Homolka
4
@oKtosiTe Rich Homolka a dit vrai, mais ce n’est pas seulement une mauvaise chose à faire, c’est aussi inutile, car cela bloquera presque immédiatement et arrêtera de consommer du processeur.
Luc

Réponses:

188

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
Mitesh Shah
la source
22
sur Ubuntu, vous pouvez installer avecsudo apt-get install stress
ben
14
sur Debian Wheezy aussi.
Enapupe
10
Sur Fedora,sudo yum install stress
Christopher Markieta
16
Arch:sudo pacman -S stress
das_j
9
brew install stresssur OS X
Christian Long
95

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 1 à 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
  )
}

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

jlliagre
la source
Merci, mais &provoque une commande à exécuter dans un thread séparé ou un noyau séparé ? Je suis confus.
mmdemirbas
3
@mmdemirbas: L'esperluette provoque l'exécution de la commande en tant que processus séparé. Le planificateur envoie ensuite tous les processus actifs à tous les cœurs disponibles.
jlliagre
1
Pour rappel, vous pouvez arrêter ce test en émettant killall bash- assurez-vous simplement qu'aucun autre script important n'est en cours d'exécution à ce moment-là.
un codeur
1
@ acoder Merci d'avoir suggéré un moyen de mettre fin à la boucle. Je voudrais cependant éviter killall bash. Répondez modifié pour ajouter une méthode plus sûre pour mettre fin à la génération de charge.
jlliagre
1
+1 pour la fonction shell lc
Akira Yamamoto
20

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.

Le script temp1.py crée trois processus (PID - 9377, 9378, 9379) qui chargent 3 de mes cœurs

Pushpak Dagade
la source
3
Quel programme utilisiez-vous pour afficher l'utilisation du processeur de cette manière? Cela me rappelle top, mais je ne me souviens pas des "graphiques" de la CPU.
Jftuga
13
@jftuga probablement htop , le plus beau frère de top .
BoppreH
2
oui c'est htop. Meilleur visualiseur de processus interactif en temps réel et coloré pour linux - htop.sourceforge.net
Pushpak Dagade
3
Ne faisait pas attention et a exécuté ceci sur une boîte de Windows. Très mauvaises choses ...
Derrick
13

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.

rkosegi
la source
8

Commencer deux

sha1sum /dev/zero &

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

Arrêter

killall sha1sum

ou

kill sha1sum
ecabuk
la source
7

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.

ce4
la source
6

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
Colin King
la source
6
Veuillez lire Comment recommander un logiciel pour des conseils sur la façon de procéder. À tout le moins, vous devez fournir plus que juste / au moins un lien, par exemple des informations supplémentaires sur le logiciel lui-même et sur la manière dont il peut être utilisé pour résoudre le problème de la question.
DavidPostill
3

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
Christian Mann
la source
1
Est-ce que cela ne rendrait pas la terminaison des processus un peu compliquée?
octobre
1
killall catdevrait le faire.
Christian Mann
1
Selon que vous ayez ou non d'autres catprocessus en cours d'exécution (ce que je fais habituellement).
OKtosiTe
2

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:

entrez la description de l'image ici

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

utilisateur
la source
1

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

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.

Lyma Lyma
la source
1

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.

mouche en polystyrène
la source
1

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.

Yichun
la source
0

Une simple ligne de commande le fait aussi:

x="x" ; while : ; do x=$x$x ; echo -n "." ; done
ott--
la source
1
Ce serait plus simple:while : ; do : ; done
Jlliagre
@jlliagre Le vôtre ne va pas au-dessus de loadavg 1.
octobre--
Votre boucle ne charge pas principalement le processeur mais davantage la mémoire. Il finira par planter avec une erreur de mémoire insuffisante.
jlliagre
@jlliagre Mine remplit la mémoire et permute (le cas échéant), générant ainsi une charge de 3 avant de la tuer car elle manque de mémoire.
ott--
4
C'est le problème. Vous ne répondez pas à la question qui est posée: comment produire une charge de processeur élevée sur un serveur. Votre script rend rapidement un système inactif, puis se bloque. Il existe des moyens beaucoup plus fiables pour obtenir un loadavg de 3. Exemple:for i in 1 2 3; do while : ; do : ; done & ; done
jlliagre
0

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.

AndreasKralj
la source