Como criar um pico de CPU com um comando bash

281

Eu quero criar uma carga de quase 100% em uma máquina Linux. É um sistema quad core e quero que todos os núcleos funcionem a toda velocidade. Idealmente, a carga da CPU duraria uma quantidade de tempo designada e depois pararia. Espero que exista algum truque no bash. Estou pensando em algum tipo de loop infinito.

Usuário1
fonte

Respostas:

283

Você também pode fazer

dd if=/dev/zero of=/dev/null

Para executar mais desses para colocar carga em mais núcleos, tente bifurcá-lo:

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 comando entre colchetes tantas vezes quanto o número de threads que você deseja produzir (aqui 4 threads). O simples pressionamento de enter o interromperá (apenas verifique se nenhum outro dd está sendo executado neste usuário ou você o mata também).

dimba
fonte
35
ofertas dd mais com I / O do que com o uso da CPU
Fred
2
Isso realmente funcionou melhor para a minha situação. Também trabalhou em Cygwin. Por alguma razão, as outras soluções não atingiram o pico da CPU. Adicionar uma contagem e fazer quatro processos em paralelo funcionou perfeitamente. Aumentou a CPU em 100% no topo e depois voltou a zero sem ajuda. Apenas quatro linhas de código e uma "espera".
usar o seguinte
62
Ler /dev/zeroe escrever para /dev/nullnão é um gerador de carga muito bom - você precisa executar muitos deles para gerar carga significativa. Melhor fazer algo parecido dd if=/dev/urandom | bzip2 -9 >> /dev/null. /dev/urandomrequer muito mais esforço para gerar saída e bzip2gasta muito esforço para compactá-la, portanto o uso geral da CPU é muito maior do que "preencher um bloco com zeros e depois jogá-lo fora".
twalberg
4
Use jobs -p | xargs killpara matar apenas os processos que você criou.
Marian
5
Twalberg, você deve fazer seu comentário em uma resposta.
Aaron McDaid
362

Eu uso estresse para esse tipo de coisa, você pode dizer quantos núcleos devem atingir o máximo .. ele também pode estressar a memória e o disco.

Exemplo para forçar 2 núcleos por 60 segundos

stress --cpu 2 --timeout 60

David
fonte
6
No Fedora,sudo yum install stress
Christopher Markieta
3
Você precisa se EPELrepo para o CentOSwget http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
Satish
4
brew install stressno OS X. Além disso, por algum motivo eu tive que especificar 8 núcleos em um quad-core MBPr
fregante
1
@ bfred.it Seus núcleos podem utilizar hyperthreading, dobrando efetivamente sua quantidade de núcleos (4 físicos e 4 virtuais). Você também vai querer enfatizar os virtuais para um teste de carga total.
Mast
6
sudo apt-get install stressem sistemas baseados em debian, para ser completo. Usei isso para testar um mod de resfriamento no kit Intel i7 NUC .
Onmylemon 26/11/2015
133

Eu acho que este é mais simples. Abra Terminal, digite o seguinte e pressione Enter.

yes > /dev/null &

Para utilizar totalmente as CPUs modernas, uma linha não é suficiente; talvez seja necessário repetir o comando para esgotar toda a energia da CPU.

Para terminar tudo isso, basta colocar

killall yes

A idéia foi originalmente encontrada aqui , embora fosse destinada a usuários de Mac, mas isso também deveria funcionar para * nix.

user1147015
fonte
7
+1 Funciona como um encanto, obrigado! Vale a pena acrescentar : este comando irá no máximo um hyperthread por núcleo da CPU. Portanto, uma CPU dual core (cada núcleo com 2 threads) terá uma carga total de 25% por yescomando (assumindo que o sistema estava ocioso).
GitaarLAB 13/01
Apenas para adicionar isso, cada iteração desse comando adiciona 25% de carga na CPU (Android) até 4 iterações e o restante não tem efeito (mesmo em termos de taxa de clock).
user3188978
30

Embora eu esteja atrasado para a festa, este post está entre os principais resultados da pesquisa no Google "gerar carga no linux".

O resultado marcado como solução pode ser usado para gerar uma carga do sistema, estou preferindo usar sha1sum /dev/zeropara impor uma carga em um núcleo de CPU.

