Ik wil een belasting van bijna 100% maken op een Linux-machine. Het is een quad core systeem en ik wil dat alle cores op volle snelheid draaien. Idealiter zou de CPU-belasting een bepaalde tijd duren en dan stoppen. Ik hoop dat er een truc in bash zit. Ik denk aan een soort oneindige lus.
Antwoord 1, autoriteit 100%
Ik gebruik stressvoor dit soort dingen, je kunt zien hoeveel cores tot max.. het zorgt ook voor stress op het geheugen en de schijf.
Voorbeeld om 2 cores 60 seconden lang te belasten
stress --cpu 2 --timeout 60
Antwoord 2, autoriteit 81%
U kunt ook doen
dd if=/dev/zero of=/dev/null
Als je er meer van wilt gebruiken om meer cores te belasten, probeer het dan te forken:
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 de opdracht tussen de accolades zo vaak als het aantal threads dat u wilt maken (hier 4 threads).
Een simpele enter-hit stopt het (zorg er wel voor dat er geen andere dd op deze gebruiker draait of je doodt het ook).
Antwoord 3, autoriteit 38%
Ik denk dat deze eenvoudiger is. Open Terminal en typ het volgende en druk op Enter.
yes > /dev/null &
Om moderne CPU’s volledig te benutten, is één regel niet genoeg, het kan zijn dat u de opdracht moet herhalen om alle CPU-kracht uit te putten.
Om dit allemaal te beëindigen, zet u gewoon
killall yes
Het idee werd oorspronkelijk hiergevonden, hoewel het was bedoeld voor Mac-gebruikers, maar dit zou ook moeten werken voor *nix.
Antwoord 4, autoriteit 10%
Hoewel ik te laat op het feest ben, behoort dit bericht tot de topresultaten in de Google-zoekopdracht ‘generate load in linux’.
Het resultaat gemarkeerd als oplossing kan worden gebruikt om een systeembelasting te genereren, ik gebruik liever sha1sum /dev/zeroom een cpu-core te belasten.
Het idee is om een hash-som te berekenen uit een oneindige datastroom (bijv. /dev/zero, /dev/urandom, …). Dit proces zal proberen een cpu-core te maximaliseren totdat het proces wordt afgebroken.
Om een belasting voor meer kernen te genereren, kunnen meerdere opdrachten aan elkaar worden gekoppeld.
bijv. genereer een 2 core-belasting:
sha1sum /dev/zero | sha1sum /dev/zero
Antwoord 5, autoriteit 9%
Om 3 cores gedurende 5 seconden te laden:
seq 3 | xargs -P0 -n1 timeout 5 yes > /dev/null
Dit resulteert in een hoge kernel (sys) belasting van de vele write() systeemaanroepen.
Als je de voorkeur geeft aan voornamelijk userland cpu-belasting:
seq 3 | xargs -P0 -n1 timeout 5 md5sum /dev/zero
Als je wilt dat het laden gewoon doorgaat totdat je op Ctrl-C drukt:
seq 3 | xargs -P0 -n1 md5sum /dev/zero
Antwoord 6, autoriteit 8%
Eén kern (roept geen extern proces op):
while true; do true; done
Twee kernen:
while true; do /bin/true; done
De laatste zorgt er echter voor dat beide van mij naar ~50% gaan…
Deze zorgt ervoor dat beide naar 100% gaan:
while true; do echo; done
Antwoord 7
Plak deze slechterik gewoon in de SSH of console van een server met linux. Je kunt de processen handmatig beëindigen, maar ik sluit de server gewoon af als ik klaar ben, sneller.
Bewerken: ik heb dit script bijgewerkt zodat het nu een timerfunctie heeft, zodat het niet nodig is om de processen te beëindigen.
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