Comment créer un pic CPU avec une commande bash

281

Je veux créer une charge proche de 100% sur une machine Linux. C'est un système quad core et je veux que tous les cœurs tournent à pleine vitesse. Idéalement, la charge du processeur durerait un certain temps, puis s'arrêterait. J'espère qu'il y a une astuce dans bash. Je pense à une sorte de boucle infinie.

Utilisateur1
la source

Réponses:

283

Vous pouvez aussi faire

dd if=/dev/zero of=/dev/null

Pour en exécuter davantage pour charger davantage de cœurs, essayez de le bifurquer:

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 la commande entre accolades autant de fois que le nombre de fils que vous souhaitez produire (ici 4 fils). Une simple entrée va l'arrêter (assurez-vous simplement qu'aucun autre dd n'est en cours d'exécution sur cet utilisateur ou vous le tuez aussi).

dimba
la source
35
dd traite plus des E / S que de l'utilisation du processeur
Fred
2
Cela a réellement fonctionné le mieux pour ma situation. Il a également fonctionné à Cygwin. Pour une raison quelconque, les autres solutions ne seraient pas tout à fait à pic sur le CPU. L'ajout d'un décompte et la création de quatre processus en parallèle ont parfaitement fonctionné. Il a dopé le CPU à 100% en haut puis redescendu à zéro sans aucune aide. Seulement quatre lignes de code et une "attente".
User1
62
La lecture /dev/zeroet l'écriture /dev/nullne sont pas un très bon générateur de charge - vous devez en exécuter beaucoup pour générer une charge importante. Mieux vaut faire quelque chose comme dd if=/dev/urandom | bzip2 -9 >> /dev/null. /dev/urandomnécessite beaucoup plus d'efforts pour générer la sortie, et bzip2dépensera beaucoup d'efforts pour essayer de la compresser, donc l'utilisation globale du CPU est beaucoup plus élevée que "remplir un bloc de zéros, puis le jeter".
twalberg
4
Utilisez jobs -p | xargs killpour tuer uniquement les processus que vous avez créés.
Marian
5
@twalberg, vous devez faire de votre commentaire une réponse.
Aaron McDaid
363

J'utilise le stress pour ce genre de chose, vous pouvez lui dire combien de cœurs au maximum .. cela permet également de stresser la mémoire et le disque.

Exemple pour stresser 2 cœurs pendant 60 secondes

stress --cpu 2 --timeout 60

David
la source
6
Sur Fedora,sudo yum install stress
Christopher Markieta
3
Vous devez EPELrepo pour CentOSwget http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
Satish
4
brew install stresssous OS X. Aussi pour une raison quelconque, j'ai dû spécifier 8 cœurs sur un MBPr quad-core
fregante
1
@ bfred.it Vos cœurs peuvent utiliser l'hyperthreading, doublant efficacement votre nombre de cœurs (4 cœurs physiques et 4 virtuels). Vous aurez également besoin de souligner les virtuels pour un test à pleine charge.
mât
6
sudo apt-get install stresssur les systèmes basés sur Debian, pour être complet. Utilisé pour tester un mod de refroidissement sur le kit Intel i7 NUC .
onmylemon
133

Je pense que celui-ci est plus simple. Ouvrez Terminal et tapez ce qui suit et appuyez sur Entrée.

yes > /dev/null &

Pour utiliser pleinement les processeurs modernes, une ligne ne suffit pas, vous devrez peut-être répéter la commande pour épuiser toute la puissance du processeur.

Pour mettre fin à tout cela, mettez simplement

killall yes

L'idée a été trouvée à l'origine ici , bien qu'elle soit destinée aux utilisateurs de Mac, mais cela devrait également fonctionner pour * nix.