A idéia é calcular uma soma de hash de um fluxo de dados infinito (por exemplo, / dev / zero, / dev / urandom, ...) esse processo tentará maximizar o núcleo de uma CPU até que o processo seja abortado. Para gerar uma carga para mais núcleos, vários comandos podem ser canalizados juntos.

por exemplo. gere uma carga de 2 núcleos: sha1sum /dev/zero | sha1sum /dev/zero

Mitms
fonte
Vendo, isso é melhor que o dd para a carga da CPU. Recebo carga máxima da CPU de 44% no dd (6 vezes) e 86% + no sha1sum. Thx ~!
AAI
26

Um núcleo (não invoca processo externo):

while true; do true; done

Dois núcleos:

while true; do /bin/true; done

Este último só faz com que os meus dois atinjam ~ 50% ...

Este fará os dois chegarem a 100%:

while true; do echo; done
L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳
fonte
no eco, perdemos o acesso ao linux. como colocar esse terceiro comando em segundo plano?
AAI
2
Por que o eco faz com que todos os núcleos da CPU cheguem a 100%?
precisa saber é o seguinte
@HaoyuanGe Todos os cpus são 100% apenas quando ecoam "nada". Substitua o do eco; com do echo "alguma corda muito, muito longa"; para ver <100% na cpus. Então, eu acredito, ecoando nada muito menos saltos e, portanto, mais código para executar (por causa do while true;) os núcleos são ~ 100% ocupado
talekeDskobeDa
Se você quiser manter um servidor responsivo enquanto a execução de um tal teste, fazê-lo em um shell separado (outra janela tmux / tela, ou sessão ssh) e renice que a Shell em primeiro lugar, por exemplo, em bash: renice 19 -p $$. Ainda maximizará as CPUs, mas não afetará outros processos.
Walf
23

Para carregar 3 núcleos por 5 segundos:

seq 3 | xargs -P0 -n1 timeout 5 yes > /dev/null

Isso resulta em alta carga do kernel (sys) de muitas chamadas do sistema write ().

Se você preferir principalmente a carga da CPU do usuário:

seq 3 | xargs -P0 -n1 timeout 5 md5sum /dev/zero

Se você deseja que a carga continue até você pressionar Ctrl-C:

seq 3 | xargs -P0 -n1 md5sum /dev/zero
James Scriven
fonte
1
Isso é possível no tinycore? xargs: opção inválida - 'P'
conman253
boa opção nativa
insira
18

Aqui está um programa que você pode baixar aqui

Instale facilmente no seu sistema Linux

./configure
make
make install

e inicie-o em uma linha de comando simples

stress -c 40

enfatizar todas as suas CPUs (como você tiver) com 40 threads cada, executando uma sqrtcomputação complexa em números gerados aleatoriamente.

Você pode até definir o tempo limite do programa

stress -c 40 -timeout 10s

ao contrário da solução proposta com o ddcomando, que lida essencialmente com IOe, portanto, não sobrecarrega seu sistema porque trabalha com dados.

O programa de estresse realmente sobrecarrega o sistema porque se trata de computação.

Fopa Léon Constantin
fonte
4
Já existe uma resposta acima para o stresscomando. Como essa resposta diz, você pode simplesmente instalá-lo via yum / apt / etc.
Asfand Qazi
1
Site não em boas condições (503 Proibido), mas está disponível nas repos :)
m3nda
11
:(){ :|:& };:

Essa bomba de garfo causará estragos na CPU e provavelmente travará seu computador.

Jeff Goldstein
fonte
13
Ajudará se eu facilitar a leitura fork_bomb () {fork_bomb | fork_bomb &}; forkbomb
Jeff Goldstein
17
Aquele falha no critério "durar um determinado período de tempo e depois parar";)
Marian
14
parece um monte de carinhas felizes.
Ponkadoodle 28/05
2
Esta bomba de garfo travou meu computador, eu tive que fazer um ciclo de energia forte.
Elijah Lynn
2
De: cyberciti.biz/faq/understanding-bash-fork-bomb AVISO! Esses exemplos podem travar seu computador se forem executados. "Depois que uma bomba de forquilha bem-sucedida for ativada em um sistema, talvez não seja possível retomar a operação normal sem reiniciar o sistema, pois a única solução para uma bomba de forquilha é destruir todas as instâncias dela."
Elijah Lynn
11

