තනි ලිනක්ස් ක්‍රියාවලියක් සඳහා මතක භාවිතය සීමා කරන්න

pdftoppmපරිශීලක විසින් සපයන ලද PDF එකක් 300DPI අනුරුවක් බවට පරිවර්තනය කිරීමට මම දුවමි. පරිශීලකයා ඉතා විශාල පිටු ප්‍රමාණයක් සහිත PDF එකක් ලබා දෙන්නේ නම් හැර මෙය විශිෂ්ටයි. pdftoppmඅඟල් 100 ක වර්ග පිටුවකට 100 * 300 * 100 * 300 * 4 පික්සෙල් එකකට බයිට් = 3.5 ජීබී, එම ප්‍රමාණයෙන් 300DPI අනුරුවක් මතකයේ තබා ගැනීමට ප්‍රමාණවත් මතකයක් වෙන් කරනු ඇත. අනිෂ්ට පරිශීලකයෙකුට මට මෝඩ විශාල පී.ඩී.එෆ් ලබා දී සියලු ආකාරයේ ගැටළු ඇති කළ හැකිය.

ඉතින් මම කරන්න කැමති දේ මම ක්‍රියාත්මක කිරීමට සූදානම් වන ළමා ක්‍රියාවලියක් සඳහා මතක භාවිතය සඳහා යම් ආකාරයක දැඩි සීමාවක් පැනවීමයි - එය මතක ධාරිතාව 500MB ට වඩා වැඩි ප්‍රමාණයක් වෙන් කිරීමට උත්සාහ කළහොත් එම ක්‍රියාවලිය මිය යන්න. එය කළ හැකිද?

මේ සඳහා ulimit භාවිතා කළ හැකි යැයි මම නොසිතමි, නමුත් එක ක්‍රියාවලියකට සමානද?

Ulimit සමඟ ගැටළු කිහිපයක් තිබේ. මාතෘකාව පිළිබඳ ප්‍රයෝජනවත් කියවීමක් මෙන්න: ලිනක්ස් හි වැඩසටහනක කාලය සහ මතක පරිභෝජනය සීමා කිරීම, කල් ඉකුත් වීමේ මෙවලමට මඟ පෙන්වන අතර කාලය හෝ මතක පරිභෝජනය අනුව ක්‍රියාවලියක් (සහ එහි දෙබලක) කූඩු කිරීමට ඔබට ඉඩ සලසයි.

කල් ඉකුත් වීමේ මෙවලමට පර්ල් 5+ අවශ්‍ය වන අතර /procගොනු පද්ධතිය සවි කර ඇත. ඊට පසු ඔබ මෙවලම උදා ලෙස පිටපත් කරයි /usr/local/bin:

curl https://raw.githubusercontent.com/pshved/timeout/master/timeout | \
  sudo tee /usr/local/bin/timeout && sudo chmod 755 /usr/local/bin/timeout

ඊට පසු, ඔබේ ප්‍රශ්නයේදී මෙන් මතක පරිභෝජනයෙන් ඔබේ ක්‍රියාවලිය 'කූඩුව' කළ හැකිය:

timeout -m 500 pdftoppm Sample.pdf

විකල්පයක් ලෙස භාවිතා කිරීමට ඔබට හැකිය -t <seconds>සහ -x <hertz>පිළිවෙළින් කාලීන හෝ CPU සීමාවන් විසින් ක්රියාවලිය සීමා කිරීමට.

මෙම මෙවලම ක්‍රියා කරන ආකාරය නම්, තත්පරයට කිහිප වතාවක් පරික්ෂා කිරීමෙන්, සැකසූ ක්‍රියාවලිය එහි නියම සීමාවන් ඉක්මවා දායක වී නොමැති නම්. මෙයින් අදහස් කරන්නේ කල් ඉකුත් වූ දැනුම් දීම් වලට පෙර ක්‍රියාවලියක් අධි දායකත්වයක් ලබා ගත හැකි කුඩා කවුළුවක් ඇති බවත් එම ක්‍රියාවලිය ills ාතනය කරන බවත්ය.

වඩාත් නිවැරදි ප්‍රවේශයක් නිසා cgroups සම්බන්ධ විය හැකි නමුත්, එය සැකසීමට බොහෝ සෙයින් සම්බන්ධ වේ, ඔබ ඩොකර් හෝ runC භාවිතා කළත්, ඒවා අතර, cgroups වටා වඩාත් පරිශීලක-හිතකාමී සාරාංශයක් ලබා දේ.

