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
@@ -18,6 +18,15 @@ def run_bash(script, env=None):
|
||||
return subprocess.run(['bash', '-c', script], capture_output=True, text=True, timeout=10, env=env)
|
||||
|
||||
|
||||
def state_source():
|
||||
source = SCRIPT.read_text()
|
||||
start = source.index(' declare -A _dd_deaf=()')
|
||||
return source[start:source.index(' while kill -0', start)]
|
||||
|
||||
|
||||
STATE = state_source()
|
||||
|
||||
|
||||
class ClientZramFocusTest(unittest.TestCase):
|
||||
def test_the_hidden_epic_launcher_is_compressed_with_the_client(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
@@ -78,217 +87,59 @@ class ClientZramFocusTest(unittest.TestCase):
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('|6000021 6000022 6000020|0', result.stdout.strip())
|
||||
|
||||
def test_refocus_restarts_the_delay_and_game_exit_restores_a_packed_client(self):
|
||||
source = SCRIPT.read_text()
|
||||
start = source.index(' _dd_focus=1\n')
|
||||
stop = source.index(' dd_watch_nap\n', start)
|
||||
body = source[start:stop]
|
||||
harness = '''
|
||||
_dd_since=-1 _dd_since_apps= _dd_packed=-1 _dd_unpack=0 _dd_apps=" 413150"
|
||||
_dd_pids=(123)
|
||||
dd_game_focused() { [ "$focused" = 1 ]; }
|
||||
dd_over_cap() { return 1; }
|
||||
dd_client_can_pageout() { return 0; }
|
||||
dd_client_can_readback() { return 0; }
|
||||
dd_zram_send() { echo "send:$1"; }
|
||||
tick() {
|
||||
SECONDS=$1 _dd_game=$2 focused=$3
|
||||
''' + body + '''
|
||||
}
|
||||
tick 0 1 1
|
||||
tick 5 1 0
|
||||
tick 30 1 1
|
||||
echo "refocus:$_dd_packed"
|
||||
tick 49 1 1
|
||||
tick 50 1 1
|
||||
tick 55 1 0
|
||||
tick 60 0 0
|
||||
'''
|
||||
result = run_bash(harness)
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['refocus:-1', 'send:1', 'send:0'], result.stdout.splitlines())
|
||||
|
||||
def monitor_harness(self):
|
||||
source = SCRIPT.read_text()
|
||||
start = source.index(' dd_zram_scan\n dd_memory_read\n')
|
||||
stop = source.index(' dd_watch_nap\n', start)
|
||||
return '''
|
||||
_dd_since=-1 _dd_since_apps= _dd_packed=-1 _dd_measured=-1 _dd_unpack=0 _dd_capped=-1 _dd_backoff=30
|
||||
_dd_apps=" 413150"
|
||||
_dd_pids=(123)
|
||||
TICK = '''
|
||||
dd_zram_scan() { _dd_game=$game _dd_pids=(10) _dd_others=() _dd_apps=" 413150"; }
|
||||
dd_game_focused() { return $focus; }
|
||||
dd_memory_read() { _dd_available=$((available * 1024)) _dd_mem_total=$((7168 * 1024)) _dd_floor=$((896 * 1024)); _dd_target=$((target * 1024)) _dd_swap_room=$((4096 * 1024)) _dd_saving=500 _dd_rate=0 _dd_psi=0; }
|
||||
dd_zram_trim() { echo "trim:$NOW"; _dd_trimmed=$((64 * 1024)); }
|
||||
dd_zram_usage() { _dd_swap=$((64 * 1024)); }
|
||||
dd_session_others() { :; }
|
||||
step() { :; }
|
||||
dd_zram_scan() { :; }
|
||||
dd_memory_read() { :; }
|
||||
dd_client_pressure() { :; }
|
||||
dd_client_pressure_finish() { :; }
|
||||
dd_session_pressure() { :; }
|
||||
dd_client_can_pageout() { return 0; }
|
||||
dd_client_can_readback() { [ "${readback:-1}" = 1 ]; }
|
||||
dd_game_focused() { [ "$focused" = 1 ] && return 0; [ "$focused" = 2 ] && return 2; return 1; }
|
||||
dd_cap_due() { [ "$cap_due" = 1 ]; }
|
||||
dd_over_cap() { [ "$over_cap" = 1 ]; }
|
||||
dd_zram_send() { echo "send:$1:$3"; }
|
||||
tick() {
|
||||
SECONDS=$1 _dd_game=$2 focused=$3 over_cap=$4 cap_due=$5
|
||||
''' + source[start:stop] + '\n}\n'
|
||||
kill() { echo "back:$NOW"; }
|
||||
game=1 focus=0 available=1500 target=1600
|
||||
run() { for NOW in $(seq "$1" "$2"); do dd_memory_tick; done; }
|
||||
'''
|
||||
|
||||
def test_client_toggle_still_disables_automatic_compression(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
DD_ZRAM_CLIENT=0
|
||||
tick 0 1 1 0 0
|
||||
tick 25 1 1 0 0
|
||||
tick 30 0 0 0 0
|
||||
''')
|
||||
def tick(self, body):
|
||||
functions = '\n'.join(function_source(name) for name in (
|
||||
'dd_memory_need', 'dd_memory_relieve', 'dd_memory_note', 'dd_client_readback', 'dd_memory_tick'))
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
script = (functions + self.TICK + body).replace('/tmp/.dd-zram', tmp + '/ctl')
|
||||
result = run_bash(('NOW=0\nset -u\n' + STATE + script).replace('SECONDS', 'NOW'))
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual('', result.stdout)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def test_a_new_game_restarts_the_compression_delay(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
_dd_apps=" 413150 1245620"
|
||||
tick 15 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
echo "starting:$_dd_packed"
|
||||
tick 34 1 1 0 0
|
||||
tick 35 1 1 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['starting:-1', 'send:1:client'], result.stdout.splitlines())
|
||||
def test_the_client_behind_a_game_is_trimmed_while_memory_is_short_of_the_target(self):
|
||||
self.assertEqual(['trim:0', 'trim:1', 'trim:2'], self.tick('run 0 2\navailable=1700; run 3 9\n'))
|
||||
|
||||
def test_ram_cap_can_still_compress_an_unfocused_client(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
DD_ZRAM_CLIENT=0 DD_RAM_CAP_MB=1024
|
||||
dd_zram_usage() { _dd_rss=$((768 * 1024)); }
|
||||
tick 0 1 0 1 1
|
||||
echo "cap:$_dd_packed:$_dd_since:$_dd_backoff"
|
||||
tick 5 0 0 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'send:1:session', 'cap:0:-1:60', 'send:0:client'], result.stdout.splitlines())
|
||||
def test_nothing_is_requested_while_the_app_holds_the_control_file(self):
|
||||
self.assertEqual(['trim:3'], self.tick(
|
||||
': > /tmp/.dd-zram.hold; run 0 2\nrm /tmp/.dd-zram.hold; run 3 3\n'))
|
||||
|
||||
def test_game_exit_defers_restore_until_the_session_is_under_the_ram_cap(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
tick 25 1 0 0 0
|
||||
tick 30 0 0 1 0
|
||||
echo "deferred:$_dd_unpack:$_dd_packed"
|
||||
tick 35 0 0 0 0
|
||||
echo "restored:$_dd_unpack"
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'deferred:1:-1', 'send:0:client', 'restored:0'], result.stdout.splitlines())
|
||||
def test_nothing_is_read_back_while_memory_is_still_needed(self):
|
||||
self.assertEqual(['trim:0'], self.tick(
|
||||
'run 0 0\ngame=0 available=4000; dd_memory_need() { _dd_need=1 _dd_hard=0 _dd_force=0; }\n'
|
||||
'dd_memory_relieve() { dd_memory_need; }; run 1 40\n'))
|
||||
|
||||
def test_game_exit_defers_readback_under_pressure_even_without_a_ram_cap(self):
|
||||
result = run_bash(self.monitor_harness() + """
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
readback=0
|
||||
tick 25 0 0 0 0
|
||||
echo "deferred:$_dd_unpack"
|
||||
readback=1
|
||||
tick 30 0 0 0 0
|
||||
echo "restored:$_dd_unpack"
|
||||
""")
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'deferred:1', 'send:0:client', 'restored:0'], result.stdout.splitlines())
|
||||
def test_game_exit_reads_the_client_back_after_a_quiet_half_minute(self):
|
||||
self.assertEqual(['trim:0', 'back:30'], self.tick('run 0 0\ngame=0 available=4000; run 1 40\n'))
|
||||
|
||||
def test_client_in_front_of_a_running_game_is_read_back_and_compressed_again_later(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
tick 25 1 0 0 0
|
||||
echo "away:$_dd_packed"
|
||||
tick 30 1 0 0 0
|
||||
echo "read:$_dd_packed:$_dd_unpack"
|
||||
tick 35 1 0 0 0
|
||||
tick 40 1 1 0 0
|
||||
tick 55 1 1 0 0
|
||||
tick 60 1 1 0 0
|
||||
echo "again:$_dd_packed"
|
||||
tick 65 0 0 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'away:20', 'send:0:client', 'read:-1:0', 'send:1:client', 'again:60', 'send:0:client'],
|
||||
result.stdout.splitlines())
|
||||
|
||||
def test_unknown_focus_keeps_the_client_compressed(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
tick 25 1 2 0 0
|
||||
tick 40 1 2 0 0
|
||||
echo "unknown:$_dd_packed:$_dd_unpack"
|
||||
tick 45 1 0 0 0
|
||||
tick 48 1 2 0 0
|
||||
tick 52 1 0 0 0
|
||||
tick 56 1 0 0 0
|
||||
echo "flicker:$_dd_packed"
|
||||
tick 57 1 0 0 0
|
||||
echo "read:$_dd_packed"
|
||||
tick 60 0 2 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'unknown:20:1', 'flicker:20', 'send:0:client', 'read:-1'],
|
||||
result.stdout.splitlines())
|
||||
def test_client_in_front_of_a_running_game_is_read_back_and_trimmed_again_later(self):
|
||||
self.assertEqual(['trim:0', 'back:30', 'trim:60'],
|
||||
self.tick('run 0 0\nfocus=1 available=4000; run 1 44\nfocus=0 available=1500; run 45 60\n'))
|
||||
|
||||
def test_a_short_look_at_the_client_keeps_it_compressed(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
tick 25 1 0 0 0
|
||||
tick 28 1 1 0 0
|
||||
tick 30 1 0 0 0
|
||||
tick 34 1 0 0 0
|
||||
echo "packed:$_dd_packed"
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'packed:20'], result.stdout.splitlines())
|
||||
self.assertEqual(['trim:0'], self.tick('run 0 0\navailable=4000; run 1 34\nfocus=1; run 35 38\nfocus=0; run 39 60\n'))
|
||||
|
||||
def test_client_in_front_waits_for_memory_and_a_ram_cap_keeps_it_compressed(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
readback=0
|
||||
tick 25 1 0 0 0
|
||||
tick 35 1 0 0 0
|
||||
echo "tight:$_dd_packed"
|
||||
readback=1
|
||||
tick 40 1 0 0 0
|
||||
echo "eased:$_dd_packed"
|
||||
_dd_ram_cap=1048576
|
||||
tick 60 1 1 0 0
|
||||
tick 80 1 1 0 0
|
||||
tick 85 1 0 0 0
|
||||
tick 100 1 0 0 0
|
||||
echo "capped:$_dd_packed"
|
||||
tick 105 0 0 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'tight:20', 'send:0:client', 'eased:-1', 'send:1:client', 'capped:80', 'send:0:client'],
|
||||
result.stdout.splitlines())
|
||||
def test_unknown_focus_keeps_the_client_compressed(self):
|
||||
self.assertEqual(['trim:0'], self.tick('run 0 0\nfocus=2 available=4000; run 1 60\n'))
|
||||
|
||||
def test_client_in_front_without_compression_reads_nothing_back(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
DD_ZRAM_CLIENT=0
|
||||
tick 0 1 1 0 0
|
||||
tick 25 1 0 0 0
|
||||
tick 40 1 0 0 0
|
||||
tick 45 0 0 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual('', result.stdout)
|
||||
def test_client_in_front_waits_for_memory(self):
|
||||
self.assertEqual(['trim:0', 'back:50'], self.tick('run 0 0\nfocus=1 available=1800 target=896; run 1 49\navailable=2500; run 50 60\n'))
|
||||
|
||||
def test_a_client_that_was_never_trimmed_reads_nothing_back(self):
|
||||
self.assertEqual([], self.tick('focus=1 available=4000; run 0 60\n'))
|
||||
|
||||
def test_scan_keeps_the_running_game_and_ignores_steams_own_reaper(self):
|
||||
temp = tempfile.TemporaryDirectory()
|
||||
|
||||
@@ -824,7 +824,6 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
"offline_without_anticheat": lambda command, env: command,
|
||||
"game_logs": lambda command, env, app_id: env,
|
||||
"directaudio_settings": lambda env: env,
|
||||
"vram_cap": lambda env: env,
|
||||
"render_path_defaults": lambda *args: None,
|
||||
"bridge_feature_level": lambda env: None,
|
||||
"force_ssbs": lambda command, env: env,
|
||||
@@ -1304,22 +1303,6 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
link.symlink_to(other, target_is_directory=True)
|
||||
self.assertTrue(chromium(str(link)))
|
||||
|
||||
def test_the_vram_cap_comes_before_the_games_own_dxvk_settings(self):
|
||||
cap = MODULE["vram_cap"]
|
||||
self.assertEqual(cap({"DD_VRAM_MB": "4096"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4096; dxgi.maxSharedMemory = 4096")
|
||||
self.assertEqual(cap({"DD_VRAM_MB": "8192"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 8192; dxgi.maxSharedMemory = 8192")
|
||||
self.assertEqual(cap({"DD_VRAM_MB": "4095"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4095; dxgi.maxSharedMemory = 4095; d3d9.maxAvailableMemory = 4095")
|
||||
self.assertEqual(cap({"DD_VRAM_MB": "2048", "DXVK_CONFIG": "dxvk.maxFrameRate = 60;"})["DXVK_CONFIG"],
|
||||
"dxgi.maxDeviceMemory = 2048; dxgi.maxSharedMemory = 2048; d3d9.maxAvailableMemory = 2048; dxvk.maxFrameRate = 60")
|
||||
for off in ({}, {"DD_VRAM_MB": "0"}, {"DD_VRAM_MB": "lots"}, {"DD_VRAM_MB": "²"}, {"DD_VRAM_MB": "-1"}):
|
||||
self.assertNotIn("DXVK_CONFIG", cap(off))
|
||||
self.assertNotIn("DROIDDECK_VRAM_CAP", cap(off))
|
||||
self.assertNotIn("DROIDDECK_VRAM_CAP_MB", cap(off))
|
||||
|
||||
def test_the_vram_cap_also_turns_on_the_vulkan_layer_that_holds_the_game_to_it(self):
|
||||
env = MODULE["vram_cap"]({"DD_VRAM_MB": "3072", "DXVK_CONFIG": "dxgi.maxDeviceMemory = 16384"})
|
||||
self.assertEqual((env["DROIDDECK_VRAM_CAP"], env["DROIDDECK_VRAM_CAP_MB"]), ("1", "3072"))
|
||||
|
||||
def test_a_games_wine_sync_choice_also_reaches_its_setup_runs(self):
|
||||
env = {"DD_SYNC": "1", "DD_SYNC_FALLBACK": "1", "DD_FSYNC_FIRST": "0", "OTHER": "kept"}
|
||||
config = {"version": 1, "games": {"42": {"DD_SYNC": "0", "DD_FSYNC_FIRST": "1", "PROTON_NO_ESYNC": "1", "FEX_TSOENABLED": "1"}}}
|
||||
|
||||
+316
-607
@@ -2,7 +2,9 @@ from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from tools.tests.test_client_zram_focus import SCRIPT, function_source, run_bash
|
||||
from tools.tests.test_client_zram_focus import STATE, function_source, run_bash
|
||||
|
||||
MB = 1024
|
||||
|
||||
|
||||
class MemoryPressureTest(unittest.TestCase):
|
||||
@@ -10,629 +12,336 @@ class MemoryPressureTest(unittest.TestCase):
|
||||
self.directory = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.directory.cleanup)
|
||||
self.root = Path(self.directory.name)
|
||||
self.memory()
|
||||
|
||||
def memory(self, available=1024, swap_free=4096, total=7168, swap_total=6144, psi='0.00'):
|
||||
(self.root / 'meminfo').write_text(
|
||||
f'MemTotal: {total * 1024} kB\nMemAvailable: {available * 1024} kB\n'
|
||||
f'SwapTotal: {swap_total * 1024} kB\nSwapFree: {swap_free * 1024} kB\n')
|
||||
(self.root / 'pressure').write_text(f'some avg10={psi} avg60=0.00 avg300=0.00 total=1234\n')
|
||||
def sample(self, available=3000, total=7168, stall=0, zram=(6144, 0), other=(4096, 0), stored=None, swapped_in=None):
|
||||
lines = [f'MemTotal: {total * MB} kB', f'MemAvailable: {available * MB} kB',
|
||||
f'SwapTotal: {(zram[0] + other[0]) * MB} kB',
|
||||
f'SwapFree: {(zram[0] - zram[1] + other[0] - other[1]) * MB} kB']
|
||||
swaps = ['Filename Type Size Used Priority']
|
||||
if zram[0]:
|
||||
swaps.append(f'/dev/block/zram0 partition {zram[0] * MB} {zram[1] * MB} 100')
|
||||
if other[0]:
|
||||
swaps.append(f'/data/swap/swapfile file {other[0] * MB} {other[1] * MB} 50')
|
||||
text = "printf '%s\\n' " + ' '.join(f"'{line}'" for line in lines) + f" > {self.root}/meminfo\n"
|
||||
text += "printf '%s\\n' " + ' '.join(f"'{line}'" for line in swaps) + f" > {self.root}/swaps\n"
|
||||
text += f"echo 'some avg10=0.00 avg60=0.00 avg300=0.00 total={stall}' > {self.root}/pressure\n"
|
||||
if swapped_in is None:
|
||||
text += f'rm -f {self.root}/vmstat\n'
|
||||
else:
|
||||
text += f"printf '%s\\n' 'pgfault 9' 'pswpin {swapped_in * MB // 4}' 'pswpout 7' > {self.root}/vmstat\n"
|
||||
if stored is None:
|
||||
text += f'rm -f {self.root}/mm_stat\n'
|
||||
else:
|
||||
text += f'echo "{stored[0] << 20} {stored[1] << 20} {stored[1] << 20} 0 0 0 0 0 0" > {self.root}/mm_stat\n'
|
||||
return text
|
||||
|
||||
def run_policy(self, body):
|
||||
functions = '\n'.join(function_source(name) for name in (
|
||||
'dd_memory_read', 'dd_memory_tight', 'dd_memory_critical', 'dd_client_can_pageout',
|
||||
'dd_client_can_readback', 'dd_client_pressure', 'dd_client_pressure_result', 'dd_zram_has_room'))
|
||||
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
|
||||
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
|
||||
harness = '''
|
||||
set -u
|
||||
_dd_pids=(123) _dd_game=1 _dd_packed=-1 _dd_pressure_at=-1 _dd_pressure_backoff=30
|
||||
rss=$((384 * 1024)) client_swap=$((512 * 1024)) reclaimed=$((128 * 1024))
|
||||
step() { :; }
|
||||
dd_zram_usage() { _dd_rss=$rss _dd_anon=${anon:-$rss} _dd_swap=$client_swap; }
|
||||
dd_zram_send() { echo "send:$1:$3"; rss=$((rss - reclaimed)); _dd_pageout_complete=${pageout_complete:-1}; }
|
||||
''' + functions + '\ndd_memory_read\n' + body
|
||||
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
|
||||
def run_policy(self, body, *names):
|
||||
functions = '\n'.join(function_source(name) for name in ('dd_memory_read', 'dd_memory_need') + names)
|
||||
for name in ('meminfo', 'swaps', 'pressure/memory', 'vmstat'):
|
||||
functions = functions.replace('/proc/' + name, str(self.root / name.split('/')[0]))
|
||||
functions = functions.replace('/sys/block/zram0/mm_stat', str(self.root / 'mm_stat'))
|
||||
functions = functions.replace('/tmp/.dd-zram', str(self.root / 'ctl'))
|
||||
result = run_bash(('NOW=0\nset -u\n' + STATE + functions + '\n' + body).replace('SECONDS', 'NOW'))
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def test_pressure_reclaims_before_the_focus_delay_and_respects_cooldown(self):
|
||||
self.assertEqual(['send:1:client', 'send:1:client'], self.run_policy('''
|
||||
SECONDS=0; dd_client_pressure
|
||||
SECONDS=5; dd_client_pressure
|
||||
SECONDS=29; dd_client_pressure
|
||||
SECONDS=30; dd_client_pressure
|
||||
'''))
|
||||
|
||||
def test_no_game_or_disabled_client_compression_does_not_reclaim(self):
|
||||
self.assertEqual([], self.run_policy('''
|
||||
_dd_game=0; dd_client_pressure
|
||||
_dd_game=1 DD_ZRAM_CLIENT=0; dd_client_pressure
|
||||
'''))
|
||||
|
||||
def test_high_available_memory_does_not_reclaim_even_with_stalls(self):
|
||||
self.memory(available=4096, psi='12.34')
|
||||
self.assertEqual([], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_psi_reclaims_with_moderate_headroom(self):
|
||||
self.memory(available=2048, psi='01.23')
|
||||
self.assertEqual(['send:1:client'], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_missing_psi_still_uses_memory_headroom(self):
|
||||
(self.root / 'pressure').unlink()
|
||||
self.assertEqual(['send:1:client'], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_missing_meminfo_never_reclaims_or_prefetches(self):
|
||||
(self.root / 'meminfo').write_text('SwapTotal: 6291456 kB\nSwapFree: 4194304 kB\n')
|
||||
self.assertEqual(['no'], self.run_policy('''
|
||||
dd_client_pressure
|
||||
if dd_client_can_readback; then echo yes; else echo no; fi
|
||||
'''))
|
||||
|
||||
def test_missing_available_memory_does_not_trigger_pressure(self):
|
||||
p = self.root / 'meminfo'
|
||||
p.write_text('\n'.join(line for line in p.read_text().splitlines() if not line.startswith('MemAvailable:')))
|
||||
self.assertEqual([], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_swap_reserve_includes_the_clients_resident_memory(self):
|
||||
self.memory(swap_free=1536)
|
||||
self.assertEqual(['no'], self.run_policy('''
|
||||
dd_client_pressure
|
||||
if dd_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))
|
||||
dd_client_pressure
|
||||
'''))
|
||||
|
||||
def test_without_swap_automatic_pageout_is_disabled(self):
|
||||
self.memory(swap_total=0, swap_free=0)
|
||||
self.assertEqual([], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_recent_periodic_pageout_prevents_an_immediate_pressure_repeat(self):
|
||||
self.assertEqual([], self.run_policy('_dd_packed=$SECONDS; dd_client_pressure'))
|
||||
|
||||
def test_ineffective_reclaim_backs_off_and_success_resets_it(self):
|
||||
self.assertEqual(['send:1:client', 'backoff:60', 'send:1:client', 'backoff:30'], self.run_policy('''
|
||||
reclaimed=0
|
||||
SECONDS=0; dd_client_pressure
|
||||
echo "backoff:$_dd_pressure_backoff"
|
||||
SECONDS=30; dd_client_pressure
|
||||
reclaimed=$((128 * 1024))
|
||||
SECONDS=60; dd_client_pressure
|
||||
echo "backoff:$_dd_pressure_backoff"
|
||||
'''))
|
||||
|
||||
def test_readback_requires_room_for_the_swapped_client_plus_headroom(self):
|
||||
self.memory(available=2048)
|
||||
self.assertEqual(['yes', 'no'], self.run_policy('''
|
||||
if dd_client_can_readback; then echo yes; else echo no; fi
|
||||
client_swap=$((1024 * 1024))
|
||||
if dd_client_can_readback; then echo yes; else echo no; fi
|
||||
'''))
|
||||
|
||||
def test_unfinished_pageout_does_not_increase_the_ineffective_reclaim_backoff(self):
|
||||
self.assertEqual(['send:1:client', 'backoff:30'], self.run_policy('''
|
||||
reclaimed=0 pageout_complete=0
|
||||
SECONDS=0; dd_client_pressure
|
||||
echo "backoff:$_dd_pressure_backoff"
|
||||
'''))
|
||||
|
||||
def test_pageout_completion_requires_a_finished_ack_from_every_live_target(self):
|
||||
proc = self.root / 'proc'
|
||||
proc.mkdir()
|
||||
for pid in (123, 456):
|
||||
(proc / str(pid)).mkdir()
|
||||
source = function_source('dd_zram_wait').replace('/proc/', str(proc) + '/')
|
||||
source = source.replace('/tmp/.dd-zram.ack.', str(self.root / 'ack.'))
|
||||
for pending in ('done', 'running', 'not_started'):
|
||||
with self.subTest(pending=pending):
|
||||
(self.root / 'ack.123').write_text('1')
|
||||
if pending != 'not_started':
|
||||
(self.root / 'ack.456').write_text('1' if pending == 'done' else '')
|
||||
result = run_bash('nap() { SECONDS=$((SECONDS + 1)); }\n' + source +
|
||||
'\nSECONDS=0; dd_zram_wait 123 456; echo "$_dd_pageout_complete"')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('1' if pending == 'done' else '0', result.stdout.strip())
|
||||
|
||||
def test_pressure_prevents_prefetch_even_if_the_client_would_fit(self):
|
||||
self.memory(available=2048, psi='2.00')
|
||||
self.assertEqual(['no'], self.run_policy('if dd_client_can_readback; then echo yes; else echo no; fi'))
|
||||
|
||||
|
||||
class SessionPressureTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.directory = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.directory.cleanup)
|
||||
self.root = Path(self.directory.name)
|
||||
self.memory()
|
||||
|
||||
def memory(self, available=1024, swap_free=6144, total=7168, swap_total=8192, psi='0.00'):
|
||||
(self.root / 'meminfo').write_text(
|
||||
f'MemTotal: {total * 1024} kB\nMemAvailable: {available * 1024} kB\n'
|
||||
f'SwapTotal: {swap_total * 1024} kB\nSwapFree: {swap_free * 1024} kB\n')
|
||||
(self.root / 'pressure').write_text(f'some avg10={psi} avg60=0.00 avg300=0.00 total=1234\n')
|
||||
|
||||
def run_policy(self, body):
|
||||
functions = '\n'.join(function_source(name) for name in (
|
||||
'dd_memory_read', 'dd_memory_tight', 'dd_memory_critical',
|
||||
'dd_client_can_pageout', 'dd_client_pressure', 'dd_client_pressure_result',
|
||||
'dd_session_pressure', 'dd_zram_has_room', 'dd_watch_nap', 'dd_zram_pick', 'dd_tier_note', 'dd_tier_readback'))
|
||||
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
|
||||
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
|
||||
harness = '''
|
||||
set -u
|
||||
_dd_game=1 _dd_tier_at=-1 _dd_tier_backoff=30 _dd_tier_pushed=0 _dd_tier_back=0 _dd_tier_targets=() _dd_tier_swaps=() _dd_tier_starts=() _dd_pids=(999)
|
||||
_dd_pressure_at=-1 _dd_pressure_backoff=30 _dd_packed=-1
|
||||
rss=$((1536 * 1024)) swap=0 pushed=$((1024 * 1024)) alive="999 321 654" started=100 complete=1
|
||||
step() { :; }
|
||||
meminfo=''' + repr(str(self.root / 'meminfo')) + '''
|
||||
dd_game_focused() { [ "${focused:-1}" = 1 ]; }
|
||||
dd_proc_start() { _dd_start=; case " $alive " in *" $1 "*) _dd_start=$started; return 0 ;; esac; return 1; }
|
||||
nap() { echo "nap:$1"; }
|
||||
dd_session_others() { _dd_session=(321 654); }
|
||||
dd_zram_usage() { _dd_rss=$rss _dd_anon=${anon:-$rss} _dd_swap=$swap; }
|
||||
dd_zram_send() { echo "send:$1:$3"; rss=$((rss - pushed)); swap=$((swap + pushed)); next_available=${available_after:-$(( $(awk '/^MemAvailable:/ { print $2 }' "$meminfo") / 1024 + 128 ))}; sed -i "s/^MemAvailable:.*/MemAvailable: $((next_available * 1024)) kB/" "$meminfo"; _dd_pageout_complete=$complete; }
|
||||
''' + functions + '\ndd_memory_read\n' + body
|
||||
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def test_low_headroom_compresses_the_game_session_at_most_every_30_seconds(self):
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
SECONDS=10; dd_session_pressure
|
||||
SECONDS=29; dd_session_pressure
|
||||
SECONDS=30; dd_session_pressure
|
||||
'''))
|
||||
|
||||
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('dd_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('dd_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('dd_session_pressure'))
|
||||
|
||||
def test_a_fast_fall_on_a_large_device_reclaims_above_the_fixed_headroom(self):
|
||||
self.memory(total=15255, available=6176)
|
||||
falling = self.root / 'falling'
|
||||
falling.write_text(
|
||||
f'MemTotal: {15255 * 1024} kB\nMemAvailable: {5367 * 1024} kB\n'
|
||||
f'SwapTotal: {8192 * 1024} kB\nSwapFree: {6144 * 1024} kB\n')
|
||||
meminfo = self.root / 'meminfo'
|
||||
self.assertEqual(['send:1:session'], self.run_policy(
|
||||
f'cp {falling} {meminfo}\nSECONDS=5; dd_session_pressure'))
|
||||
|
||||
def test_a_fall_split_across_one_second_polls_still_reclaims(self):
|
||||
self.memory(total=15255, available=6300)
|
||||
steps = []
|
||||
for second, available in ((5, 6100), (6, 6020), (7, 5940), (8, 5860), (9, 5780)):
|
||||
sample = self.root / f'meminfo-{second}'
|
||||
sample.write_text(
|
||||
f'MemTotal: {15255 * 1024} kB\nMemAvailable: {available * 1024} kB\n'
|
||||
f'SwapTotal: {8192 * 1024} kB\nSwapFree: {6144 * 1024} kB\n')
|
||||
steps.append(f'cp {sample} {self.root / "meminfo"}; SECONDS={second}; dd_session_pressure')
|
||||
self.assertEqual(['send:1:session'], self.run_policy('\n'.join(steps)))
|
||||
|
||||
def test_no_game_does_not_compress_the_session(self):
|
||||
self.assertEqual([], self.run_policy('_dd_game=0; dd_session_pressure'))
|
||||
|
||||
def test_disabled_idle_compression_does_not_compress_the_session(self):
|
||||
self.assertEqual(['send:1:client'], self.run_policy('DD_ZRAM_IDLE=0; dd_client_pressure; dd_session_pressure'))
|
||||
|
||||
def test_disabled_idle_compression_signals_only_launcher_processes(self):
|
||||
sender = (function_source('dd_zram_send') + '\n' + function_source('dd_zram_finish')).replace('/tmp/.dd-zram', str(self.root / 'control'))
|
||||
self.assertEqual(['kill:-URG 999 998', 'mode:1'], self.run_policy('''
|
||||
_dd_pids=(999 998)
|
||||
kill() { echo "kill:$*"; }
|
||||
dd_zram_wait() { _dd_pageout_complete=1; }
|
||||
dd_zram_scan() { :; }
|
||||
''' + sender + '''
|
||||
DD_ZRAM_IDLE=0; dd_client_pressure; dd_session_pressure
|
||||
echo "mode:$(cat ''' + str(self.root / 'control') + ''')"
|
||||
'''))
|
||||
|
||||
def test_disabled_idle_compression_reclaims_only_the_launcher_before_focus(self):
|
||||
self.memory(available=1700)
|
||||
self.assertEqual(['send:1:client'], self.run_policy('''
|
||||
DD_ZRAM_IDLE=0 focused=0
|
||||
dd_client_pressure
|
||||
dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_disabled_idle_compression_respects_launcher_setting_and_threshold(self):
|
||||
self.memory(available=1700)
|
||||
self.assertEqual([], self.run_policy('DD_ZRAM_IDLE=0 DD_ZRAM_CLIENT=0; dd_client_pressure; dd_session_pressure'))
|
||||
self.memory(available=1900)
|
||||
self.assertEqual([], self.run_policy('DD_ZRAM_IDLE=0; dd_client_pressure; dd_session_pressure'))
|
||||
|
||||
def test_game_reclaim_requires_focus(self):
|
||||
self.assertEqual([], self.run_policy('focused=0; dd_session_pressure'))
|
||||
|
||||
def test_game_reclaim_runs_when_focus_is_unknown(self):
|
||||
launch = self.root / 'launch'
|
||||
(launch / 'agent').mkdir(parents=True)
|
||||
body = function_source('dd_game_focused') + f'\nDD_LAUNCH_DIR={launch} _dd_apps=7\n'
|
||||
self.assertEqual(['send:1:session'], self.run_policy(body + 'dd_session_pressure'))
|
||||
(launch / 'agent' / 'focus.json').write_text('{"focusedApp": 9}')
|
||||
self.assertEqual([], self.run_policy(body + 'dd_session_pressure'))
|
||||
self.assertEqual(['unfocused'], self.run_policy(body + 'dd_game_focused || echo unfocused'))
|
||||
(launch / 'agent' / 'focus.json').unlink()
|
||||
self.assertEqual(['unfocused'], self.run_policy(body + 'dd_game_focused || echo unfocused'))
|
||||
|
||||
def test_launcher_pressure_remains_available_on_larger_devices(self):
|
||||
self.memory(total=15360, available=1400)
|
||||
self.assertEqual(['send:1:client'], self.run_policy('DD_ZRAM_IDLE=0; dd_client_pressure; dd_session_pressure'))
|
||||
|
||||
def test_enough_available_memory_does_not_compress_even_with_stalls(self):
|
||||
self.memory(available=3072, psi='5.00')
|
||||
self.assertEqual([], self.run_policy('dd_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:session'], self.run_policy('dd_session_pressure'))
|
||||
|
||||
def test_moderate_headroom_without_stalls_waits(self):
|
||||
self.memory(available=2048)
|
||||
self.assertEqual([], self.run_policy('dd_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
|
||||
_dd_sample_at=100 _dd_sample_available=2097152 _dd_growth=0 _dd_fall=524288
|
||||
sed -i 's/MemAvailable: 2097152 kB/MemAvailable: 1048576 kB/' {meminfo}
|
||||
dd_memory_read
|
||||
echo "$_dd_available:$_dd_fall:$_dd_sample_available"
|
||||
'''))
|
||||
|
||||
def test_game_reading_back_most_of_a_pageout_skips_and_doubles_the_wait(self):
|
||||
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; dd_session_pressure
|
||||
swap=$((swap / 4))
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
SECONDS=60; dd_session_pressure
|
||||
SECONDS=90; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
SECONDS=150; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_repeated_read_back_keeps_doubling_up_to_five_minutes(self):
|
||||
self.assertEqual(['backoff:300'], self.run_policy('''
|
||||
_dd_tier_backoff=240 _dd_tier_at=0 _dd_tier_targets=(999) _dd_tier_swaps=($((1024 * 1024))) _dd_tier_starts=(100) _dd_tier_pushed=$((1024 * 1024)) swap=0
|
||||
SECONDS=240; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_no_gain_pageout_doubles_the_tier_wait(self):
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session', 'backoff:120'], self.run_policy('''
|
||||
available_after=1024
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
SECONDS=30; dd_session_pressure
|
||||
SECONDS=60; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_meaningful_available_gain_keeps_the_tier_wait(self):
|
||||
self.assertEqual(['send:1:session', 'backoff:30', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
available_after=1300
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
available_after=1600
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_recovered_available_memory_resets_the_tier_wait(self):
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'backoff:30', 'send:1:session'], self.run_policy('''
|
||||
available_after=1024
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
available_after=2000
|
||||
sed -i "s/^MemAvailable:.*/MemAvailable: 2048000 kB/" "$meminfo"
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
available_after=1024
|
||||
sed -i "s/^MemAvailable:.*/MemAvailable: 1048576 kB/" "$meminfo"
|
||||
SECONDS=60; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_critical_memory_still_compresses_after_a_no_gain_pass(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
available_after=512
|
||||
SECONDS=0; dd_session_pressure
|
||||
SECONDS=30; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_a_no_gain_pass_still_skips_memory_the_game_read_back(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:session'], self.run_policy('''
|
||||
available_after=512
|
||||
SECONDS=0; dd_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_nearly_out_of_memory_ignores_the_backoff_but_keeps_30_seconds(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
_dd_tier_backoff=300
|
||||
SECONDS=0; dd_session_pressure
|
||||
SECONDS=20; dd_session_pressure
|
||||
SECONDS=30; dd_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:session', 'backoff:60', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
SECONDS=59; dd_session_pressure
|
||||
SECONDS=60; dd_session_pressure
|
||||
SECONDS=90; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_nearly_out_of_memory_retries_a_skipped_pageout_after_30_seconds(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
_dd_tier_backoff=300
|
||||
saved=$rss; rss=$((128 * 1024))
|
||||
SECONDS=330; dd_session_pressure
|
||||
rss=$saved
|
||||
SECONDS=359; dd_session_pressure
|
||||
SECONDS=360; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_small_swap_headroom_skips_the_pageout(self):
|
||||
self.memory(swap_free=1536, swap_total=2048)
|
||||
self.assertEqual([], self.run_policy('dd_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))
|
||||
dd_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))
|
||||
dd_session_pressure
|
||||
'''))
|
||||
self.assertEqual([], self.run_policy('''
|
||||
rss=$((4096 * 1024)) anon=$((1536 * 1024)) _dd_client_reserve=$((512 * 1024))
|
||||
dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_small_session_is_left_alone(self):
|
||||
self.assertEqual([], self.run_policy('rss=$((128 * 1024)); dd_session_pressure'))
|
||||
|
||||
def test_watch_polls_every_second_near_the_limit_and_stops_when_critical(self):
|
||||
self.memory(available=2560)
|
||||
self.assertEqual(['nap:1', 'nap:1', 'nap:1', 'nap:1', 'nap:1'], self.run_policy('dd_watch_nap'))
|
||||
self.memory(available=1024)
|
||||
self.assertEqual(['nap:1'], self.run_policy('_dd_available=$((2560 * 1024)); dd_watch_nap'))
|
||||
self.memory(available=4096)
|
||||
self.assertEqual(['nap:5'], self.run_policy('dd_watch_nap'))
|
||||
self.assertEqual(['nap:5'], self.run_policy('_dd_game=0; dd_watch_nap'))
|
||||
|
||||
def test_session_push_preserves_client_timestamps(self):
|
||||
self.assertEqual(['send:1:session', 'pids:321 654', 'client:-1:-1'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
dd_zram_pick session; echo "pids:${_pids[*]}"
|
||||
echo "client:$_dd_pressure_at:$_dd_packed"
|
||||
'''))
|
||||
|
||||
def test_launcher_compression_turned_off_keeps_the_launcher_out(self):
|
||||
self.assertEqual(['pids:321 654', 'client:-1:-1'], self.run_policy('''
|
||||
DD_ZRAM_CLIENT=0
|
||||
SECONDS=0; dd_session_pressure
|
||||
dd_zram_pick session; echo "pids:${_pids[*]}"
|
||||
echo "client:$_dd_pressure_at:$_dd_packed"
|
||||
''')[1:])
|
||||
|
||||
def test_low_ram_devices_compress_with_a_quarter_of_memory_left(self):
|
||||
self.memory(available=1700)
|
||||
self.assertEqual(['send:1:session'], self.run_policy('dd_session_pressure'))
|
||||
self.memory(available=1900)
|
||||
self.assertEqual([], self.run_policy('dd_session_pressure'))
|
||||
|
||||
|
||||
def test_a_compressed_process_that_exits_is_not_counted_as_read_back(self):
|
||||
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
alive=""; swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_a_process_that_starts_after_a_pageout_is_not_in_its_read_back(self):
|
||||
self.assertEqual(['send:1:session', 'targets:321 654', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "targets:${_dd_tier_targets[*]}"
|
||||
alive="999 1234"
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_read_back_wait_holds_above_the_critical_level(self):
|
||||
self.assertEqual(['send:1:session', 't:60', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
SECONDS=60; dd_session_pressure; echo t:60
|
||||
SECONDS=90; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_a_no_gain_pageout_preserves_client_timestamps(self):
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'client:-1:-1'], self.run_policy('''
|
||||
available_after=1024
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
echo "client:$_dd_pressure_at:$_dd_packed"
|
||||
'''))
|
||||
|
||||
def test_an_incomplete_pageout_does_not_restart_the_launcher_wait(self):
|
||||
self.assertEqual(['send:1:session', 'client:-1:-1'], self.run_policy('''
|
||||
complete=0
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "client:$_dd_pressure_at:$_dd_packed"
|
||||
'''))
|
||||
|
||||
|
||||
def test_a_reused_process_id_is_not_counted_as_read_back(self):
|
||||
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
started=200; swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_process_start_comes_from_stat_and_zombies_have_none(self):
|
||||
stat = self.root / 'stat'
|
||||
source = function_source('dd_proc_start').replace('/proc/$1/stat', str(stat))
|
||||
fields = ' '.join(['0'] * 17)
|
||||
for state, expected in (('S', ['ok:4242']), ('Z', ['gone:'])):
|
||||
with self.subTest(state=state):
|
||||
stat.write_text(f'77 (Wow (arm64).exe) {state} 1 {fields} 4242 99 0\n')
|
||||
result = run_bash(source + '\nif dd_proc_start 77; then echo "ok:$_dd_start"; else echo "gone:$_dd_start"; fi')
|
||||
self.assertEqual(expected, result.stdout.split())
|
||||
stat.unlink()
|
||||
result = run_bash(source + '\ndd_proc_start 77 || echo gone')
|
||||
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 = ('dd_memory_read', 'dd_memory_tight', 'dd_memory_critical',
|
||||
'dd_zram_has_room', 'dd_client_can_pageout', 'dd_client_pressure',
|
||||
'dd_client_pressure_result', 'dd_client_pressure_finish',
|
||||
'dd_session_pressure', 'dd_zram_send', 'dd_zram_finish', 'dd_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/.dd-zram', str(root / 'ctl'))
|
||||
monitor = SCRIPT.read_text()
|
||||
start = monitor.index(' _dd_preserved_growth=$_dd_growth', monitor.index('while kill -0 $$'))
|
||||
stop = monitor.index(' _dd_focus=1\n', start)
|
||||
cycle = monitor[start:stop] if body is None else body
|
||||
script = f'''
|
||||
set -u
|
||||
DD_ZRAM_CLIENT={client} _dd_game={game} _dd_pids=(123) _dd_others=(321)
|
||||
_dd_pressure_at=-1 _dd_pressure_backoff=30 _dd_packed=-1
|
||||
_dd_tier_at=-1 _dd_tier_backoff=30 _dd_tier_pushed=0
|
||||
_dd_client_reserve=0 client_rss=393216 client_anon={anonymous * 1024}
|
||||
step() {{ :; }}
|
||||
dd_session_others() {{ _dd_session=(321); }}
|
||||
dd_zram_scan() {{ _dd_pids=(456); }}
|
||||
nap() {{ echo "nap:$*:at:$NOW"; }}
|
||||
dd_zram_usage() {{
|
||||
if [ "$1" = 123 ]; then
|
||||
_dd_rss=$client_rss _dd_anon=$client_anon _dd_swap=0
|
||||
else
|
||||
_dd_rss=3145728 _dd_anon=1572864 _dd_swap=0
|
||||
fi
|
||||
}}
|
||||
kill() {{ echo "signal:$*:at:$NOW"; NOW=$((NOW + {tick})); }}
|
||||
dd_zram_wait() {{
|
||||
echo "wait:$*:at:$NOW"
|
||||
NOW=$((NOW + 12))
|
||||
_dd_pageout_complete={complete}
|
||||
[ "$1" != 123 ] || client_rss=$((client_rss - {reclaimed * 1024}))
|
||||
}}
|
||||
dd_tier_note() {{ :; }}
|
||||
dd_game_focused() {{ :; }}
|
||||
''' + source + f'''
|
||||
dd_memory_read
|
||||
_dd_fall={fall * 1024}
|
||||
''' + cycle + '''
|
||||
echo "client:$_dd_pressure_backoff:${_dd_client_reserve:-0}:${_dd_client_pending:-0}"
|
||||
def test_the_floor_follows_device_memory_within_limits(self):
|
||||
body = ''.join(self.sample(total=total) + 'dd_memory_read; echo $((_dd_floor / 1024))\n'
|
||||
for total in (3584, 7168, 15360))
|
||||
self.assertEqual(['640', '896', '1280'], self.run_policy(body))
|
||||
|
||||
def test_the_target_grows_with_how_fast_memory_is_falling(self):
|
||||
body = (self.sample(available=3000) + 'dd_memory_read; echo $_dd_rate $((_dd_target / 1024))\n' +
|
||||
self.sample(available=2800) + 'NOW=1; dd_memory_read; echo $((_dd_rate / 1024)) $((_dd_target / 1024))\n' +
|
||||
'NOW=2; dd_memory_read; echo $((_dd_rate / 1024)) $((_dd_target / 1024))\n' +
|
||||
self.sample(available=3400) + 'NOW=3; dd_memory_read; echo $((_dd_rate / 1024))\n')
|
||||
self.assertEqual(['0 896', '200 2896', '150 2396', '112'], self.run_policy(body))
|
||||
|
||||
def test_memory_the_monitor_freed_itself_does_not_hide_a_fall(self):
|
||||
body = (self.sample(available=2000) + 'dd_memory_read\n_dd_freed=$((300 * 1024))\n' +
|
||||
'NOW=2; dd_memory_read; echo $((_dd_rate / 1024)) $_dd_freed\n')
|
||||
self.assertEqual(['150 0'], self.run_policy(body))
|
||||
|
||||
def test_two_reads_in_the_same_second_keep_the_sample(self):
|
||||
body = (self.sample(available=2000) + 'dd_memory_read\n_dd_freed=4096\n' +
|
||||
self.sample(available=1000) + 'dd_memory_read; echo $_dd_rate $_dd_freed $_dd_sample_available\n')
|
||||
self.assertEqual([f'0 4096 {2000 * MB}'], self.run_policy(body))
|
||||
|
||||
def test_stall_time_becomes_a_share_of_the_interval(self):
|
||||
body = (self.sample(stall=1000) + 'dd_memory_read; echo $_dd_psi\n' +
|
||||
self.sample(stall=41000) + 'NOW=2; dd_memory_read; echo $_dd_psi\n' +
|
||||
'NOW=3; dd_memory_read; echo $_dd_psi\n')
|
||||
self.assertEqual(['0', '200', '0'], self.run_policy(body))
|
||||
|
||||
def test_room_counts_zram_only_and_keeps_a_reserve(self):
|
||||
body = (self.sample(zram=(6144, 1024)) + 'dd_memory_read; echo $((_dd_swap_room / 1024))\n' +
|
||||
self.sample(zram=(6144, 5632)) + 'dd_memory_read; echo $((_dd_swap_room / 1024))\n' +
|
||||
self.sample(zram=(0, 0), other=(4096, 1024)) + 'dd_memory_read; echo $((_dd_swap_room / 1024))\n' +
|
||||
self.sample(zram=(512, 0), other=(0, 0)) + 'dd_memory_read; echo $((_dd_swap_room / 1024))\n' +
|
||||
self.sample(zram=(0, 0), other=(4096, 1024)) + f'rm {self.root}/swaps\n' +
|
||||
'dd_memory_read; echo $((_dd_swap_room / 1024))\n')
|
||||
self.assertEqual(['4352', '-256', '-128', '384', '2560'], self.run_policy(body))
|
||||
|
||||
def test_memory_read_back_from_swap_is_remembered_for_half_a_minute(self):
|
||||
body = '_dd_page_kb=4\n' + ''.join(
|
||||
f'NOW={now}\n' + self.sample(swapped_in=total) + 'dd_memory_read; echo $((_dd_returned / 1024))\n'
|
||||
for now, total in ((0, 500), (1, 800), (2, 800), (16, 800), (17, None), (18, 900), (19, 1000), (60, 1000)))
|
||||
self.assertEqual(['0', '300', '290', '154', '149', '144', '239', '0'], self.run_policy(body))
|
||||
|
||||
def test_saving_comes_from_what_zram_really_stores(self):
|
||||
body = ''.join(self.sample(stored=stored) + 'dd_memory_read; echo $_dd_saving\n'
|
||||
for stored in (None, (32, 30), (1000, 250), (1000, 950), (1000, 20)))
|
||||
self.assertEqual(['600', '600', '750', '167', '833'], self.run_policy(body))
|
||||
|
||||
def need(self, available, rate=0, psi=0):
|
||||
return (self.sample(available=available) +
|
||||
f'dd_memory_read; _dd_rate=$(({rate} * 1024)) _dd_psi={psi}\n'
|
||||
'_dd_target=$((_dd_floor + _dd_rate * 10))\n'
|
||||
'dd_memory_need; echo $((_dd_need / 1024)) $((_dd_hard / 1024)) $_dd_force\n')
|
||||
|
||||
def test_steady_memory_above_the_floor_needs_nothing(self):
|
||||
self.assertEqual(['0 0 0'], self.run_policy(self.need(2000)))
|
||||
|
||||
def test_memory_under_the_floor_must_be_freed(self):
|
||||
self.assertEqual(['96 96 0'], self.run_policy(self.need(800)))
|
||||
|
||||
def test_a_slow_fall_is_met_ten_seconds_ahead(self):
|
||||
self.assertEqual(['196 0 0'], self.run_policy(self.need(1000, rate=30)))
|
||||
|
||||
def test_a_fast_fall_is_matched_once_memory_is_under_two_fifths(self):
|
||||
self.assertEqual(['0 0 0', '200 0 0', '0 0 0'],
|
||||
self.run_policy(self.need(2500, rate=20) + self.need(2500, rate=100) + self.need(4000, rate=100)))
|
||||
|
||||
def test_stalls_make_a_fall_urgent(self):
|
||||
self.assertEqual(['200 0 0', '200 200 0', '0 0 0'],
|
||||
self.run_policy(self.need(2500, rate=100) + self.need(2500, rate=100, psi=100) +
|
||||
self.need(2000, psi=900)))
|
||||
|
||||
def test_half_the_floor_forces(self):
|
||||
self.assertEqual(['446 446 0', '456 456 1'], self.run_policy(self.need(450) + self.need(440)))
|
||||
|
||||
RELIEVE = '''
|
||||
step() { echo "step:$*"; }
|
||||
dd_session_others() { echo others; _dd_session=(70 80); }
|
||||
dd_zram_trim() { echo "trim:$1:$(($2 / 1024)):${*:3}"; _dd_trimmed=${paged:-$2}; }
|
||||
relieve() { dd_memory_read; _dd_returned=${returned:-0}; _dd_rate=$((${2:-0} * 1024)) _dd_target=$((_dd_floor + ${2:-0} * 10240)); dd_memory_relieve; }
|
||||
_dd_pids=(10 20) _dd_game=1 _dd_focus=0 _dd_saving=500
|
||||
'''
|
||||
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 relieve(self, body):
|
||||
return self.run_policy(self.RELIEVE + body, 'dd_memory_relieve', 'dd_memory_note')
|
||||
|
||||
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_a_fall_trims_the_client_behind_a_game_by_what_zram_gives_back(self):
|
||||
self.assertEqual(['trim:2:326:10 20', f'{196 * MB} {334506 * 600 // 1000} 334506'], self.relieve(
|
||||
self.sample(available=1000) + 'relieve 1000 30; echo $_dd_need $_dd_freed $_dd_client_out\n'))
|
||||
|
||||
def test_no_game_requests_nothing(self):
|
||||
self.assertEqual(['client:30:0:0'], self.run_cycle(game=0))
|
||||
def test_the_client_in_front_is_left_alone_until_memory_is_under_the_floor(self):
|
||||
self.assertEqual(['trim:2:160:10 20'], self.relieve(
|
||||
self.sample(available=1000) + '_dd_focus=1; relieve 1000 30\n' +
|
||||
self.sample(available=800) + 'relieve 800\n'))
|
||||
|
||||
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_unknown_focus_still_trims_the_client(self):
|
||||
self.assertEqual(['trim:2:326:10 20'], self.relieve(self.sample(available=1000) + '_dd_focus=2; relieve 1000 30\n'))
|
||||
|
||||
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_the_client_is_not_trimmed_right_after_it_was_read_back(self):
|
||||
self.assertEqual(['trim:2:326:10 20'], self.relieve(
|
||||
self.sample(available=1000) + 'NOW=100 _dd_back_at=80; relieve 1000 30\nNOW=110; relieve 1000 30\n'))
|
||||
|
||||
def test_deferred_ineffective_reclaim_still_doubles_the_backoff(self):
|
||||
self.assertEqual('client:60:0:0', self.run_cycle(reclaimed=0)[-1])
|
||||
def test_without_a_game_only_the_floor_trims(self):
|
||||
self.assertEqual(['trim:2:160:10 20'], self.relieve(
|
||||
self.sample(available=1000) + '_dd_game=0 _dd_focus=1; relieve 1000 30\n' +
|
||||
self.sample(available=800) + 'relieve 800\n'))
|
||||
|
||||
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_the_session_gives_what_the_client_could_not(self):
|
||||
self.assertEqual(['trim:2:660:10 20', 'others', 'trim:2:256:70 80', 'trim:2:660:10 20', 'trim:2:256:70 80'],
|
||||
self.relieve(self.sample(available=500) + f'paged={128 * MB}; relieve 500\nNOW=1; relieve 500\n'))
|
||||
|
||||
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='dd_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='dd_zram_send 1 cap game\n'))
|
||||
def test_the_session_gets_what_the_client_left_of_the_pass(self):
|
||||
self.assertEqual(['trim:3:1024:10 20', 'others', 'trim:3:24:70 80'], self.relieve(
|
||||
self.sample(available=100) + f'paged={1000 * MB}; relieve 100\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='dd_zram_send 0 readback client\n'))
|
||||
def test_memory_that_keeps_coming_back_is_taken_off_what_a_pass_may_move(self):
|
||||
self.assertEqual(['trim:2:660:10 20', 'others', 'trim:2:156:70 80', 'trim:2:660:10 20', 'trim:2:24:10 20'], self.relieve(
|
||||
self.sample(available=500) + f'paged={256 * MB}\nreturned={100 * MB}; relieve 500\n' +
|
||||
f'NOW=1 returned={300 * MB}; relieve 500\nNOW=2 returned={1000 * MB}; relieve 500\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('dd_zram_usage').replace('/proc/', str(root) + '/')
|
||||
result = run_bash(source + '\ndd_zram_usage 123 321 654 > /dev/null; echo "$_dd_rss:$_dd_anon:$_dd_swap"')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('7000:4300:300', result.stdout.strip())
|
||||
def test_forcing_moves_memory_whatever_came_back(self):
|
||||
self.assertEqual(['trim:3:993:10 20', 'others', 'trim:3:993:70 80'], self.relieve(
|
||||
self.sample(available=300) + f'paged=0 returned={2048 * MB}; relieve 300\n'))
|
||||
|
||||
def test_the_session_is_scanned_again_after_a_new_process_scan(self):
|
||||
self.assertEqual(['others', 'others'], [line for line in self.relieve(
|
||||
self.sample(available=500) + f'paged={256 * MB}; relieve 500\n_dd_scan_at=5; relieve 500\n') if line == 'others'])
|
||||
|
||||
def test_forcing_ignores_heat_once_in_ten_seconds(self):
|
||||
lines = self.relieve(self.sample(available=300) + 'paged=0\nrelieve 300\nNOW=5; relieve 300\nNOW=10; relieve 300\n')
|
||||
self.assertEqual(['3', '3', '2', '2', '3', '3'], [line.split(':')[1] for line in lines if line.startswith('trim')])
|
||||
self.assertIn('trim:3:993:70 80', lines)
|
||||
|
||||
def trims(self, body):
|
||||
return [line.split(':')[2] for line in self.relieve(body) if line.startswith('trim') and line.endswith('10 20')]
|
||||
|
||||
def test_passes_that_free_little_come_further_and_further_apart(self):
|
||||
passes = ''.join(f'NOW={now}; relieve 500; echo at:{now}\n' for now in (0, 4, 5, 14, 15, 34, 35))
|
||||
lines = self.relieve(self.sample(available=500) + f'paged={8 * MB}\n' + passes)
|
||||
self.assertEqual(['0', '5', '15', '35'],
|
||||
[after.split(':')[1] for line, after in zip(lines, lines[1:] + ['']) if line == 'trim:2:256:70 80'])
|
||||
|
||||
def test_the_wait_between_passes_stops_at_a_minute(self):
|
||||
self.assertEqual(['60 195'], self.relieve(
|
||||
self.sample(available=500) + f'paged={8 * MB}\nfor NOW in 0 5 15 35 75 135; do relieve 500; done > /dev/null\n'
|
||||
'echo $_dd_rest $_dd_rest_until\n'))
|
||||
|
||||
def test_a_pass_that_frees_enough_is_followed_at_once(self):
|
||||
self.assertEqual(['660', '660'], self.trims(
|
||||
self.sample(available=500) + f'paged={128 * MB}; relieve 500\nNOW=1; relieve 500\n'))
|
||||
|
||||
def test_memory_that_keeps_falling_ends_the_wait(self):
|
||||
self.assertEqual(['326', '526'], self.trims(
|
||||
self.sample(available=700) + f'paged={8 * MB}; relieve 700\nNOW=1; relieve 700\n' +
|
||||
self.sample(available=600) + 'NOW=2; relieve 600\n' + self.sample(available=580) + 'NOW=3; relieve 580\n'))
|
||||
|
||||
def test_forcing_does_not_wait(self):
|
||||
self.assertEqual(['993', '993'], self.trims(
|
||||
self.sample(available=300) + 'paged=0\nrelieve 300\nNOW=1; relieve 300\n'))
|
||||
|
||||
def test_the_wait_is_forgotten_once_memory_is_back(self):
|
||||
self.assertEqual(['660', '660'], self.trims(
|
||||
self.sample(available=500) + f'paged={8 * MB}; relieve 500\n' +
|
||||
self.sample(available=3000) + 'NOW=1; relieve 3000\n' + self.sample(available=500) + 'NOW=2; relieve 500\n'))
|
||||
|
||||
def test_trims_stop_at_the_room_zram_has(self):
|
||||
self.assertEqual(['trim:2:100:10 20', 'step:memory: available 800 MB and zRAM has no room left'], self.relieve(
|
||||
self.sample(available=800, zram=(6144, 5276)) + 'relieve 800\n' +
|
||||
self.sample(available=800, zram=(6144, 5400)) + 'relieve 800\nNOW=30; relieve 800\n'))
|
||||
|
||||
def test_small_trims_are_not_logged(self):
|
||||
self.assertEqual(['step:memory: available 1000 MB, falling 30 MB/s, compressed 20 MB of the client and 0 MB of the session'],
|
||||
[line for line in self.relieve(
|
||||
self.sample(available=1000) + f'paged={10 * MB}\nrelieve 1000 30; dd_memory_note\n'
|
||||
'NOW=1; relieve 1000 30; dd_memory_note\nNOW=2; dd_memory_note\n')
|
||||
if line.startswith('step')])
|
||||
|
||||
TRIM = '''
|
||||
declare -A anon=() reply=() born=()
|
||||
nap() { :; }
|
||||
dd_pid_key() { _dd_key=$1.${born[$1]:-0}; }
|
||||
dd_zram_usage() { _dd_anon=${anon[$1]}; }
|
||||
kill() {
|
||||
echo "signal:$2:$(< "$ROOT/ctl")"
|
||||
case ${reply[$2]} in
|
||||
deaf) ;;
|
||||
gone) return 1 ;;
|
||||
*) printf %s "${reply[$2]}" > "$ROOT/ctl.trim.$2" ;;
|
||||
esac
|
||||
}
|
||||
'''
|
||||
|
||||
def trim(self, body):
|
||||
return self.run_policy(f'ROOT={self.root}\n' + self.TRIM + body + '\nls "$ROOT"; cat "$ROOT/ctl"', 'dd_memory_relieved', 'dd_zram_trim')
|
||||
|
||||
def test_a_trim_spends_its_budget_across_processes_in_order(self):
|
||||
self.assertEqual(['signal:10:2 100000', 'signal:20:2 60000', '100000', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000 [20]=500000 [30]=500000) reply=([10]=40000 [20]=60000 [30]=1)
|
||||
dd_zram_trim 2 100000 10 20 30
|
||||
echo $_dd_trimmed'''))
|
||||
|
||||
def test_a_trim_skips_small_and_gone_processes_and_stops_when_little_is_left(self):
|
||||
self.assertEqual(['signal:20:3 50000', 'signal:30:3 50000', 'signal:40:3 50000', '47000', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=4096 [20]=500000 [30]=500000 [40]=500000 [50]=500000) reply=([20]=gone [30]=0 [40]=47000 [50]=1)
|
||||
dd_zram_trim 3 50000 10 20 30 40 50
|
||||
echo $_dd_trimmed'''))
|
||||
|
||||
def test_a_process_that_never_answers_is_left_alone_for_a_minute(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'signal:20:2 9000', '500', 'signal:20:2 9000', 'signal:10:2 9000',
|
||||
'signal:20:2 9000', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000 [20]=500000) reply=([10]=deaf [20]=500)
|
||||
dd_zram_trim 2 9000 10 20
|
||||
echo $_dd_trimmed
|
||||
NOW=59 _dd_pass_at=59; dd_zram_trim 2 9000 10 20
|
||||
NOW=60 _dd_pass_at=60; dd_zram_trim 2 9000 10 20'''))
|
||||
|
||||
def test_a_new_process_with_a_silent_ones_number_is_asked(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'signal:10:2 9000', '1', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000) reply=([10]=deaf)
|
||||
dd_zram_trim 2 9000 10
|
||||
NOW=5 _dd_pass_at=5; dd_zram_trim 2 9000 10
|
||||
born[10]=7
|
||||
dd_zram_trim 2 9000 10
|
||||
NOW=62 _dd_pass_at=62 anon=(); dd_zram_trim 2 9000
|
||||
echo ${#_dd_deaf[@]}'''))
|
||||
|
||||
def test_one_pass_waits_five_seconds_in_all(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'signal:20:2 9000', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000 [20]=500000 [30]=500000) reply=([10]=- [20]=deaf [30]=deaf)
|
||||
_dd_polls=215
|
||||
dd_zram_trim 2 9000 10
|
||||
dd_zram_trim 2 9000 20 30'''))
|
||||
|
||||
def test_one_pass_ends_six_seconds_after_it_began_however_slow_the_polls(self):
|
||||
self.assertEqual(['signal:10:2 9000', '6', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000 [20]=500000) reply=([10]=deaf [20]=500)
|
||||
nap() { NOW=$((NOW + 1)); }
|
||||
dd_zram_trim 2 9000 10 20
|
||||
echo $_dd_polls'''))
|
||||
|
||||
def test_a_trim_stops_once_memory_is_back_where_it_should_be(self):
|
||||
self.assertEqual(['signal:10:2 9000', '500', 'signal:10:2 9000', 'signal:20:2 8500', '1000', 'ctl', 'meminfo', '2 0'],
|
||||
self.trim('''
|
||||
anon=([10]=500000 [20]=500000) reply=([10]=500 [20]=500)
|
||||
available() { echo "MemAvailable: $1 kB" > "$ROOT/meminfo"; }
|
||||
signal=$(declare -f kill)
|
||||
eval "raw_${signal}"
|
||||
kill() { raw_kill "$@"; available $((after)); }
|
||||
available 800000
|
||||
_dd_goal=900000 after=900000
|
||||
dd_zram_trim 2 9000 10 20
|
||||
echo $_dd_trimmed
|
||||
available 800000
|
||||
after=899999
|
||||
dd_zram_trim 2 9000 10 20
|
||||
echo $_dd_trimmed'''))
|
||||
|
||||
def test_a_held_control_file_keeps_its_acknowledgements(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'ctl', 'ctl.hold', 'ctl.trim.10', '2 9000'], self.trim('''
|
||||
anon=([10]=500000)
|
||||
kill() { echo "signal:$2:$(< "$ROOT/ctl")"; : > "$ROOT/ctl.hold"; printf 1 > "$ROOT/ctl.trim.$2"; }
|
||||
dd_zram_trim 2 9000 10'''))
|
||||
|
||||
def test_a_trim_leaves_the_acknowledgement_of_a_suspend_page_out_alone(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'ctl', 'ctl.ack.10', '2 0'], self.trim('''
|
||||
anon=([10]=500000) reply=([10]=9000)
|
||||
: > "$ROOT/ctl.ack.10"
|
||||
dd_zram_trim 2 9000 10'''))
|
||||
|
||||
READBACK = '''
|
||||
step() { echo "step:$*"; }
|
||||
kill() { echo "signal:$*:$(< "$ROOT/ctl")"; }
|
||||
dd_zram_usage() { _dd_swap=$((swap * 1024)); }
|
||||
back() { dd_memory_read; _dd_rate=0 _dd_target=$_dd_floor; dd_client_readback; }
|
||||
_dd_pids=(10 20) _dd_game=0 _dd_client_out=4096 _dd_trim_at=0 swap=400 NOW=30
|
||||
'''
|
||||
|
||||
def readback(self, body):
|
||||
return self.run_policy(f'ROOT={self.root}\n' + self.READBACK + body, 'dd_client_readback')
|
||||
|
||||
def test_the_client_is_read_back_once_memory_can_hold_it_with_a_floor_to_spare(self):
|
||||
self.assertEqual(['step:memory: available 2192 MB, reading 400 MB of the client back', 'signal:-URG 10 20:0',
|
||||
f'0 {-400 * MB * 600 // 1000} 30'], self.readback(
|
||||
self.sample(available=2191) + 'back\n' + self.sample(available=2192) + 'back\n' +
|
||||
'echo $_dd_client_out $_dd_freed $_dd_back_at\nback\n'))
|
||||
|
||||
def test_nothing_is_read_back_right_after_a_trim(self):
|
||||
self.assertEqual([], self.readback(self.sample(available=4000) + 'NOW=29; back\n'))
|
||||
|
||||
def test_a_running_game_keeps_the_client_compressed_until_the_client_is_in_front(self):
|
||||
self.assertEqual(['signal:-URG 10 20:0'], [line for line in self.readback(
|
||||
self.sample(available=4000) + '_dd_game=1\nback\n_dd_away=27; back\n_dd_away=25; back\n')
|
||||
if line.startswith('signal')])
|
||||
|
||||
def test_a_client_the_kernel_already_brought_back_needs_no_request(self):
|
||||
self.assertEqual(['0'], self.readback(self.sample(available=4000) + 'swap=8; back; echo $_dd_client_out\n'))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -60,6 +60,19 @@ static long status(const char *key) {
|
||||
return v;
|
||||
}
|
||||
|
||||
static long resident(char *start, size_t size) {
|
||||
long page = sysconf(_SC_PAGESIZE), kb = 0;
|
||||
int fd = open("/proc/self/pagemap", O_RDONLY);
|
||||
if (fd < 0) exit(8);
|
||||
for (size_t i = 0; i < size; i += page) {
|
||||
uint64_t entry;
|
||||
if (pread(fd, &entry, sizeof(entry), ((uintptr_t)start + i) / page * sizeof(entry)) != sizeof(entry)) exit(8);
|
||||
if (entry >> 63) kb += page / 1024;
|
||||
}
|
||||
close(fd);
|
||||
return kb;
|
||||
}
|
||||
|
||||
static void send_request(char mode) {
|
||||
int fd = open(ctl, O_WRONLY | O_TRUNC);
|
||||
if (fd < 0 || write(fd, &mode, 1) != 1) exit(3);
|
||||
@@ -91,6 +104,25 @@ static void request(char mode) {
|
||||
usleep(1000000);
|
||||
}
|
||||
|
||||
static long trim(char mode, long kb) {
|
||||
char ack[256], text[32];
|
||||
snprintf(ack, sizeof(ack), "%s.trim.%d", ctl, getpid());
|
||||
unlink(ack);
|
||||
FILE *f = fopen(ctl, "w");
|
||||
if (!f) exit(3);
|
||||
fprintf(f, "%c %ld\n", mode, kb);
|
||||
fclose(f);
|
||||
kill(getpid(), SIGURG);
|
||||
for (int i = 0; i < 1200; i++) {
|
||||
f = fopen(ack, "r");
|
||||
char *line = f ? fgets(text, sizeof(text), f) : NULL;
|
||||
if (f) fclose(f);
|
||||
if (line) return atol(text);
|
||||
usleep(10000);
|
||||
}
|
||||
exit(5);
|
||||
}
|
||||
|
||||
static uint64_t sum(const unsigned char *p, size_t n) {
|
||||
uint64_t s = 0;
|
||||
for (size_t i = 0; i < n; i += 64) s = s * 31 + p[i];
|
||||
@@ -167,6 +199,80 @@ int main(int argc, char **argv) {
|
||||
int status_code;
|
||||
waitpid(child, &status_code, 0);
|
||||
printf("childack %d\n", WIFEXITED(status_code) && WEXITSTATUS(status_code) == 0);
|
||||
} else if (!strcmp(argv[4], "trim")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
printf("first %ld\n", trim('2', 8192));
|
||||
printf("second %ld\n", trim('2', 8192));
|
||||
printf("swapped %ld\n", status("VmSwap:"));
|
||||
printf("rest %ld\n", trim('2', 1L << 30));
|
||||
printf("touched %d\n", sum(shared, size) != 0);
|
||||
printf("hot %ld\n", trim('2', 1L << 30));
|
||||
printf("forced %ld\n", trim('3', 1L << 30));
|
||||
request('0');
|
||||
printf("again %ld\n", trim('2', 1L << 30));
|
||||
printf("intact %d\n", sum(data, size) == before);
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "trim-small")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
long total = 0, largest = 0;
|
||||
for (int i = 0; i < 112; i++) {
|
||||
long step = trim('2', 512);
|
||||
total += step;
|
||||
if (step > largest) largest = step;
|
||||
}
|
||||
printf("small %ld\n", total);
|
||||
printf("largest %ld\n", largest);
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "trim-sparse")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
size_t wide = 32UL << 20;
|
||||
char *thin = mmap(NULL, wide, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
||||
if (thin == MAP_FAILED) exit(7);
|
||||
for (size_t i = 0; i < wide; i += 2 * page) thin[i] = 1;
|
||||
printf("sparse %ld\n", resident(thin, wide));
|
||||
for (int i = 0; i < 240; i++) trim('2', 512);
|
||||
printf("kept %ld\n", resident(thin, wide));
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "hold")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
char hold[256];
|
||||
snprintf(hold, sizeof(hold), "%s.hold", ctl);
|
||||
FILE *f = fopen(hold, "w");
|
||||
if (!f) exit(3);
|
||||
fclose(f);
|
||||
printf("empty %ld\n", trim('2', 512));
|
||||
f = fopen(hold, "w");
|
||||
if (!f) exit(3);
|
||||
fputs("1", f);
|
||||
fclose(f);
|
||||
f = fopen(ctl, "w");
|
||||
if (!f) exit(3);
|
||||
fputs("2 512\n", f);
|
||||
fclose(f);
|
||||
kill(getpid(), SIGURG);
|
||||
wait_ack();
|
||||
printf("held %ld\n", status("VmSwap:"));
|
||||
unlink(hold);
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "trim-fork")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
fflush(stdout);
|
||||
pid_t child = fork();
|
||||
if (child < 0) exit(6);
|
||||
if (child == 0) {
|
||||
for (size_t i = 0; i < size; i += page) data[i]++;
|
||||
printf("inline_trim %ld\n", trim('2', 1L << 30));
|
||||
fflush(stdout);
|
||||
_exit(0);
|
||||
}
|
||||
waitpid(child, NULL, 0);
|
||||
printf("worker_trim %ld\n", trim('2', 1L << 30));
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "burst")) {
|
||||
send_request('0');
|
||||
usleep(10000);
|
||||
@@ -280,8 +386,9 @@ class ZramPreloadTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.ctl.write_text("0")
|
||||
for ack in self.dir.glob("ctl.ack.*"):
|
||||
for ack in [*self.dir.glob("ctl.ack.*"), *self.dir.glob("ctl.trim.*")]:
|
||||
ack.unlink()
|
||||
(self.dir / "ctl.hold").unlink(missing_ok=True)
|
||||
|
||||
def run_program(self, program=None, mb=48, cycles=1, *extra):
|
||||
environment = dict(os.environ, LD_PRELOAD=str(self.lib))
|
||||
@@ -347,7 +454,9 @@ class ZramPreloadTest(unittest.TestCase):
|
||||
os.kill(process.pid, signal.SIGURG)
|
||||
os.kill(process.pid, signal.SIGUSR1)
|
||||
self.assertEqual(f"received {_ + 1}", process.stdout.readline().strip())
|
||||
output, _ = process.communicate(timeout=10)
|
||||
process.stdin.close()
|
||||
process.wait(timeout=10)
|
||||
output = process.stdout.read()
|
||||
values = dict(line.split() for line in output.splitlines())
|
||||
self.assertNotEqual(0, int(values["urg"]))
|
||||
self.assertNotEqual(0, int(values["usr"]))
|
||||
@@ -388,6 +497,50 @@ class ZramPreloadTest(unittest.TestCase):
|
||||
out = self.run_program(None, 48, 0, "fork")
|
||||
self.assertEqual([1], out["childack"])
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_trim_stops_at_its_budget_and_continues_where_it_stopped(self):
|
||||
out = self.run_program(None, 32, 0, "trim")
|
||||
self.assertTrue(7168 < out["first"][0] <= 8192, out)
|
||||
self.assertTrue(7168 < out["second"][0] <= 8192, out)
|
||||
self.assertGreater(out["swapped"][0], 15 * 1024)
|
||||
self.assertGreater(out["rest"][0], 40 * 1024)
|
||||
self.assertEqual([1], out["intact"])
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_trim_leaves_memory_that_came_straight_back(self):
|
||||
out = self.run_program(None, 32, 0, "trim")
|
||||
self.assertLess(out["hot"][0], 4 * 1024, out)
|
||||
self.assertGreater(out["forced"][0], 28 * 1024, out)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_requested_read_back_does_not_count_as_heat(self):
|
||||
out = self.run_program(None, 32, 0, "trim")
|
||||
self.assertTrue(28 * 1024 < out["again"][0] < 40 * 1024, out)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_budgets_smaller_than_a_chunk_still_reach_all_of_it(self):
|
||||
out = self.run_program(None, 32, 0, "trim-small")
|
||||
self.assertLessEqual(out["largest"][0], 512)
|
||||
self.assertGreater(out["small"][0], 52 * 1024)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_small_budgets_reach_the_end_of_a_thinly_used_chunk(self):
|
||||
out = self.run_program(None, 8, 0, "trim-sparse")
|
||||
self.assertEqual([16 * 1024], out["sparse"])
|
||||
self.assertLess(out["kept"][0], 1024, out)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_a_request_in_the_hold_file_wins_over_the_control_file(self):
|
||||
out = self.run_program(None, 32, 0, "hold")
|
||||
self.assertTrue(0 < out["empty"][0] <= 512, out)
|
||||
self.assertGreater(out["held"][0], 40 * 1024, out)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_process_without_a_worker_trims_in_small_steps(self):
|
||||
out = self.run_program(None, 48, 0, "trim-fork")
|
||||
self.assertTrue(16 * 1024 < out["inline_trim"][0] <= 32 * 1024, out)
|
||||
self.assertGreater(out["worker_trim"][0], 64 * 1024, out)
|
||||
|
||||
def test_worker_acknowledges_back_to_back_requests(self):
|
||||
out = self.run_program(None, 48, 0, "burst")
|
||||
self.assertEqual([1], out["burstack"])
|
||||
|
||||
Reference in new issue
Block a user