Как создать выброс процессора с помощью команды bash

Я использую stress для такого рода вещей, вы можете сказать, сколько ядер максимальнее.. это позволяет подчеркнуть память и диск.

Пример для напряжения 2 сердечника в течение 60 секунд

stress --cpu 2 --timeout 60

Я думаю, что это проще. Откройте терминал и введите следующее и нажмите Enter.

yes > /dev/null &

Чтобы полностью использовать современные процессоры, одной строки недостаточно, вам может потребоваться повторить команду для исчерпания всей мощности процессора.

Чтобы закончить все это, просто поместите

killall yes

Идея изначально была найдена здесь, хотя она была предназначена для пользователей Mac, но это должно работать и для * nix.

Одно ядро ​​(не вызывает внешний процесс):

while true; do true; done

Два ядра:

while true; do /bin/true; done

Последний только делает мои мои до 50%, хотя...

Это сделает оба перехода на 100%:

while true; do echo; done

Вот программа, которую вы можете скачать Здесь

Легко установить в систему Linux

./configure
make
make install

и запустите его в простой командной строке

stress -c 40

чтобы подчеркнуть все ваши процессоры (но у вас есть) с 40 потоками, каждый из которых выполняет сложное вычисление sqrt на числа, генерируемые ramdomly.

Вы даже можете определить тайм-аут программы

stress -c 40 -timeout 10s

в отличие от предлагаемого решения с командой dd, которая в основном работает с IO и, следовательно, не перегружает вашу систему, поскольку работает с данными.

Программа стресса действительно перегружает систему, потому что имеет дело с вычислением.

Я бы разделил вещь на 2 скрипта:

infin_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

:(){ :|:& };:

Эта боковая вилка приведет к хаосу к процессору и, скорее всего, приведет к краху вашего компьютера.

Чтобы загрузить 3 ядра в течение 5 секунд:

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

Это приводит к высокой загрузке ядра (sys) из многих системных вызовов write().

Если вы предпочитаете большую загрузку cpu userland:

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

Если вы хотите, чтобы загрузка продолжалась до тех пор, пока вы не нажмете Ctrl-C:

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

Бесконечный цикл - это идея, которую я тоже имел. Причудливым выглядит:

while :; do :; done

(: совпадает с true, ничего не делает и выходит с нулем)

Вы можете вызвать это в подоболочке и запустить в фоновом режиме. Делать это $num_cores раз должно быть достаточно. После спящего желаемого времени вы можете убить их всех, вы получите PID с помощью jobs -p (hint: xargs)

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

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

Несмотря на то, что я опаздываю на вечеринку, этот пост является одним из лучших результатов поиска в Google: "генерировать нагрузку в Linux".

Результат, помеченный как решение, может быть использован для генерации загрузки системы, я предпочитаю использовать sha1sum /dev/zero для наложения нагрузки на процессор.

Идея состоит в том, чтобы вычислить хэш-сумму из бесконечного потока данных (например,/dev/zero,/dev/urandom,...), этот процесс попытается максимизировать процессорное ядро ​​до тех пор, пока процесс не будет прерван. Чтобы создать нагрузку для большего количества ядер, несколько команд могут быть соединены вместе.

например. генерировать 2-х основных нагрузок: sha1sum /dev/zero | sha1sum /dev/zero

Используя здесь идеи, созданный код, который автоматически выходит после заданной продолжительности, не должен убивать процессы -

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

Используя приведенные здесь примеры, но также помогая IRC, я разработал собственное тестирование напряжения процессора script. Он использует подоболочку на поток и бесконечную петлевую технику. Вы также можете указать количество потоков и количество времени в интерактивном режиме.

#!/bin/bash
# Simple CPU stress test script

# Read the user 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

Я использовал bc (двоичный калькулятор), прося их PI с большим количеством десятичных знаков.

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

с NUMCPU (под Linux):

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

Этот метод силен, но кажется системным, поскольку я никогда не разбивал систему, использующую это.

Я прошел через Интернет, чтобы найти что-то вроде этого, и нашел этот очень удобный cpu hammer script.

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

Это делает трюк для меня:

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

и ничего не использует, кроме bash.

Я объединил некоторые ответы и добавил способ масштабирования стресса ко всему доступному процессору:

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

Просто вставьте этого плохого мальчика в SSH или консоль любого сервера, на котором запущен Linux. Вы можете убить процессы вручную, но я просто закрою сервер, когда закончите, быстрее.

Изменить: я обновил этот script, чтобы теперь иметь функцию таймера, чтобы не было необходимости убивать процессы.

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