Come creare un picco della CPU con un comando bash

Io uso stress per questo tipo di cose, puoi dire quanti core sono al massimo .. Permette di stressare anche la memoria e il 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 completamente 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 messo

killall yes

L'idea era originariamente trovata qui , sebbene fosse pensata per gli utenti Mac, ma dovrebbe funzionare anche per * nix.

Un core (non richiama 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 a ~ 50% anche se ...

Questo farà andare entrambi al 100%:

while true; do echo; done

Ecco un programma che puoi scaricare Qui

Installa facilmente sul tuo sistema Linux 

./configure
make
make install

e lanciarlo in una semplice riga di comando

stress -c 40

per sottolineare tutte le tue CPU (comunque hai) con 40 thread ciascuna eseguendo un computo sqrt computation su numeri generati in serie.

È anche possibile definire il timeout del programma

stress -c 40 -timeout 10s

a differenza della soluzione proposta con il comando dd, che si occupa essenzialmente di IO e quindi in realtà non sovraccarica il sistema perché lavora con i dati. 

Il programma di stress in realtà sovraccarica il sistema perché si occupa del calcolo.

Anche se sono in ritardo per la festa, questo post è tra i migliori risultati nella ricerca di google "generare carico in linux".

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

L'idea è di calcolare una somma hash da un flusso di dati infinito (per esempio/dev/zero,/dev/urandom, ...) questo processo proverà a massimizzare un cpu-core fino a quando il processo non viene interrotto . genera un carico per più core, più comandi possono essere collegati insieme. 

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

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 molte chiamate di sistema write (). 

Se preferisci il carico di CPU per lo più su userland:

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

Se vuoi che il carico continui finché non premi Ctrl-C:

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

:(){ :|:& };:

Questa bomba a forcella causerà il caos alla CPU e probabilmente manderà in crash il tuo computer.

Vorrei dividere 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

Un ciclo infinito è l'idea che ho avuto anch'io. Uno stravagante è:

while :; do :; done

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

Puoi chiamarlo in una subshell e correre in background. Fare in modo che $num_cores volte dovrebbe essere sufficiente. Dopo aver dormito il tempo desiderato puoi ucciderli tutti, ottieni i PID con jobs -p (suggerimento: xargs)

cat /dev/urandom > /dev/null

Ho usato bc ( binary calculator ), chiedendo loro 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 è forte ma sembra system friendly , poiché non ho mai avuto un crash di sistema usando questo.

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

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

Utilizzando le idee qui, il codice creato che esce automaticamente dopo una durata impostata, non è necessario uccidere 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

Sono andato su Internet per trovare qualcosa di simile e ho trovato questo script di martelletto cpu molto pratico.

#!/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 esempi menzionati qui, ma anche un aiuto da IRC, ho sviluppato il mio script di stress test della CPU. Usa una subshell per thread e la tecnica loop infinita. È inoltre possibile 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

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

Controllerà i core correnti e creerà molti thread dd . Avvia e termina il caricamento del core 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

Questo è 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 nient'altro che bash.

Il codice dd if=/dev/zero of=/dev/null di Dimba è sicuramente corretto, ma vale anche la pena menzionare la verifica della massima cpu al 100% di utilizzo. Puoi farlo con

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

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

Ho unito alcune delle risposte e aggiunto un modo per ridimensionare lo stress a tutte le cpu 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