Comment créer un pic CPU avec une commande bash

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.

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

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

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.

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

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

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

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.

:(){ :|:& };:

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

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)

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

cat /dev/urandom > /dev/null

#!/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

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.

#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done

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

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

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

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.

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

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

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.

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

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