Jak mogę wytworzyć duże obciążenie procesora na serwerze Linux?

Spróbuj stress To odpowiednik Windows consume.exe:

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

Nie musisz instalować żadnego dodatkowego pakietu, twój stary dobry shell jest w stanie zrobić to sam.

Ten jeden-liner załaduje twoje cztery rdzenie1 w 100%:

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

Jak to działa jest dość proste, zaczyna cztery niekończące się pętle. Każda z nich powtarza instrukcję null (:). Każda pętla jest w stanie załadować rdzeń procesora w 100%.

Jeśli używasz bash, ksh93 i innych powłok obsługujących zakresy, (tj. nie dash lub starsze ksh), możesz użyć tej nie przenośnej składni:

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

Zastąp 4 liczbą procesorów, które chciałbyś załadować, jeśli różnią się od 4.

Zakładając, że nie miałeś już uruchomionego zadania w tle, gdy uruchamiałeś jedną z tych pętli, możesz zatrzymać generowanie ładunku za pomocą tej komendy:

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

• *

Answering @underscore_d’s comment, oto ulepszona wersja, która upraszcza dużo zatrzymywania ładunku i pozwala także na określenie limitu czasu (domyślnie 60 sekund). Ta funkcja powłoki działa przynajmniej pod bash i 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
  )
}

1Uwaga, że w przypadku procesorów obsługujących więcej niż jeden wątek na rdzeń (Hyper-threading), system operacyjny będzie wysyłał obciążenie do wszystkich wirtualnych procesorów. W tym przypadku zachowanie obciążenia jest zależne od implementacji (każdy wątek może być zgłoszony jako 100% zajęty lub nie).

Zrobiłam prosty skrypt Pythona, który robi to samo. Możesz kontrolować liczbę rdzeni cpu, które chcesz załadować. Dobrą rzeczą w tym jest to, że nie zużywa on żadnych innych zasobów poza cpu (myślę, że pomysł Marka Johnsona zużyłby dużo zasobów I/O, co jest tutaj niepożądane)

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))

Wystarczy uruchomić ten skrypt z terminala $ python temp1.py. Musisz zabić skrypt, gdy skończysz.

Tutaj, jest moje zużycie cpu, gdy ładuję 3 rdzenie.

Jednym z alternatywnych sposobów jest

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

lub (jeśli nproc jest obecny)

openssl speed -multi $(nproc --all)

OpenSSL jest prawie zawsze obecny na dzisiejszych dystrybutorach, więc nie są potrzebne dodatkowe pakiety.

Start dwa

sha1sum /dev/zero &

komendy dla każdego rdzenia w systemie

Aby zatrzymać

killall sha1sum

lub

kill sha1sum

Opracowałem stress-ng, zaktualizowane narzędzie do stresu, które może podkreślić szeroki zakres aspektów systemu Linux. Aby uzyskać więcej informacji, zobacz http://kernel.ubuntu.com/~cking/stress-ng/

Użycie jest podobne do stresu

$ 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

Instaluj z

sudo apt-get install stress-ng

Zwykle biorę pakiet cpuburn:

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

Zamień 4 na liczbę rdzeni / gwinty HT, które masz lub chcesz naprężyć.

Uwaga: To napręża jak najwięcej powierzchni chipa w tym samym czasie, jest zaprogramowany do generowania maksymalnego rozproszenia mocy. Musiałem napisać ten post po raz drugi, mojej maszynie jakoś się to nie spodobało :-(

Możesz też zrobić cpuburn w sekwencjach:

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

A kiedy chcesz je zatrzymać:

killall burnP6

Możesz też pomnożyć burnP6 & aby dopasować ilość rdzeni procesora w Twoim systemie.

Możesz uruchomić tę komendę tyle razy, ile chcesz, a za każdym razem zajmie ona inny rdzeń:

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

https://github.com/GaetanoCarlucci/CPULoadGenerator

dość proste i naukowe rozwiązanie.

Tutaj możesz zobaczyć przykład dynamiki, w którym 50% obciążenia jest generowane na rdzeniu CPU 0:

Możesz uruchomić proces na innych rdzeniach w tym samym czasie.

pxz jest równoległą implementacją xz.

pxz -9e /dev/zero --stdout >/dev/null powinno zrobić ten trick, ponieważ jest to dość intensywne cpu.

Jeśli /dev/zero nie jest wystarczająco szybkie (zauważysz, że pxz ma zdławione wejścia/wyjścia) możesz zrobić pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Nowsze wersje xz mają opcję --threads, która jest substytutem pxz.

Połączyłem +jlliagre i +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 $@

Możesz użyć:

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

Powtórz dd if=/dev/zero of=/dev/null dla rdzeni CPU.

Uderz w dowolny klucz, aby zatrzymać test.

Oto sposób w jaki używam i nie ma potrzeby instalowania niczego dodatkowego.

Na przykład, aby zacząć od 4 procesów,

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

Możesz zmienić liczbę procesów poprzez opcję “-P” powyżej.

Prosty wiersz poleceń też to robi:

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

Chciałem dodać to do komentarza @jlliagre, ale nie mam dość reputacji. Jeśli zamierzasz używać tego kodu na wielu serwerach, a liczba CPU będzie się różnić, możesz użyć następującej komendy:

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

To wykorzysta wszystkie rdzenie na Twoim serwerze, niezależnie od tego, ile ich masz. Polecenie nproc jest częścią coreutils, więc powinno być w większości instalacji Linuksa.