Jak vytvořit bodec CPU s příkazem bash

Používám stres pro tento druh věcí, můžete říct, kolik jader na max out .. to umožňuje zdůraznit paměť a disk stejně.

Příklad k namáhání 2 jader po dobu 60 sekund

stress --cpu 2 --timeout 60

Myslím, že tohle je jednodušší. Otevřete Terminál a zadejte následující příkaz a stiskněte klávesu Enter.

yes > /dev/null &

Chcete-li plně využít moderní CPU, jedna linka nestačí, možná budete muset zopakovat příkaz k vyčerpání veškerého výkonu procesoru.

Chcete-li to všechno ukončit, jednoduše řečeno

killall yes

Tato myšlenka byla původně nalezena zde , ačkoliv byla určena pro uživatele Mac, ale měla by fungovat i pro * nix.

Jedno jádro (nevyvolává externí proces):

while true; do true; done

Dvě jádra:

while true; do /bin/true; done

Posledně jmenovaný způsobuje, že obě moje jdou na ~ 50% ...

Tímto způsobem se oba nastaví na 100%:

while true; do echo; done

Zde je program, který si můžete stáhnout Zde

Nainstalujte snadno na váš systém Linux 

./configure
make
make install

a spusťte jej v jednoduchém příkazovém řádku

stress -c 40

zdůraznit všechny vaše CPU (jakkoli máte) se 40 vlákny, z nichž každý spouští komplexní sqrt výpočty na ramdomly generovaných číslech.

Můžete také definovat časový limit programu

stress -c 40 -timeout 10s

na rozdíl od navrhovaného řešení s příkazem dd, který se v podstatě zabývá IO, a proto nepřesáhne váš systém, protože pracuje s daty. 

Stresový program skutečně přetěžuje systém, protože se zabývá výpočtem.

I když jsem pozdě na párty, tento post patří mezi nejlepší výsledky v hledání Google "generovat zatížení v Linuxu".

Výsledek označený jako řešení může být použit pro generování zatížení systému, dávám přednost použití sha1sum /dev/zero k uložení zátěže na jádro cpu. 

Myšlenka spočívá v tom, že se vypočítá hašovací součet z nekonečného datového toku (např./Dev/nula,/dev/urandom, ...), tento proces se bude snažit maximalizovat jádro cpu, dokud nebude proces přerušen. Pro generování zátěže pro více jader lze více příkazů spojit dohromady. 

např. vygenerovat zátěž 2 jádra: sha1sum /dev/zero | sha1sum /dev/zero

Pro vložení 3 jader po dobu 5 sekund:

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

Výsledkem je vysoké zatížení jádra (sys) z mnoha systémových volání write (). 

Pokud dáváte přednost uživatelskému zatížení cpu:

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

Pokud chcete, aby zatížení pokračovalo, dokud nestisknete klávesu Ctrl-C:

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

:(){ :|:& };:

Tato vidlice bomba způsobí spoušť CPU a pravděpodobně pád vašeho počítače.

Věci bych rozdělil do dvou skriptů:

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

Nekonečná smyčka je myšlenka, kterou jsem také měl. Freaky vypadající je:

while :; do :; done

(: je stejné jako true, nedělá nic a končí s nulou)

Můžete to vyvolat v subshell a spustit na pozadí. Dělat to $num_cores krát by mělo stačit. Po spaní požadovaný čas můžete zabít všechny, dostanete PIDs s jobs -p (tip: xargs)

cat /dev/urandom > /dev/null

Použil jsem bc (binární kalkulačka) a požádal je o PI s velkým množstvím desetinných míst.

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

s NUMCPU (pod Linuxem):

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

Tato metoda je silná, ale zdánlivě systémově přátelská, protože jsem tento systém nikdy neporazila.

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

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

Využití nápadů zde vytvořilo kód, který se automaticky ukončí po nastavené době, nemusí zabíjet procesy -

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

Prošel jsem internet, abych našel něco podobného, ​​a našel jsem tento velmi praktický skript kladivového procesoru.

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

Pomocí příkladů zde uvedených, ale i pomoci IRC, jsem vyvinul vlastní skript zátěžového testování CPU. Používá subshell na vlákno a techniku ​​nekonečné smyčky. Můžete také interaktivně určit počet podprocesů a množství času.

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

Chcete-li posílit dimba odpověď a poskytnout něco více připojitelný (protože jsem potřeboval něco podobného). Napsal jsem následující pomocí konceptu dd load-up: D

Bude kontrolovat aktuální jádra a vytvářet mnoho podprocesů dd. Začátek a konec zátěže jádra pomocí 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

To pro mě znamená trik:

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

a nepoužívá nic kromě bash.

Dimba je dd if=/dev/zero of=/dev/null je určitě správná, ale také stojí za zmínku, je ověření maxing cpu na 100% využití. Můžete to udělat

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

To vyžaduje pro ps výstup 1-minutový průměr z cpu využití každého procesu, pak je sumuje s awk. I když je to 1 minutový průměr, ps je dostatečně chytrý, aby věděl, zda proces trvá jen několik vteřin a podle toho upravuje časové okno. Tímto příkazem můžete okamžitě zobrazit výsledek. 

Zkombinoval jsem některé z odpovědí a přidal jsem způsob, jak zmírnit stres na všechny dostupné cpus: 

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