Como posso produzir uma elevada carga de CPU num servidor Linux?

Experimente stress É praticamente um equivalente do Windows consume.exe:

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

Não é necessário instalar nenhum pacote extra, a sua boa e velha shell é capaz de o fazer sozinha.

Esta linha única irá carregar os seus quatro núcleos1 a 100%:

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

Como funciona é bastante simples, inicia quatro loops infinitos. Cada um deles repete a instrução nula (:). Cada laço é capaz de carregar um núcleo de CPU a 100%.

Se utiliza bash, ksh93 e outros shells que suportam gamas, (ou seja, não dash ou mais antigos ksh), pode utilizar esta sintaxe não portátil:

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

Substitua 4 pelo número de CPUs que gostaria de carregar se fosse diferente de 4.

Assumindo que não tinha nenhum trabalho de fundo já em execução quando lançou um destes loops, pode parar a geração de carga com esse comando:

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

Resposta @underscore_d’s comment, aqui está uma versão melhorada que simplifica muito a paragem da carga e que também permite especificar um tempo limite (por defeito 60 segundos.) Um Control-C matará também todos os loops em execução. Esta função shell funciona pelo menos sob bash e 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 com as CPUs suportando mais do que um fio por núcleo (Hyper-threading), o sistema operativo irá enviar a carga para todas as CPUs virtuais. Nesse caso, o comportamento da carga depende da implementação (cada rosca pode ser reportada como 100% ocupada ou não).

Eu fiz um simples guião de pitão que faz o mesmo. Você pode controlar o número de núcleos de python que você quer carregar. O bom disto é que não vai consumir nenhum outro recurso além do cpu (acho que a ideia do Mark Johnson iria consumir muitos recursos I/O, o que é indesejável aqui)

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

Basta executar este script a partir do terminal $ python temp1.py. É preciso matar o script quando estiver pronto.

Aqui, é a minha saída de consumo de cpu quando carrego 3 dos meus núcleos.

Uma forma alternativa seria

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

ou (se nproc estiver presente)

openssl speed -multi $(nproc --all)

O OpenSSL está quase sempre presente nas distribuições de hoje em dia, pelo que não são necessários pacotes extra.

Iniciar dois comandos

sha1sum /dev/zero &

para cada núcleo do seu sistema.

Para parar

killall sha1sum

ou

kill sha1sum

Tenho desenvolvido o stress-ng, uma ferramenta de stress actualizada que pode enfatizar uma vasta gama de aspectos de um sistema Linux. Para mais informações, veja http://kernel.ubuntu.com/~cking/stress-ng/

A utilização é semelhante 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 com

sudo apt-get install stress-ng

Normalmente levo o conjunto cpuburn:

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

Substitua 4 pelo número de núcleos / HT-threads que tem ou quer stressar.

Nota: Isto stress a maior área possível de chip ao mesmo tempo, está programado para gerar a máxima dissipação de energia. Tive de escrever este post uma segunda vez, de alguma forma a minha máquina não gostou :-(

Também pode fazer cpuburn em sequências:

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

E quando os quiser parar:

killall burnP6

Também pode multiplicar burnP6 & para corresponder ao número de núcleos de CPU no seu sistema.

Pode executar esse comando quantas vezes quiser, e ele ocupará um núcleo diferente de cada vez:

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

Aqui pode ver um exemplo de dinâmica em que 50% da carga é gerada no núcleo do CPU 0:

Pode executar o processo em outros núcleos ao mesmo tempo.

pxz é uma implementação paralela de xz.

pxz -9e /dev/zero --stdout >/dev/null deve fazer o truque, uma vez que isto é bastante intensivo.

Se o /dev/zero não for suficientemente rápido (repara que o pxz é engarrafado I/O) pode fazerpxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

As novas versões do xz têm a opção --threads que é um substituto do pxz.

Eu combinei +jlliagre e +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 $@

Pode 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

Repetir dd if=/dev/zero of=/dev/null para os seus núcleos de CPU.

Carregue em qualquer tecla para parar o teste.

Aqui está a forma como eu uso e não há necessidade de instalar nada extra.

Por exemplo, para começar com 4 processos,

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

Pode alterar o número de processos através da opção “-P” acima.

Uma simples linha de comando também o faz:

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

Gostaria de acrescentar isto ao comentário de @jlliagre, mas não tenho reputação suficiente. Se vai usar este código em múltiplos servidores e a contagem de CPU vai variar, pode usar o seguinte comando:

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

Isto vai utilizar todos os núcleos do seu servidor, independentemente de quantos tiver. O comando nproc faz parte dos coreutils, pelo que deverá estar na maioria das instalações Linux.