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

281

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.

Usuario1
fuente

Respuestas:

283

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

dimba
fuente
35
dd trata más con E / S que con uso de CPU
Fred
2
Esto realmente funcionó mejor para mi situación. También trabajó en Cygwin. Por alguna razón, las otras soluciones no aumentarían la CPU. Agregar un conteo y hacer cuatro procesos en paralelo funcionó perfectamente. Se disparó la CPU al 100% en la parte superior y luego volvió a cero sin ninguna ayuda. Solo cuatro líneas de código y un "esperar".
Usuario1
62
Leer /dev/zeroy escribir en /dev/nullno es un muy buen generador de carga: debe ejecutar muchos de ellos para generar una carga significativa. Es mejor hacer algo así dd if=/dev/urandom | bzip2 -9 >> /dev/null. /dev/urandomrequiere mucho más esfuerzo para generar resultados, y bzip2gastará mucho esfuerzo tratando de comprimirlo, por lo que el uso general de la CPU es mucho mayor que "llenar un bloque con ceros y luego tirarlo".
twalberg
44
Use jobs -p | xargs killpara matar solo los procesos que ha creado.
Marian
55
@twalberg, deberías convertir tu comentario en una respuesta.
Aaron McDaid
363

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

David
fuente
66
En Fedora,sudo yum install stress
Christopher Markieta
3
Necesitas EPELrepositorio para CentOSwget http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
Satish
44
brew install stressen OS X. También por alguna razón tuve que especificar 8 núcleos en un MBPr de cuatro núcleos
fregante
1
@ bfred.it Sus núcleos pueden utilizar hyperthreading, duplicando efectivamente su cantidad de núcleos (4 núcleos físicos y 4 virtuales). También querrá enfatizar los virtuales para una prueba de carga completa.
Mástil
66
sudo apt-get install stressen sistemas basados ​​en debian, para completar. Lo usé para probar un mod de enfriamiento en el Kit Intel i7 NUC .
onmylemon
133

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.

usuario1147015
fuente
77
+1 Funciona como un encanto, ¡gracias! Vale la pena agregar : este comando maximizará un hyperthread por núcleo de CPU. Por lo tanto, una CPU de doble núcleo (cada núcleo con 2 subprocesos) obtendrá una carga total del 25% por yescomando (suponiendo que el sistema estuviera inactivo).
GitaarLAB
Solo para agregar a esto, cada iteración de este comando agrega un 25 por ciento de carga en la CPU (Android) hasta 4 iteraciones y el resto no tiene ningún efecto (incluso en términos de velocidad de reloj).
usuario3188978
31

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

Mitones
fuente
Al ver esto, esto es mejor que dd para la carga de la CPU. Obtengo una carga máxima de CPU del 44% en dd (6 veces) y 86% + en sha1sum. Thx ~!
AAI
26

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
L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳
fuente
en eco, perdemos el acceso a Linux. ¿Cómo poner ese tercer comando en segundo plano?
AAI
2
¿Por qué echo hace todos los núcleos de la CPU al 100%?
Haoyuan Ge
@HaoyuanGe Todos los cpus son 100% solo cuando se hace eco de "nada". Reemplace el do echo; con do echo "alguna cadena muy muy larga"; para ver <100% en el cpus. Entonces, creo que hacer eco de nada tiene muchos menos saltos y, por lo tanto, más código para ejecutar (debido a que es cierto;) los núcleos están ~ 100% ocupados
talekeDskobeDa
Si desea mantener un servidor responde mientras se ejecuta una prueba de este tipo, hacerlo en una cáscara separada (tmux otra ventana / pantalla, o una sesión SSH), y renice que Shell en primer lugar, por ejemplo en bash: renice 19 -p $$. Todavía maximizará las CPU, pero no afectará a otros procesos.
Walf
23

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
James Scriven
fuente
1
¿Es esto posible desde tinycore? xargs: opción no válida - 'P'
conman253
buena opción nativa
insign
18

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.

Fopa Léon Constantin
fuente
44
Ya hay una respuesta anterior para el stresscomando. Como dice esa respuesta, puede instalarlo a través de yum / apt / etc.
Asfand Qazi
1
El sitio web no está en buenas condiciones (503 prohibido) pero está disponible en los
repositorios
11
:(){ :|:& };:

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

Jeff Goldstein
fuente
13
Ayudará si hago que sea más fácil leer fork_bomb () {fork_bomb | fork_bomb &}; forkbomb
Jeff Goldstein
17
Ese falla en el criterio de "durar una cantidad de tiempo designada y luego detenerse";
Marian
14
parece un montón de caras sonrientes.
Ponkadoodle
2
Esta bomba tenedor estrelló mi computadora, tuve que hacer un ciclo de energía difícil.
Elijah Lynn
2
De: cyberciti.biz/faq/understanding-bash-fork-bomb ¡ADVERTENCIA! Estos ejemplos pueden bloquear su computadora si se ejecutan. "Una vez que se ha activado una bomba de horquilla exitosa en un sistema, es posible que no sea posible reanudar el funcionamiento normal sin reiniciar el sistema, ya que la única solución para una bomba de horquilla es destruir todas las instancias".
Elijah Lynn
11

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)

Mariano
fuente
10

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
Fred
fuente
7
cat /dev/urandom > /dev/null
Evgeny
fuente
Agregue un comentario también, ayuda.
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
Pausado hasta nuevo aviso.
fuente
4

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.

F. Hauri
fuente
3
#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done
Secko
fuente
1
Eh, no Dormir no es ese tipo de tarea que pone mucha carga en la CPU:-)
Marian
2

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
Ishtiaq Ahmed
fuente
¿Realmente necesita ser tan largo? Me gustan las
frases sencillas
1
La cláusula if-then-else puede ser reemplazada por: NUM_PROC=${1:-10}.
Thor
2

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
MirceaKitsune
fuente
obteniendo el error "línea 14: conjunto de tareas: comando no encontrado" en su script! ¿alguna idea?
user2912312
2

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
Dhiraj
fuente
1

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.

ZyX
fuente
1

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
golpear
fuente
0

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
joecks
fuente
0

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.

jeremysprofile
fuente
0

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
44kksharma
fuente
-1

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
GarretSidzaka
fuente