Come posso produrre un carico elevato della CPU su un server Linux?

Attualmente sto eseguendo il debug di un'installazione di cactus e voglio creare un carico della CPU per eseguire il debug dei miei grafici di utilizzo della CPU.

Ho provato a eseguire semplicemente cat /dev/zero > /dev/null, che funziona benissimo ma utilizza solo 1 core:

Esiste un metodo migliore per testare / massimizzare le risorse di sistema sotto carico?

Correlati: Come posso produrre un elevato carico della CPU su Windows?

Prova stress È praticamente un equivalente di Windows consume.exe:

oliver$ ./stress --cpu 3
stress: info: [18472] dispatching hogs: 3 cpu, 0 io, 0 vm, 0 hdd

Non è necessario installare alcun pacchetto aggiuntivo, la tua buona vecchia shell è in grado di farlo da sola.

Questo one-liner caricherà i tuoi quattro core ¹ al 100%:

for i in 1 2 3 4; do while : ; do : ; done & done

Come funziona è abbastanza semplice, inizia quattro cicli infiniti. Ognuno di loro sta ripetendo l'istruzione null ( :). Ogni loop è in grado di caricare un core della CPU al 100%.

Se si utilizza bash, ksh93e altre shell di supporto gamme, (cioè non dasho più ksh), è possibile utilizzare questa sintassi non portatile:

for i in {1..4}; do ...

Sostituisci 4con il numero di CPU che desideri caricare se diverso da 4.

Supponendo che non fosse già in esecuzione alcun processo in background quando è stato avviato uno di questi loop, è possibile interrompere la generazione del carico con quel comando:

for i in 1 2 3 4; do kill %$i; done

Rispondendo al commento di underscore_d, ecco una versione migliorata che semplifica molto l'arresto del carico e che consente anche di specificare un timeout (predefinito 60 secondi.) A Control- Cucciderà anche tutti i loop in fuga. Questa funzione di shell funziona almeno sotto bashe ksh.

# Usage: lc [number_of_cpus_to_load [number_of_seconds] ]
lc() {
  (
    pids=""
    cpus=${1:-1}
    seconds=${2:-60}
    echo loading $cpus CPUs for $seconds seconds
    trap 'for p in $pids; do kill $p; done' 0
    for ((i=0;i<cpus;i++)); do while : ; do : ; done & pids="$pids $!"; done
    sleep $seconds
  )
}