මෙය සීමා කළ හැකි තවත් ක්‍රමයක් නම් ලිනක්ස් පාලන කණ්ඩායම් භාවිතා කිරීමයි. ක්‍රියාවලියක (හෝ ක්‍රියාවලි සමූහයක) භෞතික මතකය අථත්‍ය මතකයෙන් වෙන් කිරීම සීමා කිරීමට ඔබට අවශ්‍ය නම් මෙය විශේෂයෙන් ප්‍රයෝජනවත් වේ. උදාහරණයක් වශයෙන්:

cgcreate -g memory:myGroup
echo 500M > /sys/fs/cgroup/memory/myGroup/memory.limit_in_bytes
echo 5G > /sys/fs/cgroup/memory/myGroup/memory.memsw.limit_in_bytes

නම් කරන ලද පාලන කණ්ඩායමක් නිර්මාණය කරනු ඇත myGroup, myGroup යටතේ ක්‍රියාත්මක වන ක්‍රියාවලි සමූහය 500 MB භෞතික මතක ශක්තිය දක්වා සහ 5000 MB swap දක්වා. පාලන කණ්ඩායම යටතේ ක්‍රියාවලියක් ක්‍රියාත්මක කිරීම සඳහා:

cgexec -g memory:myGroup pdftoppm

නවීන, උබුන්ටු බෙදාහැරීමේ මත මෙම උදාහරණයේ ස්ථාපනය අවශ්ය බව සටහන cgroup-binපැකේජය සහ සංස්කරණය කිරීම /etc/default/grubවෙනස් කිරීමට GRUB_CMDLINE_LINUX_DEFAULTකිරීමට:

GRUB_CMDLINE_LINUX_DEFAULT="cgroup_enable=memory swapaccount=1"

sudo update-grubනව කර්නල් ඇරඹුම් පරාමිතීන් සමඟ ආරම්භ කිරීම සඳහා ධාවනය සහ නැවත ආරම්භ කිරීම.

ඔබේ ක්‍රියාවලිය වැඩිපුරම මතකය පරිභෝජනය කරන දරුවන් බිහි නොකරන්නේ නම්, ඔබට setrlimitක්‍රියාකාරිත්වය භාවිතා කළ හැකිය . ඒ සඳහා වඩාත් පොදු පරිශීලක අතුරුමුහුණත වන්නේ ulimitකවචයේ විධානය භාවිතා කිරීමයි:

$ ulimit -Sv 500000     # Set ~500 mb limit
$ pdftoppm ...

මෙය ඔබගේ ක්‍රියාවලියේ "අතථ්‍ය" මතකය පමණක් සීමා කරනු ඇත, ක්‍රියාවලිය ක්‍රියාවට නංවන ලද මතකය වෙනත් ක්‍රියාවලීන් සමඟ බෙදා ගනී, සහ මතකය සිතියම් ගත කළ නමුත් වෙන් කර නැත (නිදසුනක් ලෙස, ජාවාහි විශාල සංචය). තවමත්, අථත්ය මතකය යනු විශාල වශයෙන් වර්ධනය වන ක්රියාවලීන් සඳහා ආසන්නතම දළ විශ්ලේෂණය වන අතර එම දෝෂයන් වැදගත් නොවේ.

ඔබේ වැඩසටහන ළමයින් බිහි කළහොත් සහ මතකය වෙන් කරන්නේ ඔවුන් නම්, එය වඩාත් සංකීර්ණ වන අතර, ඔබේ පාලනය යටතේ ක්‍රියාවලීන් ක්‍රියාත්මක කිරීම සඳහා සහායක ස්ක්‍රිප්ට් ලිවිය යුතුය. මම මගේ බ්ලොග් අඩවියේ ලිව්වා, ඇයි සහ කෙසේද .

ඕනෑම පද්ධති මත පදනම් වූ ඩිස්ට්‍රෝ එකක ඔබට systemd-run හරහා වක්‍රව cgroups භාවිතා කළ හැකිය. උදා: ඔබේ pdftoppmරැම් 500M ට සීමා කිරීම සඳහා, භාවිතා කරන්න:

systemd-run --scope -p MemoryLimit=500M pdftoppm

