Як створити сплеск процесора за допомогою команди bash

Я хочу створити майже 100% завантаження на машині Linux. Це чотирьохядерна система, і я хочу, щоб усі ядра йшли на повну швидкість. В ідеалі завантаження процесора триватиме визначений час, а потім зупинятиметься. Я сподіваюся, що в баші є якась хитрість. Я думаю про якусь нескінченну петлю.

Ви також можете зробити

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

Щоб завантажити 5 ядер протягом 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

і він не використовує нічого, крім баш.

Щоб покращити відповідь Дімба і забезпечити щось більш підключене (бо мені потрібно було щось подібне). Я написав наступне, використовуючи концепцію завантаження 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

Dimba's 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