නිදහස් මතකයෙන් 90% ක් පුරවන්නේ කෙසේද?

මට අඩු සම්පත් පරික්ෂා කිරීමක් කිරීමට අවශ්‍ය වන අතර ඒ සඳහා මට 90% නිදහස් මතකය පිරී තිබිය යුතුය.

මම කොහොමද මත මෙය කළ හැකි *nixක්රමය?

stress-ng යනු POSIX පද්ධති මත cpu / mem / io / hdd ආතතිය අනුකරණය කරන වැඩ බර උත්පාදක ය. මෙම ඇමතුම ලිනක්ස් <3.14 හි උපක්‍රමය කළ යුතුය:

stress-ng --vm-bytes $(awk '/MemFree/{printf "%d\n", $2 * 0.9;}' < /proc/meminfo)k --vm-keep -m 1

ලිනක්ස්> = 3.14 සඳහා, ඔබට MemAvailableමාරුවීමකින් තොරව නව ක්‍රියාවලීන් සඳහා පවතින මතකය තක්සේරු කිරීමට භාවිතා කළ හැකිය:

stress-ng --vm-bytes $(awk '/MemAvailable/{printf "%d\n", $2 * 0.9;}' < /proc/meminfo)k --vm-keep -m 1

/proc/meminfoඇමතුම free(1)/ vm_stat(1)/ etc සමඟ අනුවර්තනය කරන්න . ඔබට එය අතේ ගෙන යා හැකි නම්.

ඔබට malloc()අවශ්‍ය මතකයට සී වැඩසටහනක් ලිවිය හැකි අතර පසුව mlock()මතකය මාරු වීම වැළැක්වීමට භාවිතා කරන්න.

යතුරුපුවරු ආදානය සඳහා වැඩසටහනට රැඳී සිටීමට ඉඩ දෙන්න, සහ මතකය අගුළු ඇරීමට, මතකය නිදහස් කර පිටවීමට.

සීමිත මතකයක් සහිත වීඑම් එකක් ධාවනය කර මෘදුකාංගය පරීක්ෂා කිරීම ධාරක යන්ත්‍රයේ මතකය පිරවීමට උත්සාහ කරනවාට වඩා කාර්යක්ෂම පරීක්ෂණයක් වනු ඇතැයි මම යෝජනා කරමි.

අඩු මතක තත්වයක් වෙනත් තැනක OOM දෝෂ ඇති කර මුළු මෙහෙයුම් පද්ධතියම එල්ලා තබන්නේ නම්, ඔබ පරීක්‍ෂා කරන VM එක ඔබේ යන්ත්‍රය තුළ පමණක් එල්ලා තැබීමෙන් ඔබට වෙනත් ප්‍රයෝජනවත් ක්‍රියාවලීන් ක්‍රියාත්මක විය හැකිය.

ඔබේ පරීක්ෂාව CPU හෝ IO තීව්‍ර නොවේ නම්, ඔබට එකවර VMs පවුලක් මත විවිධාකාර අඩු මතක ප්‍රමාණවලින් පරීක්ෂණ සිදු කළ හැකිය.

මෙම HN අදහස් දැක්වීමෙන්: https://news.ycombinator.com/item?id=6695581

Dd හෝ ඊට සමාන හරහා / dev / shm පුරවන්න.

swapoff -a
dd if=/dev/zero of=/dev/shm/fill bs=1k count=1024k

ඔබ මූලික GNU මෙවලම් (තිබේ නම් sh, grep, yesහා head) ඔබ මෙය කළ හැකි:

yes | tr \\n x | head -c $BYTES | grep n
# Protip: use `head -c $((1024*1024*2))` to calculate 2MB easily

මෙය ක්‍රියාත්මක වන්නේ grep විසින් RAM හි මුළු දත්ත රේඛාවම පටවන බැවිනි (තැටි රූපයක් අඹරන විට මම මෙය තරමක් අවාසනාවන්ත ආකාරයකින් ඉගෙන ගතිමි). නව රේඛා yesප්‍රතිස්ථාපනය කිරීමෙන් ජනනය වන රේඛාව අනන්තවත් දිගු වන නමුත් එය බයිට් headවලට සීමා $BYTESවේ, එබැවින් grep මතකයේ $ BYTES පටවනු ඇත. ග්‍රෙප් මා වෙනුවෙන් 100-200KB වැනි භාවිතා කරයි, ඔබට එය වඩාත් නිවැරදි මුදලකට අඩු කිරීමට අවශ්‍ය විය හැකිය.

