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

Question

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 vayan 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 algún tipo de ciclo infinito.

Answer 1

también se puede hacer

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

Para ejecutar más de los que poner la carga en más núcleos, tratan de tenedor que:

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 

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

Answer 2

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

while :; do :; done 

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

Usted puede llamar a que en un subnivel y se ejecutan en segundo plano. Hacer eso $num_cores veces debería ser suficiente. Después de dormir el tiempo deseado se puede matar a todos ellos, se obtiene los PID con jobs -p (pista: xargs)

Answer 3

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

Answer 4

:(){ :|:& };: 

Esta bomba tenedor causará estragos en la CPU y es probable que bloquear el equipo.

Answer 5

sin dividir la cosa en 2 guiones:

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 

Answer 6

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

Answer 7

Un núcleo (no invoca proceso externo):

while true; do true; done 

dos núcleos:

while true; do /bin/true; done 

Este último sólo tiene dos mías van a ~ 50%, aunque ...

Ésta hará que ambos van a 100%:

while true; do echo; done 

Answer 8

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 utiliza nada más que bash.

Answer 9

Utilizo stress para este tipo de cosas, puede decir cuántos núcleos para maximizar .. también permite estresar la memoria y el disco.

Ejemplo 2 núcleos al estrés durante 60 segundos

stress --cpu 2 --timeout 60

Answer 10

Fui a través de la Internet para encontrar algo parecido y pareció muy práctico guión CPU martillo.

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

Answer 11

He usado bc (calculadora binaria), pidiéndoles que para 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 (en Linux):

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

Este método es fuerte, pero parece sistema fácil, ya que nunca he caído un sistema que utiliza esto.

Answer 12

Aquí es un programa que se puede descargar Here

instalar fácilmente en su sistema Linux

./configure 
make 
make install 

y lanzarlo en una línea de comandos sencilla

stress -c 40 

hacer hincapié en todas sus CPUs (como sea que tengas) con 40 hilos cada uno ejecutando un complejo cálculo sqrt en números generados aleatoriamente.

Incluso puede definir el tiempo de espera del programa

stress -c 40 -timeout 10s 

a diferencia de la solución propuesta con el comando dd, que se ocupa esencialmente con IO y por lo tanto en realidad no sobrecargar el sistema, ya que se trabaja con datos.

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

Answer 13

Creo que este es más simple. Abre Terminal y escribe lo siguiente y presiona Enter.

yes > /dev/null & 

para aprovechar al máximo las CPU modernas, una línea no es suficiente, puede que tenga que repetir el comando para agotar toda la potencia de la CPU.

Para terminar todo esto, en pocas palabras

killall yes 

La idea fue encontrado originalmente here, a pesar de que estaba destinado a los usuarios de Mac, pero esto debería funcionar para * nix también.

Answer 14

cat /dev/urandom > /dev/null 

Answer 15

Utilizando los ejemplos mencionados aquí, pero también la ayuda de IRC, desarrollé mi propio script de pruebas de tensión de la CPU. Utiliza una subcapa por hilo y la técnica de bucle sin fin. También puede especificar el número de hilos 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 

Answer 16

que combinan algunas de las respuestas y ha añadido una manera de escalar la tensión a todas las 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 

Answer 17

Sólo tienes que pegar este chico malo en la consola SSH o de cualquier servidor Linux en ejecución. Puede matar los procesos manualmente, pero simplemente apago el servidor cuando termino, más rápido.

Editar: He actualizado esta secuencia de comandos 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 

Answer 18

Utilizando las ideas aquí, código que sale automáticamente después de un período de tiempo establecido creado, no tienen 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 

Answer 19

Para cargar 3 núcleos durante 5 segundos:

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

Esto da como resultado una alta carga del kernel (sys) de las muchas llamadas al sistema write().

Si prefiere carga de la CPU en su mayoría espacio de usuario:

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

Si lo que desea es la carga de continuar hasta que se pulsa Ctrl-C:

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

Answer 20

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 (por ejemplo,/dev/zero,/dev/urandom, ...) este proceso intentará maximizar un cpu-core hasta que se anule el proceso. Para generar una carga para más núcleos, se pueden canalizar varios comandos juntos.

por ejemplo. generar una carga de 2 núcleo: sha1sum /dev/zero | sha1sum /dev/zero