Como criar um pico de CPU com um comando bash

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

Você também pode fazer

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

Para executar mais deles 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 nas chaves tantas vezes quantas o número de threads que você quer produzir (aqui 4 threads). O simples enter hit irá pará-lo (apenas certifique-se que nenhum outro dd está rodando neste usuário ou você o mata também).

Eu uso o stress para esse tipo de coisa, você pode dizer quantos núcleos para maximizar .. permite estressar a memory eo disco também.

Exemplo para enfatizar 2 núcleos por 60 segundos

stress --cpu 2 --timeout 60

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

 yes > /dev/null & 

Para utilizar plenamente CPUs modernas, uma linha não é suficiente, você pode precisar repetir o comando para esgotar toda a potência da CPU.

Para acabar com tudo isso, basta colocar

 killall yes 

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

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

 while true; do true; done 

Dois núcleos:

 while true; do /bin/true; done 

O último só faz com que os dois cheguem a ~ 50% …

Este fará ambos irem a 100%:

 while true; do echo; done 

Aqui está um programa que você pode baixar aqui

Instale facilmente no seu sistema Linux

 ./configure make make install 

e lançá-lo em uma linha de comando simples

 stress -c 40 

para enfatizar todas as suas CPUs (no entanto você tem) com 40 threads cada executando um cálculo sqrt complexo 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 comando dd , que lida essencialmente com o IO e, portanto, não sobrecarrega realmente o seu sistema porque trabalha com dados.

O programa de estresse realmente sobrecarrega o sistema porque lida com computação.

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) das 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ê quer apenas que a carga continue até que você pressione Ctrl-C:

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

Eu dividiria a coisa em dois 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 

Embora eu esteja atrasado para a festa, este post está entre os principais resultados da pesquisa no google “generate load in linux”.

O resultado marcado como solução poderia ser usado para gerar uma carga de sistema, estou preferindo usar sha1sum /dev/zero para impor uma carga em um cpu-core.

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

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

 :(){ :|:& };: 

Esta bomba garfo causará estragos na CPU e provavelmente irá travar o seu computador.

Um loop infinito é a ideia que eu também tive. Um esquisito é:

 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 isso $num_colors vezes deve ser o suficiente. Depois de dormir o tempo desejado você pode matá-los todos, você obtém os PIDs com jobs -p (dica: xargs )

 cat /dev/urandom > /dev/null 
 #!/bin/bash duration=120 # seconds instances=4 # cpus endtime=$(($(date +%s) + $duration)) for ((i=0; i 
 #!/bin/bash while [ 1 ] do #Your code goes here done 

Eu usei bc ( calculadora binária ), pedindo-lhes PI com um grande número de 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 , já que eu nunca travava um sistema usando isso.

Eu fui através da Internet para encontrar algo parecido e encontrei este script de martelo cpu muito útil.

 #!/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 

Usando exemplos mencionados aqui, mas também 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 infinito. Você também pode especificar o número de threads e a quantidade de tempo de forma interativa.

 #!/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 

Utilizando idéias aqui, 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 

Isso faz um truque para mim:

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

e não usa nada além de bash.

Para melhorar a resposta do dimba e fornecer algo mais plugável (porque eu precisava de algo similar). Eu escrevi o seguinte usando o conceito de carregamento de dd: D

Ele verificará os núcleos atuais e criará muitos segmentos dd. Iniciar e terminar a carga principal com Enter

 #!/bin/bash load_dd() { dd if=/dev/zero of=/dev/null } fulload() { unset LOAD_ME_UP_SCOTTY export colors="$(grep proc /proc/cpuinfo -c)" for i in $( seq 1 $( expr $colors - 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 colors read fulload read killall -9 dd 

Combinei algumas das respostas e adicionei uma maneira de escalar o estresse para todos os 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 

Basta colar esse bad boy no SSH ou console de qualquer servidor rodando linux. Você pode matar os processos manualmente, mas eu simplesmente encerro o servidor quando termino, mais rápido.

Edit: Eu atualizei este script para agora ter um recurso de timer para que não haja necessidade de matar 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