ඔබට කාල සීමාවක් එකතු කිරීමට අවශ්‍ය නම්, මෙය ඉතා පහසුවෙන් කළ හැකිය bash(ක්‍රියාත්මක නොවනු ඇත sh):

cat <(yes | tr \\n x | head -c $BYTES) <(sleep $NumberOfSeconds) | grep n

මෙම <(command): දෙයක්, මෙහි එය මත වැඩි තොරතුරු ටිකක් දැන ගත යුතු නමුත් බොහෝ විට ඉතා ප්රයෝජනවත් වේ පෙනේ http://tldp.org/LDP/abs/html/process-sub.html

එවිට භාවිතය සඳහා cat: catපිටවන තෙක් යෙදවුම් සම්පුර්ණ වන තෙක් බලා සිටින අතර, එක් පයිප්පයක් විවෘතව තබා ගැනීමෙන්, එය grep පණපිටින් තබා ගනී.

ඔබට pvRAM භාවිතය සෙමින් වැඩි කිරීමට අවශ්‍ය නම් :

yes | tr \\n x | head -c $BYTES | pv -L $BYTESPERSEC | grep n

උදාහරණයක් වශයෙන්:

yes | tr \\n x | head -c $((1024*1024*1024)) | pv -L $((1024*1024)) | grep n

තත්පරයට 1MB අනුපාතයකින් ගිගාබයිට් දක්වා භාවිතා කරනු ඇත. අමතර ප්‍රසාද දීමනාවක් ලෙස, pvවර්තමාන භාවිත අනුපාතය සහ මෙතෙක් භාවිතා කර ඇති මුළු භාවිතය ඔබට පෙන්වනු ඇත. ඇත්ත වශයෙන්ම මෙය පෙර ප්‍රභේද සමඟ ද කළ හැකිය:

yes | tr \\n x | head -c $BYTES | pv | grep n

| pv |කොටස ඇතුළත් කිරීමෙන් ඔබට වත්මන් තත්වය පෙන්වනු ඇත (ප්‍රතිදානය සහ එකතුව, පෙරනිමියෙන්, මම සිතන්නේ - එසේ නොමැතිනම් මිනිසා (ual) පිටුව බලන්න).

තවත් පිළිතුරක් ඇයි? පිළිගත් පිළිතුර පැකේජයක් ස්ථාපනය කිරීම නිර්දේශ කරයි (පැකේජ කළමණාකරුවෙකු අවශ්‍ය නොවී සෑම චිප්සෙට් සඳහාම නිකුතුවක් ඇති බව මම විශ්වාස කරමි); ඉහළම ඡන්දය දුන් පිළිතුර සී වැඩසටහනක් සම්පාදනය කිරීම නිර්දේශ කරයි (ඔබේ ඉලක්ක වේදිකාව සඳහා සම්පාදනය කිරීම සඳහා මට සම්පාදකයෙකු හෝ මෙවලම් කට්ටලයක් ස්ථාපනය කර නොතිබුණි); දෙවන ඉහළම ඡන්දය දුන් පිළිතුර VM එකක යෙදුම ධාවනය කිරීම නිර්දේශ කරයි (ඔව්, මෙම දුරකථනයේ අභ්‍යන්තර sdcard එක usb හෝ වෙනත් දෙයක් හරහා dd කර වර්චුවල් බොක්ස් රූපයක් නිර්මාණය කිරීමට මට ඉඩ දෙන්න); තෙවනුව යෝජනා කරන්නේ ඇරඹුම් අනුපිළිවෙලෙහි යම් දෙයක් වෙනස් කිරීමට යෝජනා කරන අතර එය අපේක්ෂිත පරිදි RAM පුරවන්නේ නැත; සිව්වනුව පමණක් ක්‍රියාත්මක වන්නේ / dev / shm සවිකිරීමේ ස්ථානය (1) පවතින අතර (2) විශාලය (නැවත ගණනය කිරීමේ අවශ්‍ය මූල); පස්වැන්න නියැදි කේතයකින් තොරව ඉහත බොහෝ දේ ඒකාබද්ධ කරයි; හයවැන්න හොඳ පිළිතුරක් නමුත් මගේම ප්‍රවේශයක් ඉදිරිපත් කිරීමට පෙර මෙම පිළිතුර මා දුටුවේ නැත, ඒ නිසා මම සිතුවා මගේම දෑ එකතු කර ගැනීමට, එය මතක තබා ගැනීමට හෝ ටයිප් කිරීමට කෙටි නිසා පටල රේඛාව ඇත්ත වශයෙන්ම කාරණයේ හරය බව ඔබට නොපෙනේ; හත්වන තැනැත්තා නැවත ප්‍රශ්නයට පිළිතුරු සපයන්නේ නැත (ඒ වෙනුවට ක්‍රියාවලියක් සීමා කිරීමට ulimit භාවිතා කරයි); අටවැන්න ඔබව පයිතන් ස්ථාපනය කිරීමට උත්සාහ කරයි; නවවන පුද්ගලයා සිතන්නේ අප සියල්ලන්ම ඉතා නිර්ව්‍යාජ නොවන අතර අවසානයේ දහවන තැනැත්තා තමාගේම C ++ වැඩසටහනක් ලියා ඇති අතර එමඟින් ඉහළම ඡන්දය දුන් පිළිතුරට සමාන ප්‍රශ්නයක් ඇති කරයි.

