Как создать всплеск процессора с помощью команды 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 "генерировать нагрузку в linux".

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

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

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

:(){ :|:& };:

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

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

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 (двоичный калькулятор), прося у них пи с большим количеством десятичных знаков.

$ 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, я разработал свой собственный сценарий стресс-тестирования процессора. Он использует subshell на поток и метод бесконечного цикла. Вы также можете задать количество потоков и количество времени в интерактивном режиме.

#!/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. Начало и конец основной нагрузки с 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

просто вставьте этого плохого мальчика В 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