it-swarm-eu.dev

Come creare un picco della CPU con un comando bash

Voglio creare un carico quasi del 100% su una macchina Linux. È un sistema quad-core e voglio che tutti i core procedano a tutta velocità. Idealmente, il carico della CPU durerebbe un certo periodo di tempo e poi si fermerebbe. Spero che ci sia qualche trucco in bash. Sto pensando ad una sorta di loop infinito. 

229
User1

Puoi anche fare

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

Per eseguire più di quelli per caricare più core, provare a biforcare: 

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). Semplice invio hit lo interromperà (assicurati solo che nessun altro dd sia in esecuzione su questo utente o lo uccidi anche tu). 

233
dimba

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

311
David

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.

98
user1147015

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.

17

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

15
Mitms

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
14
James Scriven
:(){ :|:& };:

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

10
Jeff Goldstein

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
10
Fred

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)

9
Marian
cat /dev/urandom > /dev/null
7
Evgeny

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.

4
F. Hauri
#!/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
4
#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done
3
Secko

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
2
Dhiraj

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
2
Ishtiaq Ahmed

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
2
MirceaKitsune

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
1
knope

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.

1
ZyX

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. 

0
jeremysprofile

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
0
joecks