1. ලිනක්ස් ධාවනය;
2. mem=nn[KMG]කර්නල් ඇරඹුම් පරාමිතිය සමඟ ආරම්භ කරන්න

( විස්තර සඳහා ලිනක්ස් / ප්‍රලේඛනය / කර්නල්-පරාමිතීන්. txt බලන්න).

මගේ තිත් ලිපිගොනු වල සමාන දෙයක් කිරීමට මම ශ්‍රිතයක් තබා ගනිමි. https://github.com/sagotsky/.dotfiles/blob/master/.functions#L248

function malloc() {
  if [[ $# -eq 0 || $1 -eq '-h' || $1 -lt 0 ]] ; then
    echo -e "usage: malloc N\n\nAllocate N mb, wait, then release it."
  else 
    N=$(free -m | grep Mem: | awk '{print int($2/10)}')
    if [[ $N -gt $1 ]] ;then 
      N=$1
    fi
    sh -c "MEMBLOB=\$(dd if=/dev/urandom bs=1MB count=$N) ; sleep 1"
  fi
}

සරල පයිතන් විසඳුමක් කොපමණ ප්‍රමාණයක් තිබේද?

#!/usr/bin/env python

import sys
import time

if len(sys.argv) != 2:
    print "usage: fillmem <number-of-megabytes>"
    sys.exit()

count = int(sys.argv[1])

megabyte = (0,) * (1024 * 1024 / 8)

data = megabyte * count

while True:
    time.sleep(1)

රැම්ෆ් තිබේ නම් එය කෙසේද? එය සවි කර විශාල ගොනුවක් හරහා පිටපත් කරන්න? කිසිදු තියෙනවා නම් /dev/shmකිසිම ramfs සහ - මම සමහර ආදාන වටිනාකම මත පදනම් වූ විශාල malloc කරන්නේ බව ඉතා කුඩා C වැඩසටහන් අනුමාන? විශාල මතකයක් සහිත බිට් 32 පද්ධතියක් මත එකවර කිහිප වතාවක් ධාවනය කිරීමට සිදුවිය හැකිය.

සීමිත ක්‍රියාවලියක් සහිත විශේෂිත ක්‍රියාවලියක් පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම්, වෙන් කළ හැකි ulimitමතක ප්‍රමාණය සීමා කිරීමට භාවිතා කිරීම වඩා හොඳය .

මම හිතන්නේ මෙය වඩාත් නිර්මාණාත්මක පිළිතුරක් සඳහා තරඟ වදින පුද්ගලයින් විසින් වැරදි ප්‍රශ්නයක් ඇසීමේ සහ සිහිබුද්ධියෙන් ගිලී යන අවස්ථාවකි. ඔබට අවශ්‍ය වන්නේ OOM තත්වයන් අනුකරණය කිරීමට නම්, ඔබට මතකය පිරවීම අවශ්‍ය නොවේ. අභිරුචි විබෙදන්නෙකු භාවිතා කර නිශ්චිත ප්‍රතිපාදන ගණනකට පසුව එය අසාර්ථක වන්න. මෙම ප්‍රවේශය SQLite සඳහා ප්‍රමාණවත් ලෙස ක්‍රියා කරන බව පෙනේ .

මම මේ සඳහා කුඩා C ++ වැඩසටහන ලිව්වා: https://github.com/rmetzger/dynamic-ballooner

මෙම ක්‍රියාවට නැංවීමේ වාසිය නම් මතකය නිදහස් කිරීමට හෝ නැවත වෙන් කිරීමට අවශ්‍ය නම් වරින් වර පරීක්ෂා කිරීමයි.