mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 21:06:09 +00:00
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.
196 lines
12 KiB
Markdown
196 lines
12 KiB
Markdown
# Automatic memory management
|
||
|
||
The Steam session keeps enough memory free on its own. There are no memory settings: the
|
||
session monitor in `droiddeck-session` measures how much memory is available and how fast it is
|
||
being taken, and compresses just enough idle memory into zRAM to stay ahead of it.
|
||
|
||
## What the monitor measures
|
||
|
||
Each pass reads four things:
|
||
|
||
- `MemAvailable` from `/proc/meminfo`.
|
||
- The fall rate: how much `MemAvailable` dropped since the last pass, plus what the monitor
|
||
itself freed in between, per second. A peak decays by a quarter per pass, so one burst keeps
|
||
the monitor alert for a few seconds without holding it there.
|
||
- Memory stall: the change in the `some` total of `/proc/pressure/memory`, as a percentage of
|
||
the time between passes. A missing PSI file reads as no stall.
|
||
- zRAM room and saving: free space on the zRAM swap devices in `/proc/swaps` after a reserve
|
||
of one eighth of zRAM (at least 128 MiB), and the measured saving per compressed byte from
|
||
`/sys/block/zram0/mm_stat` (bounded to 1.2:1–6:1, 2.5:1 before 64 MiB has been stored).
|
||
Disk swap is not counted as room: paging to storage is what causes long stalls.
|
||
|
||
The monitor sleeps five seconds between passes while more than two fifths of RAM is available
|
||
and memory is steady, and one second otherwise.
|
||
|
||
## Levels
|
||
|
||
| Level | Value | Meaning |
|
||
| --- | --- | --- |
|
||
| Floor | one eighth of RAM, bounded to 640–1280 MiB | Below this the system is close to killing the session. `lmkd` ended a session on a 7.5 GiB device with 490 MiB available. |
|
||
| Target | floor + ten seconds of the fall rate | Where the monitor wants available memory to stay. |
|
||
| Burst | two seconds of the fall rate, when that is at least 64 MiB and less than two fifths of RAM is available | Memory that will be taken before the next passes can react. |
|
||
|
||
The amount to free is the distance to the target or the burst, whichever is larger. The hard
|
||
part of it is what available memory is short of the floor, and nothing when it is above. With
|
||
a memory stall of at least 1% the hard part is two seconds of the fall rate when that is
|
||
larger, whatever the size of the fall and however much memory is available.
|
||
|
||
## What gets compressed, in order
|
||
|
||
1. The Steam client and hidden launchers, while a game is running and the client is not known
|
||
to be in front (unreadable focus data counts as not in front), or at any time when there is
|
||
a hard need. Without a hard need the client is left alone for 30 seconds after
|
||
it was read back.
|
||
2. Processes of the session that loaded `libddsession.so` (the game, Wine and its services),
|
||
largest first, only for the hard part that the client did not cover. One pass moves at
|
||
most 256 MiB.
|
||
|
||
Both use the preload's cold-only request (`2 <kB>`): each process pages out only memory it has
|
||
not touched recently and stops at the budget, so memory in use stays in RAM and is not read
|
||
straight back. The budget is the amount to free divided by the measured saving, limited to the
|
||
zRAM room. With less than half the floor available the request ignores heat (`3 <kB>`), moves
|
||
up to 1 GiB, and runs at most once every ten seconds.
|
||
|
||
Two things keep memory from going in and out of zRAM. The preload remembers each 1 MiB chunk
|
||
it paged out: when a quarter or more of those pages are resident again at the next visit, the
|
||
chunk is hot and is passed over for the next 64 visits, then 128, then 255. And the monitor
|
||
reads `pswpin` from `/proc/vmstat`: what was read back from swap, fading over half a minute,
|
||
is taken off what one pass may move (1 GiB in all, at most 256 MiB of it from the session). A device
|
||
whose working set does not fit therefore stops being trimmed and is left to the kernel, until
|
||
the forced level is reached.
|
||
|
||
A pass that gives back less than a quarter of what the floor is short by is followed by a wait:
|
||
five seconds, doubling after each such pass up to a minute. The wait ends early when available
|
||
memory drops another eighth of the floor or reaches the forced level, and is forgotten after a
|
||
pass that gives back enough or once nothing is needed.
|
||
|
||
Requests go to one process at a time. The monitor waits for that process's acknowledgement
|
||
(the kB it paged out) before the next, reads `MemAvailable` again, and stops once the budget is
|
||
met or available memory is back at the level the pass was started for. A process that has not
|
||
started within half a second, or has not finished when the pass (client and session together)
|
||
has waited five seconds in total or six seconds have gone by since it began, is skipped for a
|
||
minute, and a late answer from it is discarded. A process is known by its number and start time, so a new process that got the
|
||
number of a skipped one is asked. Processes with less
|
||
than 8 MiB of anonymous memory are skipped. While the app pages the session out for suspend, or
|
||
reads it back on resume, it holds the monitor off with `/tmp/.dd-zram.hold` and writes its own
|
||
request (`1` to page out, `0` to read back) into that file. A signalled process reads the hold
|
||
file first and the control file only when the hold file is missing or empty, so a trim request
|
||
the monitor wrote at the same moment cannot replace the app's. The suspend page-out answers `1`
|
||
in `/tmp/.dd-zram.ack.<pid>` and a trim answers its kB in `/tmp/.dd-zram.trim.<pid>`, so the
|
||
monitor never removes or reads an answer the app is waiting for, and the app never takes a
|
||
trim's answer for its own. A trim budget smaller than a chunk covers the stretch of the chunk
|
||
that holds that many resident pages, and the next request continues from where it ended. With less than 64 MiB of zRAM room nothing is requested and the
|
||
session log says so once a minute.
|
||
|
||
With no shortage nothing is compressed. A game that fits in memory is never touched, and Steam
|
||
is no longer compressed on a timer.
|
||
|
||
## Reading the client back
|
||
|
||
Once the client has been compressed, it is read back in one request when the game has exited,
|
||
or the client has been in front of the game for five seconds, and at least 30 seconds have
|
||
passed since the last request, and available memory covers the client's swap plus the target
|
||
and the floor. Missing or unreadable focus data never counts as the client in front. Demand
|
||
paging alone left the Steam library and menus blank for about half a minute in that case.
|
||
Suspending the session while it is asleep, hidden or the screen is off still pages everything
|
||
out, and resuming reads it back when available memory is at least twice what those processes
|
||
have in swap at that moment and, after it, 1 GiB or a tenth of RAM, whichever is larger, stays
|
||
available.
|
||
|
||
## Threads
|
||
|
||
Page-out never runs on a thread of the game. The preload's signal handler only wakes its
|
||
`zr-worker` thread, which does the `madvise` calls. A forked process
|
||
without a worker trims inline in steps of at most 32 MiB per request and looks at no more
|
||
than 512 MiB of its address space each time. The page-out for a suspend and the read-back
|
||
after it are not limited there: they run once, while the process is being stopped or
|
||
started, and cover all of it. The monitor is a
|
||
shell loop in the session, outside every game process.
|
||
|
||
The session log gets a line once at least 16 MiB has moved since the last one, at most every
|
||
five seconds:
|
||
`memory: available N MB, falling N MB/s, compressed N MB of the client and N MB of the session`.
|
||
|
||
No root settings, swap sizes, compression algorithms, Android process priorities or
|
||
game-specific settings are changed.
|
||
|
||
## Measurements behind the levels
|
||
|
||
|
||
Continuing an existing Caravan save reproduced a whole-session low-memory kill with the
|
||
pressure helper running. Android recorded `ApplicationExitInfo` reason `LOW_MEMORY`, and
|
||
`lmkd` killed the foreground app with `oom_score_adj=0` because the device was not responding.
|
||
The last half-second sample before the kill still had 2,172,612 KiB swap free. Over the
|
||
captured interval, system unevictable memory grew from 1,955,932 to 3,236,276 KiB and shmem
|
||
from 1,690,276 to 2,965,900 KiB, while the game's private swap reached 1,916,136 KiB. The
|
||
pressure helper found the launcher already largely reclaimed: its first request at Continue
|
||
reduced aggregate launcher RSS only from 263 to 255 MiB and backed off. Thus launcher reclaim
|
||
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.
|
||
|
||
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:
|
||
|
||
| | No session page-out | Session compressed at character select |
|
||
| --- | --- | --- |
|
||
| available before Enter World | 1,569–1,800 MiB | 2,329 MiB |
|
||
| game resident / in zram before Enter World | 1,919 / 13 MiB | 409 / 1,523 MiB |
|
||
| GPU (KGSL) memory during the load | 0.97 → 1.99 GiB | 0.96 → 1.99 GiB |
|
||
| lowest available | 491 MiB | 623 MiB |
|
||
| result | `LOW_MEMORY` kill of the whole session 58 s after Enter World | in the world at 35 FPS after three minutes |
|
||
|
||
The killed run had 7.4 GiB of swap free at the time: reclaim did not keep up with the GPU
|
||
allocation, not swap capacity. Little Nightmares at the same settings compressed from 1.41 GiB to
|
||
0.25 GiB resident in 2.6 seconds (1.1 GiB stored in about 0.5 GiB of zram) and read back 70 MiB in
|
||
the following minute at its menu and 440 MiB while loading the next area; frame rate stayed at
|
||
44–46 FPS with one or two short frame-time spikes. These are single runs, not averages.
|
||
|
||
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,
|
||
and KGSL's per-process GPU reclaim `state` is root-only. Page-out therefore runs inside each
|
||
process through the preload, and GPU memory itself cannot be compressed from userspace.
|
||
|
||
## CRAM and the bounded pager experiment
|
||
|
||
[Meta's CRAM proposal](https://lpc.events/event/20/contributions/2424/) uses memory compression
|
||
hardware to allow byte/cacheline reads without software decompression faults. A userspace
|
||
software pager cannot reproduce that hardware property. This is separate from Valve's device
|
||
memory cgroup prioritization work.
|
||
|
||
`tools/experiments/anonymous-memory-pager.c` is an opt-in feasibility probe, not a preload or
|
||
runtime component. Build it for the guest architecture with a Linux compiler:
|
||
|
||
```sh
|
||
cc -O2 -Wall -Wextra -Werror -pthread tools/experiments/anonymous-memory-pager.c -ldl -o /tmp/anonymous-memory-pager
|
||
/tmp/anonymous-memory-pager 64
|
||
```
|
||
|
||
It requires `liblz4.so.1` and `UFFD_USER_MODE_ONLY`. The requested arena is bounded to
|
||
1–256 MiB. Half its pages contain a repeating byte and half contain pseudorandom bytes;
|
||
these are synthetic data, not a game-memory compression estimate. The probe registers only
|
||
its own arena, packs compressed or incompressible pages into a separate store, discards the
|
||
original physical pages, then restores them on demand with `UFFDIO_COPY`. It checks the full
|
||
checksum and subsequent writes. A separate child checks kernel access to an evicted buffer.
|
||
The compressed store is retained until the probe ends; this is one eviction/restore cycle,
|
||
without hot/cold selection, concurrent eviction, lifecycle hooks or game integration.
|
||
|
||
On the Pocket FIT Elite's Android 6.6.82 kernel, tested from DroidDeck's unprivileged guest:
|
||
|
||
| Measurement | Result |
|
||
| --- | --- |
|
||
| unrestricted `userfaultfd` | `EPERM` |
|
||
| userspace-only creation and API negotiation | available |
|
||
| arena / compressed payload | 64 MiB / 33,767,424 bytes |
|
||
| process RSS before / after eviction | 68,864 / 36,340 KiB |
|
||
| restored pages / checksum / writes | 16,384 / intact / intact |
|
||
| resident scan / compress and evict / faulted scan | 46.851 / 17.289 / 446.524 ms |
|
||
| kernel pipe write from evicted buffer | `EFAULT` |
|
||
|
||
These timings include the full checksum scan and are one synthetic run, not a comparison
|
||
against zram or a game-performance result. The normal unrestricted pager interface was denied;
|
||
`/dev/userfaultfd` was also inaccessible. The kernel-access result is a hard integration
|
||
constraint: a transparent heap-wide pager cannot assume every access comes from userspace.
|
||
Wine/FEX signal handling, syscall buffers, shared and GPU memory, mapping changes, concurrent
|
||
writes and allocation overhead would all need a correctness design before enabling such a
|
||
pager in a real game. The experiment is deliberately excluded from runtime builds.
|