diff --git a/app/src/main/java/com/droiddeck/launcher/core/HostProcess.kt b/app/src/main/java/com/droiddeck/launcher/core/HostProcess.kt index 0757192461..114e337892 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/HostProcess.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/HostProcess.kt @@ -13,6 +13,11 @@ object HostProcess { @JvmStatic fun start(command: String, env: Array?, dir: File?, onExit: Consumer?, onLine: Consumer?, outputFile: File?): Int { + return start(command, env, dir, onExit, onLine, outputFile, null) + } + + @JvmStatic + fun start(command: String, env: Array?, dir: File?, onExit: Consumer?, onLine: Consumer?, outputFile: File?, onOutputComplete: Runnable?): Int { val argv = split(command) if (argv.isEmpty()) return -1 return try { @@ -35,6 +40,8 @@ object HostProcess { try { process.inputStream.bufferedReader().useLines { lines -> lines.forEach { onLine.accept(it) } } } catch (e: Exception) { + } finally { + onOutputComplete?.run() } }, "proc-out-$pid").apply { priority = Thread.NORM_PRIORITY - 1; isDaemon = true; start() } } diff --git a/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt b/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt index b9c0256dbf..c7b4a78c7c 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt @@ -5,6 +5,9 @@ import android.util.Log import java.io.BufferedWriter import java.io.File import java.io.FileOutputStream +import java.nio.file.Files +import java.nio.file.StandardCopyOption +import java.util.concurrent.atomic.AtomicInteger object SessionLogCapture { private const val TAG = "SessionLogCapture" @@ -104,4 +107,53 @@ object SessionLogCapture { Log.w(TAG, "could not dump the crash buffer", e) } } + + fun dumpMemoryPressure(target: File) { + var temporary: File? = null + try { + val staged = File.createTempFile(target.name, ".part", target.parentFile).also { temporary = it } + val lines = StringBuilder() + val done = java.util.concurrent.CountDownLatch(1) + val outputDone = java.util.concurrent.CountDownLatch(1) + val exitStatus = AtomicInteger(Int.MIN_VALUE) + val pid = HostProcess.start( + "/system/bin/logcat -b events -d -v threadtime -t 800", null, target.parentFile, + { status -> exitStatus.set(status); done.countDown() }, + { line -> synchronized(lines) { lines.append(line).append('\n') } }, + null, + outputDone::countDown, + ) + val deadline = System.nanoTime() + java.util.concurrent.TimeUnit.SECONDS.toNanos(10) + val finished = if (pid == -1) false else { + val exitTime = deadline - System.nanoTime() + exitTime > 0 && done.await(exitTime, java.util.concurrent.TimeUnit.NANOSECONDS) && + (deadline - System.nanoTime()).let { it > 0 && outputDone.await(it, java.util.concurrent.TimeUnit.NANOSECONDS) } + } + val body = synchronized(lines) { lines.toString() } + val status = exitStatus.get() + val pressure = runCatching { File("/proc/pressure/memory").readText() }.getOrDefault("unavailable\n") + val meminfo = runCatching { File("/proc/meminfo").readText() }.getOrDefault("unavailable\n") + val gpu = runCatching { File("/sys/class/kgsl/kgsl/page_alloc").readText() }.getOrDefault("unavailable\n") + staged.writeText( + "Android memory events:\n" + + when { + pid == -1 -> "(logcat could not be started at all)\n" + status != Int.MIN_VALUE && status != 0 -> "(logcat failed with exit status $status; no Android memory events were captured)\n" + + if (body.isEmpty()) "" else "\nlogcat command output:\n$body" + !finished -> if (body.isEmpty()) "(logcat did not finish within 10 s; nothing captured)\n" + else body + "(logcat did not finish within 10 s; later events may be missing)\n" + body.isNotEmpty() -> body + else -> "(no readable events were returned)\n" + } + + "\n/proc/pressure/memory:\n$pressure\n/proc/meminfo:\n$meminfo\n/sys/class/kgsl/kgsl/page_alloc:\n$gpu" + ) + Files.move( + staged.toPath(), target.toPath(), + StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE, + ) + } catch (e: Exception) { + temporary?.delete() + Log.w(TAG, "could not dump memory pressure diagnostics", e) + } + } } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionArtifacts.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionArtifacts.kt index cb766a2de3..3ac0ef8ab6 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionArtifacts.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionArtifacts.kt @@ -77,6 +77,7 @@ object SessionArtifacts { copySteamLogs(context, dir, record, steamArch) VacDiagnostics.collect(context, dir) SessionLogCapture.dumpCrashBuffer(File(dir, "crash.log")) + SessionLogCapture.dumpMemoryPressure(File(dir, "memory-pressure.log")) val scrubbed = markScrubbed(scrubTree(record)) SessionEvents.record("session.artifacts_collected", mapOf("reason" to reason), dir) if (scrubbed) File(dir, COMPLETE_MARKER).writeText("collected: $reason at ${now()}\n") @@ -594,6 +595,10 @@ object SessionArtifacts { if (!crashLog.exists()) { SessionLogCapture.dumpCrashBuffer(crashLog) } + val memoryLog = File(dir, "memory-pressure.log") + if (newest && !memoryLog.exists()) { + SessionLogCapture.dumpMemoryPressure(memoryLog) + } if (stopWhenSessionStarts && SessionState.running) { record.failed = true record.deferred = true diff --git a/docs/development/low-memory.md b/docs/development/low-memory.md index 4b8e9b459e..81055ff0b1 100644 --- a/docs/development/low-memory.md +++ b/docs/development/low-memory.md @@ -9,8 +9,10 @@ Every five seconds the monitor reads `MemAvailable`, swap headroom and memory PS headroom means less than one fifth of total RAM (bounded to 512–1536 MiB), or at least 1% `some avg10` memory stall with less than one third of RAM available. Pressure requests target only the launcher processes already recognized by the monitor, never the game. They require -at least 128 MiB launcher RSS and enough free swap to cover its entire RSS while leaving -one fifth of swap (at least 256 MiB) free. The regular automatic client request uses the +at least 128 MiB launcher RSS and enough free swap to cover its anonymous RSS while leaving +one fifth of swap (at least 256 MiB) free. File-backed resident pages do not consume this +budget: the page-out helper targets private anonymous mappings. If `RssAnon` is absent from a +process's status, its full RSS is used instead. The regular automatic client request uses the same swap guard. An explicit session RAM cap retains its existing behavior. Pressure requests are at least 30 seconds apart. Reclaiming less than 16 MiB doubles the @@ -41,27 +43,32 @@ reduced aggregate launcher RSS only from 263 to 255 MiB and backed off. Thus lau does not resolve this load failure, and this run did not exhaust swap. The unevictable/shmem growth needs allocation attribution before treating it as a driver or GPU-memory diagnosis. -## Low-RAM devices: compressing idle game memory +## Pressure reclaim: compressing idle game memory -On devices with at most 13 GiB `MemTotal` (every 12 GB phone and handheld and below), the -monitor also compresses the game session itself when memory runs out. The trigger is absolute -headroom, not a percentage: Android's `lmkd` killed a session on a 7.5 GiB device with +The monitor also compresses the game session itself when observed pressure approaches the +system kill boundary. There is no RAM-size gate. The trigger is absolute real headroom, not a +percentage: Android's `lmkd` killed a session on a 7.5 GiB device with 490 MiB still available, so a 95% used threshold (about 400 MiB left on 8 GB) is already past the kill. A world load added 1 GiB of GPU memory in about ten seconds, and compressing 1.4 GiB took 2.6 seconds, so the request has to leave room for both. -The session request runs when available memory falls below a quarter of RAM (bounded to -768–2560 MiB, 1.85 GiB on an 8 GB device), or below one and a half times that with at least 1% -`some avg10` memory stall. One request pages out every session process that loaded -`libblsession.so`: the game, Wine and its services, plus the launcher processes unless their -compression is turned off, under a single wait. It runs before the launcher-only check, which -can wait up to 12 seconds for acknowledgements. While a game runs and available memory is under -twice that level, memory is read every second instead of every five. Requests are at least 30 seconds apart and need the same swap reserve as launcher -requests. When the session has read back more than half of what the previous request compressed, -that memory is in use: the request is skipped and the wait doubles, up to five minutes. A -request whose memory stayed compressed resets it to 30 seconds. Below half the headroom the -wait is ignored and only the 30-second spacing applies. The state resets when the game exits. Devices above 13 GiB keep the -launcher-only behaviour. +The session request runs when real headroom falls below a quarter of RAM (bounded to +768–2560 MiB), or below one and a half times that with at least 1% `some` or `full avg10` +memory stall. Real headroom subtracts positive growth in KGSL allocation, `Unevictable`, and +`Shmem` from `MemAvailable`; a rapid fall also qualifies near twice the headroom. The monitor +may first request page-out of idle Steam and hidden launchers, subject to the Performance +setting and client reclaim limits. When both qualify, both requests are sent before waiting +for either to complete, so a slow launcher acknowledgement does not delay the game request. Until the client +request finishes, its anonymous RSS remains reserved from the session's swap budget. Completion +and backoff are measured against the processes that received each request, even if a later scan +finds different processes. The session request targets processes that loaded +`libblsession.so`: the game, Wine and its services, and excludes Steam and hidden launchers. +Requests are at least 30 seconds apart and need the same +swap reserve as launcher requests. When the session has read back more than half of what the +previous request compressed, that memory is in use: the request is skipped and the wait doubles, +up to five minutes. A request whose memory stayed compressed resets it to 30 seconds. Below half +the headroom the wait is ignored and only the 30-second spacing applies. The state resets when +the game exits. Measured on a Retroid Pocket Duo (7.5 GiB, kernel 6.6, 6 GiB lzo-rle zram plus a 4 GiB swap file) entering the world in World of Warcraft: Forever, one run each: @@ -91,7 +98,8 @@ A second run on that build showed the trigger arriving too late: character selec there. During the load, available memory crossed the headroom 9 seconds after Enter World, but the launcher check ran first and waited 12 seconds for acknowledgements; the game request started at 21 seconds, moved about 200 MiB, and `lmkd` ended the session at 30 seconds. The quarter-of-RAM -level and the game-first single request address both. +level starts reclaim earlier. Sending both requests before waiting removes the launcher +acknowledgement delay; it does not guarantee that reclaim can keep up with every loading peak. Without root an app cannot write its memory cgroup's `memory.reclaim` (owned by `system`), `process_madvise` on another process returns `EPERM`, `PAGEMAP_SCAN` is absent before Linux 6.7, diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index df27767405..9ec12398f4 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -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 diff --git a/tools/tests/test_client_zram_focus.py b/tools/tests/test_client_zram_focus.py index 5cd7d3cd4a..db2d3f80e1 100644 --- a/tools/tests/test_client_zram_focus.py +++ b/tools/tests/test_client_zram_focus.py @@ -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 ]; } diff --git a/tools/tests/test_memory_pressure.py b/tools/tests/test_memory_pressure.py index 13f9e2f8d3..01c32c3f82 100644 --- a/tools/tests/test_memory_pressure.py +++ b/tools/tests/test_memory_pressure.py @@ -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()