¹ _{Notare che con le CPU che supportano più di un thread per core (Hyper-threading), il sistema operativo invierà il carico a tutte le CPU virtuali. In tal caso, il comportamento del carico dipende dall'implementazione (ogni thread potrebbe essere segnalato come occupato al 100% o meno).} .

Ho creato un semplice script Python che fa lo stesso. È possibile controllare il numero di core della CPU che si desidera caricare. La cosa positiva di questo è che non consumerà altre risorse oltre alla CPU. (Penso che l'idea di Mark Johnson consumerebbe molte risorse di I / O, cosa che qui non è desiderata.)

from multiprocessing import Pool

def f(x):
    # Put any cpu (only) consuming operation here. I have given 1 below -
    while True:
        x * x

# decide how many cpus you need to load with.
no_of_cpu_to_be_consumed = 3

p = Pool(processes=no_of_cpu_to_be_consumed)
p.map(f, range(no_of_cpu_to_be_consumed))

Basta eseguire questo script dal terminale $ python temp1.py. Devi uccidere lo script quando hai finito.

Ecco l'output del mio consumo di CPU quando carico 3 dei miei core.

Un modo alternativo sarebbe

openssl speed -multi $(grep -ci processor /proc/cpuinfo)

o (se è presente nproc)

openssl speed -multi $(nproc --all)

OpenSSL è quasi sempre presente nelle distribuzioni al giorno d'oggi, quindi non sono necessari pacchetti aggiuntivi.

Inizia due

sha1sum /dev/zero &

comandi per ogni core del tuo sistema.

Fermare

killall sha1sum

o

kill sha1sum

Di solito prendo la suite cpuburn:

sudo apt-get install cpuburn
for i in {1..4}; do burnK7 & done

Sostituisci 4 con il numero di core / thread HT che hai o vuoi stressare.

Nota: questo sollecita la massima area possibile del chip allo stesso tempo, è programmato per generare la massima dissipazione di potenza. Ho dovuto scrivere questo post una seconda volta, in qualche modo la mia macchina non mi è piaciuta :-(

Puoi anche eseguire cpuburn in sequenze:

burnP6 & burnP6 & burnP6 & burnP6 & 
[1] 28520
[2] 28521
[3] 28522
[4] 28523

E quando vuoi fermarli:

killall burnP6

Puoi anche moltiplicare burnP6 &per abbinare il numero di core della CPU sul tuo sistema.

Ho sviluppato stress-ng, uno strumento di stress aggiornato che può sottolineare un'ampia gamma di aspetti di un sistema Linux. Per ulteriori informazioni, consultare http://kernel.ubuntu.com/~cking/stress-ng/

L'uso è simile allo stress

$ stress-ng --cpu 4 --vm 2 --fork 8 --switch 4 --timeout 1m
stress-ng: info:  [32254] dispatching hogs: 4 cpu, 8 fork, 4 switch, 2 vm
stress-ng: info:  [32254] cache allocate: default cache size: 8192K

Installa con

sudo apt-get install stress-ng

Puoi eseguire quel comando tutte le volte che vuoi e ogni volta occuperà un core diverso:

$ CORES=1
$ for i in `seq 1 $CORES`; do cat /dev/zero > /dev/null &
> done
[1] 8388

https://github.com/GaetanoCarlucci/CPULoadGenerator

soluzione piuttosto semplice e scientifica.

Qui puoi vedere un esempio di dinamica in cui viene generato un carico del 50% sul core della CPU 0:

È possibile eseguire il processo su altri core contemporaneamente.

Ho combinato sia + jlliagre che + ecabuk.

#!/bin/bash
lc() {
    nowMs=$(date +%s)
    (
        pids=""
        cpus=${1:-1}
        seconds=${2:-60}
        echo "[$(date)] loading $cpus CPUs for $seconds seconds"
        echo "[$(date)] Expected completion: [$(date --date=@$(expr $nowMs + $seconds))]"
        trap 'for p in $pids; do kill $p; done' 0
        for ((i=0;i<cpus;i++)); do
            sha1sum /dev/zero &
            pids="$pids $!";
        done
        sleep $seconds
    )
    echo "[$(date)] Done"
}

lc $@

Puoi usare:

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

Ripetere l'operazione dd if=/dev/zero of=/dev/nullper i core della CPU.

Premi un tasto qualsiasi per interrompere il test.

pxzè un'implementazione parallela di xz.

pxz -9e /dev/zero --stdout >/dev/null dovrebbe fare il trucco, poiché questo è abbastanza intenso per la CPU.

Se /dev/zeronon è abbastanza veloce (si nota che pxzviene bloccato l'I / O) è possibile farlo pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Le versioni più recenti di xzhanno l' --threadsopzione che è un sostituto per pxz.

Ecco come uso e non è necessario installare nulla in più.

Ad esempio per iniziare con 4 processi,

nproc | xargs seq | xargs -n1 -P4 md5sum /dev/zero

È possibile modificare il numero di processi mediante l'opzione "-P" sopra.

Anche una semplice riga di comando lo fa:

x="x" ; while : ; do x=$x$x ; echo -n "." ; done

Volevo aggiungere questo al commento di @jlliagre, ma non ho abbastanza reputazione. Se utilizzerai questo codice su più server e il conteggio della CPU varierà, puoi usare il seguente comando:

for ((i=1; i<=`nproc --all`; i++)); do while : ; do : ; done & done

Questo utilizzerà tutti i core sul tuo server indipendentemente da quanti ne hai. Il comando nprocfa parte di coreutils, quindi dovrebbe essere sulla maggior parte delle installazioni Linux.