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

Actualmente estoy en el proceso de depurar una instalación de Cacti y quiero crear una carga de CPU para depurar mis gráficos de utilización de CPU.

Intenté simplemente ejecutar cat /dev/zero > /dev/null, lo que funciona muy bien pero solo utiliza 1 núcleo:

¿Existe un mejor método para probar / maximizar los recursos del sistema bajo carga?

Relacionado: ¿Cómo puedo producir una alta carga de CPU en Windows?

Probar stress Es casi un equivalente de Windows consume.exe:

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

No es necesario instalar ningún paquete adicional, su viejo y buen shell puede hacerlo solo.

Este one-liner cargará sus cuatro núcleos ¹ al 100%:

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

Cómo funciona es bastante simple, inicia cuatro bucles sin fin. Cada uno de ellos está repitiendo la instrucción nula ( :). Cada ciclo puede cargar un núcleo de CPU al 100%.

Si usa bash, ksh93y otros shells que admiten rangos (es decir, no dasho anteriores ksh), puede usar esta sintaxis no portátil:

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

Reemplace 4con el número de CPU que le gustaría cargar, si es diferente 4.

Suponiendo que ya no tenía un trabajo en segundo plano ejecutándose cuando lanzó uno de estos bucles, puede detener la generación de 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 (predeterminado de 60 segundos). A Control: Ctambién matará todos los bucles fuera de control. Esta función de shell funciona al menos bajo bashy 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
  )
}

¹ _{Tenga en cuenta que con las CPU que admiten más de un subproceso por núcleo (Hyper-threading), el sistema operativo enviará la carga a todas las CPU virtuales. En ese caso, el comportamiento de la carga depende de la implementación (cada subproceso puede informarse como 100% ocupado o no).} .

Hice un script de python simple que hace lo mismo. Puede controlar la cantidad de núcleos de CPU que desea cargar. Lo bueno de esto es que no consumirá ningún otro recurso además de la CPU. (Creo que la idea de Mark Johnson consumiría muchos recursos de E / S, lo que no se desea 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))

Simplemente ejecute este script desde la terminal $ python temp1.py. Debes matar el script cuando hayas terminado.

Aquí está mi salida de consumo de 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 casi siempre está presente en las distribuciones actuales, por lo que no se necesitan paquetes adicionales.

Comience dos

sha1sum /dev/zero &

comandos para cada núcleo en su sistema.

Para detener

killall sha1sum

o

kill sha1sum

Normalmente tomo la suite cpuburn:

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

Reemplace 4 con el número de núcleos / hilos HT que tiene o desea estresar.

Nota: Esto enfatiza la mayor cantidad de área de chip posible al mismo tiempo, está programado para generar la máxima disipación de potencia. Tuve que escribir esta publicación por segunda vez, de alguna manera a mi máquina no le gustó :-(

También puedes hacer cpuburn en secuencias:

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

Y cuando quieras detenerlos:

killall burnP6

También puede multiplicar burnP6 &para que coincida con la cantidad de núcleos de CPU en su sistema.

He estado desarrollando stress-ng, una herramienta de estrés actualizada que puede enfatizar una amplia gama de aspectos de un sistema Linux. Para obtener más información, consulte http://kernel.ubuntu.com/~cking/stress-ng/

El uso es similar al estrés.

$ 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

Puede ejecutar ese comando tantas veces como lo desee, y tomará 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

Solución bastante simple y científica.

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

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

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

Repita dd if=/dev/zero of=/dev/nullpara sus núcleos de CPU.

Presione cualquier tecla para detener la prueba.

pxzes 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/zerono es lo suficientemente rápido (nota que pxzse estrangula la E / S), puede hacer pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Las versiones más nuevas de xztienen la --threadsopción que sustituye pxz.

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

Por ejemplo, para comenzar con 4 procesos,

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

Puede cambiar el número de procesos mediante la opción "-P" anterior.

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

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

Quería agregar esto al comentario de @ jlliagre, pero no tengo suficiente reputación. Si va a usar este código en varios servidores y el recuento de CPU variará, puede usar el siguiente comando:

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

Esto utilizará todos los núcleos en su servidor, independientemente de cuántos tenga. El comando nproces parte de coreutils, por lo que debería estar en la mayoría de las instalaciones de Linux.