Jak mogę uzyskać duże obciążenie procesora na serwerze z systemem Linux?

Obecnie debuguję instalację kaktusów i chcę utworzyć obciążenie procesora, aby debugować moje wykresy wykorzystania procesora.

Próbowałem po prostu uruchomić cat /dev/zero > /dev/null, co działa świetnie, ale wykorzystuje tylko 1 rdzeń:

Czy istnieje lepsza metoda testowania / maksymalizowania zasobów systemowych pod obciążeniem?

Powiązane: Jak mogę uzyskać duże obciążenie procesora w systemie Windows?

Spróbuj stress Jest to prawie odpowiednik systemu 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, twoja stara dobra powłoka jest w stanie zrobić to sama.

Ten jednowarstwowy załaduje cztery rdzenie ¹ na 100%:

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

Jak to działa, jest dość proste, uruchamia cztery nieskończone pętle. Każdy z nich powtarza instrukcję zerową ( :). Każda pętla jest w stanie załadować rdzeń procesora na 100%.

Jeśli używasz bash, ksh93i inne pociski wspieranie zakresy, (czyli nie dashlub starszy ksh), można użyć tej składni non przenośnym:

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

Zamień 4na liczbę procesorów, które chcesz załadować, jeśli różnią się od 4.

Zakładając, że nie uruchomiłeś już żadnego zadania w tle po uruchomieniu jednej z tych pętli, możesz zatrzymać generowanie obciążenia za pomocą tego polecenia:

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

Odpowiadając na komentarz @ underscore_d, tutaj jest ulepszona wersja, która znacznie upraszcza zatrzymanie ładowania i która pozwala również określić limit czasu (domyślnie 60 sekund.) A Control- Czabije również wszystkie niekontrolowane pętle. Ta funkcja powłoki działa co najmniej pod bashi 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
  )
}

¹ _{Należy pamiętać, że w przypadku procesorów obsługujących więcej niż jeden wątek na rdzeń (Hyper-Threading), system operacyjny rozdzieli obciążenie na wszystkie wirtualne procesory. W takim przypadku zachowanie obciążenia zależy od implementacji (każdy wątek może być zgłaszany jako zajęty w 100% lub nie).} .

Zrobiłem prosty skrypt Pythona, który robi to samo. Możesz kontrolować liczbę rdzeni procesora, które chcesz załadować. Dobrą rzeczą jest to, że nie zużywa żadnych innych zasobów oprócz procesora. (Myślę, że pomysł Marka Johnsona zużyłby dużo zasobów we / wy, 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))

Po prostu uruchom ten skrypt z terminala $ python temp1.py. Po zakończeniu musisz zabić skrypt.

Oto moje zużycie mocy procesora, gdy ładuję 3 rdzenie.

Byłby jeden alternatywny sposób

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

lub (jeśli nproc jest obecny)

openssl speed -multi $(nproc --all)

OpenSSL jest prawie zawsze obecny w obecnych dystrybucjach, więc nie są potrzebne żadne dodatkowe pakiety.

Zacznij dwa

sha1sum /dev/zero &

polecenia dla każdego rdzenia w systemie.

Zatrzymać

killall sha1sum

lub

kill sha1sum

Zwykle biorę pakiet cpuburn:

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

Zamień 4 na liczbę rdzeni / gwintów HT, które masz lub chcesz podkreślić.

Uwaga: Obciąża to jednocześnie jak najwięcej powierzchni chipa, jest zaprogramowane tak, aby generowało maksymalne rozproszenie mocy. Musiałem napisać ten post po raz drugi, jakoś mojej maszynie się to nie podobało :-(

Możesz również wykonać cpuburn w sekwencjach:

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

A kiedy chcesz je zatrzymać:

killall burnP6

Można również pomnożyć, burnP6 &aby dopasować liczbę rdzeni procesora w systemie.

Opracowuję stress-ng, zaktualizowane narzędzie do obsługi stresu, które może obciążać wiele różnych 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

Zainstaluj za pomocą

sudo apt-get install stress-ng

Możesz uruchomić to polecenie tyle razy, ile chcesz, i za każdym razem zajmie inny rdzeń:

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

https://github.com/GaetanoCarlucci/CPULoadGenerator

całkiem proste i naukowe rozwiązanie.

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

Możesz uruchomić proces na innych rdzeniach jednocześnie.

Połączyłem zarówno + 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/nulldla rdzeni procesora.

Naciśnij dowolny klawisz, aby zatrzymać test.

pxzjest równoległą implementacją xz.

pxz -9e /dev/zero --stdout >/dev/null powinien załatwić sprawę, ponieważ jest to dość intensywne procesor.

Jeśli /dev/zeronie jest wystarczająco szybki (zauważysz, że pxzprzepustnica we / wy jest ograniczona), możesz to zrobić pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Nowsze wersje xzmają --threadsopcję, która jest zamiennikiem pxz.

Oto sposób, w jaki korzystam i nie trzeba instalować niczego dodatkowego.

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

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

Możesz zmienić liczbę procesów za pomocą opcji „-P” powyżej.

Robi to również prosta linia poleceń:

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

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

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

Spowoduje to wykorzystanie wszystkich rdzeni na serwerze bez względu na ich liczbę. Polecenie nprocjest częścią coreutils, więc powinno być w większości instalacji Linuksa.