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

Prova stress È praticamente l'equivalente di Windows consume.exe:

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

Non c'è bisogno di installare alcun pacchetto extra, il vostro buon vecchio shell è in grado di farlo da solo.

Questo one-liner caricherà i vostri quattro core1 al 100%:

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

Come funziona è abbastanza semplice, avvia quattro loop infiniti. Ognuno di essi ripete l'istruzione nulla (:). Ogni loop è in grado di caricare un core di CPU al 100%.

Se si utilizza bash, ksh93 e altre shell che supportano le gamme, (cioè non dash o più vecchie ksh), è possibile utilizzare questa sintassi non portatile:

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

Sostituire 4 con il numero di CPU che si desidera caricare se diverso da 4.

Supponendo che non aveste un lavoro in background già in esecuzione quando avete lanciato uno di questi loop, potete fermare la generazione del carico con questo 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 permette anche di specificare un timeout (default 60 secondi.) Un Control-C ucciderà anche tutti i loop in runaway. Questa funzione di shell funziona almeno sotto bash e 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
  )
}
``` &001 

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

Ho fatto una semplice sceneggiatura in pitone che fa lo stesso. È possibile controllare il numero di core cpu che si desidera caricare. La cosa positiva è che non consumerà nessun'altra risorsa oltre alla cpu (penso che l'idea di Mark Johnson consumerebbe un sacco di risorse di I/O, il che è indesiderato in questo caso)

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))
``` &001 

. È necessario uccidere lo script quando hai finito. 


Qui, è la mia uscita di consumo cpu quando carico 3 dei miei core. 


![Script temp1.py creates three processes (PIDs - 9377, 9378, 9379) which load 3 of my cores](https://i.stack.imgur.com/eUVtY.png)

Un modo alternativo sarebbe

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

o (se nproc è presente)

&001 &001

OpenSSL è quasi sempre presente sulle distro di oggi, quindi non sono necessari pacchetti extra.

Avviare due comandi

sha1sum /dev/zero &
``` ```
killall sha1sum

per ogni nucleo del vostro sistema.

Per fermare

kill sha1sum

o

&001

Ho sviluppato stress-ng, uno strumento di stress aggiornato che può mettere in evidenza una vasta gamma di aspetti di un sistema Linux. Per maggiori informazioni, vedere http://kernel.ubuntu.com/~cking/stress-ng/

L'uso è simile a 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

Installare con

sudo apt-get install stress-ng

Di solito prendo la suite cpuburn:

sudo apt-get install cpuburn
for i in {1..4}; do burnK7 & done
``` ```
burnP6 & burnP6 & burnP6 & burnP6 & 
[1] 28520
[2] 28521
[3] 28522
[4] 28523

Sostituire 4 con il numero di nuclei / HT-threads che si ha o si vuole stressare.

Nota: Questo stressa la maggior area di chip possibile 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 :-(

Potreste anche fare cpuburn in sequenze:

killall burnP6
``` &001 



E quando volete fermarli: 


&001 


Potreste anche moltiplicare `burnP6 &` per uguagliare il numero di core di CPU sul vostro sistema.

È possibile eseguire quel comando tutte le volte che si desidera, e ogni volta occuperà un nucleo diverso:

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

https://github.com/GaetanoCarlucci/CPULoadGenerator &003

soluzione piuttosto semplice e scientifica.

Qui si può 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.

pxz è un'implementazione parallela di xz.

pxz -9e /dev/zero --stdout >/dev/null dovrebbe fare il trucco, perché è abbastanza intensivo.

Se /dev/zero non è abbastanza veloce (si nota che pxz viene strozzato in I/O) si può farepxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Le versioni più recenti di xz hanno l'opzione --threads che è un sostituto di pxz.

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 $@

È possibile utilizzare:

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
``` &001 


Ripeti `dd if=/dev/zero of=/dev/null` per i core della CPU. 


Premere un tasto qualsiasi per interrompere il test.

Ecco come si usa e non c'è bisogno di installare nulla in più.

Per esempio per iniziare con 4 processi,

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

È possibile modificare il numero di processi con 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 avete intenzione di usare questo codice su più server e il numero di CPU varia, potete usare il seguente comando:

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

Questo utilizzerà tutti i core del vostro server, indipendentemente da quanti ne avete. Il comando nproc fa parte dei coreutils, quindi dovrebbe essere presente sulla maggior parte delle installazioni Linux.