Um loop infinito é a ideia que eu também tive. Um de aparência esquisita é:

while :; do :; done

( :é o mesmo que true, não faz nada e sai com zero)

Você pode chamar isso em um subshell e executar em segundo plano. Fazer esse $num_corestempo deve ser suficiente. Depois de dormir o tempo desejado você pode matá-los todos, você obtém os PIDs com jobs -p(dica: xargs)

Marian
fonte
10

Eu dividiria a coisa em 2 scripts:

infinite_loop.bash:

#!/bin/bash
while [ 1 ] ; do
    # Force some computation even if it is useless to actually work the CPU
    echo $((13**99)) 1>/dev/null 2>&1
done

cpu_spike.bash:

#!/bin/bash
# Either use environment variables for NUM_CPU and DURATION, or define them here
for i in `seq ${NUM_CPU}` : do
    # Put an infinite loop on each CPU
    infinite_loop.bash &
done

# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}
killall infinite_loop.bash
Fred
fonte
7
cat /dev/urandom > /dev/null
Evgeny
fonte
Adicione algum comentário também, isso ajuda.
Lokesh
4
#!/bin/bash
duration=120    # seconds
instances=4     # cpus
endtime=$(($(date +%s) + $duration))
for ((i=0; i<instances; i++))
do
    while (($(date +%s) < $endtime)); do :; done &
done
Pausado até novo aviso.
fonte
4

Eu usei bc( calculadora binária ), pedindo PI com muitas casas decimais.

$ for ((i=0;i<$NUMCPU;i++));do
    echo 'scale=100000;pi=4*a(1);0' | bc -l &
    done ;\
    sleep 4; \
    killall bc

com NUMCPU (no Linux):

$ NUMCPU=$(grep $'^processor\t*:' /proc/cpuinfo |wc -l)

Este método é forte, mas parece amigável ao sistema , pois nunca travou um sistema usando isso.

F. Hauri
fonte
3
#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done
Secko
fonte
1
Ah não. Dormir não é esse tipo de tarefa que coloca muita laod na CPU:-)
Marian
2

Entrei na Internet para encontrar algo parecido e encontrei esse script muito útil de martelo de CPU.

#!/bin/sh

# unixfoo.blogspot.com

if [ $1 ]; then
    NUM_PROC=$1
else
    NUM_PROC=10
fi

for i in `seq 0 $((NUM_PROC-1))`; do
    awk 'BEGIN {for(i=0;i<10000;i++)for(j=0;j<10000;j++);}' &
done
Ishtiaq Ahmed
fonte
Realmente precisa demorar tanto? I como one-liners melhores para este tipo de tarefa ...
Nikana Reklawyks
1
A cláusula de if-then-else pode ser substituído por: NUM_PROC=${1:-10}.
Thor
2

Usando os exemplos mencionados aqui, mas também a ajuda do IRC, desenvolvi meu próprio script de teste de estresse da CPU. Ele usa um subshell por thread e a técnica de loop sem fim. Você também pode especificar o número de threads e a quantidade de tempo interativamente.

#!/bin/bash
# Simple CPU stress test script

# Read the user's input
echo -n "Number of CPU threads to test: "
read cpu_threads
echo -n "Duration of the test (in seconds): "
read cpu_time

# Run an endless loop on each thread to generate 100% CPU
echo -e "\E[32mStressing ${cpu_threads} threads for ${cpu_time} seconds...\E[37m"
for i in $(seq ${cpu_threads}); do
    let thread=${i}-1
    (taskset -cp ${thread} $BASHPID; while true; do true; done) &
done

# Once the time runs out, kill all of the loops
sleep ${cpu_time}
echo -e "\E[32mStressing complete.\E[37m"
kill 0
MirceaKitsune
fonte
recebendo erro "linha 14: conjunto de tarefas: comando não encontrado" em seu script! qualquer ideia?
user2912312
2

Utilizando idéias aqui, o código criado que sai automaticamente após uma duração definida, não precisa matar processos -

#!/bin/bash
echo "Usage : ./killproc_ds.sh 6 60  (6 threads for 60 secs)"

