Como posso produzir alta carga de CPU em um servidor Linux?

Atualmente, estou no processo de depuração de uma instalação do Cacti e quero criar carga de CPU para depurar meus gráficos de utilização da CPU.

Tentei simplesmente executar cat /dev/zero > /dev/null, o que funciona muito bem, mas utiliza apenas 1 núcleo:

Existe um método melhor de testar / maximizar os recursos do sistema sob carga?

Relacionado: Como posso produzir alta carga de CPU no Windows?

Tente stress É praticamente o 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, seu bom e velho shell é capaz de fazê-lo sozinho.

Esse liner carregará seus quatro núcleos ¹ em 100%:

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

Como funciona é bastante simples, inicia quatro loops sem fim. Cada um deles está repetindo a instrução nula ( :). Cada loop é capaz de carregar um núcleo de CPU a 100%.

Se você usar bash, ksh93e outras conchas apoio faixas, (ou seja, não dashanos ou mais ksh), você pode usar essa sintaxe não portátil:

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

Substitua 4pelo número de CPUs que você deseja carregar, se diferente 4.

Supondo que você ainda não estivesse executando o trabalho em segundo plano quando lançou um desses loops, é possível parar a geração de carga com esse comando:

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

Respondendo ao comentário de @ underscore_d, aqui está uma versão aprimorada que simplifica bastante a interrupção do carregamento e também permite especificar um tempo limite (padrão 60 segundos). A Control- Ctambém matará todos os loops descontrolados. Esta função shell funciona pelo menos sob bashe 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
  )
}

¹ _{Observe que, com as CPUs suportando mais de um encadeamento por núcleo (Hyper-threading), o sistema operacional envia a carga para todas as CPUs virtuais. Nesse caso, o comportamento do carregamento depende da implementação (cada encadeamento pode ser relatado como 100% ocupado ou não).} .

Eu fiz um script python simples que faz o mesmo. Você pode controlar o número de núcleos da CPU que deseja carregar. O bom disso é que ele não consumirá nenhum outro recurso além da CPU. (Acho que a ideia de mark johnson consumiria muitos recursos de E / S, 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 no terminal $ python temp1.py. Você precisa matar o script quando terminar.

Aqui está minha saída de consumo de CPU quando eu carrego 3 dos meus núcleos.

Uma maneira 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 distros de hoje em dia, portanto, nenhum pacote extra é necessário.

Comece dois

sha1sum /dev/zero &

comandos para todos os núcleos do seu sistema.

Parar

killall sha1sum

ou

kill sha1sum

Eu normalmente uso o pacote cpuburn:

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

Substitua 4 pelo número de núcleos / threads HT que você tem ou deseja enfatizar.

Nota: Isso enfatiza o máximo possível de área de chip ao mesmo tempo, e está programado para gerar a máxima dissipação de energia. Eu tive que escrever este post uma segunda vez, de alguma forma minha máquina não gostou :-(

Você também pode executar cpuburn em sequências:

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

E quando você quiser detê-los:

killall burnP6

Você também pode multiplicar burnP6 &para corresponder ao número de núcleos da CPU no seu sistema.

Estou desenvolvendo o stress-ng, uma ferramenta de estresse atualizada que pode enfatizar uma ampla gama de aspectos de um sistema Linux. Para mais informações, consulte http://kernel.ubuntu.com/~cking/stress-ng/

O uso é semelhante ao estresse

$ 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

Instale com

sudo apt-get install stress-ng

Você pode executar esse comando quantas vezes quiser e ele terá um núcleo diferente a cada vez:

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

https://github.com/GaetanoCarlucci/CPULoadGenerator

solução bastante simples e científica.

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

Você pode executar o processo em outros núcleos ao mesmo tempo.

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 $@

Você 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

Repita o procedimento dd if=/dev/zero of=/dev/nullpara os núcleos da CPU.

Pressione qualquer tecla para interromper o teste.

pxzé uma implementação paralela de xz.

pxz -9e /dev/zero --stdout >/dev/null deve fazer o truque, pois isso é bastante intensivo da CPU.

Se /dev/zeronão for rápido o suficiente (você percebe que a pxzotimização da E / S) é possível pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

As versões mais recentes do xztêm a --threadsopção que é um substituto pxz.

Aqui está a maneira que 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

Você pode alterar o número de processos pela opção "-P" acima.

Uma linha de comando simples também:

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

Queria adicionar isso ao comentário de @ jlliagre, mas não tenho reputação suficiente. Se você usar esse código em vários servidores e a contagem de CPU variar, poderá usar o seguinte comando:

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

Isso utilizará todos os núcleos do servidor, independentemente de quantos você tiver. O comando nprocfaz parte do coreutils, portanto deve estar na maioria das instalações do Linux.