Jak utworzyć skok CPU za pomocą polecenia bash


281

Chcę utworzyć prawie 100% obciążenia na komputerze z systemem Linux. To system czterordzeniowy i chcę, aby wszystkie rdzenie pracowały z pełną prędkością. Najlepiej byłoby, gdyby obciążenie procesora trwało przez określony czas, a następnie się zatrzymało. Mam nadzieję, że jest jakaś sztuczka w bashu. Myślę o jakiejś nieskończonej pętli.


Odpowiedzi:


283

Możesz też zrobić

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

Aby uruchomić więcej z nich i obciążyć więcej rdzeni, spróbuj rozwidlić:

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 polecenie w nawiasach klamrowych tyle razy, ile jest wątków, które chcesz wyprodukować (tutaj 4 wątki). Proste wciśnięcie Enter go zatrzyma (upewnij się, że żaden inny dd nie działa na tym użytkowniku lub go zabijesz).


35
dd dotyczy więcej operacji we / wy niż użycia procesora
Fred

2
To faktycznie działało najlepiej w mojej sytuacji. Działa również w Cygwin. Z jakiegoś powodu inne rozwiązania nie przyspieszają procesora. Dodanie liczby i wykonanie czterech równoległych procesów działało idealnie. Wzmocnił procesor na 100% w górę, a następnie wrócił do zera bez żadnej pomocy. Tylko cztery wiersze kodu i „czekaj”.
Użytkownik 1

62
Odczytywanie /dev/zeroi pisanie do /dev/nullnie jest zbyt dobrym generatorem obciążenia - musisz uruchomić wiele z nich, aby wygenerować znaczne obciążenie. Lepiej zrobić coś takiego dd if=/dev/urandom | bzip2 -9 >> /dev/null. /dev/urandomwymaga znacznie większego wysiłku, aby wygenerować dane wyjściowe i bzip2poświęci dużo wysiłku, próbując je skompresować, więc ogólne użycie procesora jest znacznie wyższe niż „wypełnienie bloku zerami, a następnie wyrzucenie go”.
twalberg,

4
Służy jobs -p | xargs killdo zabijania tylko utworzonych procesów.
Marian

5
@twalberg, powinieneś zamienić swój komentarz w odpowiedź.
Aaron McDaid

363

Używam stresu do tego rodzaju rzeczy, możesz powiedzieć, ile rdzeni ma się maksymalnie wydłużyć .. pozwala to również na stresowanie pamięci i dysku.

Przykład obciążenia 2 rdzeni przez 60 sekund

stress --cpu 2 --timeout 60


6
Na Fedorze,sudo yum install stress
Christopher Markieta

3
Musisz EPELrepo dla CentOSwget http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
Satish

4
brew install stressna OS X. Również z jakiegoś powodu musiałem określić 8 rdzeni na czterordzeniowym MBPr
fregante

1
@ bfred.it Twoje rdzenie mogą korzystać z hipertekstu, skutecznie podwajając liczbę rdzeni (4 fizyczne i 4 wirtualne). Będziesz także chciał zaakcentować wirtualne dla testu pełnego obciążenia.
Maszt

6
sudo apt-get install stressw systemach opartych na Debianie, dla kompletności. Wykorzystano to do przetestowania modu chłodzenia w zestawie Intel i7 NUC .
onmylemon

133

Myślę, że ten jest prostszy. Otwórz Terminal, wpisz następujące polecenie i naciśnij klawisz Enter.

yes > /dev/null &

Aby w pełni wykorzystać nowoczesne procesory, jedna linia nie wystarczy, konieczne może być powtórzenie polecenia, aby wyczerpać całą moc procesora.

Aby zakończyć to wszystko, po prostu

killall yes

Pomysł został pierwotnie znaleziony tutaj , chociaż był przeznaczony dla użytkowników komputerów Mac, ale powinno to również działać w przypadku * nix.


7
+1 Działa jak urok, dziękuję! Warto dodać : to polecenie zwiększy maksymalnie jeden hyperthread na rdzeń procesora. Tak więc dwurdzeniowy procesor (każdy rdzeń posiadający 2 wątki) otrzyma całkowite obciążenie 25% na yespolecenie (zakładając, że system byłby bezczynny).
GitaarLAB

Aby dodać do tego, każda iteracja tego polecenia zwiększa obciążenie procesora (Androida) o 25 procent, aż do 4 iteracji, a reszta nie ma wpływu (nawet pod względem częstotliwości taktowania).
user3188978,

30

Chociaż jestem spóźniony na imprezę, ten post jest jednym z najlepszych wyników w wyszukiwarce Google „generuj obciążenie w systemie Linux”.

Wynik oznaczony jako rozwiązanie może być wykorzystany do wygenerowania obciążenia systemu, wolę użyć sha1sum /dev/zerodo nałożenia obciążenia na rdzeń procesora.

