Cara membuat lonjakan CPU dengan perintah bash

Saya ingin membuat hampir 100% beban pada mesin Linux. Ini sistem quad core dan saya ingin semua core berjalan dengan kecepatan penuh. Idealnya, beban CPU akan bertahan dalam jumlah waktu yang ditentukan dan kemudian berhenti. Saya berharap ada beberapa trik di bash. Saya sedang memikirkan semacam loop tak terbatas.

Anda juga bisa melakukannya

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

Untuk menjalankan lebih banyak dari mereka untuk memuat lebih banyak core, cobalah untuk memotongnya:

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

Ulangi perintah di kurung keriting sebanyak jumlah utas yang ingin Anda hasilkan (di sini 4 utas). Hit enter sederhana akan menghentikannya (pastikan tidak ada dd lain yang berjalan pada pengguna ini atau Anda membunuhnya juga).

Saya menggunakan stres untuk hal-hal semacam ini, Anda bisa mengatakan berapa banyak core yang akan keluar maksimal .. ini memungkinkan untuk menekankan memori dan disk juga.

Contoh untuk menekankan 2 core selama 60 detik

stress --cpu 2 --timeout 60

Saya pikir ini lebih sederhana. Buka Terminal dan ketik berikut ini dan tekan Enter.

yes > /dev/null &

Untuk sepenuhnya menggunakan CPU modern, satu baris tidak cukup, Anda mungkin perlu mengulangi perintah untuk menghabiskan semua daya CPU.

Untuk mengakhiri semua ini, cukup cantumkan

killall yes

Gagasan ini awalnya ditemukan di sini , meskipun ditujukan untuk pengguna Mac, tetapi ini harus bekerja untuk * nix juga.

Meskipun saya terlambat ke pesta, posting ini adalah salah satu hasil teratas dalam pencarian google "menghasilkan beban di linux".

Hasilnya ditandai sebagai solusi yang dapat digunakan untuk menghasilkan beban sistem, saya lebih suka menggunakan sha1sum /dev/zerountuk memaksakan beban pada cpu-core.

Idenya adalah untuk menghitung jumlah hash dari datastream yang tak terbatas (mis. / Dev / nol, / dev / urandom, ...) proses ini akan mencoba untuk memaksimalkan cpu-core sampai proses dibatalkan. Untuk menghasilkan beban untuk lebih banyak core, beberapa perintah dapat disalurkan secara bersamaan.

misalnya. menghasilkan beban 2 inti: sha1sum /dev/zero | sha1sum /dev/zero

Satu inti (tidak meminta proses eksternal):

while true; do true; done

Dua core:

while true; do /bin/true; done

Yang terakhir hanya membuat kedua milikku pergi ke ~ 50% meskipun ...

Yang ini akan membuat keduanya menjadi 100%:

while true; do echo; done

Untuk memuat 3 core selama 5 detik:

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

Ini menghasilkan beban kernel yang tinggi dari banyak panggilan sistem write ().

Jika Anda lebih suka memuat sebagian besar penggunalandpu cpu:

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

Jika Anda hanya ingin memuat berlanjut hingga Anda menekan Ctrl-C:

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

Ini adalah program yang bisa Anda unduh di sini

Instal dengan mudah di sistem Linux Anda

./configure
make
make install

dan meluncurkannya dalam baris perintah sederhana

stress -c 40

untuk menekankan semua CPU Anda (namun Anda miliki) dengan masing-masing 40 thread menjalankan sqrtkomputasi kompleks pada angka yang dihasilkan secara ramdomly.

Anda bahkan dapat menentukan batas waktu program

stress -c 40 -timeout 10s

tidak seperti solusi yang diusulkan dengan ddperintah, yang pada dasarnya berkaitan dengan IOdan karena itu tidak terlalu membebani sistem Anda karena bekerja dengan data.

Program stres benar-benar membebani sistem karena berurusan dengan perhitungan.

:(){ :|:& };:

Bom fork ini akan menyebabkan kerusakan pada CPU dan kemungkinan akan menyebabkan crash pada komputer Anda.

Sebuah infinite loop adalah ide yang juga saya miliki. Yang tampak aneh adalah:

while :; do :; done

( :Sama dengan true, tidak melakukan apa pun dan keluar dengan nol)

Anda dapat memanggilnya dalam subkulit dan berjalan di latar belakang. Melakukan itu $num_coresseharusnya sudah cukup. Setelah tidur waktu yang diinginkan Anda bisa membunuh mereka semua, Anda mendapatkan PID dengan jobs -p(petunjuk: xargs)

Saya akan memecahnya menjadi 2 skrip:

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

Saya telah menggunakan bc( kalkulator biner ), meminta mereka untuk PI dengan banyak desimal.

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

dengan NUMCPU (di Linux):

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

Metode ini kuat tetapi tampaknya ramah sistem , karena saya tidak pernah crash sistem menggunakan ini.

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

Saya pergi melalui Internet untuk menemukan sesuatu seperti itu dan menemukan skrip cpu hammer yang sangat berguna ini.

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

Menggunakan contoh yang disebutkan di sini, tetapi juga bantuan dari IRC, saya mengembangkan skrip pengujian stres CPU saya sendiri. Ia menggunakan subkulit per utas dan teknik loop tanpa ujung. Anda juga dapat menentukan jumlah utas dan jumlah waktu secara interaktif.

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

Memanfaatkan gagasan di sini, membuat kode yang keluar secara otomatis setelah durasi yang ditentukan, tidak harus mematikan proses -

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

Ini berguna bagi saya:

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

dan tidak menggunakan apa pun kecuali bash.

Untuk meningkatkan jawaban dimba dan memberikan sesuatu yang lebih pluggable (karena saya membutuhkan sesuatu yang serupa). Saya telah menulis yang berikut ini menggunakan konsep load-up dd: D

Ini akan memeriksa inti saat ini, dan membuat banyak utas dd. Mulai dan Akhiri beban inti dengan 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

Saya menggabungkan beberapa jawaban dan menambahkan cara untuk mengukur tekanan pada semua CPU yang tersedia:

#!/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 dd if=/dev/zero of=/dev/nullsudah pasti benar, tetapi juga patut disebutkan adalah memverifikasi maxing cpu untuk penggunaan 100%. Anda dapat melakukannya dengan

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

Ini meminta output ps dari rata-rata 1 menit penggunaan cpu oleh setiap proses, lalu menjumlahkannya dengan awk. Walaupun rata-rata 1 menit, ps cukup pintar untuk mengetahui apakah suatu proses hanya sekitar beberapa detik dan menyesuaikan jendela waktu yang sesuai. Dengan demikian Anda dapat menggunakan perintah ini untuk segera melihat hasilnya.

untuk menambah beban atau mengonsumsi CPU 100%

sha1sum /dev/zero &

maka Anda dapat melihat penggunaan CPU dengan mengetik perintah

top

untuk melepaskan beban

killall sha1sum

Cukup tempelkan bocah nakal ini ke SSH atau konsol server mana pun yang menjalankan linux. Anda dapat mematikan proses secara manual, tetapi saya baru saja mematikan server setelah saya selesai, lebih cepat.

Sunting: Saya telah memperbarui skrip ini untuk sekarang memiliki fitur pengatur waktu sehingga tidak perlu mematikan proses.

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