ලිනක්ස් සේවාදායකයක ඉහළ CPU බරක් නිපදවන්නේ කෙසේද?

මම දැනට පතොක් ස්ථාපනය ස්ථාපනය නිදොස් කිරීමේ ක්‍රියාවලියක යෙදී සිටින අතර මගේ CPU උපයෝගීතා ප්‍රස්තාර නිදොස්කරණය කිරීම සඳහා CPU භාරය නිර්මාණය කිරීමට අවශ්‍යය.

මම සරලව ධාවනය කිරීමට උත්සාහ කළෙමි cat /dev/zero > /dev/null, එය විශිෂ්ට ලෙස ක්‍රියා කරන නමුත් 1 හරය පමණක් භාවිතා කරයි:

පද්ධති සම්පත් පරික්ෂා කිරීම / උපරිම කිරීම සඳහා වඩා හොඳ ක්‍රමයක් තිබේද?

ආශ්‍රිත: වින්ඩෝස් මත ඉහළ CPU බරක් නිෂ්පාදනය කරන්නේ කෙසේද?

උත්සාහ කරන්න stress එය වින්ඩෝස් වලට සමානයි consume.exe:

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

අමතර පැකේජයක් ස්ථාපනය කිරීමට අවශ්‍ය නැත, ඔබේ හොඳ පැරණි කවචයට එය තනිවම කළ හැකිය.

මෙම එක්-ලයිනර් මඟින් ඔබේ හරය ¹ 100% ට පටවනු ඇත :

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

එය ක්‍රියා කරන ආකාරය තරමක් සරල ය, එය නිමක් නැති ලූප හතරක් ආරම්භ කරයි. ඒ සෑම එකක්ම ශුන්‍ය උපදෙස් ( :) පුනරාවර්තනය කරයි . සෑම පුඩුවක්ම 100% ක CPU හරයක් පැටවීමට හැකියාව ඇත.

ඔබ භාවිතා කරන්නේ නම් bash, ksh93සහ පරාසයන් සඳහා ආධාරක වන වෙනත් ෂෙල් වෙඩි (එනම් dashපැරණි හෝ ඊට වැඩි නොවේ ksh), ඔබට මෙම අතේ ගෙන යා නොහැකි සින්ටැක්ස් භාවිතා කළ හැකිය:

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

4වෙනස් වීමට නම් ඔබ පූරණය කිරීමට කැමති CPU ගණන සමඟ ප්‍රතිස්ථාපනය කරන්න 4.

ඔබ මෙම ලූප වලින් එකක් දියත් කරන විට ඔබට දැනටමත් පසුබිම් රැකියාවක් නොමැති බව උපකල්පනය කිරීමෙන්, ඔබට එම විධානය සමඟ බර උත්පාදනය නැවැත්විය හැකිය:

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

@ Underscore_d ගේ ප්‍රකාශයට පිළිතුරු සැපයීම, මෙහි වැඩි දියුණු කරන ලද අනුවාදයක් වන අතර එය බර පැටවීම නැවැත්වීම සරල කරන අතර කල් ඉකුත් වීමක් නියම කිරීමට ඉඩ දෙයි (පෙරනිමිය තත්පර 60 යි.) A Control- ධාවනය වන Cසියලුම ලූප ද විනාශ කරයි. මෙම කවචයේ ක්‍රියාකාරිත්වය අවම වශයෙන් යටතේ bashසහ 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
  )
}

^[1] _{CPUs එක් හරයකට එක් නූල් එකකට වඩා (හයිපර්-නූල්) සහය දක්වන විට, මෙහෙයුම් පද්ධතිය සියලු අථත්‍ය CPU වෙත බර යවනු ඇත. එවැනි අවස්ථාවකදී, පැටවීමේ හැසිරීම ක්‍රියාත්මක කිරීම මත රඳා පවතී (එක් එක් නූල් 100% කාර්යබහුලද නැද්ද යන්න වාර්තා කළ හැකිය).} .

මම සරල පයිතන් පිටපතක් සෑදුවෙමි. ඔබට පැටවීමට අවශ්‍ය cpu මධ්‍ය ගණන පාලනය කළ හැකිය. මෙහි ඇති හොඳ දෙය නම් එය cpu හැර වෙනත් සම්පතක් පරිභෝජනය නොකිරීමයි. (මාක් මාර්ක් ජොන්සන්ගේ අදහස I / O සම්පත් විශාල ප්‍රමාණයක් පරිභෝජනය කරනු ඇති අතර එය මෙහි නුසුදුසුය.)

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.
no_of_cpu_to_be_consumed = 3

p = Pool(processes=no_of_cpu_to_be_consumed)
p.map(f, range(no_of_cpu_to_be_consumed))

මෙම ස්ක්‍රිප්ට් එක පර්යන්තයෙන් ධාවනය කරන්න $ python temp1.py. ඔබ අවසන් වූ පසු පිටපත මරා දැමිය යුතුය.

මෙන්න, මම මගේ හර 3 ක් පටවන විට මගේ cpu පරිභෝජන ප්‍රතිදානය වේ.

එක් විකල්ප ක්‍රමයක් වනු ඇත

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

හෝ (nproc තිබේ නම්)

openssl speed -multi $(nproc --all)

