¿Cómo puedo producir una alta carga de CPU en un servidor Linux?

Intenta stress Es más o menos un equivalente de los Windows consume.exe:

oliver$ ./stress --cpu 3
stress: info: [18472] dispatching hogs: 3 cpu, 0 io, 0 vm, 0 hdd

No hay necesidad de instalar ningún paquete extra, tu vieja y buena cáscara es capaz de hacerlo sola.

Esta línea cargará tus cuatro núcleos1 al 100%:

for i in 1 2 3 4; do while : ; do : ; done & done

La forma en que funciona es bastante simple, inicia cuatro bucles interminables. Cada uno de ellos repite la instrucción nula (:). Cada bucle es capaz de cargar un núcleo de CPU al 100%.

Si utilizas bash, ksh93 y otros shells que soporten rangos, (es decir, no dash o más antiguo ksh), puedes utilizar esta sintaxis no portátil:

for i in {1..4}; do ...

Reemplaza 4 con el número de CPUs que te gustaría cargar si es diferente de 4.

Asumiendo que no tenías ningún trabajo de fondo ya ejecutándose cuando lanzaste uno de estos bucles, puedes detener la generación de la carga con ese comando:

for i in 1 2 3 4; do kill %$i; done

Respondiendo al comentario de @underscore_d, aquí hay una versión mejorada que simplifica mucho la detención de la carga y que también permite especificar un tiempo de espera (por defecto 60 segundos.) Un Control-C matará todos los bucles que se escapen también. Esta función del shell funciona al menos bajo bash y ksh.

# Usage: lc [number_of_cpus_to_load [number_of_seconds] ]
lc() {
  (
    pids=""
    cpus=${1:-1}
    seconds=${2:-60}
    echo loading $cpus CPUs for $seconds seconds
    trap 'for p in $pids; do kill $p; done' 0
    for ((i=0;i<cpus;i++)); do while : ; do : ; done & pids="$pids $!"; done
    sleep $seconds
  )
}

1Nota que con CPUs que soporten más de un hilo por núcleo (Hyper-threading), el SO despachará la carga a todas las CPUs virtuales. En ese caso, el comportamiento de la carga depende de la implementación (cada hilo puede ser reportado como 100% ocupado o no)..

Hice un simple guión de pitón que hace lo mismo. Puedes controlar el número de núcleos de CPU que quieres cargar. Lo bueno de esto es que no consumirá ningún otro recurso aparte de la cpu. (Creo que la idea de Mark Johnson consumiría muchos recursos de E/S, lo cual no es deseable aquí.)

from multiprocessing import Pool

def f(x):
    # Put any cpu (only) consuming operation here. I have given 1 below -
    while True:
        x * x

# decide how many cpus you need to load with.
no_of_cpu_to_be_consumed = 3

p = Pool(processes=no_of_cpu_to_be_consumed)
p.map(f, range(no_of_cpu_to_be_consumed))

Sólo ejecuta este script desde la terminal $ python temp1.py. Necesitas matar el script cuando termines.

Aquí está la salida del consumo de mi cpu cuando cargo 3 de mis núcleos.

Una forma alternativa sería

openssl speed -multi $(grep -ci processor /proc/cpuinfo)

o (si nproc está presente)

openssl speed -multi $(nproc --all)

OpenSSL está casi siempre presente en las distros de hoy en día, así que no se necesitan paquetes extra.

Iniciar dos

sha1sum /dev/zero &

Comandos para cada núcleo de su sistema.

Para detenerse

killall sha1sum

o

kill sha1sum

He estado desarrollando Stress-ng, una herramienta actualizada para el estrés que puede hacer hincapié en una amplia gama de aspectos de un sistema Linux. Para más información, vea http://kernel.ubuntu.com/~cking/stress-ng/

El uso es similar a stress

$ stress-ng --cpu 4 --vm 2 --fork 8 --switch 4 --timeout 1m
stress-ng: info: [32254] dispatching hogs: 4 cpu, 8 fork, 4 switch, 2 vm
stress-ng: info: [32254] cache allocate: default cache size: 8192K

Instalar con

sudo apt-get install stress-ng

Normalmente tomo la suite cpuburn:

sudo apt-get install cpuburn
for i in {1..4}; do burnK7 & done

Reemplaza 4 con el número de núcleos / HT-hilos que tienes o quieres estresar.

Nota: Esto estresa tanta área de chip como sea posible al mismo tiempo, está programado para generar la máxima disipación de energía. Tuve que escribir este post por segunda vez, de alguna manera a mi máquina no le gustó :-(

También podrías hacer cpuburn en secuencias:

burnP6 & burnP6 & burnP6 & burnP6 & 
[1] 28520
[2] 28521
[3] 28522
[4] 28523

Y cuando quieras detenerlos:

killall burnP6

También podrías multiplicar burnP6 & para igualar el número de núcleos de CPU en tu sistema.

Puedes ejecutar ese comando tantas veces como quieras, y ocupará un núcleo diferente cada vez:

$ CORES=1
$ for i in `seq 1 $CORES`; do cat /dev/zero > /dev/null &
> done
[1] 8388

https://github.com/GaetanoCarlucci/CPULoadGenerator

Una solución bastante simple y científica.

Aquí puedes ver un ejemplo de dinámica en el que el 50% de la carga se genera en el núcleo 0 de la CPU:

Puedes ejecutar el proceso en otros núcleos al mismo tiempo.

pxz es una implementación paralela de xz.

pxz -9e /dev/zero --stdout >/dev/null debería hacer el truco, ya que esto es bastante intensivo en cpu.

Si /dev/zero no es lo suficientemente rápido (notas que pxz se estrangula) puedes hacer pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Las nuevas versiones de xz tienen la opción de --threads que es un sustituto de pxz.

Combiné ambos +jlliagre y +ecabuk.

#!/bin/bash
lc() {
    nowMs=$(date +%s)
    (
        pids=""
        cpus=${1:-1}
        seconds=${2:-60}
        echo "[$(date)] loading $cpus CPUs for $seconds seconds"
        echo "[$(date)] Expected completion: [$(date --date=@$(expr $nowMs + $seconds))]"
        trap 'for p in $pids; do kill $p; done' 0
        for ((i=0;i<cpus;i++)); do
            sha1sum /dev/zero &
            pids="$pids $!";
        done
        sleep $seconds
    )
    echo "[$(date)] Done"
}

lc $@

Puedes usar:

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

Repite dd if=/dev/zero of=/dev/null para los núcleos de tu CPU.

Pulsa cualquier tecla para detener la prueba.

Esta es la forma que uso y no hay necesidad de instalar nada extra.

Por ejemplo, para empezar con 4 procesos,

nproc | xargs seq | xargs -n1 -P4 md5sum /dev/zero

Puedes cambiar el número de procesos con la opción “-P” de arriba.

Una simple línea de comando también lo hace:

x="x" ; while : ; do x=$x$x ; echo -n "." ; done

Quería añadir esto al comentario de @jlliagre, pero no tengo suficiente reputación. Si vas a usar este código en múltiples servidores y el número de CPU variará, puedes usar el siguiente comando:

for ((i=1; i<=`nproc --all`; i++)); do while : ; do : ; done & done

Esto utilizará todos los núcleos de tu servidor sin importar cuántos tengas. El comando nproc es parte de coreutils por lo que debería estar en la mayoría de las instalaciones de Linux.