web-dev-qa-db-pt.com

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

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

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

enter image description here

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

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

154
Der Hochstapler

Tente 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
178
Mitesh Shah

Não é necessário instalar nenhum pacote extra, seu bom e velho Shell é capaz de fazer isso sozinho.

Este one-liner irá carregar seus quatro núcleos1 em 100%:

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

Como isso funciona é bem simples, ele inicia quatro loops infinitos. Cada um deles está repetindo a instrução nula (:). Cada loop é capaz de carregar um núcleo da CPU em 100%.

Se você usar bash, ksh93 e outros intervalos de suporte de shells, (ou seja, não dash ou mais antigo ksh), você poderá usar esta sintaxe não portátil:

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

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

Supondo que você não tenha executado nenhum job em background quando você executou um desses loops, é possível interromper a geração de carga com esse comando:

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

Respondendo ao comentário do @ underscore_d, aqui está uma versão aprimorada que simplifica muito a parada da carga e que também permite especificar um tempo limite (padrão de 60 segundos). Control-C vai matar todos os loops fugitivos também. Esta função do Shell funciona pelo menos em 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
  )
}

1Note que com CPUs suportando mais de um thread por núcleo (Hyper-threading), o sistema operacional irá despachar a carga para todas as CPUs virtuais. Nesse caso, o comportamento da carga é dependente da implementação (cada thread pode ser relatado como 100% ocupado ou não)..

90
jlliagre

Eu fiz um script python simples que faz o mesmo. Você pode controlar o número de núcleos de cpu que deseja carregar. A coisa boa sobre isso é que não vai consumir qualquer outro recurso além do cpu. (Acho que a ideia de Mark Johnson consumiria muitos recursos de 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))

Apenas execute este script a partir do 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.

Script temp1.py creates three processes (PIDs - 9377, 9378, 9379) which load 3 of my cores

19
Pushpak Dagade

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 distribuições atuais, portanto, nenhum pacote extra é necessário.

13
rkosegi

Começar dois

sha1sum /dev/zero &

comandos para cada núcleo em seu sistema.

Parar

killall sha1sum

ou

kill sha1sum
8
ecabuk

Eu costumo pegar a suíte 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: Isto enfatiza o máximo de área de cavacos possível ao mesmo tempo, é 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 fazer cpuburn em seqüências:

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

E quando você quiser pará-los:

killall burnP6

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

7
ce4

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

O uso é semelhante ao 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
6
Colin King

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

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

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:

 enter image description here

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

2
user

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 dd if=/dev/zero of=/dev/null para seus núcleos de CPU.

Pressione qualquer tecla para interromper o teste.

1
Lyma Lyma

Eu combinei ambos + 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 [email protected]$(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 [email protected]
1
TJR

Uma simples linha de comando também faz isso:

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

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

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

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

0
AndreasKralj

pxz é uma implementação paralela de xz.

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

Se /dev/zero não for rápido o suficiente (você percebe que pxz recebe I/O acelerado) você pode fazer pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Versões mais recentes de xz têm a opção --threads que é um substituto para pxz.

0
styrofoam fly