Chodzi o to, aby obliczyć sumę skrótu z nieskończonego strumienia danych (np. / Dev / zero, / dev / urandom, ...) ten proces będzie próbował zmaksymalizować rdzeń procesora, dopóki proces nie zostanie przerwany. Aby wygenerować obciążenie dla większej liczby rdzeni, można połączyć wiele poleceń razem.

na przykład. generować obciążenie 2 rdzenia: sha1sum /dev/zero | sha1sum /dev/zero


Widząc, jest to lepsze niż dd dla obciążenia procesora. Otrzymuję maksymalne obciążenie procesora 44% na dd (6 razy) i 86% + na sha1sum. Dzięki ~!
AAI

26

Jeden rdzeń (nie wywołuje zewnętrznego procesu):

while true; do true; done

Dwa rdzenie:

while true; do /bin/true; done

To ostatnie sprawia, że ​​oba moje osiągają ~ 50% ...

Ten sprawi, że oba osiągną 100%:

while true; do echo; done

na echo tracimy dostęp do systemu Linux. jak umieścić to trzecie polecenie w tle?
AAI

2
Dlaczego echo sprawia, że ​​wszystkie rdzenie procesora osiągają 100%?
Haoyuan Ge

@HaoyuanGe Wszystkie cpus są w 100% tylko wtedy, gdy echo „nic”. Zamień echo do; z do echo "jakiś bardzo, bardzo długi ciąg znaków"; aby zobaczyć <100% na procesorze. Tak więc, wierzę, że echo niczego nie ma dużo mniej skoków, a zatem więcej kodu do wykonania (ponieważ chociaż jest to prawda;) rdzenie są ~ 100% zajęte
talekeDskobeDa

Jeśli chcesz zachować serwer reaguje podczas gdy działa taki test, zrób to w osobnej powłoce (innym oknie tmux / ekranu lub sesji ssh) i Renice że Shell pierwszy, na przykład w bash: renice 19 -p $$. Nadal będzie maksymalizować procesory, ale nie wpłynie na inne procesy.
Walf

23

Aby załadować 3 rdzenie przez 5 sekund:

seq 3 | xargs -P0 -n1 timeout 5 yes > /dev/null

Powoduje to duże obciążenie jądra (sys) z wielu wywołań systemowych write ().

Jeśli wolisz ładować procesor głównie z obszaru użytkownika:

seq 3 | xargs -P0 -n1 timeout 5 md5sum /dev/zero

Jeśli chcesz, aby ładowanie trwało do momentu naciśnięcia klawiszy Ctrl-C:

seq 3 | xargs -P0 -n1 md5sum /dev/zero

1
Czy to możliwe z Tinycore? xargs: nieprawidłowa opcja - „P”
conman253

fajna natywna opcja
insign

18

Oto program, który możesz pobrać tutaj

Zainstaluj łatwo w systemie Linux

./configure
make
make install

i uruchom go w prostym wierszu poleceń

stress -c 40

aby zaakcentować wszystkie procesory (bez względu na to, jakie są) za pomocą 40 wątków, z których każdy sqrtwykonuje skomplikowane obliczenia na liczbach generowanych z dużą częstotliwością.

Możesz nawet zdefiniować limit czasu programu

stress -c 40 -timeout 10s

w przeciwieństwie do proponowanego rozwiązania z ddpoleceniem, które dotyczy zasadniczo IOi dlatego tak naprawdę nie przeciąża systemu, ponieważ pracuje z danymi.

Program warunków skrajnych naprawdę przeciąża system, ponieważ zajmuje się obliczeniami.


4
Powyżej jest już odpowiedź na stresspolecenie. Jak mówi ta odpowiedź, możesz po prostu zainstalować go za pomocą yum / apt / etc.
Asfand Qazi

1
Strona internetowa nie jest w dobrym stanie (503 zabronione), ale jest dostępna na
repozytoriach

11
:(){ :|:& };:

Ta bomba widełkowa spowoduje spustoszenie w procesorze i prawdopodobnie spowoduje awarię komputera.


13
Pomoże, jeśli ułatwię czytanie fork_bomb () {fork_bomb | fork_bomb &}; Forkbomb
Jeff Goldstein

17
Ten nie spełnia kryterium „trwać przez określony czas, a potem przestać”;)
Marian

14
wygląda jak grupa uśmiechniętych buziek.
Ponkadoodle

2
Ta bomba rozwidlona rozbiła mój komputer, musiałem wykonać twardy cykl zasilania.
Elijah Lynn