සටහන: මෙය ඔබෙන් මුරපදයක් ඉල්ලා සිටින නමුත් යෙදුම ඔබේ පරිශීලකයා ලෙස දියත් වේ. විධානය අවශ්‍ය යැයි සිතීමට ඔබව රැවටීමට මෙය ඉඩ නොදෙන්න sudo, මන්ද එය විධානය මූල යටතේ ක්‍රියාත්මක වීමට හේතු වන අතර එය ඔබගේ අභිප්‍රාය නොවීය.

ඔබට මුරපදය ඇතුළත් නොකිරීමට අවශ්‍ය නම් (සියල්ලට පසු, ඔබේ මතකය ඔබ සතු පරිශීලකයෙකු ලෙස, එය සීමා කිරීමට ඔබට මුරපදයක් අවශ්‍ය වන්නේ ඇයි) , ඔබට --userවිකල්පයක් භාවිතා කළ හැකිය, කෙසේ වෙතත් මෙය ක්‍රියාත්මක කිරීම සඳහා ඔබට cgroupsv2 සහය අවශ්‍ය වේ. දැන් කර්නල් පරාමිතිය සමඟ ආරම්භ කිරීමට අවශ්‍ය වේsystemd.unified_cgroup_hierarchy .

මම පහත පිටපත භාවිතා කරමි. එය හරහා cgroups භාවිතා කරයි cgmanager. යාවත්කාලීන කිරීම: එය දැන් සිට විධාන භාවිතා කරයි cgroup-tools. මෙම ස්ක්‍රිප්ටය නම් limitmemකර එය ඔබගේ $ PATH තුළට දමන්න, ඔබට එය භාවිතා කළ හැකිය limitmem 100M bash. මෙය මතකය සහ හුවමාරු භාවිතය යන දෙකම සීමා කරයි. මතකය සීමා කිරීම සඳහා රේඛාව ඉවත් කරන්න memory.memsw.limit_in_bytes.

සංස්කරණය කරන්න: පෙරනිමියෙන් ලිනක්ස් ස්ථාපනයන් මෙය මතක භාවිතය සීමා කරයි, හුවමාරු භාවිතය නොවේ. Swap භාවිතය සීමා කිරීම සක්‍රීය කිරීම සඳහා, ඔබේ ලිනක්ස් පද්ධතියේ swap ගිණුම්කරණය සක්‍රීය කළ යුතුය. සැකසීම / එකතු ඔබ විසින් swapaccount=1දී /etc/default/grubඒ වගේ දෙයක් වගේ නිසා

GRUB_CMDLINE_LINUX="swapaccount=1"

ඉන්පසු ධාවනය sudo update-grubකර නැවත ආරම්භ කරන්න.

වියාචනය: cgroup-toolsඅනාගතයේ දී ද බිඳී ගියහොත් මා පුදුම නොවනු ඇත . නිවැරදි විසඳුම වනුයේ cgroup කළමනාකරණය සඳහා systemd api භාවිතා කිරීමයි, නමුත් එම atm සඳහා විධාන රේඛා මෙවලම් නොමැත

#!/bin/sh

# This script uses commands from the cgroup-tools package. The cgroup-tools commands access the cgroup filesystem directly which is against the (new-ish) kernel's requirement that cgroups are managed by a single entity (which usually will be systemd). Additionally there is a v2 cgroup api in development which will probably replace the existing api at some point. So expect this script to break in the future. The correct way forward would be to use systemd's apis to create the cgroups, but afaik systemd currently (feb 2018) only exposes dbus apis for which there are no command line tools yet, and I didn't feel like writing those.

# strict mode: error if commands fail or if unset variables are used
set -eu

if [ "$#" -lt 2 ]
then
    echo Usage: `basename $0` "<limit> <command>..."
    echo or: `basename $0` "<memlimit> -s <swaplimit> <command>..."
    exit 1
fi

cgname="limitmem_$$"

# parse command line args and find limits

limit="$1"
swaplimit="$limit"
shift

if [ "$1" = "-s" ]
then
    shift
    swaplimit="$1"
    shift
fi

if [ "$1" = -- ]
then
    shift
fi

if [ "$limit" = "$swaplimit" ]
then
    memsw=0
    echo "limiting memory to $limit (cgroup $cgname) for command $@" >&2
else
    memsw=1
    echo "limiting memory to $limit and total virtual memory to $swaplimit (cgroup $cgname) for command $@" >&2
fi