user1147015
la source
7
+1 Fonctionne comme un charme, merci! À ajouter : cette commande maximisera un hyperthread par cœur de processeur. Ainsi, un processeur dual core (chaque core ayant 2 threads) obtiendra une charge totale de 25% par yescommande (en supposant que le système était sinon inactif).
GitaarLAB
Pour ajouter à cela, chaque itération de cette commande ajoute une charge de 25% sur le processeur (Android) jusqu'à 4 itérations et les autres n'ont aucun effet (même en termes de fréquence d'horloge).
user3188978
31

Bien que je sois en retard à la fête, ce message figure parmi les meilleurs résultats de la recherche Google "générer une charge sous Linux".

Le résultat marqué comme solution pourrait être utilisé pour générer une charge système, je préfère utiliser sha1sum /dev/zeropour imposer une charge sur un cpu-core.

L'idée est de calculer une somme de hachage à partir d'un flux de données infini (par exemple. / Dev / zero, / dev / urandom, ...) ce processus essaiera de maximiser un processeur-core jusqu'à ce que le processus soit abandonné. Pour générer une charge pour plus de cœurs, plusieurs commandes peuvent être regroupées.

par exemple. générer une charge à 2 noyaux: sha1sum /dev/zero | sha1sum /dev/zero

Mitms
la source
En voyant, cela vaut mieux que dd pour la charge CPU. J'obtiens une charge maximale de CPU de 44% sur dd (6 fois) et 86% + sur sha1sum. Thx ~!
AAI
26

Un noyau (n'invoque pas de processus externe):

while true; do true; done

Deux noyaux:

while true; do /bin/true; done

Ce dernier fait seulement passer les deux à ~ 50% ...

Celui-ci fera passer les deux à 100%:

while true; do echo; done
L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳
la source
sur l'écho, nous perdons l'accès à Linux. comment mettre cette 3e commande en arrière-plan?
AAI
2
Pourquoi l'écho fait-il 100% de tous les cœurs de processeur?
Haoyuan Ge
@HaoyuanGe Tous les processeurs sont à 100% uniquement en faisant écho à "rien". Remplacez l'écho do; avec do echo "une chaîne très très longue"; pour voir <100% sur le cpus. Donc, je crois que l'écho de rien a beaucoup moins de sauts et donc plus de code à exécuter (car c'est vrai;) les cœurs sont ~ 100% occupés
talekeDskobeDa
Si vous voulez garder un serveur réactif tout en exécutant un tel test, faites - le dans une coquille séparée ( une autre fenêtre tmux / écran, ou d'une session ssh) et renice cette coquille d' abord, par exemple en bash: renice 19 -p $$. Cela maximisera toujours les processeurs, mais n'empiétera pas sur d'autres processus.
Walf
23

Pour charger 3 cœurs pendant 5 secondes:

seq 3 | xargs -P0 -n1 timeout 5 yes > /dev/null

Il en résulte une charge élevée du noyau (sys) à partir des nombreux appels système write ().

Si vous préférez principalement la charge du processeur utilisateur:

seq 3 | xargs -P0 -n1 timeout 5 md5sum /dev/zero

Si vous souhaitez simplement que le chargement continue jusqu'à ce que vous appuyiez sur Ctrl-C:

seq 3 | xargs -P0 -n1 md5sum /dev/zero
James Scriven
la source
1
Est-ce possible à partir de tinycore? xargs: option invalide - 'P'
conman253
belle option native
insigne
18

Voici un programme que vous pouvez télécharger ici

Installez facilement sur votre système Linux

./configure
make
make install

et lancez-le dans une simple ligne de commande

stress -c 40

pour mettre l'accent sur tous vos processeurs (comme vous en avez) avec 40 threads exécutant chacun un sqrtcalcul complexe sur des nombres générés de manière aléatoire.

Vous pouvez même définir le délai d'expiration du programme

stress -c 40 -timeout 10s

contrairement à la solution proposée avec la ddcommande, qui traite essentiellement IOet donc ne surcharge pas vraiment votre système car vous travaillez avec des données.

Le programme de stress surcharge vraiment le système car il traite du calcul.

Fopa Léon Constantin
la source
4
Il y a déjà une réponse ci-dessus pour la stresscommande. Comme le dit cette réponse, vous pouvez simplement l'installer via yum / apt / etc.
Asfand Qazi
1
Le site Web n'est pas en bon état (503 interdit) mais est disponible sur les repos :)
m3nda
11
:(){ :|:& };:

Cette bombe à fourche causera des ravages au processeur et fera probablement planter votre ordinateur.

Jeff Goldstein
la source
13
Ça va aider si je facilite la lecture de fork_bomb () {fork_bomb | fork_bomb &}; forkbomb
Jeff Goldstein
17
Celui-là échoue sur le critère "durer un laps de temps désigné puis s'arrêter";)
Marian
14
ressemble à un tas de visages souriants.
Ponkadoodle
2
Cette bombe à fourche a fait planter mon ordinateur, j'ai dû faire un cycle d'alimentation difficile.
Elijah Lynn
2
De: cyberciti.biz/faq/understanding-bash-fork-bomb AVERTISSEMENT! Ces exemples peuvent planter votre ordinateur s'ils sont exécutés. "Une fois qu'une bombe à fourche réussie a été activée dans un système, il peut ne pas être possible de reprendre un fonctionnement normal sans redémarrer le système car la seule solution à une bombe à fourche est d'en détruire toutes les instances."
Elijah Lynn
11

Une boucle infinie est l'idée que j'ai eue aussi. Un aspect bizarre est:

while :; do :; done

( :est le même que true, ne fait rien et sort avec zéro)

Vous pouvez appeler cela dans un sous-shell et exécuter en arrière-plan. Faire cela $num_coresdevrait suffire. Après avoir dormi le temps désiré , vous pouvez les tuer tous, vous obtenez les avec PIDs jobs -p(indice: xargs)

Marian
la source
10

Je diviserais la chose en 2 scripts:

infinite_loop.bash:

#!/bin/bash
while [ 1 ] ; do
    # Force some computation even if it is useless to actually work the CPU
    echo $((13**99)) 1>/dev/null 2>&1
done

cpu_spike.bash:

#!/bin/bash
# Either use environment variables for NUM_CPU and DURATION, or define them here
for i in `seq ${NUM_CPU}` : do
    # Put an infinite loop on each CPU
    infinite_loop.bash &
done

# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}
killall infinite_loop.bash
Fred
la source
7
cat /dev/urandom > /dev/null
Evgeny
la source
Ajoutez également quelques commentaires, cela aide.
Lokesh
4
#!/bin/bash
duration=120    # seconds
instances=4     # cpus
endtime=$(($(date +%s) + $duration))
for ((i=0; i<instances; i++))
do
    while (($(date +%s) < $endtime)); do :; done &
done
En pause jusqu'à nouvel ordre.
la source
4

J'ai utilisé bc( calculatrice binaire ), en leur demandant PI avec un grand nombre de décimales.

$ for ((i=0;i<$NUMCPU;i++));do
    echo 'scale=100000;pi=4*a(1);0' | bc -l &
    done ;\
    sleep 4; \
    killall bc

avec NUMCPU (sous Linux):

$ NUMCPU=$(grep $'^processor\t*:' /proc/cpuinfo |wc -l)

Cette méthode est puissante mais semble conviviale , car je n'ai jamais écrasé un système utilisant cela.

F. Hauri
la source
3
#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done
Secko
la source
1
Eh non. Dormir n'est pas ce genre de tâche qui met beaucoup de temps sur le processeur:-)
Marian
2

Je suis allé sur Internet pour trouver quelque chose comme ça et j'ai trouvé ce script marteau cpu très pratique.

#!/bin/sh

# unixfoo.blogspot.com

if [ $1 ]; then
    NUM_PROC=$1
else
    NUM_PROC=10
fi

for i in `seq 0 $((NUM_PROC-1))`; do
    awk 'BEGIN {for(i=0;i<10000;i++)for(j=0;j<10000;j++);}' &
done
Ishtiaq Ahmed
la source
Faut-il vraiment que ce soit aussi long? J'aime mieux les one-liners pour ce genre de tâche…
Nikana Reklawyks
1
If-then-else clause peut être remplacée par: NUM_PROC=${1:-10}.
Thor
2

En utilisant les exemples mentionnés ici, mais aussi l'aide d'IRC, j'ai développé mon propre script de test de stress CPU. Il utilise un sous-shell par thread et la technique de boucle sans fin. Vous pouvez également spécifier le nombre de threads et la durée de manière interactive.

#!/bin/bash
# Simple CPU stress test script

# Read the user's input
echo -n "Number of CPU threads to test: "
read cpu_threads
echo -n "Duration of the test (in seconds): "
read cpu_time

# Run an endless loop on each thread to generate 100% CPU
echo -e "\E[32mStressing ${cpu_threads} threads for ${cpu_time} seconds...\E[37m"
for i in $(seq ${cpu_threads}); do
    let thread=${i}-1
    (taskset -cp ${thread} $BASHPID; while true; do true; done) &
done

# Once the time runs out, kill all of the loops
sleep ${cpu_time}
echo -e "\E[32mStressing complete.\E[37m"
kill 0
MirceaKitsune
la source
obtenir l'erreur "ligne 14: tasket: commande introuvable" sur votre script! une idée?
user2912312
2

En utilisant les idées ici, le code créé qui se termine automatiquement après une durée définie, n'a pas à tuer les processus -

#!/bin/bash
echo "Usage : ./killproc_ds.sh 6 60  (6 threads for 60 secs)"

# Define variables
NUM_PROCS=${1:-6} #How much scaling you want to do
duration=${2:-20}    # seconds

function infinite_loop {
endtime=$(($(date +%s) + $duration))
while (($(date +%s) < $endtime)); do
    #echo $(date +%s)
    echo $((13**99)) 1>/dev/null 2>&1
    $(dd if=/dev/urandom count=10000 status=none| bzip2 -9 >> /dev/null) 2>&1 >&/dev/null
done
echo "Done Stressing the system - for thread $1"
}


echo Running for duration $duration secs, spawning $NUM_PROCS threads in background
for i in `seq ${NUM_PROCS}` ;
do
# Put an infinite loop
    infinite_loop $i  &
done
Dhiraj
la source
1

Cela fait un tour pour moi:

bash -c 'for (( I=100000000000000000000 ; I>=0 ; I++ )) ; do echo $(( I+I*I )) & echo $(( I*I-I )) & echo $(( I-I*I*I )) & echo $(( I+I*I*I )) ; done' &>/dev/null

et il n'utilise rien sauf bash.

ZyX
la source
1

Pour améliorer la réponse de dimba et fournir quelque chose de plus enfichable (parce que j'avais besoin de quelque chose de similaire). J'ai écrit ce qui suit en utilisant le concept de chargement dd: D

Il vérifiera les cœurs actuels et créera autant de threads dd. Démarrer et terminer la charge de base avec Enter

#!/bin/bash

load_dd() {
    dd if=/dev/zero of=/dev/null
}

fulload() {
    unset LOAD_ME_UP_SCOTTY
    export cores="$(grep proc /proc/cpuinfo -c)"
    for i in $( seq 1 $( expr $cores - 1 ) )
      do
    export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd | ')"
  done
        export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd &')"
    eval ${LOAD_ME_UP_SCOTTY}
}

echo press return to begin and stop fullload of cores
  read
  fulload
  read
  killall -9 dd
knope
la source
0

J'ai combiné certaines des réponses et ajouté un moyen d'échelle du stress à tous les processeurs disponibles:

#!/bin/bash

function infinite_loop { 
    while [ 1 ] ; do
        # Force some computation even if it is useless to actually work the CPU
        echo $((13**99)) 1>/dev/null 2>&1
    done
}

# Either use environment variables for DURATION, or define them here
NUM_CPU=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
PIDS=()
for i in `seq ${NUM_CPU}` ;
do
# Put an infinite loop on each CPU
    infinite_loop &
    PIDS+=("$!")
done

# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}

# Parent kills its children 
for pid in "${PIDS[@]}"
do
    kill $pid
done
joecks
la source
0

Dimba dd if=/dev/zero of=/dev/nullest certainement correct, mais il convient également de mentionner la vérification du maximum du processeur à 100% d'utilisation. Vous pouvez le faire avec

ps -axro pcpu | awk '{sum+=$1} END {print sum}'

Cela demande une sortie ps d'une moyenne d'une minute de l'utilisation du processeur par chaque processus, puis les additionne avec awk. Bien qu'il s'agisse d'une moyenne d'une minute, ps est suffisamment intelligent pour savoir si un processus ne dure que quelques secondes et ajuste la fenêtre temporelle en conséquence. Ainsi, vous pouvez utiliser cette commande pour voir immédiatement le résultat.

jeremysprofile
la source
0

pour augmenter la charge ou consommer le CPU à 100%

sha1sum /dev/zero &

alors vous pouvez voir les utilisations du processeur en tapant la commande

top

pour libérer la charge

killall sha1sum
44kksharma
la source
-1

Collez simplement ce mauvais garçon dans la SSH ou la console de n'importe quel serveur exécutant Linux. Vous pouvez tuer les processus manuellement, mais j'arrête simplement le serveur lorsque j'ai terminé, plus rapidement.

Edit: j'ai mis à jour ce script pour avoir maintenant une fonction de minuterie afin qu'il ne soit pas nécessaire de tuer les processus.

read -p "Please enter the number of minutes for test >" MINTEST && [[ $MINTEST == ?(-)+([0-9]) ]]; NCPU="$(grep -c ^processor /proc/cpuinfo)";  ((endtime=$(date +%s) + ($MINTEST*60))); NCPU=$((NCPU-1)); for ((i=1; i<=$NCPU; i++)); do while (($(date +%s) < $endtime)); do : ; done & done
GarretSidzaka
la source