Come creare un picco della CPU con un comando bash

Voglio creare un carico quasi al 100% su una macchina Linux. È un sistema quad core e voglio che tutti i core vadano a tutta velocità. Idealmente, il carico della CPU dovrebbe durare un determinato periodo di tempo e quindi arrestarsi. Spero che ci sia qualche trucco a Bash. Sto pensando a una sorta di ciclo infinito.

Puoi anche fare

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

Per eseguire più di questi per caricare più core, prova a biforcarlo:

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

Ripeti il ​​comando tra parentesi graffe quante volte il numero di thread che vuoi produrre (qui 4 thread). Il semplice tasto Invio lo interromperà (assicurati solo che nessun altro dd sia in esecuzione su questo utente o lo uccidi anche tu).

Uso lo stress per questo tipo di cose, puoi dirgli quanti core massimizzare .. consente anche di stressare memoria e disco.

Esempio per sollecitare 2 core per 60 secondi

stress --cpu 2 --timeout 60

Penso che questo sia più semplice. Apri Terminale e digita quanto segue e premi Invio.

yes > /dev/null &

Per utilizzare pienamente le moderne CPU, una riga non è sufficiente, potrebbe essere necessario ripetere il comando per esaurire tutta la potenza della CPU.

Per finire tutto questo, semplicemente

killall yes

L'idea è stata originariamente trovata qui , sebbene fosse destinata agli utenti Mac, ma dovrebbe funzionare anche per * nix.

Anche se sono in ritardo alla festa, questo post è tra i migliori risultati nella ricerca di Google "genera carico in Linux".

Il risultato contrassegnato come soluzione potrebbe essere utilizzato per generare un carico di sistema, preferisco utilizzare sha1sum /dev/zero per imporre un carico su un core della CPU.

L'idea è di calcolare una somma hash da un flusso di dati infinito (es. / Dev / zero, / dev / urandom, ...) questo processo tenterà di massimizzare un core cpu fino a quando il processo non viene interrotto. Per generare un carico per più core, è possibile eseguire il piping di più comandi insieme.

per esempio. generare un carico di 2 core: sha1sum /dev/zero | sha1sum /dev/zero

Un core (non invoca il processo esterno):

while true; do true; done

Due core:

while true; do /bin/true; done

Quest'ultimo fa sì che entrambi i miei vadano solo al 50% circa ...

Questo farà andare entrambi al 100%:

while true; do echo; done

Per caricare 3 core per 5 secondi:

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

Ciò comporta un carico elevato del kernel (sys) dalle numerose chiamate di sistema write ().

Se si preferisce il caricamento della cpu prevalentemente userland:

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

Se vuoi solo che il caricamento continui fino a quando premi Ctrl-C:

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

Ecco un programma che puoi scaricare qui

Installa facilmente sul tuo sistema Linux

./configure
make
make install

e avviarlo in una semplice riga di comando

stress -c 40

stressare tutte le tue CPU (comunque tu abbia) con 40 thread ciascuno con un complesso sqrt calcolo su numeri generati ramdomly.

È anche possibile definire il timeout del programma

stress -c 40 -timeout 10s

a differenza della soluzione proposta con il ddcomando, che si occupa essenzialmente di IOe quindi non sovraccarica il sistema perché si lavora con i dati.

Il programma di stress sovraccarica davvero il sistema perché ha a che fare con il calcolo.

:(){ :|:& };:

Questa bomba a forcella causerà il caos alla CPU e probabilmente farà schiantare il computer.

Un ciclo infinito è anche l'idea che ho avuto. Un aspetto bizzarro è:

while :; do :; done

( :è uguale a true, non fa nulla ed esce con zero)

Puoi chiamarlo in una subshell ed eseguire in background. In questo modo i $num_corestempi dovrebbero essere sufficienti. Dopo aver dormito il tempo desiderato da poterli uccidere tutti, si ottiene il PID con jobs -p(suggerimento: xargs)

Dividerei la cosa in 2 script:

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

Ho usato bc( calcolatrice binaria ), chiedendo loro di PI con un sacco di decimali.

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

con NUMCPU (sotto Linux):

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

Questo metodo è efficace ma sembra amichevole per il sistema , poiché non ho mai avuto un crash con un sistema che lo utilizzava.

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

Sono andato su Internet per trovare qualcosa del genere e ho trovato questo script di cpu hammer molto utile.

#!/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 gli esempi citati qui, ma anche l'aiuto di IRC, ho sviluppato il mio script di stress test della CPU. Usa una subshell per thread e la tecnica loop infinita. Puoi anche specificare il numero di thread e la quantità di tempo in modo interattivo.

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

Utilizzando qui le idee, il codice creato che esce automaticamente dopo una durata prestabilita, non è necessario interrompere i processi -

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

Questo fa un trucco per me:

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 non usa altro che bash.

Per migliorare la risposta di Dimba e fornire qualcosa di più collegabile (perché avevo bisogno di qualcosa di simile). Ho scritto quanto segue usando il concetto di caricamento di dd: D

Controllerà i core attuali e creerà molti thread dd. Avvia e termina il carico principale con Invio

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

Ho combinato alcune delle risposte e aggiunto un modo per ridimensionare lo stress a tutti i cpus disponibili:

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

Dimba's dd if=/dev/zero of=/dev/nullè sicuramente corretto, ma vale anche la pena ricordare che è stato verificato un maxing della CPU al 100% di utilizzo. Puoi farlo con

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

Ciò richiede l'output ps di una media di 1 minuto dell'utilizzo della cpu da parte di ciascun processo, quindi li somma con awk. Sebbene sia una media di 1 minuto, ps è abbastanza intelligente da sapere se un processo dura solo pochi secondi e regola di conseguenza la finestra temporale. Quindi puoi usare questo comando per vedere immediatamente il risultato.

aumentare il carico o consumare la CPU al 100%

sha1sum /dev/zero &

allora puoi vedere gli usi della CPU digitando command

top

per rilasciare il carico

killall sha1sum

Basta incollare questo cattivo ragazzo in SSH o console di qualsiasi server che esegue Linux. Puoi terminare i processi manualmente, ma ho appena chiuso il server più velocemente.

Modifica: ho aggiornato questo script per avere ora una funzione timer in modo che non sia necessario interrompere i processi.

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