2
Od: cyberciti.biz/faq/understanding-bash-fork-bomb OSTRZEŻENIE! Te przykłady mogą spowodować awarię komputera, jeśli zostaną wykonane. „Po aktywacji udanej bomby widełkowej w systemie może nie być możliwe wznowienie normalnej pracy bez ponownego uruchomienia systemu, ponieważ jedynym rozwiązaniem bomby widełkowej jest zniszczenie wszystkich jej wystąpień”.
Elijah Lynn

11

Nieskończona pętla to również pomysł. Dziwacznie wyglądający jest:

while :; do :; done

( :jest taki sam jaktrue , nic nie robi i wychodzi z zerem)

Możesz to nazwać w podpowłoce i uruchomić w tle. Robienie tego $num_coresczasu powinno wystarczyć. Po spanie żądany czas można je zabić wszystkich, można dostać się z PID jobs -p(podpowiedź: xargs)


10

Podzielę tę rzecz na 2 skrypty:

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


4
#!/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

Użyłem bc( kalkulator binarny ), prosząc ich o PI z dużą liczbą miejsc po przecinku.

$ for ((i=0;i<$NUMCPU;i++));do
    echo 'scale=100000;pi=4*a(1);0' | bc -l &
    done ;\
    sleep 4; \
    killall bc

z NUMCPU (pod Linuksem):

$ NUMCPU=$(grep $'^processor\t*:' /proc/cpuinfo |wc -l)

Ta metoda jest silna, ale wydaje się przyjazna dla systemu , ponieważ nigdy nie rozbiłam systemu przy użyciu tego.


3
#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done

1
Eh, nie. Spanie nie jest tego rodzaju zadaniem, które kładzie duży nacisk na procesor:-)
Marian

2

Przeszukałem Internet, aby znaleźć coś podobnego i znalazłem ten bardzo przydatny skrypt młota procesora.

#!/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

Czy to naprawdę musi być tak długie? Najbardziej podobają mi się jedno-
linijki

1
Klauzula if-then-else może być zastąpiony przez: NUM_PROC=${1:-10}.
Thor

2

Korzystając ze wspomnianych tutaj przykładów, ale także pomocy IRC, opracowałem własny skrypt do testowania obciążenia procesora. Używa podpowłoki na wątek i techniki nieskończonej pętli. Możesz także interaktywnie określić liczbę wątków i czas.

#!/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

uzyskiwanie błędu „wiersz 14: zestaw zadań: nie znaleziono polecenia” w skrypcie! dowolny pomysł?
user2912312,

2

Wykorzystując tutaj pomysły, utworzony kod, który wychodzi automatycznie po określonym czasie, nie musi zabijać procesów -

#!/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

1

To dla mnie sztuczka:

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

i używa tylko bash.


1

Aby poprawić odpowiedź dimby i zapewnić coś bardziej podłączalnego (ponieważ potrzebowałem czegoś podobnego). Napisałem następujące przy użyciu koncepcji ładowania dd: D

Sprawdza bieżące rdzenie i tworzy tyle wątków dd. Rozpocznij i zakończ ładowanie rdzenia za pomocą Enter

#!/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

0

Połączyłem niektóre odpowiedzi i dodałem sposób na skalowanie stresu do wszystkich dostępnych cpus:

#!/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

Dimba's dd if=/dev/zero of=/dev/nulljest zdecydowanie poprawne, ale warto również wspomnieć o sprawdzeniu maksymalizacji procesora do 100% użycia. Możesz to zrobić za pomocą

ps -axro pcpu | awk '{sum+=$1} END {print sum}'

To prosi o wyjście ps o 1-minutową średnią użycia procesora przez każdy proces, a następnie sumuje je za pomocą awk. Chociaż jest to średnia 1 minuta, ps jest wystarczająco inteligentny, aby wiedzieć, czy proces trwał tylko kilka sekund i odpowiednio dostosowuje okno czasowe. Dlatego możesz użyć tego polecenia, aby natychmiast zobaczyć wynik.


0

w celu zwiększenia obciążenia lub zużycia procesora 100%

sha1sum /dev/zero &

wtedy możesz zobaczyć użycie procesora, wpisując polecenie

top

aby zwolnić ładunek

killall sha1sum

-1

Po prostu wklej tego złego chłopca do SSH lub konsoli dowolnego serwera z systemem Linux. Możesz zabić procesy ręcznie, ale ja po prostu zamykam serwer, kiedy skończę, szybciej.

Edycja: Zaktualizowałem ten skrypt, aby teraz miał funkcję timera, dzięki czemu nie ma potrzeby zabijania procesów.

read -p "Please enter the number of minutes for test >" MINTEST && [[ $MINTEST == ?(-)+([0-9]) ]]; NCPU="$(grep -c ^processor /proc/cpuinfo)";  ((endtime=$(date +%s) + ($MINTEST*60))); NCPU=$((NCPU-1)); for ((i=1; i<=$NCPU; i++)); do while (($(date +%s) < $endtime)); do : ; done & done
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.