# create cgroup
sudo cgcreate -g "memory:$cgname"
sudo cgset -r memory.limit_in_bytes="$limit" "$cgname"
bytes_limit=`cgget -g "memory:$cgname" | grep memory.limit_in_bytes | cut -d\  -f2`

# try also limiting swap usage, but this fails if the system has no swap
if sudo cgset -r memory.memsw.limit_in_bytes="$swaplimit" "$cgname"
then
    bytes_swap_limit=`cgget -g "memory:$cgname" | grep memory.memsw.limit_in_bytes | cut -d\  -f2`
else
    echo "failed to limit swap"
    memsw=0
fi

# create a waiting sudo'd process that will delete the cgroup once we're done. This prevents the user needing to enter their password to sudo again after the main command exists, which may take longer than sudo's timeout.
tmpdir=${XDG_RUNTIME_DIR:-$TMPDIR}
tmpdir=${tmpdir:-/tmp}
fifo="$tmpdir/limitmem_$$_cgroup_closer"
mkfifo --mode=u=rw,go= "$fifo"
sudo -b sh -c "head -c1 '$fifo' >/dev/null ; cgdelete -g 'memory:$cgname'"

# spawn subshell to run in the cgroup. If the command fails we still want to remove the cgroup so unset '-e'.
set +e
(
set -e
# move subshell into cgroup
sudo cgclassify -g "memory:$cgname" --sticky `sh -c 'echo $PPID'`  # $$ returns the main shell's pid, not this subshell's.
exec "$@"
)

# grab exit code 
exitcode=$?

set -e

# show memory usage summary

peak_mem=`cgget -g "memory:$cgname" | grep memory.max_usage_in_bytes | cut -d\  -f2`
failcount=`cgget -g "memory:$cgname" | grep memory.failcnt | cut -d\  -f2`
percent=`expr "$peak_mem" / \( "$bytes_limit" / 100 \)`

echo "peak memory used: $peak_mem ($percent%); exceeded limit $failcount times" >&2

if [ "$memsw" = 1 ]
then
    peak_swap=`cgget -g "memory:$cgname" | grep memory.memsw.max_usage_in_bytes | cut -d\  -f2`
    swap_failcount=`cgget -g "memory:$cgname" |grep memory.memsw.failcnt | cut -d\  -f2`
    swap_percent=`expr "$peak_swap" / \( "$bytes_swap_limit" / 100 \)`

    echo "peak virtual memory used: $peak_swap ($swap_percent%); exceeded limit $swap_failcount times" >&2
fi

# remove cgroup by sending a byte through the pipe
echo 1 > "$fifo"
rm "$fifo"

exit $exitcode

daemontoolsමාර්ක් ජොන්සන් විසින් යෝජනා කරන ලද මෙවලම් වලට අමතරව , සොයාගත හැකි දේ ද සලකා බැලිය chpstහැකිය runit. Runit ම එකට එකතු වී ඇති busyboxබැවින් ඔබ එය දැනටමත් ස්ථාපනය කර ඇත.

මෙම මිනිසා පිටුවchpst සංදර්ශන විකල්පය:

-m බයිට් මතකය සීමා කරයි. දත්ත ඛණ්ඩය, සිරස් කොටස, අගුළු දැමූ භෞතික පිටු, සහ එක් ක්‍රියාවලියකට ඇති සියලුම කොටස් බයිට් වලට සීමා කරන්න.

මම උබුන්ටු 18.04.2 එල්ටීඑස් ධාවනය කරන අතර ඔහු යෝජනා කරන පරිදි ජන්කනිස් පිටපත මට වැඩ කරන්නේ නැත. ධාවනය limitmem 100M scriptයනු අසීමිත හුවමාරුවකින් 100MB RAM ප්‍රමාණයක් සීමා කිරීමයි .

පරාමිතියක් නම් කර නොමැති limitmem 100M -s 100M scriptබැවින් ධාවනය නිහ ly ව අසමත් වේ .cgget -g "memory:$cgname"memory.memsw.limit_in_bytes

ඒ නිසා මම swap අක්‍රීය කළා:

# create cgroup
sudo cgcreate -g "memory:$cgname"
sudo cgset -r memory.limit_in_bytes="$limit" "$cgname"
sudo cgset -r memory.swappiness=0 "$cgname"
bytes_limit=`cgget -g "memory:$cgname" | grep memory.limit_in_bytes | cut -d\  -f2`