mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 12:56:06 +00:00
feat(session): manage memory automatically and remove the manual memory controls (#2853)
Memory in the Steam session is kept above a floor by a monitor instead of the zRAM, RAM cap and VRAM cap settings, which are removed.
This commit is contained in:
1 parent
123c431b8e
commit
adf13d0bdd
60 files changed
+1117
-2264
No files matched your search
@@ -14,7 +14,6 @@ from pathlib import Path
|
||||
GAME_PREFIX = "DROIDDECK_GAME_"
|
||||
GAME_SPLIT_KEYS = ("TU_DEBUG", "MESA_NO_ERROR")
|
||||
CHROMIUM_FILES = {"chrome-sandbox", "chrome_100_percent.pak", "v8_context_snapshot.bin"}
|
||||
D3D9_DEFAULT_MEMORY_MB = 4096
|
||||
SYNC_KEYS = ("DD_SYNC", "DD_SYNC_FALLBACK", "DD_FSYNC_FIRST", "DD_SYNC_MIN_NOFILE", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC", "PROTON_NO_NTSYNC", "WINEESYNC")
|
||||
SEED_REDISTS = "/usr/local/bin/droiddeck-seed-redists"
|
||||
PACK_KEYS = ("WINESERVER", "DD_SYNC_PACK", "WINEESYNC", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC")
|
||||
@@ -470,21 +469,6 @@ def split_game_gpu(entries):
|
||||
return result
|
||||
|
||||
|
||||
def vram_cap(env):
|
||||
value = env.get("DD_VRAM_MB", "")
|
||||
if not re.fullmatch(r"[1-9][0-9]{0,6}", value):
|
||||
return env
|
||||
result = env.copy()
|
||||
cap = "dxgi.maxDeviceMemory = {0}; dxgi.maxSharedMemory = {0}".format(int(value))
|
||||
if int(value) < D3D9_DEFAULT_MEMORY_MB:
|
||||
cap += "; d3d9.maxAvailableMemory = {0}".format(int(value))
|
||||
own = result.get("DXVK_CONFIG", "").strip().strip(";").strip()
|
||||
result["DXVK_CONFIG"] = cap + "; " + own if own else cap
|
||||
result["DROIDDECK_VRAM_CAP"] = "1"
|
||||
result["DROIDDECK_VRAM_CAP_MB"] = value
|
||||
return result
|
||||
|
||||
|
||||
def parse_cores(text):
|
||||
cores = set()
|
||||
for part in text.replace(" ", "").split(","):
|
||||
@@ -1456,7 +1440,6 @@ def main():
|
||||
if mic_enabled == "0":
|
||||
env["AUDIO_DIRECT_MIC"] = "0"
|
||||
env = directaudio_settings(env)
|
||||
env = vram_cap(env)
|
||||
note = render_path_defaults(command, env) if app_id else None
|
||||
if note:
|
||||
print("droiddeck-game-env: " + note, file=sys.stderr)
|
||||
|
||||
@@ -132,6 +132,7 @@ clear_stale_tmp() {
|
||||
[ -z "${DD_INSIDE:-}" ] && clear_stale_tmp
|
||||
if [ -z "${DD_INSIDE:-}" ]; then
|
||||
if [ "${DD_ZRAM:-0}" = 1 ]; then printf 0 > /tmp/.dd-zram; else rm -f /tmp/.dd-zram; fi
|
||||
rm -f /tmp/.dd-zram.hold
|
||||
dd if=/dev/zero of=/tmp/.dd-clock bs=8 count=1 conv=notrunc status=none
|
||||
fi
|
||||
|
||||
@@ -756,13 +757,6 @@ case $mode in
|
||||
fi
|
||||
if [ "${DD_ZRAM:-0}" = 1 ]; then
|
||||
step "zRAM compression: on"
|
||||
[ "${DD_ZRAM_CLIENT:-1}" = 1 ] || step "zRAM: Steam, the hidden Epic Games Launcher and Battle.net are not compressed while games run (turned off in Performance)"
|
||||
_dd_ram_cap=0
|
||||
case ${DD_RAM_CAP_MB:-} in
|
||||
''|0) ;;
|
||||
*[!0-9]*|0*|???????*) step "RAM cap: ignored invalid value '$DD_RAM_CAP_MB'" ;;
|
||||
*) _dd_ram_cap=$((DD_RAM_CAP_MB * 1024)); step "RAM cap: ${DD_RAM_CAP_MB} MB" ;;
|
||||
esac
|
||||
(
|
||||
dd_zram_scan() {
|
||||
_dd_game=0 _dd_pids=() _dd_others=() _dd_apps=
|
||||
@@ -839,284 +833,235 @@ case $mode in
|
||||
echo "$# processes, resident $((_rss / 1024)) MB, in zram $((_swap / 1024)) MB"
|
||||
}
|
||||
dd_memory_read() {
|
||||
local _k _v _u _kind _fields _avg _whole _frac _gpu_bytes _growth _saved_growth _saved_fall
|
||||
_saved_growth=${_dd_preserved_growth:-0} _saved_fall=${_dd_preserved_fall:-0}
|
||||
_dd_preserved_growth=0 _dd_preserved_fall=0
|
||||
_dd_mem_total=0 _dd_available=-1 _dd_swap_total=0 _dd_swap_free=-1
|
||||
_dd_psi_some=0 _dd_psi_full=0 _dd_gpu=0 _dd_unevictable=0 _dd_shmem=0
|
||||
local _k _v _u _kind _fields _name _type _size _used _orig _comp _mem _dt _fall
|
||||
local _stall=-1 _swap_total=0 _swap_free=0 _total=0 _room=0 _listed=0 _in=-1
|
||||
_dd_mem_total=0 _dd_available=-1
|
||||
while read -r _k _v _u; do
|
||||
case $_v in ''|*[!0-9]*) continue ;; esac
|
||||
case $_k in
|
||||
MemTotal:) _dd_mem_total=$_v ;;
|
||||
MemAvailable:) _dd_available=$_v ;;
|
||||
SwapTotal:) _dd_swap_total=$_v ;;
|
||||
SwapFree:) _dd_swap_free=$_v ;;
|
||||
Unevictable:) _dd_unevictable=$_v ;;
|
||||
Shmem:) _dd_shmem=$_v ;;
|
||||
SwapTotal:) _swap_total=$_v ;;
|
||||
SwapFree:) _swap_free=$_v ;;
|
||||
esac
|
||||
done 2>/dev/null < /proc/meminfo
|
||||
while read -r _name _type _size _used _u; do
|
||||
_listed=1
|
||||
case $_name in */zram[0-9]*) ;; *) continue ;; esac
|
||||
case $_size$_used in ''|*[!0-9]*) continue ;; esac
|
||||
_total=$((_total + _size)) _room=$((_room + _size - _used))
|
||||
done 2>/dev/null < /proc/swaps
|
||||
[ "$_listed" = 1 ] || _total=$_swap_total _room=$_swap_free
|
||||
_dd_swap_room=$((_total / 8))
|
||||
[ "$_dd_swap_room" -ge $((128 * 1024)) ] || _dd_swap_room=$((128 * 1024))
|
||||
_dd_swap_room=$((_room - _dd_swap_room))
|
||||
_dd_saving=600
|
||||
if [ -r /sys/block/zram0/mm_stat ] && read -r _orig _comp _mem _u 2>/dev/null < /sys/block/zram0/mm_stat; then
|
||||
case $_orig$_mem in
|
||||
''|*[!0-9]*) ;;
|
||||
*) [ "$_orig" -lt $((64 << 20)) ] || _dd_saving=$(((_orig - _mem) / (_orig / 1000))) ;;
|
||||
esac
|
||||
[ "$_dd_saving" -ge 167 ] || _dd_saving=167
|
||||
[ "$_dd_saving" -le 833 ] || _dd_saving=833
|
||||
fi
|
||||
if [ -r /proc/pressure/memory ]; then
|
||||
while read -r _kind _fields; do
|
||||
[ "$_kind" = some ] || [ "$_kind" = full ] || continue
|
||||
_avg=${_fields#avg10=} _avg=${_avg%% *}
|
||||
_whole=${_avg%%.*} _frac=${_avg#*.}
|
||||
[ "$_frac" = "$_avg" ] && _frac=00
|
||||
_frac=${_frac}00
|
||||
_frac=${_frac:0:2}
|
||||
case $_whole$_frac in ''|*[!0-9]*) continue ;; esac
|
||||
if [ "$_kind" = some ]; then
|
||||
_dd_psi_some=$((10#$_whole * 100 + 10#$_frac))
|
||||
else
|
||||
_dd_psi_full=$((10#$_whole * 100 + 10#$_frac))
|
||||
fi
|
||||
[ "$_kind" = some ] || continue
|
||||
_fields=${_fields##*total=}
|
||||
case $_fields in ''|*[!0-9]*) ;; *) _stall=$_fields ;; esac
|
||||
done 2>/dev/null < /proc/pressure/memory
|
||||
fi
|
||||
if [ -r /sys/class/kgsl/kgsl/page_alloc ]; then
|
||||
read -r _gpu_bytes _u < /sys/class/kgsl/kgsl/page_alloc
|
||||
case $_gpu_bytes in ''|*[!0-9]*) _gpu_bytes=0 ;; esac
|
||||
_dd_gpu=$((_gpu_bytes / 1024))
|
||||
while read -r _k _v; do
|
||||
[ "$_k" = pswpin ] || continue
|
||||
case $_v in ''|*[!0-9]*) ;; *) _in=$((_v * _dd_page_kb)) ;; esac
|
||||
break
|
||||
done 2>/dev/null < /proc/vmstat
|
||||
_dt=$((SECONDS - ${_dd_sample_at:-$SECONDS}))
|
||||
if [ -z "${_dd_sample_at:-}" ]; then
|
||||
_dd_rate=0 _dd_psi=0 _dd_returned=0
|
||||
elif [ "$_dt" -gt 0 ] && [ "$_dd_available" -ge 0 ]; then
|
||||
_fall=$(((_dd_sample_available - _dd_available + _dd_freed) / _dt))
|
||||
_dd_rate=$((_dd_rate * 3 / 4))
|
||||
[ "$_fall" -le "$_dd_rate" ] || _dd_rate=$_fall
|
||||
_dd_psi=0
|
||||
[ "$_stall" -lt 0 ] || [ "$_dd_sample_stall" -lt 0 ] || _dd_psi=$(((_stall - _dd_sample_stall) / (_dt * 100)))
|
||||
_dd_returned=$((_dt < 30 ? _dd_returned * (30 - _dt) / 30 : 0))
|
||||
[ "$_in" -lt "$_dd_sample_in" ] || [ "$_dd_sample_in" -lt 0 ] || _dd_returned=$((_dd_returned + _in - _dd_sample_in))
|
||||
fi
|
||||
_dd_psi=$_dd_psi_some
|
||||
[ "$_dd_psi_full" -gt "$_dd_psi" ] && _dd_psi=$_dd_psi_full
|
||||
if [ "${_dd_sample_at:-}" = "" ]; then
|
||||
_dd_growth=0 _dd_fall=0
|
||||
_dd_sample_at=$SECONDS _dd_sample_available=$_dd_available _dd_sample_gpu=$_dd_gpu
|
||||
_dd_sample_unevictable=$_dd_unevictable _dd_sample_shmem=$_dd_shmem
|
||||
elif [ "$SECONDS" -gt "$_dd_sample_at" ]; then
|
||||
_dd_growth=0 _dd_fall=0
|
||||
_growth=$((_dd_gpu - _dd_sample_gpu)); [ "$_growth" -gt 0 ] && _dd_growth=$((_dd_growth + _growth))
|
||||
_growth=$((_dd_unevictable - _dd_sample_unevictable)); [ "$_growth" -gt 0 ] && _dd_growth=$((_dd_growth + _growth))
|
||||
_growth=$((_dd_shmem - _dd_sample_shmem)); [ "$_growth" -gt 0 ] && _dd_growth=$((_dd_growth + _growth))
|
||||
_dd_fall=$((_dd_sample_available - _dd_available))
|
||||
[ "$_saved_growth" -gt "$_dd_growth" ] && _dd_growth=$_saved_growth
|
||||
[ "$_saved_fall" -gt "$_dd_fall" ] && _dd_fall=$_saved_fall
|
||||
if [ $((SECONDS - _dd_sample_at)) -ge 5 ]; then
|
||||
_dd_sample_at=$SECONDS _dd_sample_available=$_dd_available _dd_sample_gpu=$_dd_gpu
|
||||
_dd_sample_unevictable=$_dd_unevictable _dd_sample_shmem=$_dd_shmem
|
||||
fi
|
||||
if [ "$_dd_available" -ge 0 ] && { [ -z "${_dd_sample_at:-}" ] || [ "$_dt" -gt 0 ]; }; then
|
||||
_dd_sample_at=$SECONDS _dd_sample_available=$_dd_available _dd_sample_stall=$_stall _dd_sample_in=$_in _dd_freed=0
|
||||
fi
|
||||
_dd_real_available=$_dd_available
|
||||
[ "$_dd_real_available" -ge 0 ] && _dd_real_available=$((_dd_real_available - _dd_growth))
|
||||
_dd_headroom=$((_dd_mem_total / 5))
|
||||
[ "$_dd_headroom" -ge $((512 * 1024)) ] || _dd_headroom=$((512 * 1024))
|
||||
[ "$_dd_headroom" -le $((1536 * 1024)) ] || _dd_headroom=$((1536 * 1024))
|
||||
_dd_tier_headroom=$((_dd_mem_total / 4))
|
||||
[ "$_dd_tier_headroom" -ge $((768 * 1024)) ] || _dd_tier_headroom=$((768 * 1024))
|
||||
[ "$_dd_tier_headroom" -le $((2560 * 1024)) ] || _dd_tier_headroom=$((2560 * 1024))
|
||||
_dd_fall_headroom=$((_dd_tier_headroom * 2))
|
||||
[ "$_dd_fall_headroom" -ge $((_dd_mem_total * 2 / 5)) ] || _dd_fall_headroom=$((_dd_mem_total * 2 / 5))
|
||||
_dd_swap_reserve=$((_dd_swap_total / 5))
|
||||
[ "$_dd_swap_reserve" -ge $((256 * 1024)) ] || _dd_swap_reserve=$((256 * 1024))
|
||||
_dd_floor=$((_dd_mem_total / 8))
|
||||
[ "$_dd_floor" -ge $((640 * 1024)) ] || _dd_floor=$((640 * 1024))
|
||||
[ "$_dd_floor" -le $((1280 * 1024)) ] || _dd_floor=$((1280 * 1024))
|
||||
_dd_target=$((_dd_floor + _dd_rate * 10))
|
||||
}
|
||||
dd_memory_tight() {
|
||||
[ "$_dd_mem_total" -gt 0 ] && [ "$_dd_available" -ge 0 ] &&
|
||||
{ [ "$_dd_real_available" -lt "$_dd_headroom" ] ||
|
||||
{ [ "$_dd_psi" -ge 100 ] && [ "$_dd_real_available" -lt $((_dd_mem_total / 3)) ]; } ||
|
||||
{ [ "$_dd_fall" -ge $((256 * 1024)) ] && [ "$_dd_real_available" -lt $((_dd_headroom * 2)) ]; }; }
|
||||
}
|
||||
dd_client_can_pageout() {
|
||||
dd_memory_read
|
||||
dd_zram_usage "${_dd_pids[@]}" > /dev/null
|
||||
[ "$_dd_mem_total" -gt 0 ] && dd_zram_has_room
|
||||
}
|
||||
dd_zram_has_room() {
|
||||
[ "$_dd_swap_total" -gt 0 ] &&
|
||||
[ $((_dd_swap_free - _dd_anon - ${_dd_client_reserve:-0})) -ge "$_dd_swap_reserve" ]
|
||||
}
|
||||
dd_client_can_readback() {
|
||||
dd_memory_read
|
||||
dd_zram_usage "${_dd_pids[@]}" > /dev/null
|
||||
[ "$_dd_mem_total" -gt 0 ] && ! dd_memory_tight && ! dd_memory_critical &&
|
||||
[ "$_dd_real_available" -ge $((_dd_swap * 2)) ] &&
|
||||
[ $((_dd_real_available - _dd_swap)) -ge "$_dd_headroom" ]
|
||||
}
|
||||
dd_client_pressure() {
|
||||
[ "${DD_ZRAM_CLIENT:-1}" = 1 ] && [ "$_dd_game" = 1 ] &&
|
||||
[ "${#_dd_pids[@]}" -gt 0 ] && { dd_memory_tight || dd_memory_critical; } || return 0
|
||||
[ "$_dd_pressure_at" -lt 0 ] ||
|
||||
[ $((SECONDS - _dd_pressure_at)) -ge "$_dd_pressure_backoff" ] || return 0
|
||||
[ "$_dd_packed" -lt 0 ] || [ $((SECONDS - _dd_packed)) -ge 30 ] || return 0
|
||||
_dd_pressure_at=$SECONDS
|
||||
if ! dd_client_can_pageout; then
|
||||
step "zRAM: pressure reclaim skipped, swap headroom too small ($((_dd_swap_free / 1024)) MB free)"
|
||||
return 0
|
||||
dd_memory_need() {
|
||||
local _burst=$((_dd_rate * 2))
|
||||
_dd_need=0 _dd_hard=0 _dd_force=0
|
||||
[ "$_dd_mem_total" -gt 0 ] && [ "$_dd_available" -ge 0 ] || return 0
|
||||
_dd_need=$((_dd_target - _dd_available)) _dd_hard=$((_dd_floor - _dd_available))
|
||||
if [ "$_burst" -ge $((64 * 1024)) ] && [ "$_dd_available" -lt $((_dd_mem_total * 2 / 5)) ] && [ "$_burst" -gt "$_dd_need" ]; then
|
||||
_dd_need=$_burst
|
||||
fi
|
||||
[ "$_dd_rss" -ge $((128 * 1024)) ] || return 0
|
||||
_dd_pressure_before=$_dd_rss
|
||||
if [ "${1:-}" = defer ]; then
|
||||
_dd_client_reserve=$_dd_anon
|
||||
_dd_client_pending=1
|
||||
fi
|
||||
dd_zram_send 1 "memory pressure, compressing the client (available $((_dd_available / 1024)) MB, swap free $((_dd_swap_free / 1024)) MB)" client "${1:-}"
|
||||
_dd_packed=$SECONDS
|
||||
if [ "${1:-}" = defer ]; then
|
||||
_dd_client_targets=("${_dd_zram_targets[@]}")
|
||||
else
|
||||
dd_client_pressure_result
|
||||
if [ "$_dd_psi" -ge 100 ] && [ "$_burst" -gt "$_dd_hard" ]; then
|
||||
_dd_hard=$_burst
|
||||
fi
|
||||
[ "$_dd_hard" -gt 0 ] || _dd_hard=0
|
||||
[ "$_dd_need" -ge "$_dd_hard" ] || _dd_need=$_dd_hard
|
||||
[ "$_dd_available" -ge $((_dd_floor / 2)) ] || _dd_force=1
|
||||
}
|
||||
dd_client_pressure_finish() {
|
||||
[ "${_dd_client_pending:-0}" = 1 ] || return 0
|
||||
dd_zram_finish 1 "${_dd_client_targets[@]}"
|
||||
dd_client_pressure_result "${_dd_client_targets[@]}"
|
||||
_dd_client_pending=0 _dd_client_reserve=0 _dd_client_targets=()
|
||||
}
|
||||
dd_client_pressure_result() {
|
||||
[ "${_dd_pageout_complete:-0}" = 1 ] || return 0
|
||||
if [ "$#" -gt 0 ]; then dd_zram_usage "$@" > /dev/null; else dd_zram_usage "${_dd_pids[@]}" > /dev/null; fi
|
||||
if [ $((_dd_pressure_before - _dd_rss)) -lt $((16 * 1024)) ]; then
|
||||
_dd_pressure_backoff=$((_dd_pressure_backoff * 2 > 300 ? 300 : _dd_pressure_backoff * 2))
|
||||
else
|
||||
_dd_pressure_backoff=30
|
||||
fi
|
||||
}
|
||||
dd_memory_critical() {
|
||||
[ "$_dd_mem_total" -gt 0 ] && [ "$_dd_available" -ge 0 ] &&
|
||||
{ [ "$_dd_real_available" -lt "$_dd_tier_headroom" ] ||
|
||||
{ [ "$_dd_psi" -ge 100 ] && [ "$_dd_real_available" -lt $((_dd_tier_headroom * 3 / 2)) ]; } ||
|
||||
{ [ "$_dd_fall" -ge $((256 * 1024)) ] && [ "$_dd_real_available" -lt "$_dd_fall_headroom" ]; }; }
|
||||
}
|
||||
dd_session_pressure() {
|
||||
dd_memory_read
|
||||
dd_memory_critical || _dd_tier_backoff=30 _dd_tier_nogain=0
|
||||
[ "$_dd_game" = 1 ] && dd_memory_critical || return 0
|
||||
[ "${DD_ZRAM_IDLE:-1}" = 1 ] && dd_game_focused 0 || return 0
|
||||
local _wait=$_dd_tier_backoff _before _available_before _pids _targets _gain _min_gain
|
||||
[ "$_dd_available" -ge $((_dd_headroom / 2)) ] || [ "$_dd_tier_pushed" -lt 0 ] || _wait=30
|
||||
[ "$_dd_tier_at" -lt 0 ] || [ $((SECONDS - _dd_tier_at)) -ge "$_wait" ] || return 0
|
||||
if [ "$_dd_tier_at" -ge 0 ] && [ "$_dd_tier_pushed" -gt 0 ]; then
|
||||
dd_tier_readback
|
||||
if [ "$_dd_tier_back" -le $((_dd_tier_pushed / 2)) ]; then
|
||||
[ "${_dd_tier_nogain:-0}" = 1 ] || _dd_tier_backoff=30
|
||||
else
|
||||
_dd_tier_backoff=$((_dd_tier_backoff * 2 > 300 ? 300 : _dd_tier_backoff * 2))
|
||||
_dd_tier_at=$SECONDS _dd_tier_pushed=-1
|
||||
step "zRAM: the game read back most of its last page-out, next try in ${_dd_tier_backoff} s"
|
||||
return 0
|
||||
fi
|
||||
fi
|
||||
_dd_tier_at=$SECONDS _dd_tier_pushed=0
|
||||
dd_zram_pick session
|
||||
dd_zram_usage "${_pids[@]}" > /dev/null
|
||||
[ "$_dd_rss" -ge $((256 * 1024)) ] || return 0
|
||||
if ! dd_zram_has_room; then
|
||||
step "zRAM: low-memory page-out skipped, swap headroom too small ($((_dd_swap_free / 1024)) MB free)"
|
||||
return 0
|
||||
fi
|
||||
_targets=("${_pids[@]}") _before=$_dd_swap _available_before=$_dd_available
|
||||
dd_zram_send 1 "low memory (available $((_dd_real_available / 1024)) MB), compressing idle game memory" session
|
||||
dd_zram_usage "${_targets[@]}" > /dev/null
|
||||
_dd_tier_pushed=$((_dd_swap - _before))
|
||||
dd_tier_note "${_targets[@]}"
|
||||
if [ "${_dd_pageout_complete:-0}" = 1 ]; then
|
||||
dd_memory_read
|
||||
_gain=$((_dd_available - _available_before))
|
||||
_min_gain=$((_dd_tier_headroom / 16))
|
||||
[ "$_min_gain" -ge $((16 * 1024)) ] || _min_gain=$((16 * 1024))
|
||||
if [ "$_gain" -lt "$_min_gain" ]; then
|
||||
_dd_tier_backoff=$((_dd_tier_backoff * 2 > 300 ? 300 : _dd_tier_backoff * 2))
|
||||
_dd_tier_at=$SECONDS _dd_tier_nogain=1
|
||||
step "zRAM: low-memory page-out gained only $((_gain / 1024)) MB available, next try in ${_dd_tier_backoff} s"
|
||||
else
|
||||
_dd_tier_nogain=0
|
||||
fi
|
||||
fi
|
||||
}
|
||||
dd_proc_start() {
|
||||
local _s=
|
||||
_dd_start=
|
||||
read -r _s 2>/dev/null < "/proc/$1/stat" || return 1
|
||||
_s=${_s##*) }
|
||||
set -- $_s
|
||||
[ "$1" != Z ] && [ "$#" -ge 20 ] || return 1
|
||||
_dd_start=${20}
|
||||
}
|
||||
dd_tier_note() {
|
||||
local _p
|
||||
_dd_tier_targets=() _dd_tier_swaps=() _dd_tier_starts=()
|
||||
for _p in "$@"; do
|
||||
dd_proc_start "$_p" || continue
|
||||
dd_zram_usage "$_p" > /dev/null
|
||||
_dd_tier_targets+=("$_p") _dd_tier_swaps+=("$_dd_swap") _dd_tier_starts+=("$_dd_start")
|
||||
done
|
||||
}
|
||||
dd_tier_readback() {
|
||||
local _i _back=0
|
||||
for _i in "${!_dd_tier_targets[@]}"; do
|
||||
dd_proc_start "${_dd_tier_targets[$_i]}" && [ "$_dd_start" = "${_dd_tier_starts[$_i]}" ] || continue
|
||||
dd_zram_usage "${_dd_tier_targets[$_i]}" > /dev/null
|
||||
[ "${_dd_tier_swaps[$_i]}" -le "$_dd_swap" ] || _back=$((_back + _dd_tier_swaps[_i] - _dd_swap))
|
||||
done
|
||||
_dd_tier_back=$_back
|
||||
}
|
||||
dd_watch_nap() {
|
||||
local _i
|
||||
if [ "$_dd_game" = 1 ] && [ "$_dd_available" -ge 0 ] && [ "$_dd_real_available" -lt "$_dd_fall_headroom" ]; then
|
||||
for _i in 1 2 3 4 5; do
|
||||
nap 1
|
||||
dd_memory_read
|
||||
dd_memory_critical && return 0
|
||||
done
|
||||
else
|
||||
nap 5
|
||||
fi
|
||||
return 0
|
||||
dd_pid_key() {
|
||||
local _s
|
||||
_dd_key=$1
|
||||
read -r _s 2>/dev/null < "/proc/$1/stat" || return 0
|
||||
set -- ${_s##*) }
|
||||
_dd_key=$_dd_key.${20:-}
|
||||
}
|
||||
dd_session_others() {
|
||||
local _p
|
||||
local -A _known=()
|
||||
_dd_session=()
|
||||
for _p in "${_dd_others[@]}"; do
|
||||
grep -q -m1 '/libddsession\.so$' "/proc/$_p/maps" 2>/dev/null && _dd_session+=("$_p")
|
||||
dd_pid_key "$_p"
|
||||
[ -n "${_dd_preloaded[$_dd_key]:-}" ] ||
|
||||
grep -q -m1 '/libddsession\.so$' "/proc/$_p/maps" 2>/dev/null || continue
|
||||
_known[$_dd_key]=1
|
||||
dd_zram_usage "$_p" > /dev/null
|
||||
_dd_session+=("$_dd_anon $_p")
|
||||
done
|
||||
_dd_preloaded=()
|
||||
for _p in "${!_known[@]}"; do
|
||||
_dd_preloaded[$_p]=1
|
||||
done
|
||||
[ "${#_dd_session[@]}" -gt 0 ] || return 0
|
||||
mapfile -t _dd_session < <(printf '%s\n' "${_dd_session[@]}" | sort -rn)
|
||||
_dd_session=("${_dd_session[@]#* }")
|
||||
}
|
||||
dd_zram_pick() {
|
||||
if [ "$1" = game ]; then
|
||||
dd_session_others
|
||||
_pids=("${_dd_session[@]}")
|
||||
[ "${DD_ZRAM_CLIENT:-1}" != 1 ] || _pids+=("${_dd_pids[@]}")
|
||||
elif [ "$1" = session ]; then
|
||||
dd_session_others
|
||||
_pids=("${_dd_session[@]}")
|
||||
dd_memory_relieved() {
|
||||
local _k _v _u
|
||||
while read -r _k _v _u; do
|
||||
[ "$_k" = MemAvailable: ] || continue
|
||||
case $_v in ''|*[!0-9]*) return 1 ;; esac
|
||||
[ "$_v" -ge "$_dd_goal" ]
|
||||
return
|
||||
done 2>/dev/null < /proc/meminfo
|
||||
return 1
|
||||
}
|
||||
dd_zram_trim() {
|
||||
local _mode=$1 _left=$2 _p _k _n _i _acks=()
|
||||
shift 2
|
||||
_dd_trimmed=0
|
||||
for _k in "${!_dd_deaf[@]}"; do
|
||||
[ "${_dd_deaf[$_k]}" -gt "$SECONDS" ] || unset "_dd_deaf[$_k]"
|
||||
done
|
||||
for _p in "$@"; do
|
||||
[ "$_left" -ge 4096 ] && [ "$_dd_polls" -lt 250 ] && [ $((SECONDS - _dd_pass_at)) -lt 6 ] &&
|
||||
[ ! -e /tmp/.dd-zram.hold ] || break
|
||||
! dd_memory_relieved || break
|
||||
dd_pid_key "$_p"
|
||||
_k=$_dd_key
|
||||
[ "${_dd_deaf[$_k]:-0}" -le "$SECONDS" ] || continue
|
||||
dd_zram_usage "$_p" > /dev/null
|
||||
[ "$_dd_anon" -ge 8192 ] || continue
|
||||
printf %s - > "/tmp/.dd-zram.trim.$_p"
|
||||
_acks+=("/tmp/.dd-zram.trim.$_p")
|
||||
printf '%s %s\n' "$_mode" "$_left" > /tmp/.dd-zram
|
||||
kill -URG "$_p" 2>/dev/null || continue
|
||||
_dd_deaf[$_k]=$((SECONDS + 60))
|
||||
for ((_i = 0; _dd_polls < 250 && SECONDS - _dd_pass_at < 6; _i++, _dd_polls++)); do
|
||||
[ ! -e /tmp/.dd-zram.hold ] || { _dd_deaf[$_k]=0; break; }
|
||||
_n=
|
||||
read -r _n 2>/dev/null < "/tmp/.dd-zram.trim.$_p" || :
|
||||
case $_n in
|
||||
-) [ "$_i" -lt 25 ] || break ;;
|
||||
''|*[!0-9]*) ;;
|
||||
*) _dd_trimmed=$((_dd_trimmed + _n)) _left=$((_left - _n)) _dd_deaf[$_k]=0; break ;;
|
||||
esac
|
||||
nap 0.02
|
||||
done
|
||||
done
|
||||
[ ! -e /tmp/.dd-zram.hold ] || return 0
|
||||
printf '2 0\n' > /tmp/.dd-zram
|
||||
[ "${#_acks[@]}" = 0 ] || rm -f "${_acks[@]}"
|
||||
}
|
||||
dd_memory_relieve() {
|
||||
local _mode=2 _budget _gain=0 _rest _cap=$((256 * 1024)) _all=$((1024 * 1024))
|
||||
dd_memory_need
|
||||
_dd_polls=0 _dd_pass_at=$SECONDS
|
||||
if [ "$_dd_need" -le 0 ]; then
|
||||
_dd_rest=0
|
||||
return 0
|
||||
fi
|
||||
[ "$_dd_rest" = 0 ] || [ "$_dd_force" = 1 ] || [ "$SECONDS" -ge "$_dd_rest_until" ] ||
|
||||
[ "$_dd_available" -lt $((_dd_rest_available - _dd_floor / 8)) ] || return 0
|
||||
if [ "$_dd_swap_room" -lt $((64 * 1024)) ]; then
|
||||
if [ $((SECONDS - _dd_full_at)) -ge 60 ]; then
|
||||
_dd_full_at=$SECONDS
|
||||
step "memory: available $((_dd_available / 1024)) MB and zRAM has no room left"
|
||||
fi
|
||||
return 0
|
||||
fi
|
||||
if [ "$_dd_force" = 1 ] && [ $((SECONDS - _dd_forced_at)) -ge 10 ]; then
|
||||
_mode=3 _dd_forced_at=$SECONDS _cap=$_all
|
||||
else
|
||||
_pids=("${_dd_pids[@]}")
|
||||
_cap=$((_cap - _dd_returned)) _all=$((_all - _dd_returned))
|
||||
fi
|
||||
if [ "${#_dd_pids[@]}" -gt 0 ] && [ "$_all" -ge 4096 ] &&
|
||||
{ [ "$_dd_hard" -gt 0 ] ||
|
||||
{ [ "$_dd_game" = 1 ] && [ "$_dd_focus" != 1 ] && [ $((SECONDS - _dd_back_at)) -ge 30 ]; }; }; then
|
||||
_budget=$((_dd_need * 1000 / _dd_saving))
|
||||
[ "$_budget" -le "$_all" ] || _budget=$_all
|
||||
[ "$_budget" -le "$_dd_swap_room" ] || _budget=$_dd_swap_room
|
||||
_dd_goal=$((_dd_available + _dd_need))
|
||||
dd_zram_trim "$_mode" "$_budget" "${_dd_pids[@]}"
|
||||
_gain=$((_dd_trimmed * _dd_saving / 1000))
|
||||
_dd_swap_room=$((_dd_swap_room - _dd_trimmed)) _all=$((_all - _dd_trimmed))
|
||||
[ "$_cap" -le "$_all" ] || _cap=$_all
|
||||
_dd_client_out=$((_dd_client_out + _dd_trimmed)) _dd_note_client=$((_dd_note_client + _dd_trimmed))
|
||||
[ "$_dd_trimmed" = 0 ] || _dd_trim_at=$SECONDS
|
||||
fi
|
||||
_rest=$((_dd_hard - _gain))
|
||||
if [ "$_rest" -gt 0 ] && [ "$_cap" -ge 4096 ] && [ "$_dd_swap_room" -ge $((64 * 1024)) ]; then
|
||||
[ "$_dd_session_at" = "$_dd_scan_at" ] || dd_session_others
|
||||
_dd_session_at=$_dd_scan_at
|
||||
_budget=$((_rest * 1000 / _dd_saving))
|
||||
[ "$_budget" -le "$_cap" ] || _budget=$_cap
|
||||
[ "$_budget" -le "$_dd_swap_room" ] || _budget=$_dd_swap_room
|
||||
_dd_goal=$((_dd_available + _dd_hard))
|
||||
dd_zram_trim "$_mode" "$_budget" "${_dd_session[@]}"
|
||||
_gain=$((_gain + _dd_trimmed * _dd_saving / 1000))
|
||||
_dd_note_session=$((_dd_note_session + _dd_trimmed))
|
||||
fi
|
||||
_dd_freed=$((_dd_freed + _gain))
|
||||
if [ "$_dd_hard" -gt 0 ] && [ "$_gain" -lt $((_dd_hard / 4)) ]; then
|
||||
_dd_rest=$((_dd_rest > 0 ? _dd_rest * 2 : 5))
|
||||
[ "$_dd_rest" -le 60 ] || _dd_rest=60
|
||||
_dd_rest_until=$((SECONDS + _dd_rest)) _dd_rest_available=$_dd_available
|
||||
else
|
||||
_dd_rest=0
|
||||
fi
|
||||
}
|
||||
dd_zram_wait() {
|
||||
local _p _left _start=$SECONDS
|
||||
while [ $((SECONDS - _start)) -lt 12 ]; do
|
||||
_left=0
|
||||
for _p in "$@"; do
|
||||
[ -s "/tmp/.dd-zram.ack.$_p" ] && continue
|
||||
[ -d "/proc/$_p" ] || continue
|
||||
[ $((SECONDS - _start)) -ge 2 ] && [ ! -e "/tmp/.dd-zram.ack.$_p" ] && continue
|
||||
_left=1
|
||||
done
|
||||
[ "$_left" = 1 ] || break
|
||||
nap 0.2
|
||||
done
|
||||
_dd_pageout_complete=1
|
||||
for _p in "$@"; do
|
||||
if [ -d "/proc/$_p" ] && [ ! -s "/tmp/.dd-zram.ack.$_p" ]; then _dd_pageout_complete=0; fi
|
||||
rm -f "/tmp/.dd-zram.ack.$_p"
|
||||
done
|
||||
dd_memory_note() {
|
||||
[ $((_dd_note_client + _dd_note_session)) -ge $((16 * 1024)) ] && [ $((SECONDS - _dd_noted_at)) -ge 5 ] || return 0
|
||||
step "memory: available $((_dd_available / 1024)) MB, falling $((_dd_rate / 1024)) MB/s, compressed $((_dd_note_client / 1024)) MB of the client and $((_dd_note_session / 1024)) MB of the session"
|
||||
_dd_note_client=0 _dd_note_session=0 _dd_noted_at=$SECONDS
|
||||
}
|
||||
dd_zram_send() {
|
||||
local _mode=$1 _what=$2 _which=$3 _pids _p
|
||||
dd_zram_pick "$_which"
|
||||
step "zRAM: $_what ($(dd_zram_usage "${_pids[@]}"))"
|
||||
for _p in "${_pids[@]}"; do rm -f "/tmp/.dd-zram.ack.$_p"; done
|
||||
printf '%s' "$_mode" > /tmp/.dd-zram
|
||||
[ "${#_pids[@]}" = 0 ] || kill -URG "${_pids[@]}" 2>/dev/null
|
||||
_dd_zram_targets=("${_pids[@]}")
|
||||
[ "${4:-}" != defer ] || return 0
|
||||
dd_zram_finish "$_mode" "${_pids[@]}"
|
||||
}
|
||||
dd_zram_finish() {
|
||||
local _mode=$1
|
||||
shift
|
||||
if [ "$_mode" = 1 ]; then dd_zram_wait "$@"; else nap 5; fi
|
||||
dd_zram_scan
|
||||
step "zRAM: done ($(dd_zram_usage "$@"))"
|
||||
dd_client_readback() {
|
||||
[ "$_dd_client_out" -gt 0 ] && [ "${#_dd_pids[@]}" -gt 0 ] || return 0
|
||||
[ "$_dd_game" = 0 ] || { [ -n "$_dd_away" ] && [ $((SECONDS - _dd_away)) -ge 5 ]; } || return 0
|
||||
[ $((SECONDS - _dd_trim_at)) -ge 30 ] || return 0
|
||||
dd_zram_usage "${_dd_pids[@]}" > /dev/null
|
||||
if [ "$_dd_swap" -lt $((16 * 1024)) ]; then
|
||||
_dd_client_out=0
|
||||
return 0
|
||||
fi
|
||||
[ $((_dd_available - _dd_swap)) -ge $((_dd_target + _dd_floor)) ] || return 0
|
||||
step "memory: available $((_dd_available / 1024)) MB, reading $((_dd_swap / 1024)) MB of the client back"
|
||||
printf 0 > /tmp/.dd-zram || return 0
|
||||
kill -URG "${_dd_pids[@]}" 2>/dev/null || return 0
|
||||
_dd_freed=$((_dd_freed - _dd_swap * _dd_saving / 1000))
|
||||
_dd_client_out=0 _dd_back_at=$SECONDS
|
||||
}
|
||||
dd_game_focused() {
|
||||
if [ "${DD_DESKTOP:-}" = 1 ] || [ -z "${DD_LAUNCH_DIR:-}" ]; then
|
||||
@@ -1131,92 +1076,40 @@ case $mode in
|
||||
esac
|
||||
return 1
|
||||
}
|
||||
dd_over_cap() {
|
||||
[ "$_dd_ram_cap" -gt 0 ] || return 1
|
||||
_dd_measured=$SECONDS
|
||||
dd_session_others
|
||||
dd_zram_usage "${_dd_pids[@]}" "${_dd_session[@]}" > /dev/null
|
||||
[ "$_dd_rss" -gt "$_dd_ram_cap" ]
|
||||
}
|
||||
dd_cap_due() {
|
||||
[ "$_dd_ram_cap" -gt 0 ] && { [ "$_dd_measured" -lt 0 ] || [ $((SECONDS - _dd_measured)) -ge 30 ]; }
|
||||
}
|
||||
_dd_since=-1 _dd_since_apps= _dd_packed=-1 _dd_measured=-1 _dd_unpack=0 _dd_capped=-1 _dd_backoff=30
|
||||
_dd_pressure_at=-1 _dd_pressure_backoff=30 _dd_tier_at=-1 _dd_tier_backoff=30 _dd_tier_nogain=0 _dd_tier_pushed=0 _dd_tier_back=0 _dd_tier_targets=() _dd_tier_swaps=() _dd_tier_starts=()
|
||||
_dd_client_pending=0 _dd_client_reserve=0 _dd_client_targets=() _dd_away=
|
||||
_dd_sample_at= _dd_sample_available=0 _dd_sample_gpu=0 _dd_sample_unevictable=0 _dd_sample_shmem=0
|
||||
while kill -0 $$ 2>/dev/null; do
|
||||
dd_zram_scan
|
||||
dd_memory_read
|
||||
if dd_cap_due; then
|
||||
if dd_over_cap; then
|
||||
if [ "$_dd_capped" -lt 0 ] || [ $((SECONDS - _dd_capped)) -ge "$_dd_backoff" ]; then
|
||||
dd_zram_usage "${_dd_pids[@]}" > /dev/null
|
||||
if [ "$_dd_rss" -ge $((512 * 1024)) ]; then
|
||||
dd_zram_send 1 "over the ${DD_RAM_CAP_MB} MB RAM cap, compressing the client" client
|
||||
[ "$_dd_game" = 1 ] && _dd_packed=$SECONDS
|
||||
else
|
||||
step "RAM cap: over, client already small ($((_dd_rss / 1024)) MB resident), skipping it"
|
||||
fi
|
||||
dd_over_cap && dd_zram_send 1 "still over the RAM cap, compressing the rest of the session" session
|
||||
if dd_over_cap; then
|
||||
_dd_backoff=$((_dd_backoff * 2 > 600 ? 600 : _dd_backoff * 2))
|
||||
step "RAM cap: still over after paging out, next try in ${_dd_backoff} s"
|
||||
else
|
||||
_dd_backoff=30
|
||||
fi
|
||||
_dd_capped=$SECONDS
|
||||
fi
|
||||
else
|
||||
_dd_backoff=30
|
||||
dd_memory_tick() {
|
||||
if [ $((SECONDS - _dd_scan_at)) -ge 5 ]; then
|
||||
_dd_scan_at=$SECONDS
|
||||
dd_zram_scan
|
||||
_dd_focus=1
|
||||
if [ "$_dd_game" = 1 ]; then
|
||||
dd_game_focused && _dd_focus=0 || _dd_focus=$?
|
||||
fi
|
||||
fi
|
||||
_dd_preserved_growth=$_dd_growth _dd_preserved_fall=$_dd_fall
|
||||
dd_client_pressure defer
|
||||
_dd_preserved_growth=$_dd_growth _dd_preserved_fall=$_dd_fall
|
||||
dd_session_pressure
|
||||
dd_client_pressure_finish
|
||||
_dd_focus=1
|
||||
[ "$_dd_game" = 1 ] && { dd_game_focused && _dd_focus=0 || _dd_focus=$?; }
|
||||
if [ "$_dd_game" = 1 ] && [ "$_dd_focus" = 0 ]; then
|
||||
_dd_away=
|
||||
if [ "$_dd_since" -lt 0 ] || [ "$_dd_since_apps" != "$_dd_apps" ]; then
|
||||
_dd_since=$SECONDS _dd_since_apps=$_dd_apps
|
||||
fi
|
||||
if [ "${DD_ZRAM_CLIENT:-1}" = 1 ] && [ $((SECONDS - _dd_since)) -ge 20 ] && [ "${#_dd_pids[@]}" -gt 0 ] &&
|
||||
{ [ "$_dd_packed" -lt 0 ] || [ $((SECONDS - _dd_packed)) -ge 300 ]; } && dd_client_can_pageout; then
|
||||
dd_zram_send 1 "compressing the client" client
|
||||
_dd_packed=$SECONDS
|
||||
fi
|
||||
elif [ "$_dd_game" != 1 ]; then
|
||||
_dd_away=
|
||||
if [ "$_dd_packed" -ge 0 ]; then
|
||||
_dd_unpack=1
|
||||
fi
|
||||
_dd_since=-1 _dd_packed=-1 _dd_tier_at=-1 _dd_tier_backoff=30 _dd_tier_nogain=0 _dd_tier_pushed=0 _dd_tier_targets=() _dd_tier_swaps=() _dd_tier_starts=()
|
||||
else
|
||||
_dd_since=-1
|
||||
if [ "$_dd_focus" = 1 ]; then
|
||||
[ -n "${_dd_away-}" ] || _dd_away=$SECONDS
|
||||
if [ "$_dd_game" = 1 ] && [ "$_dd_focus" = 1 ]; then
|
||||
[ -n "$_dd_away" ] || _dd_away=$SECONDS
|
||||
else
|
||||
_dd_away=
|
||||
fi
|
||||
if [ "$_dd_packed" -ge 0 ]; then
|
||||
_dd_unpack=1
|
||||
fi
|
||||
fi
|
||||
if [ "$_dd_unpack" = 1 ] &&
|
||||
{ [ "$_dd_game" = 0 ] || { [ "${_dd_ram_cap:-0}" = 0 ] && [ -n "${_dd_away-}" ] && [ $((SECONDS - _dd_away)) -ge 5 ]; }; } &&
|
||||
! dd_over_cap && dd_client_can_readback; then
|
||||
if [ "$_dd_game" = 0 ]; then
|
||||
dd_zram_send 0 "memory recovered, reading the client back" client
|
||||
else
|
||||
dd_zram_send 0 "the client is in front of the game, reading it back" client
|
||||
_dd_packed=-1
|
||||
fi
|
||||
_dd_unpack=0
|
||||
dd_memory_read
|
||||
[ ! -e /tmp/.dd-zram.hold ] || return 0
|
||||
dd_memory_relieve
|
||||
dd_memory_note
|
||||
[ "$_dd_need" -gt 0 ] || dd_client_readback
|
||||
}
|
||||
declare -A _dd_deaf=() _dd_preloaded=()
|
||||
_dd_scan_at=-5 _dd_session_at=-1 _dd_session=() _dd_focus=1 _dd_away=
|
||||
_dd_page_kb=$(($(getconf PAGESIZE 2>/dev/null || echo 4096) / 1024)) _dd_returned=0 _dd_polls=0 _dd_pass_at=0 _dd_goal=0
|
||||
_dd_sample_at= _dd_freed=0 _dd_client_out=0 _dd_note_client=0 _dd_note_session=0
|
||||
_dd_trim_at=-30 _dd_back_at=-30 _dd_forced_at=-10 _dd_full_at=-60 _dd_noted_at=-5
|
||||
_dd_rest=0 _dd_rest_until=0 _dd_rest_available=0
|
||||
while kill -0 $$ 2>/dev/null; do
|
||||
dd_memory_tick
|
||||
if [ "$_dd_available" -ge 0 ] &&
|
||||
{ [ "$_dd_available" -lt $((_dd_mem_total * 2 / 5)) ] || [ "$_dd_rate" -ge $((16 * 1024)) ]; }; then
|
||||
nap 1
|
||||
else
|
||||
nap 5
|
||||
fi
|
||||
dd_watch_nap
|
||||
done
|
||||
) &
|
||||
fi
|
||||
|
||||
+167
-30
@@ -20,7 +20,16 @@
|
||||
#define ZR_CTL "/tmp/.dd-zram"
|
||||
#endif
|
||||
#define ZR_SWAPPED (1ULL << 62)
|
||||
#define ZR_PRESENT (1ULL << 63)
|
||||
#define ZR_BATCH 512
|
||||
#define ZR_CHUNK (1UL << 20)
|
||||
#define ZR_SLOTS 32768UL
|
||||
#define ZR_PROBES 16
|
||||
#define ZR_HEAT_MAX 3
|
||||
#define ZR_SKIP 32U
|
||||
#define ZR_INLINE_KB (32UL << 10)
|
||||
#define ZR_INLINE_CHUNKS 512UL
|
||||
#define ZR_FAILED (~0UL)
|
||||
#define ZR_FUTEX_WAIT 0
|
||||
#define ZR_FUTEX_WAKE 1
|
||||
|
||||
@@ -33,18 +42,43 @@ static char zr_maps[8192];
|
||||
static uint64_t zr_entries[ZR_BATCH];
|
||||
static struct iovec zr_iov[ZR_BATCH];
|
||||
static char zr_sink[ZR_BATCH];
|
||||
static struct zr_slot {
|
||||
unsigned long key;
|
||||
uint16_t gen;
|
||||
uint16_t pushed;
|
||||
uint16_t kept;
|
||||
uint8_t heat;
|
||||
uint8_t skip;
|
||||
} zr_slots[ZR_SLOTS];
|
||||
static uint16_t zr_gen = 1;
|
||||
static unsigned long zr_cursor;
|
||||
static unsigned long zr_visits;
|
||||
|
||||
static int zr_open(const char *path) {
|
||||
return (int)zr_sys(SYS_openat, AT_FDCWD, path, O_RDONLY | O_CLOEXEC, 0);
|
||||
}
|
||||
|
||||
static int zr_mode(void) {
|
||||
char c = 0;
|
||||
int fd = zr_open(ZR_CTL);
|
||||
if (fd < 0) return -1;
|
||||
long n = zr_sys(SYS_read, fd, &c, 1);
|
||||
zr_sys(SYS_close, fd);
|
||||
return n == 1 && (c == '0' || c == '1') ? c - '0' : -1;
|
||||
static int zr_mode(unsigned long *want) {
|
||||
char text[24];
|
||||
long n = 0;
|
||||
int fd = zr_open(ZR_CTL ".hold");
|
||||
if (fd >= 0) {
|
||||
n = zr_sys(SYS_read, fd, text, sizeof(text));
|
||||
zr_sys(SYS_close, fd);
|
||||
}
|
||||
if (n < 1) {
|
||||
fd = zr_open(ZR_CTL);
|
||||
if (fd < 0) return -1;
|
||||
n = zr_sys(SYS_read, fd, text, sizeof(text));
|
||||
zr_sys(SYS_close, fd);
|
||||
}
|
||||
if (n < 1 || text[0] < '0' || text[0] > '3') return -1;
|
||||
unsigned long kb = 0;
|
||||
for (long i = 2; i < n && text[i] >= '0' && text[i] <= '9'; i++)
|
||||
kb = kb * 10 + (unsigned long)(text[i] - '0');
|
||||
*want = kb / (zr_page / 1024);
|
||||
if (text[0] >= '2' && *want == 0) return -1;
|
||||
return text[0] - '0';
|
||||
}
|
||||
|
||||
static unsigned long zr_hex(const char **p) {
|
||||
@@ -96,16 +130,103 @@ static void zr_read_back(int pagemap, unsigned long start, unsigned long end) {
|
||||
}
|
||||
}
|
||||
|
||||
static void zr_walk(int compress) {
|
||||
int maps = zr_open("/proc/self/maps");
|
||||
if (maps < 0) return;
|
||||
int pagemap = compress ? -1 : zr_open("/proc/self/pagemap");
|
||||
if (!compress && pagemap < 0) {
|
||||
zr_sys(SYS_close, maps);
|
||||
return;
|
||||
static unsigned long zr_count(int pagemap, unsigned long start, unsigned long end, uint64_t bit) {
|
||||
unsigned long count = 0;
|
||||
long size = (long)((end - start) / zr_page * sizeof(uint64_t));
|
||||
long got;
|
||||
do {
|
||||
if (zr_sys(SYS_lseek, pagemap, (long)(start / zr_page * sizeof(uint64_t)), SEEK_SET) < 0) return ZR_FAILED;
|
||||
got = zr_sys(SYS_read, pagemap, zr_entries, size);
|
||||
} while (got < 0 && errno == EINTR);
|
||||
if (got != size) return ZR_FAILED;
|
||||
for (long i = 0; i < got / (long)sizeof(uint64_t); i++)
|
||||
if (zr_entries[i] & bit) count++;
|
||||
return count;
|
||||
}
|
||||
|
||||
static struct zr_slot *zr_slot(unsigned long addr, int create) {
|
||||
unsigned long key = addr / zr_page + 1;
|
||||
unsigned long home = key * 2654435761UL % ZR_SLOTS;
|
||||
for (unsigned long i = 0; i < ZR_PROBES; i++) {
|
||||
struct zr_slot *slot = &zr_slots[(home + i) % ZR_SLOTS];
|
||||
if (slot->key == key) return slot;
|
||||
if (slot->key == 0 && !create) return NULL;
|
||||
if (slot->key == 0) {
|
||||
slot->key = key;
|
||||
return slot;
|
||||
}
|
||||
}
|
||||
if (!create) return NULL;
|
||||
memset(&zr_slots[home], 0, sizeof(zr_slots[home]));
|
||||
zr_slots[home].key = key;
|
||||
return &zr_slots[home];
|
||||
}
|
||||
|
||||
static unsigned long zr_trim(int pagemap, unsigned long start, unsigned long end,
|
||||
unsigned long want, int force, unsigned long lo, unsigned long hi) {
|
||||
unsigned long done = 0;
|
||||
for (unsigned long addr = start, next; addr < end && done < want; addr = next) {
|
||||
next = (addr | (ZR_CHUNK - 1)) + 1;
|
||||
if (next > end || next < addr) next = end;
|
||||
if (next <= lo || addr >= hi) continue;
|
||||
if (zr_visits == 0) break;
|
||||
zr_visits--;
|
||||
zr_cursor = next;
|
||||
if (addr < (unsigned long)(zr_slots + ZR_SLOTS) && next > (unsigned long)zr_slots) continue;
|
||||
unsigned long present = zr_count(pagemap, addr, next, ZR_PRESENT);
|
||||
if (present == ZR_FAILED) continue;
|
||||
struct zr_slot *slot = zr_slot(addr, 0);
|
||||
if (slot != NULL && slot->gen == zr_gen && slot->pushed > 0) {
|
||||
if (present > slot->kept && (present - slot->kept) * 4 > slot->pushed) {
|
||||
if (slot->heat < ZR_HEAT_MAX) slot->heat++;
|
||||
slot->skip = (uint8_t)(ZR_SKIP << slot->heat > 255 ? 255 : ZR_SKIP << slot->heat);
|
||||
slot->pushed = 0;
|
||||
} else if (slot->heat > 0) {
|
||||
slot->heat--;
|
||||
}
|
||||
}
|
||||
if (slot != NULL && slot->skip > 0 && !force) {
|
||||
slot->skip--;
|
||||
continue;
|
||||
}
|
||||
if (present == 0) continue;
|
||||
unsigned long from = addr < lo ? lo : addr;
|
||||
unsigned long left = present;
|
||||
while (from < next && done + present - left < want) {
|
||||
unsigned long budget = want - done - (present - left);
|
||||
unsigned long i = (from - addr) / zr_page;
|
||||
for (; i < (next - addr) / zr_page && budget > 0; i++)
|
||||
if (zr_entries[i] & ZR_PRESENT) budget--;
|
||||
unsigned long to = addr + i * zr_page;
|
||||
zr_sys(SYS_madvise, from, to - from, MADV_PAGEOUT);
|
||||
from = to;
|
||||
unsigned long now = zr_count(pagemap, addr, next, ZR_PRESENT);
|
||||
if (now == ZR_FAILED) break;
|
||||
left = now < present ? now : present;
|
||||
}
|
||||
if (from < next) zr_cursor = from;
|
||||
if (left >= present) continue;
|
||||
if (slot == NULL) slot = zr_slot(addr, 1);
|
||||
if (slot->gen != zr_gen) slot->pushed = 0;
|
||||
slot->gen = zr_gen;
|
||||
slot->pushed = (uint16_t)(slot->pushed + present - left);
|
||||
slot->kept = (uint16_t)left;
|
||||
done += present - left;
|
||||
}
|
||||
return done;
|
||||
}
|
||||
|
||||
static unsigned long zr_walk(int mode, unsigned long want, unsigned long lo, unsigned long hi) {
|
||||
int maps = zr_open("/proc/self/maps");
|
||||
if (maps < 0) return 0;
|
||||
int pagemap = mode == 1 ? -1 : zr_open("/proc/self/pagemap");
|
||||
if (mode != 1 && pagemap < 0) {
|
||||
zr_sys(SYS_close, maps);
|
||||
return 0;
|
||||
}
|
||||
unsigned long done = 0;
|
||||
size_t have = 0;
|
||||
for (;;) {
|
||||
while (done < want && zr_visits > 0) {
|
||||
long n = zr_sys(SYS_read, maps, zr_maps + have, sizeof(zr_maps) - 1 - have);
|
||||
if (n < 0 && errno == EINTR) continue;
|
||||
if (n <= 0) break;
|
||||
@@ -113,12 +234,13 @@ static void zr_walk(int compress) {
|
||||
zr_maps[have] = 0;
|
||||
char *line = zr_maps;
|
||||
char *nl;
|
||||
while ((nl = memchr(line, '\n', have - (size_t)(line - zr_maps))) != NULL) {
|
||||
while (done < want && zr_visits > 0 && (nl = memchr(line, '\n', have - (size_t)(line - zr_maps))) != NULL) {
|
||||
*nl = 0;
|
||||
unsigned long s, e;
|
||||
if (zr_eligible(line, compress, &s, &e) && e > s) {
|
||||
if (compress) zr_sys(SYS_madvise, s, e - s, MADV_PAGEOUT);
|
||||
else zr_read_back(pagemap, s, e);
|
||||
if (zr_eligible(line, mode != 0, &s, &e) && e > s) {
|
||||
if (mode == 0) zr_read_back(pagemap, s, e);
|
||||
else if (mode == 1) zr_sys(SYS_madvise, s, e - s, MADV_PAGEOUT);
|
||||
else done += zr_trim(pagemap, s, e, want - done, mode == 3, lo, hi);
|
||||
}
|
||||
line = nl + 1;
|
||||
}
|
||||
@@ -128,11 +250,12 @@ static void zr_walk(int compress) {
|
||||
}
|
||||
if (pagemap >= 0) zr_sys(SYS_close, pagemap);
|
||||
zr_sys(SYS_close, maps);
|
||||
return done;
|
||||
}
|
||||
|
||||
static void zr_ack(int done) {
|
||||
static const char suffix[] = ".ack.";
|
||||
char path[sizeof(ZR_CTL) + sizeof(suffix) + 20];
|
||||
static void zr_ack(long value, int trim) {
|
||||
const char *suffix = trim ? ".trim." : ".ack.";
|
||||
char path[sizeof(ZR_CTL) + sizeof(".trim.") + 20];
|
||||
char digits[20];
|
||||
size_t n = 0, d = 0;
|
||||
for (const char *p = ZR_CTL; *p; p++) path[n++] = *p;
|
||||
@@ -143,15 +266,29 @@ static void zr_ack(int done) {
|
||||
path[n] = 0;
|
||||
int fd = (int)zr_sys(SYS_openat, AT_FDCWD, path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0600);
|
||||
if (fd < 0) return;
|
||||
if (done) zr_sys(SYS_write, fd, "1", 1UL);
|
||||
for (d = 0; value >= 0 && (d == 0 || value > 0); value /= 10) digits[d++] = (char)('0' + value % 10);
|
||||
for (n = 0; d > 0;) path[n++] = digits[--d];
|
||||
if (n > 0) zr_sys(SYS_write, fd, path, n);
|
||||
zr_sys(SYS_close, fd);
|
||||
}
|
||||
|
||||
static void zr_request(void) {
|
||||
int mode = zr_mode();
|
||||
if (mode == 1) zr_ack(0);
|
||||
if (mode >= 0) zr_walk(mode);
|
||||
if (mode == 1) zr_ack(1);
|
||||
static void zr_request(int worker) {
|
||||
unsigned long want = 0;
|
||||
int mode = zr_mode(&want);
|
||||
if (mode < 0) return;
|
||||
if (!worker && want > ZR_INLINE_KB / (zr_page / 1024)) want = ZR_INLINE_KB / (zr_page / 1024);
|
||||
zr_visits = worker ? ZR_FAILED : ZR_INLINE_CHUNKS;
|
||||
if (mode > 0) zr_ack(-1, mode > 1);
|
||||
if (mode < 2) {
|
||||
zr_walk(mode, 1, 0, 0);
|
||||
zr_gen++;
|
||||
if (mode == 1) zr_ack(1, 0);
|
||||
return;
|
||||
}
|
||||
unsigned long from = zr_cursor;
|
||||
unsigned long done = zr_walk(mode, want, from, ~0UL);
|
||||
if (done < want && from > 0) done += zr_walk(mode, want - done, 0, from);
|
||||
zr_ack((long)(done * (zr_page / 1024)), 1);
|
||||
}
|
||||
|
||||
static void *zr_worker_main(void *unused) {
|
||||
@@ -160,7 +297,7 @@ static void *zr_worker_main(void *unused) {
|
||||
for (;;) {
|
||||
while (!__atomic_exchange_n(&zr_pending, 0, __ATOMIC_SEQ_CST))
|
||||
zr_sys(SYS_futex, &zr_pending, ZR_FUTEX_WAIT, 0, NULL, NULL, 0);
|
||||
zr_request();
|
||||
zr_request(1);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
@@ -176,7 +313,7 @@ static void zr_handler(int sig, siginfo_t *info, void *context) {
|
||||
} else while (__atomic_load_n(&zr_pending, __ATOMIC_SEQ_CST)
|
||||
&& !__atomic_exchange_n(&zr_busy, 1, __ATOMIC_SEQ_CST)) {
|
||||
__atomic_store_n(&zr_pending, 0, __ATOMIC_SEQ_CST);
|
||||
zr_request();
|
||||
zr_request(0);
|
||||
__atomic_store_n(&zr_busy, 0, __ATOMIC_SEQ_CST);
|
||||
}
|
||||
errno = saved;
|
||||
|
||||
Reference in new issue
Block a user