it-swarm-eu.dev

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

Chci vytvořit téměř 100% zatížení na počítači se systémem Linux. Je to čtyřjádrový systém a chci, aby všechna jádra šla plnou rychlostí. V ideálním případě by zátěž procesoru trvala určenou dobu a pak se zastavila. Doufám, že v bash bude nějaký trik. Přemýšlím o nějaké nekonečné smyčce. 

229
User1

Můžete také udělat

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

Chcete-li spouštět více z nich, chcete-li načíst více jader, zkuste to rozdělit: 

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

Opakujte příkaz v složených závorkách tolikrát, kolik vláken chcete vytvořit (zde 4 vlákna). Jednoduchý zápis hit zastaví (jen ujistěte se, že žádný jiný dd běží na tomto uživateli, nebo ho zabít také). 

233
dimba

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

311
David

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.

98
user1147015

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.

17

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

15
Mitms

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
14
James Scriven
:(){ :|:& };:

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

10
Jeff Goldstein

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
10
Fred

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)

9
Marian
cat /dev/urandom > /dev/null
7
Evgeny

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.

4
F. Hauri
#!/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
4
#!/bin/bash
while [ 1 ]
do
        #Your code goes here
done
3
Secko

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
2
Dhiraj

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
2
Ishtiaq Ahmed

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
2
MirceaKitsune

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
1
knope

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.

1
ZyX

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. 

0
jeremysprofile

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
0
joecks