OpenSSL සෑම විටම පාහේ වර්තමානයේ ඩිස්ට්‍රෝස් වල පවතී, එබැවින් අමතර පැකේජ අවශ්‍ය නොවේ.

දෙකක් ආරම්භ කරන්න

sha1sum /dev/zero &

ඔබේ පද්ධතියේ සෑම හරයක් සඳහාම විධාන.

නැවැත්වීමට

killall sha1sum

හෝ

kill sha1sum

ලිනක්ස් පද්ධතියක පුළුල් පරාසයක් අවධාරණය කළ හැකි යාවත්කාලීන ආතති මෙවලමක් වන මම ආතතිය- ng සංවර්ධනය කරමින් සිටිමි. වැඩි විස්තර සඳහා, http://kernel.ubuntu.com/~cking/stress-ng/ බලන්න

භාවිතය ආතතියට සමානය

$ 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

සමඟ ස්ථාපනය කරන්න

sudo apt-get install stress-ng

මම සාමාන්‍යයෙන් cpuburn කට්ටලය ගන්නවා:

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

ඔබට ඇති හෝ අවධාරණය කිරීමට අවශ්‍ය හර / එච්ටී-නූල් ගණන සමඟ 4 ආදේශ කරන්න.

සටහන: මෙය එකවර හැකි තරම් චිප ප්‍රදේශයක් අවධාරණය කරයි, එය උපරිම බලය විසුරුවා හැරීම සඳහා වැඩසටහන්ගත කර ඇත. මට මෙම ලිපිය දෙවන වරට ලිවීමට සිදු විය, කෙසේ හෝ මගේ යන්ත්‍රය එයට කැමති නොවීය :-(

ඔබට අනුපිළිවෙලින් cpuburn කළ හැකිය:

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

ඔබට ඒවා නැවැත්වීමට අවශ්‍ය වූ විට:

killall burnP6

burnP6 &ඔබේ පද්ධතියේ ඇති CPU මධ්‍ය ගණනට ගැලපෙන පරිදි ගුණනය කළ හැකිය .

ඔබට අවශ්‍ය පරිදි වාර ගණනක් එම විධානය ක්‍රියාත්මක කළ හැකි අතර, එය සෑම විටම වෙනස් හරයක් ගනී:

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

https://github.com/GaetanoCarlucci/CPULoadGenerator

ඉතා සරල හා විද්‍යාත්මක විසඳුමක්.

CPU core 0 හි 50% ක බරක් ජනනය කරන ගතික උදාහරණය මෙහි ඔබට දැක ගත හැකිය:

ඔබට එකවර ක්‍රියාවලිය වෙනත් හරයන් මත ක්‍රියාත්මක කළ හැකිය.

මම + jlliagre සහ + 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 $@

ඔයාට පාවිච්චි කරන්න පුළුවන්:

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

dd if=/dev/zero of=/dev/nullඔබේ CPU හරයන් සඳහා නැවත නැවත කරන්න.

පරීක්ෂණය නැවැත්වීමට ඕනෑම යතුරක් ඔබන්න.

pxzසමාන්තරව ක්‍රියාත්මක කිරීමකි xz.

pxz -9e /dev/zero --stdout >/dev/null මෙය තරමක් cpu තීව්‍ර බැවින් උපක්‍රමය කළ යුතුය.

/dev/zeroප්‍රමාණවත් තරම් වේගවත් නොවේ නම් ( pxzI / O තෙරපෙන බව ඔබට පෙනේ ) ඔබට කළ හැකිය pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

නවතම අනුවාද xzතිබිය --threadsආදේශකයක් වන විකල්පය pxz.

මෙන්න මම භාවිතා කරන ක්‍රමය වන අතර අමතර කිසිවක් ස්ථාපනය කිරීමේ අවශ්‍යතාවයක් නොමැත.

උදාහරණයක් ලෙස ක්‍රියාවලි 4 කින් ආරම්භ කිරීමට,

nproc | xargs seq | xargs -n1 -P4 md5sum /dev/zero

ඉහත "-P" විකල්පය මඟින් ඔබට ක්‍රියාවලි ගණන වෙනස් කළ හැකිය.

සරල විධාන රේඛාවක් ද එය කරයි:

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

මට මෙය @ jlliagre ගේ ප්‍රකාශයට එකතු කිරීමට අවශ්‍ය විය, නමුත් මට ප්‍රමාණවත් කීර්තියක් නැත. ඔබ මෙම කේතය බහු සේවාදායකයන්හි භාවිතා කිරීමට යන්නේ නම් සහ CPU ගණන වෙනස් වේ නම්, ඔබට පහත විධානය භාවිතා කළ හැකිය:

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

ඔබ සතුව කොපමණ ප්‍රමාණයක් තිබුණද මෙය ඔබගේ සේවාදායකයේ ඇති සියලුම හරයන් භාවිතා කරයි. විධානය nproccoreutils හි කොටසක් වන බැවින් බොහෝ ලිනක්ස් ස්ථාපනයන්හි තිබිය යුතුය.

stressඔබේ CPU හි ඇති සියලුම හරයන් සඳහන් කරමින් වැඩසටහන ක්‍රියාත්මක කරන්න:

stress -c `nproc`

ඔබට එය ඩේබියන් / උබුන්ටු වලින් ලබා ගත හැකිය: sudo apt install stress