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

Question

Atualmente, estou no processo de depuração de uma instalação do Cacti e deseja 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:

Existeummétodomelhordetestar/maximizarosrecursosdosistemasobcarga?

Related:How can I produce high CPU load on Windows?

    

Answer 1

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

    

Answer 2

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

Este one-liner 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 outros intervalos de suporte de shells, (ou seja, não dash ou mais antigo ksh ), poderá usar esta sintaxe não portátil:

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

Substitua 4 pelo número de CPUs que você deseja carregar se for 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 parando a carga e que também permite especificar um timeout (padrão 60 segundos). A Controle - C 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
  )
}

    

Answer 3

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 esse script no terminal $ python temp1.py . Você precisa matar o script quando terminar.

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

    

Answer 4

Um caminho alternativo 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.

    

Answer 5

Comece dois

sha1sum /dev/zero &

comandos para cada núcleo no seu sistema.

Para parar

killall sha1sum

ou

kill sha1sum

    

Answer 6

Eu geralmente uso 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 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 o cpuburn em sequê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.

    

Answer 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, consulte o link

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

    

Answer 8

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

    

Answer 9

link

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.

    

Answer 10

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

    

Answer 11

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.

    

Answer 12

Uma linha de comando simples também:

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

    

Answer 13

pxz é uma implementação paralela de xz .

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

Se /dev/zero não for rápido o suficiente (você percebe que pxz obtém E / S acelerado), você pode fazer pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

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