# Define variables
NUM_PROCS=${1:-6} #How much scaling you want to do
duration=${2:-20}    # seconds

function infinite_loop {
endtime=$(($(date +%s) + $duration))
while (($(date +%s) < $endtime)); do
    #echo $(date +%s)
    echo $((13**99)) 1>/dev/null 2>&1
    $(dd if=/dev/urandom count=10000 status=none| bzip2 -9 >> /dev/null) 2>&1 >&/dev/null
done
echo "Done Stressing the system - for thread $1"
}


echo Running for duration $duration secs, spawning $NUM_PROCS threads in background
for i in `seq ${NUM_PROCS}` ;
do
# Put an infinite loop
    infinite_loop $i  &
done
Dhiraj
fonte
1

Isso faz um truque para mim:

bash -c 'for (( I=100000000000000000000 ; I>=0 ; I++ )) ; do echo $(( I+I*I )) & echo $(( I*I-I )) & echo $(( I-I*I*I )) & echo $(( I+I*I*I )) ; done' &>/dev/null

e não usa nada, exceto o bash.

ZyX
fonte
1

Para melhorar a resposta do dimba e fornecer algo mais conectável (porque eu precisava de algo semelhante). Escrevi o seguinte usando o conceito de carregamento do dd: D

Ele verificará os núcleos atuais e criará muitos threads dd. Iniciar e finalizar o carregamento principal com Enter

#!/bin/bash

load_dd() {
    dd if=/dev/zero of=/dev/null
}

fulload() {
    unset LOAD_ME_UP_SCOTTY
    export cores="$(grep proc /proc/cpuinfo -c)"
    for i in $( seq 1 $( expr $cores - 1 ) )
      do
    export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd | ')"
  done
        export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd &')"
    eval ${LOAD_ME_UP_SCOTTY}
}

echo press return to begin and stop fullload of cores
  read
  fulload
  read
  killall -9 dd
knope
fonte
0

Combinei algumas das respostas e adicionei uma maneira de dimensionar o estresse para todas as CPUs disponíveis:

#!/bin/bash

function infinite_loop { 
    while [ 1 ] ; do
        # Force some computation even if it is useless to actually work the CPU
        echo $((13**99)) 1>/dev/null 2>&1
    done
}

# Either use environment variables for DURATION, or define them here
NUM_CPU=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
PIDS=()
for i in `seq ${NUM_CPU}` ;
do
# Put an infinite loop on each CPU
    infinite_loop &
    PIDS+=("$!")
done

# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}

# Parent kills its children 
for pid in "${PIDS[@]}"
do
    kill $pid
done
joecks
fonte
0

O Dimba's dd if=/dev/zero of=/dev/nullestá definitivamente correto, mas também vale a pena mencionar a verificação de como maximizar o uso da CPU para 100%. Você pode fazer isso com

ps -axro pcpu | awk '{sum+=$1} END {print sum}'

Isso solicita uma saída ps de uma média de 1 minuto do uso da CPU por cada processo e depois os soma com awk. Embora seja uma média de 1 minuto, o ps é inteligente o suficiente para saber se um processo dura apenas alguns segundos e ajusta a janela de tempo de acordo. Assim, você pode usar este comando para ver imediatamente o resultado.

jeremysprofile
fonte
0

aumentar a carga ou consumir 100% da CPU

sha1sum /dev/zero &

então você pode ver o uso da CPU digitando o comando

top

para liberar a carga

killall sha1sum
44kksharma
fonte
-1

Basta colar esse bad boy no SSH ou no console de qualquer servidor que esteja executando o Linux. Você pode matar os processos manualmente, mas eu apenas desligo o servidor quando terminar, mais rápido.

Editar: atualizei este script para agora ter um recurso de timer, para que não haja necessidade de interromper os processos.

read -p "Please enter the number of minutes for test >" MINTEST && [[ $MINTEST == ?(-)+([0-9]) ]]; NCPU="$(grep -c ^processor /proc/cpuinfo)";  ((endtime=$(date +%s) + ($MINTEST*60))); NCPU=$((NCPU-1)); for ((i=1; i<=$NCPU; i++)); do while (($(date +%s) < $endtime)); do : ; done & done
GarretSidzaka
fonte