Probeer stress Het is vrijwel hetzelfde als Windows consume.exe:

oliver$ ./stress --cpu 3
stress: info: [18472] dispatching hogs: 3 cpu, 0 io, 0 vm, 0 hdd
```.

Je hoeft geen extra pakket te installeren, je goede oude schil kan het alleen.

Deze one-liner laadt je vier kernen1 op 100%:

for i in 1 2 3 4; do while : ; do : ; done & done

Hoe het werkt is vrij eenvoudig, het start vier eindeloze lussen. Elk van deze lussen herhaalt de null instructie (:). Elke lus is in staat om een CPU kern op 100% te laden.

Als je bash, ksh93 en andere shells ondersteunende bereiken gebruikt, (dus niet dash of oudere ksh), kun je deze niet-overdraagbare syntax gebruiken:

for i in {1..4}; do ...

Vervang 4 met het aantal CPU’s dat je wilt laden als het anders is dan 4.

In de veronderstelling dat je geen achtergrond job had die al draaide toen je een van deze lussen lanceerde, kan je het laden stoppen met dat commando:

for i in 1 2 3 4; do kill %$i; done

• *

Antwoorden @underscore_d’s commentaar, hier is een verbeterde versie die veel vereenvoudigen bij het stoppen van het laden en die ook het opgeven van een time-out (standaard 60 seconden.) Een Control-C zal ook alle weggelopen lussen doden. Deze shell functie werkt tenminste onder bash en ksh.

# Usage: lc [number_of_cpus_to_load [number_of_seconds] ]
lc() {
  (
    pids=""
    cpus=${1:-1}
    seconds=${2:-60}
    echo loading $cpus CPUs for $seconds seconds
    trap 'for p in $pids; do kill $p; done' 0
    for ((i=0;i<cpus;i++)); do while : ; do : ; done & pids="$pids $!"; done
    sleep $seconds
  )
}

1Note dat met CPU’s die meer dan één thread per core ondersteunen (Hyper-threading), het OS de load naar alle virtuele CPU’s zal sturen. In dat geval is het loadgedrag afhankelijk van de implementatie (elke thread kan als 100% bezet worden gerapporteerd of niet).

Ik heb een eenvoudig pythonscript gemaakt dat hetzelfde doet. Je kunt het aantal cpu-kernen dat je wilt laden zelf bepalen. Het goede hieraan is dat het geen andere bron dan de cpu verbruikt (ik denk dat mark johnson’s idee veel I/O bronnen zou verbruiken, wat hier ongewenst is.) “` from multiprocessing import Pool

def f(x): # Put any cpu (only) consuming operation here. I have given 1 below - while True: x * x

decide how many cpus you need to load with.

noofcputobe_consumed = 3

p = Pool(processes=noofcputobeconsumed) p.map(f, range(noofcputobeconsumed)) ”`

Voer dit script gewoon uit vanaf de terminal $ python temp1.py. Je moet het script doden als je klaar bent.

Hier, is mijn cpu verbruik output als ik 3 van mijn kernen laad.

Een alternatieve manier zou zijn

openssl speed -multi $(grep -ci processor /proc/cpuinfo)

of (als nproc aanwezig is)

openssl speed -multi $(nproc --all)

OpenSSL is bijna altijd aanwezig op de huidige distro’s, dus geen extra pakketten nodig.

Start twee

sha1sum /dev/zero &

commando’s voor elke kern in uw systeem.

Om

killall sha1sum

te stoppen of

kill sha1sum
``` &001

Ik heb een stress-ng ontwikkeld, een bijgewerkt stress-tool dat een breed scala aan aspecten van een Linux-systeem kan benadrukken. Voor meer informatie, zie http://kernel.ubuntu.com/~cking/stress-ng/

Gebruik is vergelijkbaar met stress

