Jak utworzyć skok CPU za pomocą polecenia bash

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.

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

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

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.

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

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

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

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.

:(){ :|:& };:

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

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)

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

cat /dev/urandom > /dev/null

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

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.

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

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

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

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

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.

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

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

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.

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

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