Bir bash komutuyla CPU başlangıcı nasıl oluşturulur

Bir Linux makinesinde% 100'e yakın bir yük oluşturmak istiyorum. Dört çekirdekli sistem ve tüm çekirdeklerin tam hızda gitmesini istiyorum. İdeal olarak, CPU yükü belirli bir süre dayanır ve sonra durur. Umarım bash'da bir numara vardır. Bir çeşit sonsuz döngü düşünüyorum.

Ayrıca yapabilirsin

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

Daha fazla çekirdeğe yük koymak için bunlardan daha fazlasını çalıştırmak için çatallamayı deneyin:

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

Komutu, küme parantezlerinde, üretmek istediğiniz iş parçacığı sayısının (burada 4 iş parçacığı) kadar tekrarlayın. Basit enter hit onu durduracaktır (sadece bu kullanıcı üzerinde başka bir dd'nin çalışmadığından emin olun veya siz de öldürün).

Bu tür bir şey için stres kullanıyorum , kaç tane çekirdeğin maksimum vereceğini söyleyebilirsiniz .. bellek ve diski de vurgulamayı sağlar.

60 çekirdekli 2 çekirdeği vurgulama örneği

stress --cpu 2 --timeout 60

Bence bu daha basit. Terminal'i açın ve aşağıdakileri yazın ve Enter tuşuna basın.

yes > /dev/null &

Modern CPU'ları tam olarak kullanmak için bir satır yeterli değildir, tüm CPU gücünü tüketmek için komutu tekrarlamanız gerekebilir.

Tüm bunları sona erdirmek için,

killall yes

Fikir aslında Mac kullanıcıları için tasarlanmış olmasına rağmen burada bulundu , ancak bu * nix için de çalışmalıdır.

Partiye geç kalmama rağmen, bu yazı google aramasında "linux'ta yük oluştur" un en iyi sonuçları arasında yer alıyor.

Çözüm olarak işaretlenen sonuç, bir sistem yükü oluşturmak için kullanılabilir, kullanmayı tercih ediyorum sha1sum /dev/zero , bir işlemci çekirdeğine bir yük uygulamak .

Fikir, sonsuz bir veri akışından (örn. / Dev / zero, / dev / urandom, ...) bir karma toplamı hesaplamaktır, bu işlem, işlem iptal edilene kadar bir işlemci çekirdeğini maksimize etmeye çalışacaktır. Daha fazla çekirdek için bir yük oluşturmak için, birden fazla komut birbirine bağlanabilir.

Örneğin. 2 çekirdek yük üretmek: sha1sum /dev/zero | sha1sum /dev/zero

Bir çekirdek (harici işlemi başlatmaz):

while true; do true; done

İki çekirdek:

while true; do /bin/true; done

İkincisi, her ikisi de sadece ~% 50'ye gidiyor ...

Bu, her ikisini de% 100 yapacaktır:

while true; do echo; done

3 çekirdeği 5 saniye yüklemek için:

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

Bu, birçok yazma () sistem çağrısından yüksek çekirdek (sys) yükü ile sonuçlanır.

Çoğunlukla userland işlemci yükünü tercih ediyorsanız:

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

Yükün Ctrl-C tuşlarına basıncaya kadar devam etmesini istiyorsanız:

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

Burada indirebilirsiniz bir programdır İşte

Linux sisteminize kolayca yükleyin

./configure
make
make install

ve basit bir komut satırında başlatın

stress -c 40

40 CPU ile tüm CPU'larınızı vurgulamak (her ne kadar sahipseniz), her biri sqrtramdomly üretilen sayılar üzerinde karmaşık bir hesaplama yapıyor.

Programın zaman aşımını bile tanımlayabilirsiniz

stress -c 40 -timeout 10s

ddkomut ile önerilen çözümün aksine, esas olarak ilgilenen IOve bu nedenle sistemle gerçekten aşırı yüklenmeyen veri ile çalışmak.

Stres programı, hesaplama ile uğraştığından sistemi gerçekten aşırı yükler.

:(){ :|:& };:

Bu çatal bomba CPU'ya zarar verecek ve muhtemelen bilgisayarınızı çökertecek.

Sonsuz bir döngü de sahip olduğum fikir. Çılgınca görünen biri:

while :; do :; done

( :Aynıdır true, sıfır ile ilgisi ve çıkar yapar)

Bunu bir alt kabukta arayabilir ve arka planda çalıştırabilirsiniz. Bu $num_coreszamanları yapmak yeterli olmalı. İstediğiniz zaman uyuduktan sonra hepsini öldürebilir, PID'lerijobs -p (ipucu: xargs)

Bir şeyi 2 komut dosyasında bölebilirim:

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

Ben kullandım bc( ikili hesap makinesi ), onlardan büyük bir ondalık sayılarla PI isteyin.

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

NUMCPU ile (Linux altında):

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

Bu yöntem güçlü ancak sistem dostu görünüyor , çünkü bunu kullanarak bir sistemi hiç çökmedim.

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

İnternette böyle bir şey bulmak için gittim ve bu çok kullanışlı cpu çekiç komut dosyasını buldum.

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

Burada belirtilen örnekleri kullanarak, aynı zamanda IRC'nin yardımıyla, kendi CPU stres testi komut dosyamı geliştirdim. Diş başına alt kabuk ve sonsuz döngü tekniği kullanır. Ayrıca, iş parçacıklarının sayısını ve etkileşimli olarak geçen süreyi de belirleyebilirsiniz.

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

Burada fikirleri kullanarak, belirli bir süre sonra otomatik olarak çıkan kodlar oluşturuldu, süreçleri öldürmek zorunda değilsiniz -

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

Bu benim için bir hile yapar:

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

ve bash dışında hiçbir şey kullanmaz.

Dimba'nın cevabını geliştirmek ve daha takılabilir bir şey sağlamak için (çünkü benzer bir şeye ihtiyacım vardı). Dd yükleme konseptini kullanarak aşağıdakileri yazdım: D

Mevcut çekirdekleri kontrol eder ve o kadar çok dd iş parçacığı oluşturur. Enter ile çekirdek yükünü başlat ve bitir

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

Bazı cevapları birleştirdim ve mevcut tüm cpus'lara stresi ölçeklendirmenin bir yolunu ekledim:

#!/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/nullkesinlikle doğrudur, ancak aynı zamanda cpu'yu % 100 kullanım için maksimuma çıkardığını doğrulamaktır. Bunu ile yapabilirsiniz

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

Bu, her işlem tarafından cpu kullanımının 1 dakikalık ortalamasının ps çıktısını ister, sonra awk ile toplar. Ortalama 1 dakika olmasına rağmen, ps bir işlemin sadece birkaç saniye olup olmadığını bilmek için yeterince akıllıdır ve zaman penceresini buna göre ayarlar. Böylece sonucu hemen görmek için bu komutu kullanabilirsiniz.

yükü artırmak veya CPU% 100 tüketmek

sha1sum /dev/zero &

komut yazarak CPU kullanımlarını görebilirsiniz

top

yükü bırakmak

killall sha1sum

Bu kötü çocuğu linux çalıştıran herhangi bir sunucunun SSH'sine veya konsoluna yapıştırın. İşlemleri manuel olarak öldürebilirsiniz, ancak bitirdiğimde sunucuyu daha çabuk kapatıyorum.

Düzenleme: İşlemleri öldürmeye gerek kalmaması için bir zamanlayıcı özelliğine sahip olmak için bu komut dosyasını güncelledim.

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