$ stress-ng --cpu 4 --vm 2 --fork 8 --switch 4 --timeout 1m
stress-ng: info: [32254] dispatching hogs: 4 cpu, 8 fork, 4 switch, 2 vm
stress-ng: info: [32254] cache allocate: default cache size: 8192K

Installeren met

sudo apt-get install stress-ng

Ik neem meestal de cpuburn suite:

sudo apt-get install cpuburn
for i in {1..4}; do burnK7 & done

Vervang 4 door het aantal kernen / HT-threads dat je hebt of wilt belasten.

Opmerking: Dit belast zoveel mogelijk chipoppervlak tegelijk, het is geprogrammeerd om maximale vermogensdissipatie te genereren. Ik moest dit bericht een tweede keer schrijven, op de een of andere manier vond mijn machine het niet leuk :-(

Je kon ook cpuburn doen in reeksen:

burnP6 & burnP6 & burnP6 & burnP6 & 
[1] 28520
[2] 28521
[3] 28522
[4] 28523

En als je ze wilt stoppen:

killall burnP6

Je kon ook burnP6 & vermenigvuldigen om overeen te komen met het aantal CPU-kernen op je systeem.

Je kunt dat commando zo vaak als je wilt uitvoeren, en het zal elke keer een andere kern innemen:

$ CORES=1
$ for i in `seq 1 $CORES`; do cat /dev/zero > /dev/null &
> done
[1] 8388

https://github.com/GaetanoCarlucci/CPULoadGenerator ](https://github.com/GaetanoCarlucci/CPULoadGenerator)

vrij eenvoudige en wetenschappelijke oplossing.

Hier ziet u een dynamisch voorbeeld waarbij 50% belasting wordt gegenereerd op CPU core 0:

U kunt het proces tegelijkertijd op andere kernen laten lopen.

pxz is een parallelle implementatie van xz.

pxz -9e /dev/zero --stdout >/dev/null zou de truc moeten doen, aangezien dit vrij cpu-intensief is.

Als /dev/zero niet snel genoeg is (je merkt dat pxz I/O-gedregd wordt) kun je pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

doen. Nieuwere versies van xz hebben de --threads optie die een vervanging is voor pxz.

Ik combineerde zowel +jlliagre als +ecabuk.

#!/bin/bash
lc() {
    nowMs=$(date +%s)
    (
        pids=""
        cpus=${1:-1}
        seconds=${2:-60}
        echo "[$(date)] loading $cpus CPUs for $seconds seconds"
        echo "[$(date)] Expected completion: [$(date --date=@$(expr $nowMs + $seconds))]"
        trap 'for p in $pids; do kill $p; done' 0
        for ((i=0;i<cpus;i++)); do
            sha1sum /dev/zero &
            pids="$pids $!";
        done
        sleep $seconds
    )
    echo "[$(date)] Done"
}

lc $@

U kunt gebruik maken van:

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

Herhaal dd if=/dev/zero of=/dev/null voor uw CPU-kernen.

Druk op een willekeurige toets om de test te stoppen.

Dit is de manier waarop ik gebruik en het is niet nodig om iets extra’s te installeren.

Bijvoorbeeld om te beginnen met 4 processen, nproc | xargs seq | xargs -n1 -P4 md5sum /dev/zero

U kunt het aantal processen wijzigen door de optie “-P” hierboven.

Een eenvoudige opdrachtregel doet het ook:

x="x" ; while : ; do x=$x$x ; echo -n "." ; done

Ik wilde dit toevoegen aan @jlliagre’s commentaar, maar ik heb niet genoeg reputatie. Als je deze code op meerdere servers gaat gebruiken en het aantal CPU’s zal variëren, kun je het volgende commando gebruiken:

for ((i=1; i<=`nproc --all`; i++)); do while : ; do : ; done & done

Dit zal alle cores op je server gebruiken, ongeacht hoeveel je er hebt. Het commando nproc is onderdeel van coreutils en zou dus op de meeste Linux installaties moeten staan.