fix(memory): reclaim idle session memory under pressure (#2382)

This commit is contained in:
MaxsTechReview authored and GitHub committed 2026-11-12 07:38:28 -05:00
1 parent da5a36151b
commit a8237e8927
7 files changed
+379 -82

No files matched your search

@@ -811,19 +811,30 @@ case $mode in
fi
}
bl_zram_usage() {
local _p _k _v _u _rss=0 _swap=0
local _p _k _v _u _resident _anonymous _rss=0 _anon=0 _swap=0
for _p in "$@"; do
_resident=0 _anonymous=-1
while read -r _k _v _u; do
case $_k in VmRSS:) _rss=$((_rss + _v)) ;; VmSwap:) _swap=$((_swap + _v)) ;; esac
case $_v in ''|*[!0-9]*) continue ;; esac
case $_k in
VmRSS:) _resident=$_v ;;
RssAnon:) _anonymous=$_v ;;
VmSwap:) _swap=$((_swap + _v)) ;;
esac
done 2>/dev/null < "/proc/$_p/status"
[ "$_anonymous" -ge 0 ] || _anonymous=$_resident
_rss=$((_rss + _resident)) _anon=$((_anon + _anonymous))
done
_bl_rss=$_rss
_bl_rss=$_rss _bl_anon=$_anon
_bl_swap=$_swap
echo "$# processes, resident $((_rss / 1024)) MB, in zram $((_swap / 1024)) MB"
}
bl_memory_read() {
local _k _v _u _kind _fields _avg
_bl_mem_total=0 _bl_available=-1 _bl_swap_total=0 _bl_swap_free=-1 _bl_psi=0
local _k _v _u _kind _fields _avg _whole _frac _gpu_bytes _growth _saved_growth _saved_fall
_saved_growth=${_bl_preserved_growth:-0} _saved_fall=${_bl_preserved_fall:-0}
_bl_preserved_growth=0 _bl_preserved_fall=0
_bl_mem_total=0 _bl_available=-1 _bl_swap_total=0 _bl_swap_free=-1
_bl_psi_some=0 _bl_psi_full=0 _bl_gpu=0 _bl_unevictable=0 _bl_shmem=0
while read -r _k _v _u; do
case $_v in ''|*[!0-9]*) continue ;; esac
case $_k in
@@ -831,15 +842,50 @@ case $mode in
MemAvailable:) _bl_available=$_v ;;
SwapTotal:) _bl_swap_total=$_v ;;
SwapFree:) _bl_swap_free=$_v ;;
Unevictable:) _bl_unevictable=$_v ;;
Shmem:) _bl_shmem=$_v ;;
esac
done 2>/dev/null < /proc/meminfo
if [ -r /proc/pressure/memory ]; then
while read -r _kind _fields; do
[ "$_kind" = some ] || continue
_avg=${_fields#avg10=} _avg=${_avg%% *} _avg=${_avg%%.*}
case $_avg in ''|*[!0-9]*) ;; *) _bl_psi=$((10#$_avg)) ;; esac
[ "$_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
_bl_psi_some=$((10#$_whole * 100 + 10#$_frac))
else
_bl_psi_full=$((10#$_whole * 100 + 10#$_frac))
fi
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
_bl_gpu=$((_gpu_bytes / 1024))
fi
_bl_psi=$_bl_psi_some
[ "$_bl_psi_full" -gt "$_bl_psi" ] && _bl_psi=$_bl_psi_full
if [ "${_bl_sample_at:-}" = "" ]; then
_bl_growth=0 _bl_fall=0
_bl_sample_at=$SECONDS _bl_sample_available=$_bl_available _bl_sample_gpu=$_bl_gpu
_bl_sample_unevictable=$_bl_unevictable _bl_sample_shmem=$_bl_shmem
elif [ "$SECONDS" -gt "$_bl_sample_at" ]; then
_bl_growth=0 _bl_fall=0
_growth=$((_bl_gpu - _bl_sample_gpu)); [ "$_growth" -gt 0 ] && _bl_growth=$((_bl_growth + _growth))
_growth=$((_bl_unevictable - _bl_sample_unevictable)); [ "$_growth" -gt 0 ] && _bl_growth=$((_bl_growth + _growth))
_growth=$((_bl_shmem - _bl_sample_shmem)); [ "$_growth" -gt 0 ] && _bl_growth=$((_bl_growth + _growth))
_bl_fall=$((_bl_sample_available - _bl_available))
[ "$_saved_growth" -gt "$_bl_growth" ] && _bl_growth=$_saved_growth
[ "$_saved_fall" -gt "$_bl_fall" ] && _bl_fall=$_saved_fall
_bl_sample_at=$SECONDS _bl_sample_available=$_bl_available _bl_sample_gpu=$_bl_gpu
_bl_sample_unevictable=$_bl_unevictable _bl_sample_shmem=$_bl_shmem
fi
_bl_real_available=$_bl_available
[ "$_bl_real_available" -ge 0 ] && _bl_real_available=$((_bl_real_available - _bl_growth))
_bl_headroom=$((_bl_mem_total / 5))
[ "$_bl_headroom" -ge $((512 * 1024)) ] || _bl_headroom=$((512 * 1024))
[ "$_bl_headroom" -le $((1536 * 1024)) ] || _bl_headroom=$((1536 * 1024))
@@ -851,25 +897,29 @@ case $mode in
}
bl_memory_tight() {
[ "$_bl_mem_total" -gt 0 ] && [ "$_bl_available" -ge 0 ] &&
{ [ "$_bl_available" -lt "$_bl_headroom" ] ||
{ [ "$_bl_psi" -ge 1 ] && [ "$_bl_available" -lt $((_bl_mem_total / 3)) ]; }; }
{ [ "$_bl_real_available" -lt "$_bl_headroom" ] ||
{ [ "$_bl_psi" -ge 100 ] && [ "$_bl_real_available" -lt $((_bl_mem_total / 3)) ]; } ||
{ [ "$_bl_fall" -ge $((256 * 1024)) ] && [ "$_bl_real_available" -lt $((_bl_headroom * 2)) ]; }; }
}
bl_client_can_pageout() {
bl_memory_read
bl_zram_usage "${_bl_pids[@]}" > /dev/null
[ "$_bl_mem_total" -gt 0 ] && [ "$_bl_swap_total" -gt 0 ] &&
[ $((_bl_swap_free - _bl_rss)) -ge "$_bl_swap_reserve" ]
[ "$_bl_mem_total" -gt 0 ] && bl_zram_has_room
}
bl_zram_has_room() {
[ "$_bl_swap_total" -gt 0 ] &&
[ $((_bl_swap_free - _bl_anon - ${_bl_client_reserve:-0})) -ge "$_bl_swap_reserve" ]
}
bl_client_can_readback() {
bl_memory_read
bl_zram_usage "${_bl_pids[@]}" > /dev/null
[ "$_bl_mem_total" -gt 0 ] && ! bl_memory_tight &&
[ "$_bl_available" -ge $((_bl_swap * 2)) ] &&
[ $((_bl_available - _bl_swap)) -ge "$_bl_headroom" ]
[ "$_bl_mem_total" -gt 0 ] && ! bl_memory_tight && ! bl_memory_critical &&
[ "$_bl_real_available" -ge $((_bl_swap * 2)) ] &&
[ $((_bl_real_available - _bl_swap)) -ge "$_bl_headroom" ]
}
bl_client_pressure() {
[ "${BL_ZRAM_CLIENT:-1}" = 1 ] && [ "$_bl_game" = 1 ] &&
[ "${#_bl_pids[@]}" -gt 0 ] && bl_memory_tight || return 0
[ "${#_bl_pids[@]}" -gt 0 ] && { bl_memory_tight || bl_memory_critical; } || return 0
[ "$_bl_pressure_at" -lt 0 ] ||
[ $((SECONDS - _bl_pressure_at)) -ge "$_bl_pressure_backoff" ] || return 0
[ "$_bl_packed" -lt 0 ] || [ $((SECONDS - _bl_packed)) -ge 30 ] || return 0
@@ -879,12 +929,29 @@ case $mode in
return 0
fi
[ "$_bl_rss" -ge $((128 * 1024)) ] || return 0
local _before=$_bl_rss
bl_zram_send 1 "memory pressure, compressing the client (available $((_bl_available / 1024)) MB, swap free $((_bl_swap_free / 1024)) MB)" client
_bl_pressure_before=$_bl_rss
if [ "${1:-}" = defer ]; then
_bl_client_reserve=$_bl_anon
_bl_client_pending=1
fi
bl_zram_send 1 "memory pressure, compressing the client (available $((_bl_available / 1024)) MB, swap free $((_bl_swap_free / 1024)) MB)" client "${1:-}"
_bl_packed=$SECONDS
if [ "${1:-}" = defer ]; then
_bl_client_targets=("${_bl_zram_targets[@]}")
else
bl_client_pressure_result
fi
}
bl_client_pressure_finish() {
[ "${_bl_client_pending:-0}" = 1 ] || return 0
bl_zram_finish 1 "${_bl_client_targets[@]}"
bl_client_pressure_result "${_bl_client_targets[@]}"
_bl_client_pending=0 _bl_client_reserve=0 _bl_client_targets=()
}
bl_client_pressure_result() {
[ "${_bl_pageout_complete:-0}" = 1 ] || return 0
bl_zram_usage "${_bl_pids[@]}" > /dev/null
if [ $((_before - _bl_rss)) -lt $((16 * 1024)) ]; then
if [ "$#" -gt 0 ]; then bl_zram_usage "$@" > /dev/null; else bl_zram_usage "${_bl_pids[@]}" > /dev/null; fi
if [ $((_bl_pressure_before - _bl_rss)) -lt $((16 * 1024)) ]; then
_bl_pressure_backoff=$((_bl_pressure_backoff * 2 > 300 ? 300 : _bl_pressure_backoff * 2))
else
_bl_pressure_backoff=30
@@ -892,15 +959,13 @@ case $mode in
}
bl_memory_critical() {
[ "$_bl_mem_total" -gt 0 ] && [ "$_bl_available" -ge 0 ] &&
{ [ "$_bl_available" -lt "$_bl_tier_headroom" ] ||
{ [ "$_bl_psi" -ge 1 ] && [ "$_bl_available" -lt $((_bl_tier_headroom * 3 / 2)) ]; }; }
}
bl_low_ram() {
[ "$_bl_mem_total" -gt 0 ] && [ "$_bl_mem_total" -le $((13 * 1024 * 1024)) ]
{ [ "$_bl_real_available" -lt "$_bl_tier_headroom" ] ||
{ [ "$_bl_psi" -ge 100 ] && [ "$_bl_real_available" -lt $((_bl_tier_headroom * 3 / 2)) ]; } ||
{ [ "$_bl_fall" -ge $((256 * 1024)) ] && [ "$_bl_real_available" -lt $((_bl_tier_headroom * 2)) ]; }; }
}
bl_session_pressure() {
bl_memory_read
[ "$_bl_game" = 1 ] && bl_low_ram && bl_memory_critical || return 0
[ "$_bl_game" = 1 ] && bl_memory_critical || return 0
local _wait=$_bl_tier_backoff _before _pids _targets
[ "$_bl_available" -ge $((_bl_headroom / 2)) ] || [ "$_bl_tier_pushed" -lt 0 ] || _wait=30
[ "$_bl_tier_at" -lt 0 ] || [ $((SECONDS - _bl_tier_at)) -ge "$_wait" ] || return 0
@@ -916,21 +981,18 @@ case $mode in
fi
fi
_bl_tier_at=$SECONDS _bl_tier_pushed=0
bl_zram_pick game
bl_zram_pick session
bl_zram_usage "${_pids[@]}" > /dev/null
[ "$_bl_rss" -ge $((256 * 1024)) ] || return 0
if [ "$_bl_swap_total" -le 0 ] || [ $((_bl_swap_free - _bl_rss)) -lt "$_bl_swap_reserve" ]; then
if ! bl_zram_has_room; then
step "zRAM: low-memory page-out skipped, swap headroom too small ($((_bl_swap_free / 1024)) MB free)"
return 0
fi
_targets=("${_pids[@]}") _before=$_bl_swap
bl_zram_send 1 "low memory (available $((_bl_available / 1024)) MB), compressing idle game memory" game
bl_zram_send 1 "low memory (available $((_bl_real_available / 1024)) MB), compressing idle game memory" session
bl_zram_usage "${_targets[@]}" > /dev/null
_bl_tier_pushed=$((_bl_swap - _before))
bl_tier_note "${_targets[@]}"
if [ "${_bl_pageout_complete:-0}" = 1 ] && [ "${BL_ZRAM_CLIENT:-1}" = 1 ] && [ "${#_bl_pids[@]}" -gt 0 ]; then
_bl_pressure_at=$SECONDS _bl_packed=$SECONDS
fi
}
bl_proc_start() {
local _s=
@@ -961,7 +1023,7 @@ case $mode in
}
bl_watch_nap() {
local _i
if [ "$_bl_game" = 1 ] && bl_low_ram && [ "$_bl_available" -ge 0 ] && [ "$_bl_available" -lt $((_bl_tier_headroom * 2)) ]; then
if [ "$_bl_game" = 1 ] && [ "$_bl_available" -ge 0 ] && [ "$_bl_real_available" -lt $((_bl_tier_headroom * 2)) ]; then
for _i in 1 2 3 4 5; do
nap 1
bl_memory_read
@@ -1017,10 +1079,16 @@ case $mode in
for _p in "${_pids[@]}"; do rm -f "/tmp/.bl-zram.ack.$_p"; done
printf '%s' "$_mode" > /tmp/.bl-zram
[ "${#_pids[@]}" = 0 ] || kill -URG "${_pids[@]}" 2>/dev/null
if [ "$_mode" = 1 ]; then bl_zram_wait "${_pids[@]}"; else nap 5; fi
_bl_zram_targets=("${_pids[@]}")
[ "${4:-}" != defer ] || return 0
bl_zram_finish "$_mode" "${_pids[@]}"
}
bl_zram_finish() {
local _mode=$1
shift
if [ "$_mode" = 1 ]; then bl_zram_wait "$@"; else nap 5; fi
bl_zram_scan
bl_zram_pick "$_which"
step "zRAM: done ($(bl_zram_usage "${_pids[@]}"))"
step "zRAM: done ($(bl_zram_usage "$@"))"
}
bl_game_focused() {
if [ "${BL_DESKTOP:-}" = 1 ] || [ -z "${BL_LAUNCH_DIR:-}" ]; then
@@ -1047,6 +1115,8 @@ case $mode in
}
_bl_since=-1 _bl_since_apps= _bl_packed=-1 _bl_measured=-1 _bl_unpack=0 _bl_capped=-1 _bl_backoff=30
_bl_pressure_at=-1 _bl_pressure_backoff=30 _bl_tier_at=-1 _bl_tier_backoff=30 _bl_tier_pushed=0 _bl_tier_back=0 _bl_tier_targets=() _bl_tier_swaps=() _bl_tier_starts=()
_bl_client_pending=0 _bl_client_reserve=0 _bl_client_targets=()
_bl_sample_at= _bl_sample_available=0 _bl_sample_gpu=0 _bl_sample_unevictable=0 _bl_sample_shmem=0
while kill -0 $$ 2>/dev/null; do
bl_zram_scan
bl_memory_read
@@ -1073,8 +1143,11 @@ case $mode in
_bl_backoff=30
fi
fi
_bl_preserved_growth=$_bl_growth _bl_preserved_fall=$_bl_fall
bl_client_pressure defer
_bl_preserved_growth=$_bl_growth _bl_preserved_fall=$_bl_fall
bl_session_pressure
bl_client_pressure
bl_client_pressure_finish
if [ "$_bl_game" = 1 ] && bl_game_focused; then
if [ "$_bl_since" -lt 0 ] || [ "$_bl_since_apps" != "$_bl_apps" ]; then
_bl_since=$SECONDS _bl_since_apps=$_bl_apps
+1
View File
@@ -121,6 +121,7 @@ step() { :; }
bl_zram_scan() { :; }
bl_memory_read() { :; }
bl_client_pressure() { :; }
bl_client_pressure_finish() { :; }
bl_session_pressure() { :; }
bl_client_can_pageout() { return 0; }
bl_client_can_readback() { [ "${readback:-1}" = 1 ]; }
+177 -26
View File
@@ -2,7 +2,7 @@ from pathlib import Path
import tempfile
import unittest
from tools.tests.test_client_zram_focus import function_source, run_bash
from tools.tests.test_client_zram_focus import SCRIPT, function_source, run_bash
class MemoryPressureTest(unittest.TestCase):
@@ -20,8 +20,8 @@ class MemoryPressureTest(unittest.TestCase):
def run_policy(self, body):
functions = '\n'.join(function_source(name) for name in (
'bl_memory_read', 'bl_memory_tight', 'bl_client_can_pageout',
'bl_client_can_readback', 'bl_client_pressure'))
'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical', 'bl_client_can_pageout',
'bl_client_can_readback', 'bl_client_pressure', 'bl_client_pressure_result', 'bl_zram_has_room'))
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
harness = '''
@@ -29,7 +29,7 @@ set -u
_bl_pids=(123) _bl_game=1 _bl_packed=-1 _bl_pressure_at=-1 _bl_pressure_backoff=30
rss=$((384 * 1024)) client_swap=$((512 * 1024)) reclaimed=$((128 * 1024))
step() { :; }
bl_zram_usage() { _bl_rss=$rss _bl_swap=$client_swap; }
bl_zram_usage() { _bl_rss=$rss _bl_anon=${anon:-$rss} _bl_swap=$client_swap; }
bl_zram_send() { echo "send:$1:$3"; rss=$((rss - reclaimed)); _bl_pageout_complete=${pageout_complete:-1}; }
''' + functions + '\nbl_memory_read\n' + body
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
@@ -80,6 +80,13 @@ if bl_client_can_readback; then echo yes; else echo no; fi
self.assertEqual(['no'], self.run_policy('''
bl_client_pressure
if bl_client_can_pageout; then echo yes; else echo no; fi
'''))
def test_client_swap_budget_excludes_file_backed_memory(self):
self.memory(swap_free=1536)
self.assertEqual(['send:1:client'], self.run_policy('''
rss=$((2048 * 1024)) anon=$((256 * 1024))
bl_client_pressure
'''))
def test_without_swap_automatic_pageout_is_disabled(self):
@@ -152,20 +159,20 @@ class SessionPressureTest(unittest.TestCase):
def run_policy(self, body):
functions = '\n'.join(function_source(name) for name in (
'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical', 'bl_low_ram',
'bl_session_pressure', 'bl_watch_nap', 'bl_zram_pick', 'bl_tier_note', 'bl_tier_readback'))
'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical',
'bl_session_pressure', 'bl_zram_has_room', 'bl_watch_nap', 'bl_zram_pick', 'bl_tier_note', 'bl_tier_readback'))
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
harness = '''
set -u
_bl_game=1 _bl_tier_at=-1 _bl_tier_backoff=30 _bl_tier_pushed=0 _bl_tier_back=0 _bl_tier_targets=() _bl_tier_swaps=() _bl_tier_starts=() _bl_pids=(999)
_bl_pressure_at=-1 _bl_packed=-1
rss=$((1536 * 1024)) swap=0 pushed=$((1024 * 1024)) alive=999 started=100 complete=1
rss=$((1536 * 1024)) swap=0 pushed=$((1024 * 1024)) alive="999 321 654" started=100 complete=1
step() { :; }
bl_proc_start() { _bl_start=; case " $alive " in *" $1 "*) _bl_start=$started; return 0 ;; esac; return 1; }
nap() { echo "nap:$1"; }
bl_session_others() { _bl_session=(321 654); }
bl_zram_usage() { _bl_rss=$rss _bl_swap=$swap; }
bl_zram_usage() { _bl_rss=$rss _bl_anon=${anon:-$rss} _bl_swap=$swap; }
bl_zram_send() { echo "send:$1:$3"; rss=$((rss - pushed)); swap=$((swap + pushed)); _bl_pageout_complete=$complete; }
''' + functions + '\nbl_memory_read\n' + body
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
@@ -174,19 +181,27 @@ bl_zram_send() { echo "send:$1:$3"; rss=$((rss - pushed)); swap=$((swap + pushed
return result.stdout.splitlines()
def test_low_headroom_compresses_the_game_session_at_most_every_30_seconds(self):
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
SECONDS=0; bl_session_pressure
SECONDS=10; bl_session_pressure
SECONDS=29; bl_session_pressure
SECONDS=30; bl_session_pressure
'''))
def test_twelve_gigabyte_devices_are_included_and_larger_ones_are_not(self):
for total, expected in ((11264, ['send:1:game']), (12288, ['send:1:game']), (15360, [])):
def test_pressure_policy_is_independent_of_ram_size(self):
for total, expected in ((11264, ['send:1:session']), (12288, ['send:1:session']), (16384, ['send:1:session'])):
with self.subTest(total=total):
self.memory(total=total)
self.assertEqual(expected, self.run_policy('bl_session_pressure'))
def test_large_device_with_real_headroom_does_not_reclaim(self):
self.memory(total=16384, available=5120, psi='12.34')
self.assertEqual([], self.run_policy('bl_session_pressure'))
def test_large_device_with_psi_and_moderate_headroom_reclaims(self):
self.memory(total=16384, available=3072, psi='1.23')
self.assertEqual(['send:1:session'], self.run_policy('bl_session_pressure'))
def test_no_game_does_not_compress_the_session(self):
self.assertEqual([], self.run_policy('_bl_game=0; bl_session_pressure'))
@@ -196,15 +211,26 @@ SECONDS=30; bl_session_pressure
def test_stalls_with_moderate_headroom_compress_before_the_hard_limit(self):
self.memory(available=2048, psi='1.50')
self.assertEqual(['send:1:game'], self.run_policy('bl_session_pressure'))
self.assertEqual(['send:1:session'], self.run_policy('bl_session_pressure'))
def test_moderate_headroom_without_stalls_waits(self):
self.memory(available=2048)
self.assertEqual([], self.run_policy('bl_session_pressure'))
def test_same_second_memory_read_preserves_the_pressure_baseline(self):
self.memory(available=2048)
meminfo = self.root / 'meminfo'
self.assertEqual(['1048576:524288:2097152'], self.run_policy(f'''
SECONDS=100
_bl_sample_at=100 _bl_sample_available=2097152 _bl_growth=0 _bl_fall=524288
sed -i 's/MemAvailable: 2097152 kB/MemAvailable: 1048576 kB/' {meminfo}
bl_memory_read
echo "$_bl_available:$_bl_fall:$_bl_sample_available"
'''))
def test_game_reading_back_most_of_a_pageout_skips_and_doubles_the_wait(self):
self.assertEqual(['send:1:game', 'backoff:60', 'send:1:game', 'backoff:60',
'send:1:game', 'backoff:30'], self.run_policy('''
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session', 'backoff:60',
'send:1:session', 'backoff:30'], self.run_policy('''
pushed=$((512 * 1024))
SECONDS=0; bl_session_pressure
swap=$((swap / 4))
@@ -226,7 +252,7 @@ echo "backoff:$_bl_tier_backoff"
def test_nearly_out_of_memory_ignores_the_backoff_but_keeps_30_seconds(self):
self.memory(available=512)
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
_bl_tier_backoff=300
SECONDS=0; bl_session_pressure
SECONDS=20; bl_session_pressure
@@ -235,7 +261,7 @@ SECONDS=30; bl_session_pressure
def test_nearly_out_of_memory_still_backs_off_when_the_game_reads_its_pageout_back(self):
self.memory(available=512)
self.assertEqual(['send:1:game', 'backoff:60', 'send:1:game'], self.run_policy('''
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session'], self.run_policy('''
SECONDS=0; bl_session_pressure
swap=0
SECONDS=30; bl_session_pressure
@@ -247,7 +273,7 @@ SECONDS=90; bl_session_pressure
def test_nearly_out_of_memory_retries_a_skipped_pageout_after_30_seconds(self):
self.memory(available=512)
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
SECONDS=0; bl_session_pressure
swap=0
SECONDS=30; bl_session_pressure
@@ -263,6 +289,24 @@ SECONDS=360; bl_session_pressure
self.memory(swap_free=1536, swap_total=2048)
self.assertEqual([], self.run_policy('bl_session_pressure'))
def test_file_backed_resident_memory_does_not_consume_the_swap_budget(self):
self.memory(swap_free=3088, swap_total=6144)
self.assertEqual(['send:1:session'], self.run_policy('''
rss=$((4096 * 1024)) anon=$((1024 * 1024))
bl_session_pressure
'''))
def test_anonymous_memory_and_pending_client_still_need_the_full_swap_reserve(self):
self.memory(swap_free=3088, swap_total=6144)
self.assertEqual([], self.run_policy('''
rss=$((4096 * 1024)) anon=$((2048 * 1024))
bl_session_pressure
'''))
self.assertEqual([], self.run_policy('''
rss=$((4096 * 1024)) anon=$((1536 * 1024)) _bl_client_reserve=$((512 * 1024))
bl_session_pressure
'''))
def test_small_session_is_left_alone(self):
self.assertEqual([], self.run_policy('rss=$((128 * 1024)); bl_session_pressure'))
@@ -275,10 +319,10 @@ SECONDS=360; bl_session_pressure
self.assertEqual(['nap:5'], self.run_policy('bl_watch_nap'))
self.assertEqual(['nap:5'], self.run_policy('_bl_game=0; bl_watch_nap'))
def test_one_push_compresses_the_game_and_the_launcher_and_restarts_the_launcher_wait(self):
self.assertEqual(['send:1:game', 'pids:321 654 999', 'client:0:0'], self.run_policy('''
def test_session_push_preserves_client_timestamps(self):
self.assertEqual(['send:1:session', 'pids:321 654', 'client:-1:-1'], self.run_policy('''
SECONDS=0; bl_session_pressure
bl_zram_pick game; echo "pids:${_pids[*]}"
bl_zram_pick session; echo "pids:${_pids[*]}"
echo "client:$_bl_pressure_at:$_bl_packed"
'''))
@@ -286,19 +330,19 @@ echo "client:$_bl_pressure_at:$_bl_packed"
self.assertEqual(['pids:321 654', 'client:-1:-1'], self.run_policy('''
BL_ZRAM_CLIENT=0
SECONDS=0; bl_session_pressure
bl_zram_pick game; echo "pids:${_pids[*]}"
bl_zram_pick session; echo "pids:${_pids[*]}"
echo "client:$_bl_pressure_at:$_bl_packed"
''')[1:])
def test_low_ram_devices_compress_with_a_quarter_of_memory_left(self):
self.memory(available=1700)
self.assertEqual(['send:1:game'], self.run_policy('bl_session_pressure'))
self.assertEqual(['send:1:session'], self.run_policy('bl_session_pressure'))
self.memory(available=1900)
self.assertEqual([], self.run_policy('bl_session_pressure'))
def test_a_compressed_process_that_exits_is_not_counted_as_read_back(self):
self.assertEqual(['send:1:game', 'send:1:game', 'backoff:30'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
SECONDS=0; bl_session_pressure
alive=""; swap=0
SECONDS=30; bl_session_pressure
@@ -306,7 +350,7 @@ echo "backoff:$_bl_tier_backoff"
'''))
def test_a_process_that_starts_after_a_pageout_is_not_in_its_read_back(self):
self.assertEqual(['send:1:game', 'targets:999', 'send:1:game', 'backoff:30'], self.run_policy('''
self.assertEqual(['send:1:session', 'targets:321 654', 'send:1:session', 'backoff:30'], self.run_policy('''
SECONDS=0; bl_session_pressure
echo "targets:${_bl_tier_targets[*]}"
alive="999 1234"
@@ -315,7 +359,7 @@ echo "backoff:$_bl_tier_backoff"
'''))
def test_an_incomplete_pageout_does_not_restart_the_launcher_wait(self):
self.assertEqual(['send:1:game', 'client:-1:-1'], self.run_policy('''
self.assertEqual(['send:1:session', 'client:-1:-1'], self.run_policy('''
complete=0
SECONDS=0; bl_session_pressure
echo "client:$_bl_pressure_at:$_bl_packed"
@@ -323,7 +367,7 @@ echo "client:$_bl_pressure_at:$_bl_packed"
def test_a_reused_process_id_is_not_counted_as_read_back(self):
self.assertEqual(['send:1:game', 'send:1:game', 'backoff:30'], self.run_policy('''
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
SECONDS=0; bl_session_pressure
started=200; swap=0
SECONDS=30; bl_session_pressure
@@ -344,5 +388,112 @@ echo "backoff:$_bl_tier_backoff"
self.assertEqual(['gone'], result.stdout.split())
class ReclaimDispatchTest(unittest.TestCase):
def run_cycle(self, client=1, game=1, anonymous=384, complete=1, reclaimed=128, body=None, available=1024, fall=0, tick=0):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
(root / 'meminfo').write_text(
f'MemTotal: 7340032 kB\nMemAvailable: {available * 1024} kB\n'
'SwapTotal: 6291456 kB\nSwapFree: 4194304 kB\n')
(root / 'pressure').write_text('some avg10=0.00 avg60=0.00 avg300=0.00 total=0\n')
names = ('bl_memory_read', 'bl_memory_tight', 'bl_memory_critical',
'bl_zram_has_room', 'bl_client_can_pageout', 'bl_client_pressure',
'bl_client_pressure_result', 'bl_client_pressure_finish',
'bl_session_pressure', 'bl_zram_send', 'bl_zram_finish', 'bl_zram_pick')
source = '\n'.join(function_source(name) for name in names)
source = source.replace('/proc/meminfo', str(root / 'meminfo'))
source = source.replace('/proc/pressure/memory', str(root / 'pressure'))
source = source.replace('/tmp/.bl-zram', str(root / 'ctl'))
monitor = SCRIPT.read_text()
start = monitor.index(' _bl_preserved_growth=$_bl_growth', monitor.index('while kill -0 $$'))
stop = monitor.index(' if [ "$_bl_game" = 1 ] && bl_game_focused', start)
cycle = monitor[start:stop] if body is None else body
script = f'''
set -u
BL_ZRAM_CLIENT={client} _bl_game={game} _bl_pids=(123) _bl_others=(321)
_bl_pressure_at=-1 _bl_pressure_backoff=30 _bl_packed=-1
_bl_tier_at=-1 _bl_tier_backoff=30 _bl_tier_pushed=0
_bl_client_reserve=0 client_rss=393216 client_anon={anonymous * 1024}
step() {{ :; }}
bl_session_others() {{ _bl_session=(321); }}
bl_zram_scan() {{ _bl_pids=(456); }}
nap() {{ echo "nap:$*:at:$NOW"; }}
bl_zram_usage() {{
if [ "$1" = 123 ]; then
_bl_rss=$client_rss _bl_anon=$client_anon _bl_swap=0
else
_bl_rss=3145728 _bl_anon=1572864 _bl_swap=0
fi
}}
kill() {{ echo "signal:$*:at:$NOW"; NOW=$((NOW + {tick})); }}
bl_zram_wait() {{
echo "wait:$*:at:$NOW"
NOW=$((NOW + 12))
_bl_pageout_complete={complete}
[ "$1" != 123 ] || client_rss=$((client_rss - {reclaimed * 1024}))
}}
bl_tier_note() {{ :; }}
''' + source + f'''
bl_memory_read
_bl_fall={fall * 1024}
''' + cycle + '''
echo "client:$_bl_pressure_backoff:${_bl_client_reserve:-0}:${_bl_client_pending:-0}"
'''
result = run_bash('NOW=0\n' + script.replace('SECONDS', 'NOW'))
self.assertEqual(0, result.returncode, result.stderr)
self.assertEqual('', result.stderr)
return result.stdout.splitlines()
def test_both_requests_are_sent_before_either_wait(self):
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:0',
'wait:321:at:0', 'wait:123:at:12', 'client:30:0:0'], self.run_cycle())
def test_disabled_client_is_never_signalled_or_waited_for(self):
self.assertEqual(['signal:-URG 321:at:0', 'wait:321:at:0', 'client:30:0:0'],
self.run_cycle(client=0))
def test_no_game_requests_nothing(self):
self.assertEqual(['client:30:0:0'], self.run_cycle(game=0))
def test_a_client_with_no_anonymous_pages_still_finishes_its_request(self):
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:0',
'wait:321:at:0', 'wait:123:at:12', 'client:30:0:0'],
self.run_cycle(anonymous=0))
def test_falling_headroom_survives_a_tick_between_requests(self):
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:1',
'wait:321:at:2', 'wait:123:at:14', 'client:30:0:0'],
self.run_cycle(available=2304, fall=512, tick=1))
def test_deferred_ineffective_reclaim_still_doubles_the_backoff(self):
self.assertEqual('client:60:0:0', self.run_cycle(reclaimed=0)[-1])
def test_deferred_incomplete_reclaim_does_not_double_the_backoff(self):
self.assertEqual('client:30:0:0', self.run_cycle(reclaimed=0, complete=0)[-1])
def test_explicit_combined_send_keeps_its_synchronous_wait(self):
self.assertEqual(['signal:-URG 321 123:at:0', 'wait:321 123:at:0', 'client:30:0:0'],
self.run_cycle(body='bl_zram_send 1 cap game\n'))
self.assertEqual(['signal:-URG 321:at:0', 'wait:321:at:0', 'client:30:0:0'],
self.run_cycle(client=0, body='bl_zram_send 1 cap game\n'))
def test_readback_keeps_its_synchronous_delay(self):
self.assertEqual(['signal:-URG 123:at:0', 'nap:5:at:0', 'client:30:0:0'],
self.run_cycle(body='bl_zram_send 0 readback client\n'))
def test_usage_sums_anonymous_rss_and_falls_back_per_process(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
for pid, contents in ((123, 'VmRSS: 2000 kB\nRssAnon: 300 kB\nVmSwap: 100 kB\n'),
(321, 'VmRSS: 4000 kB\nVmSwap: 200 kB\n'),
(654, 'VmRSS: 1000 kB\nRssAnon: 0 kB\n')):
(root / str(pid)).mkdir()
(root / str(pid) / 'status').write_text(contents)
source = function_source('bl_zram_usage').replace('/proc/', str(root) + '/')
result = run_bash(source + '\nbl_zram_usage 123 321 654 > /dev/null; echo "$_bl_rss:$_bl_anon:$_bl_swap"')
self.assertEqual(0, result.returncode, result.stderr)
self.assertEqual('7000:4300:300', result.stdout.strip())
if __name__ == '__main__':
unittest.main()