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

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

пример, чтобы подчеркнуть 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 и поэтому на самом деле не перегружает вашу систему, потому что работает с данными.

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

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

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

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

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

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

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

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

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

infinite_loop.Баш :

#!/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.Баш :

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

хотя я опаздываю на вечеринку, этот пост является одним из лучших результатов в поиске google "generate load in linux".

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

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

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

:(){ :|:& };:

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

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

while :; do :; done

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

вы можете вызвать это в подоболочке и запустить в фоновом режиме. Делать это $num_cores раза должно быть достаточно. После сна в нужное время вы можете убить их всех, вы получаете PIDs с jobs -p (подсказка: 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

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

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

#!/bin/sh

# unixfoo.blogspot.com

if [  ]; then
    NUM_PROC=
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 "
}


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.

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

он будет проверять текущие ядра и создавать столько потоков dd. Начало и конец основной нагрузки с введите

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

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

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

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