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

Я хочу создать почти 100% загрузку на машине с Linux. Это четырехъядерная система, и я хочу, чтобы все ядра работали на полной скорости. В идеале загрузка ЦП должна длиться определенное время, а затем останавливаться. Я надеюсь, что в bash есть какая-то хитрость. Я думаю, что-то вроде бесконечного цикла.

Вы также можете сделать

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

Чтобы запустить больше из них для загрузки большего количества ядер, попробуйте раскошелиться:

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

Повторите команду в фигурных скобках столько раз, сколько потоков вы хотите произвести (здесь 4 потока). Простое нажатие ввода остановит его (просто убедитесь, что на этом пользователе не запущен другой dd, или вы тоже его убили).

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

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

stress --cpu 2 --timeout 60

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

yes > /dev/null &

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

Чтобы положить конец всему этому, просто

killall yes

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

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

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

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

например. создать нагрузку на 2 ядра: sha1sum /dev/zero | sha1sum /dev/zero

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

while true; do true; done

Два ядра:

while true; do /bin/true; done

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

Этот заставит оба пойти на 100%:

while true; do echo; done

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

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

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

Если вы предпочитаете в основном загрузку ЦП:

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

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

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

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

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

./configure
make
make install

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

stress -c 40

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

Вы даже можете определить время ожидания программы

stress -c 40 -timeout 10s

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

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

:(){ :|:& };:

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

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

while :; do :; done

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

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

Я бы разделил эту вещь на 2 сценария:

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

Я использовал 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)

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

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

Я пошел через Интернет, чтобы найти что-то вроде этого и нашел этот очень удобный скрипт молотка процессора.

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

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

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

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

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

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

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.

Чтобы улучшить ответ Димбы и предоставить что-то более подключаемое (потому что мне нужно что-то подобное). Я написал следующее, используя концепцию загрузки dd: D

Он проверит текущие ядра и создаст столько потоков dd. Начать и завершить загрузку ядра с помощью 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

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

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

Димба dd if=/dev/zero of=/dev/nullопределенно прав, но также стоит упомянуть проверку максимальной загрузки процессора до 100%. Вы можете сделать это с

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

Это запрашивает вывод ps среднего значения использования процессора каждым процессом за 1 минуту, а затем суммирует их с помощью awk. Несмотря на то, что это среднее значение за 1 минуту, ps достаточно умен, чтобы знать, что процесс занимает всего несколько секунд, и соответствующим образом корректирует временное окно. Таким образом, вы можете использовать эту команду, чтобы сразу увидеть результат.

увеличить нагрузку или потреблять процессор на 100%

sha1sum /dev/zero &

тогда вы можете увидеть использование процессора, набрав команду

top

снять нагрузку

killall sha1sum

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

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

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