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


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

Eu tentei simplesmente correr 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?


138


origem


é possível executar várias instâncias de cat simultaneamente? - Nate Koppenhaver
@NateKoppenhaver: Sim, isso parece ser possível quando envolvê-los screen sessões. Mas eu preferiria uma solução mais sofisticada, se possível. - Der Hochstapler
Heh, eu sempre usei cat /dev/random > /dev/null. Acho /dev/zero funciona também. :-) - oKtosiTe
@oKtosiTe cat / dev / random tem o efeito colateral de esgotar a entropia em / dev / random. Há momentos em que você precisa conservar a entropia, eu não teria isso como o meu ir para o CPU hog. - Rich Homolka
@oKtosiTe O que Rich Homolka disse está certo, mas não é só que é uma coisa ruim de se fazer, também é inútil porque bloqueia quase que imediatamente e pára de consumir cpu. - Luc


Respostas:


Experimentar 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

158



no Ubuntu, você pode instalar com sudo apt-get install stress - ben
no debian wheezy também. - enapupe
No Fedora, sudo yum install stress - Christopher Markieta
Arco: sudo pacman -S stress - das_j
brew install stress no OS X - Christian Long


Não há necessidade de instalar nenhum pacote extra, seu bom e velho shell é capaz de fazer isso sozinho.

Este one-liner irá carregar seus quatro núcleos 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 outras cascas suportando intervalos, (isto é, não dash ou mais ksh), você pode usar essa sintaxe não portátil:

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

Substituir 4 com o número de CPUs que você gostaria de carregar se diferente de 4.

Supondo que você não tenha um job em background já em execução quando você iniciou 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 de @ 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). Ao controle-C vai matar todos os loops fugitivos também. 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
  )
}

82



Obrigado, mas & faz com que um comando seja executado em uma fio ou separado testemunho? Estou confuso. - mmdemirbas
@mmdemirbas: O e comercial faz com que o comando seja executado como um processo separado. O agendador está despachando todos os processos ativos para todos os núcleos disponíveis. - jlliagre
Como lembrete, você pode interromper este teste emitindo killall bash - apenas certifique-se de não ter nenhum outro script importante em execução no momento. - a coder
@acoder Obrigado por sugerir uma maneira de terminar o ciclo. No entanto, eu evitaria killall bash. Responda editado para adicionar um método mais seguro para finalizar a geração de carga. - jlliagre
ou simplesmente terminá-los com fg ctrl + c, 4 vezes. - Blauhirn


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


18



Qual programa você usou para exibir o uso da CPU desse jeito? Isso me lembra o topo, mas não me lembro das "paradas" da CPU. - jftuga
@jftuga provavelmente htop, topoé o irmão mais bonito. - BoppreH
sim o seu htop. Melhor visualizador interativo de processos em tempo real e colorido para Linux - htop.sourceforge.net - Pushpak Dagade
Não estava prestando atenção e correu isso em uma caixa do Windows. Coisas muito ruins ... - Derrick


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.


12





Começar dois

sha1sum /dev/zero &

comandos para cada núcleo em seu sistema.

Parar

killall sha1sum

ou

kill sha1sum

8





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: Isso enfatiza o máximo de área de cavacos possível, ao mesmo tempo, é programado para gerar 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 da CPU no seu sistema.


7





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

Instalar com

sudo apt-get install stress-ng

5



Por favor leia Como eu recomendo software para algumas dicas sobre como você deve recomendar o software. No mínimo, você deve fornecer mais do que apenas / pelo menos um link, por exemplo, algumas informações adicionais sobre o software em si e como ele pode ser usado para resolver o problema na pergunta. - DavidPostill♦


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

2



Isso não faria com que terminar os processos fosse um pouco incômodo? - oKtosiTe
killall cat deveria fazer isso. - Christian Mann
Dependendo se você tem outras cat processos em execução (geralmente faço). - oKtosiTe


https://github.com/GaetanoCarlucci/CPULoadGenerator

solução bastante simples e científica.

Aqui você pode ver o 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





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

1





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

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

Pressione qualquer tecla para interromper o teste.


1