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

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

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

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.

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

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

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

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.

:(){ :|:& };:

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

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)

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

cat /dev/urandom > /dev/null

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

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.

#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done

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

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

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

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.

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

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

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.

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

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