Cómo crear un pico de CPU con un comando bash

Quiero crear una carga cercana al 100% en una máquina Linux. Es un sistema de cuatro núcleos y quiero que todos los núcleos funcionen a toda velocidad. Idealmente, la carga de la CPU duraría una cantidad de tiempo designada y luego se detendría. Espero que haya algún truco en bash. Estoy pensando en una especie de bucle infinito.

También puedes hacer

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

Para ejecutar más de esos para cargar más núcleos, intente bifurcarlo:

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

Repita el comando en las llaves tantas veces como el número de hilos que desea producir (aquí 4 hilos). Simple enter hit lo detendrá (solo asegúrese de que no se esté ejecutando ningún otro dd en este usuario o también lo matará).

Utilizo el estrés para este tipo de cosas, puedes decirle cuántos núcleos maximizar ... también permite estresar la memoria y el disco.

Ejemplo para estresar 2 núcleos durante 60 segundos

stress --cpu 2 --timeout 60

Creo que este es más simple. Abra la Terminal y escriba lo siguiente y presione Entrar.

yes > /dev/null &

Para utilizar completamente las CPU modernas, una línea no es suficiente, es posible que deba repetir el comando para agotar toda la potencia de la CPU.

Para terminar con todo esto, simplemente pon

killall yes

La idea se encontró originalmente aquí , aunque estaba destinada a usuarios de Mac, pero también debería funcionar para * nix.

Aunque llego tarde a la fiesta, esta publicación se encuentra entre los mejores resultados en la búsqueda de Google "generar carga en Linux".

El resultado marcado como solución podría usarse para generar una carga del sistema, prefiero usar sha1sum /dev/zero para imponer una carga en un núcleo de CPU.

La idea es calcular una suma hash a partir de un flujo de datos infinito (p. Ej. / Dev / zero, / dev / urandom, ...) este proceso intentará maximizar un cpu-core hasta que se cancele el proceso. Para generar una carga para más núcleos, se pueden canalizar varios comandos juntos.

p.ej. generar una carga de 2 núcleos: sha1sum /dev/zero | sha1sum /dev/zero

Un núcleo (no invoca un proceso externo):

while true; do true; done

Dos núcleos:

while true; do /bin/true; done

Sin embargo, esto último solo hace que los dos míos alcancen ~ 50% ...

Este hará que ambos lleguen al 100%:

while true; do echo; done

Para cargar 3 núcleos durante 5 segundos:

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

Esto resulta en una alta carga de kernel (sys) de las muchas llamadas al sistema write ().

Si prefiere principalmente la carga de la CPU de userland:

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

Si solo desea que la carga continúe hasta que presione Ctrl-C:

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

Aquí hay un programa que puedes descargar aquí

Instalar fácilmente en su sistema Linux

./configure
make
make install

y ejecútalo en una línea de comando simple

stress -c 40

para estresar todas tus CPU (como sea que tengas) con 40 hilos cada uno ejecutando un complejo sqrt cálculo en números generados aleatoriamente.

Incluso puedes definir el tiempo de espera del programa

stress -c 40 -timeout 10s

a diferencia de la solución propuesta con el ddcomando, que trata esencialmente conIO y, por lo tanto, realmente no sobrecarga su sistema porque trabaja con datos.

El programa de estrés realmente sobrecarga el sistema porque se ocupa de la computación.

:(){ :|:& };:

Esta bomba tenedor causará estragos en la CPU y probablemente bloqueará su computadora.

Un bucle infinito es la idea que también tuve. Una de aspecto extraño es:

while :; do :; done

( :es lo mismo que true, no hace nada y sale con cero)

Puede llamar a eso en una subshell y ejecutar en segundo plano. Hacer ese $num_corestiempo debería ser suficiente. Después de dormir el tiempo deseado se puede matar a todos ellos, se obtiene con los PID jobs -p(pista: xargs)

Yo dividiría la cosa 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

He usado bc( calculadora binaria ), pidiéndoles PI con una gran cantidad de decimales.

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

con NUMCPU (bajo Linux):

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

Este método es fuerte pero parece amigable con el sistema , ya que nunca he bloqueado un sistema al usar esto.

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

Fui a través de Internet para encontrar algo así y encontré este muy útil script de cpu hammer.

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

Utilizando los ejemplos mencionados aquí, pero también la ayuda de IRC, desarrollé mi propio script de prueba de estrés de CPU. Utiliza una subshell por hilo y la técnica de bucle sin fin. También puede especificar el número de subprocesos y la cantidad de tiempo de forma interactiva.

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

Utilizando ideas aquí, el código creado que sale automáticamente después de una duración establecida, no tiene que matar procesos:

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

Esto hace un truco para mí:

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

y no usa nada excepto bash.

Para mejorar la respuesta de dimba y proporcionar algo más conectable (porque necesitaba algo similar). He escrito lo siguiente usando el concepto de carga dd: D

Verificará los núcleos actuales y creará tantos subprocesos dd. Iniciar y finalizar la carga del núcleo con 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

Combiné algunas de las respuestas y agregué una forma de escalar el estrés a todos los cpus 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/nulles definitivamente correcto, pero también vale la pena mencionar que está verificando maximizar la CPU al 100% de uso. Puedes hacer esto con

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

Esto solicita una salida de ps de un promedio de 1 minuto del uso de la CPU por cada proceso, luego los suma con awk. Si bien es un promedio de 1 minuto, ps es lo suficientemente inteligente como para saber si un proceso solo ha durado unos segundos y ajusta la ventana de tiempo en consecuencia. Por lo tanto, puede usar este comando para ver inmediatamente el resultado.

para aumentar la carga o consumir CPU 100%

sha1sum /dev/zero &

entonces puede ver los usos de la CPU escribiendo el comando

top

para liberar la carga

killall sha1sum

Simplemente pegue a este chico malo en el SSH o la consola de cualquier servidor que ejecute Linux. Puede matar los procesos manualmente, pero apago el servidor cuando termino, más rápido.

Editar: He actualizado este script para que ahora tenga una función de temporizador para que no haya necesidad de matar los procesos.

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