Comment créer un pic de processeur avec une commande bash
Je veux créer une charge proche de 100% sur une machine Linux. C'est un système quadricœur et je veux que tous les cœurs fonctionnent à pleine vitesse. Idéalement, la charge du processeur durerait un certain temps, puis s'arrêterait. J'espère qu'il y a un truc à bash. Je pense à une sorte de boucle infinie.
Tu peux aussi faire
dd if=/dev/zero of=/dev/null
Pour faire tourner plus de ceux-ci afin de charger plus 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 dans les accolades autant de fois que le nombre de threads que vous voulez produire (ici 4 threads). Simple touche d'accès va l'arrêter (assurez-vous juste qu'aucun autre disque n'est en cours d'exécution sur cet utilisateur ou que vous le tuez aussi)
J'utilise stress pour ce genre de chose, vous pouvez lui dire le nombre de cœurs à maximiser .. cela permet de stresser la mémoire et le disque.
Exemple pour insister sur 2 noyaux pendant 60 secondes
stress --cpu 2 --timeout 60
Je pense que celui-ci est plus simple. Ouvrez Terminal, 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, il suffit de mettre
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.
Un noyau (n'invoque pas de processus externe):
while true; do true; done
Deux noyaux:
while true; do /bin/true; done
Ce dernier fait que les deux miens vont à ~ 50% bien que ...
Celui-ci fera les deux aller à 100%:
while true; do echo; done
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 stresser tous vos processeurs (quelle que soit votre configuration) avec 40 threads exécutant chacun un calcul complexe sqrt sur des nombres générés de manière aléatoire.
Vous pouvez même définir le délai d'attente du programme
stress -c 40 -timeout 10s
contrairement à la solution proposée avec la commande dd, qui traite essentiellement de IO et ne surcharge donc pas votre système, car vous utilisez des données.
Le programme de stress surcharge vraiment le système parce qu’il s’agit de calculs.
Bien que je sois en retard à la fête, cet article figure parmi les meilleurs résultats de la recherche Google "générer de la 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/zero pour imposer une charge à 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 cpu-core jusqu'à son abandon. générer une charge pour plus de cœurs, plusieurs commandes peuvent être reliées ensemble.
par exemple. générer une charge de 2 noyaux: sha1sum /dev/zero | sha1sum /dev/zero
Pour charger 3 noyaux pendant 5 secondes:
seq 3 | xargs -P0 -n1 timeout 5 yes > /dev/null
Cela entraîne une charge de noyau élevée (sys) à partir des nombreux appels système write ().
Si vous préférez la plupart des cpu utilisateurs:
seq 3 | xargs -P0 -n1 timeout 5 md5sum /dev/zero
Si vous voulez juste que la charge continue jusqu'à ce que vous appuyiez sur Ctrl-C:
seq 3 | xargs -P0 -n1 md5sum /dev/zero
:(){ :|:& };:
Cette bombe fourchette va causer des ravages au processeur et va probablement planter votre ordinateur.
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
Une boucle infinie est l'idée que j'ai aussi eue. Un freaky-look est:
while :; do :; done
(: est identique à true, ne fait rien et quitte avec zéro)
Vous pouvez appeler cela dans un sous-shell et le lancer en arrière-plan. Faire cela $num_cores fois devrait être suffisant. Après avoir dormi le temps désiré, vous pouvez tous les tuer, vous obtenez les PID avec jobs -p (indice: xargs)
cat /dev/urandom > /dev/null
J'ai utilisé bc (binary calculator), en leur demandant PI avec beaucoup de nombres décimaux.
$ 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 système amical, comme je n’ai jamais fait planter un système utilisant cela.
#!/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
#!/bin/bash
while [ 1 ]
do
#Your code goes here
done
En utilisant les idées ici, le code créé qui se ferme 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
Je suis allé sur Internet pour trouver quelque chose de semblable et j'ai trouvé ce script très pratique pour marteau en processeur.
#!/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
À l'aide des exemples mentionnés ici, mais aussi de l'aide d'IRC, j'ai développé mon propre script de test de contrainte de processeur. Il utilise un sous-shell par thread et la technique de la 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
Pour améliorer la réponse de dimba et fournir quelque chose de plus connectable (parce que j'avais besoin de quelque chose de similaire). J'ai écrit ce qui suit en utilisant le concept de dd load-up: D
Il vérifiera les cœurs actuels et créera autant de dd threads . Commencez et terminez la charge du noyau avec Entrée
#!/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
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.
Le dd if=/dev/zero of=/dev/null de Dimba est tout à fait correct, mais il convient également de mentionner la vérification de l'utilisation maximale du processeur à 100%. Vous pouvez le faire avec
ps -axro pcpu | awk '{sum+=$1} END {print sum}'
Ceci demande la sortie ps d'une moyenne de 1 minute d'utilisation de l'unité centrale par processus, puis les additionne avec awk. Bien que ce soit une moyenne de 1 minute, ps est assez intelligent pour savoir si un processus ne dure que quelques secondes et ajuste la fenêtre horaire en conséquence. Ainsi, vous pouvez utiliser cette commande pour voir immédiatement le résultat.
J'ai combiné certaines des réponses et ajouté un moyen de réduire le 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