Nelle sezioni precedenti abbiamo visto come il kernel gestisce la memoria a livello di sistema. In questo capitolo, approfondiamo i gruppi di controllo della memoria (memcg), il meccanismo utilizzato da Android per partizionare e controllare l'utilizzo della memoria per le singole app.
Comprendere memcg è fondamentale perché è il livello a cui il sistema può scegliere come target singole app per il recupero o impostare limiti di memoria, consentendo una gestione proattiva dei footprint della memoria delle app.
Gruppi di controllo della memoria (memcg)
I gruppi di controllo (cgroup) sono una funzionalità del kernel Linux che consente di organizzare i processi in gruppi gerarchici e di distribuire tra loro le risorse di sistema (come CPU, memoria e I/O). memcg è il controller cgroup specifico per la memoria.
Concetti chiave di memcg
- Addebito memcg: quando un processo in un memcg alloca una pagina di memoria (anonima o supportata da file), questa pagina viene "addebitata" al memcg. La carica totale di un memcg è la somma di tutte le pagine utilizzate da tutti i processi al suo interno.
- Contabilità gerarchica: la memoria utilizzata viene contabilizzata nell'albero. Un addebito in un cgroup secondario viene conteggiato anche nell'utilizzo del cgroup principale.
- Limiti di memoria: ogni memcg supporta una soglia di recupero flessibile tramite
memory.high, che i budget di memoria delle app utilizzano per attivare il recupero mirato e la limitazione dell'allocazione senza richiamare l'OOM killer. Supporta anche un limite massimo tramitememory.max, che i limiti di memoria di sistema utilizzano per terminare i processi fuori controllo quando il recupero non riesce a mantenere l'utilizzo al di sotto del limite. - Recupero per memcg: quando un memcg supera il limite o quando il sistema ha bisogno di memoria, il kernel può scegliere come target un memcg specifico per il recupero. Ciò significa rimuovere le pagine dei file o scambiare le pagine anonime con ZRAM.
La gerarchia memcg di Android
Android utilizza una gerarchia specifica per gestire i processi delle app. Questa struttura consente al sistema di applicare policy diverse a tipi di app diversi (ad esempio, in primo piano o in background).

/sys/fs/cgroup/apps/: la radice di tutte le app per Android.uid_<UID>/: una directory per l'ID utente di ogni app. Tutti i processi appartenenti allo stesso pacchetto applicativo condividono questo gruppo.pid_<PID>/: una directory per ogni singolo processo e per tutti i processi secondari creati tramite fork. In questo modo, è possibile un controllo e un monitoraggio granulari delle app con più processi.
Esercizio pratico: esplorazione di memcg
In questo esercizio, troverai la directory memcg per MemoryLab e osserverai il suo carico di memoria in tempo reale.
1. Avvia MemoryLab
Assicurati che MemoryLab sia in esecuzione sul tuo dispositivo.
2. Trova il memcg di MemoryLab
Innanzitutto, recupera il PID dell'app MemoryLab in esecuzione:
adb shell pidof com.android.memorylab
# Example output: 11672
Ora individua la directory cgroup. Puoi trovare questa opzione in /proc/<PID>/cgroup:
adb shell cat /proc/11672/cgroup
# Example output: 0::/apps/uid_10274/pid_11672
In cgroup v2, il percorso dopo 0:: rappresenta la gerarchia memcg relativa a /sys/fs/cgroup. Quindi il percorso completo è
/sys/fs/cgroup/apps/uid_10274/pid_11672/.
3. Leggi le statistiche memcg
Vai alla directory e osserva i file chiave:
# Current memory usage (in bytes)
adb shell cat /sys/fs/cgroup/apps/uid_10274/pid_11672/memory.current
# Example output:
# 1591324672
memory.current mostra la quantità totale di memoria (in byte) attualmente addebitata a questo cgroup.
# Detailed statistics
adb shell cat /sys/fs/cgroup/apps/uid_10274/pid_11672/memory.stat | head -n 10
# Example output:
# anon 1585098752
# file 741376
# kernel 5484544
# kernel_stack 393216
# pagetables 4583424
# sec_pagetables 0
# percpu 216
# sock 0
# vmalloc 4096
# shmem 20480
memory.stat fornisce una suddivisione: * anon: quantità di memoria anonima
(heap, stack). * file: quantità di memoria basata su file (cache della pagina). *
swap: quantità di memoria scambiata con ZRAM.
4. Osserva le modifiche
- Apri MemoryLab.
- Prendi nota del valore di
memory.current. - Tocca Allocate Java Memory (10MB) (Alloca memoria Java (10 MB)) più volte.
- Leggi di nuovo
memory.current. Dovresti vedere un aumento di circa 10 MB per ogni tocco. - Tocca Assegna bitmap. Controlla
memory.statper vedere l'aumento dianon.
Recupero proattivo con memory.reclaim
Una funzionalità molto utile di memcg (v2) è il file memory.reclaim. La scrittura di un valore in questo file indica al kernel di tentare immediatamente di recuperare la quantità di memoria specificata da questo memcg e da tutti i memcg sottostanti.
In che modo Android utilizza memory.reclaim
CachedAppOptimizer di Android utilizza questa funzionalità per recuperare la memoria dalle app dopo che sono state congelate. La funzionalità App Freezer di Android garantisce che le app memorizzate nella cache consumino la minor quantità possibile di RAM quando non sono in esecuzione. Quando un'app viene spostata in background e viene bloccata, il sistema scrive la memoria utilizzata corrente dell'app nel file memory.reclaim. In questo modo, il kernel viene forzato a rimuovere tutte le pagine di file possibili e a scambiare tutte le pagine anonime con ZRAM, riducendo al minimo l'impatto dell'app.
Puoi ottenere lo stesso "recupero massimo" manualmente leggendo memory.current
e riscrivendolo in memory.reclaim:
# Force reclaim of everything
adb shell "cat /sys/fs/cgroup/apps/uid_10274/pid_11672/memory.current > /sys/fs/cgroup/apps/uid_10274/pid_11672/memory.reclaim"
Esercizio: forza il recupero e la traccia
Ora forzeremo il kernel a recuperare la memoria da MemoryLab e acquisiremo l'attività in una traccia Perfetto.
- Preparazione: assicurati che MemoryLab abbia alcune allocazioni (Java e bitmap).
Avvia tracciamento: utilizza questa configurazione di traccia in linea per acquisire eventi di pianificazione, recupero e cache di pagina.
# Use a config that captures scheduling, reclaim and page cache events adb shell perfetto -c - --txt -o /data/misc/perfetto-traces/reclaim.perfetto-trace <<EOF buffers: { size_kb: 131072 fill_policy: RING_BUFFER } data_sources: { config { name: "linux.ftrace" ftrace_config { ftrace_events: "sched/sched_switch" ftrace_events: "sched/sched_wakeup" ftrace_events: "kmem/rss_stat" ftrace_events: "mm_filemap_add_to_page_cache" ftrace_events: "mm_filemap_delete_from_page_cache" ftrace_events: "vmscan/mm_vmscan_direct_reclaim_begin" ftrace_events: "vmscan/mm_vmscan_direct_reclaim_end" ftrace_events: "vmscan/mm_vmscan_memcg_reclaim_begin" ftrace_events: "vmscan/mm_vmscan_memcg_reclaim_end" symbolize_ksyms: true } } } data_sources: { config { name: "linux.process_stats" process_stats_config { scan_all_processes_on_start: true } } } EOFPressione e recupero degli attivatori:
- In MemoryLab, tocca Allocate Native Memory (1GB) (Alloca memoria nativa (1 GB)). In questo modo, verrà attivata una pressione a livello di sistema.
In un terminale separato, recupera 200 MB:
adb shell "echo 200M > /sys/fs/cgroup/apps/uid_10274/pid_11672/memory.reclaim"
Fault Back In: torna a MemoryLab. Tocca Thrash Pagecache (Refault test).
Interrompi la traccia: premi Ctrl+C nel terminale di traccia.
Analisi del recupero in Perfetto
Quando apri la traccia, puoi vedere in azione il recupero sia a livello di sistema sia per app:

Cerca quanto segue nella traccia:
- kswapd: cerca
kswapd0in Kernel threads (nello screenshot precedente è stato bloccato manualmente in alto). Vedrai che si attiva e viene eseguito (sezioni verdi) mentre il sistema fatica a trovare pagine libere. - Direct Reclaim: esamina i thread di processo
com.android.memorylab. Vedrai sezioni di eventi ftrace viola (comemm_vmscan_direct_reclaim_begin) direttamente sotto la traccia di pianificazione del thread. Ciò indica che il thread dell'app è bloccato in attesa che il kernel liberi le pagine. - Contatori RSS e Swap:
mem.rss.anon: aumenta man mano che tocchi i pulsanti di allocazione.mem.swap: aumenta costantemente man mano chekswapde i thread dell'app (soggetti a recupero diretto) comprimono le pagine anonime in ZRAM.
- Recupero memcg: se ingrandisci il momento in cui hai attivato il recupero manuale, vedrai un netto calo sia di
rss.anonche dirss.file, accompagnato da eventimm_vmscan_memcg_reclaim.
← A livello di sistema | ↑ Su | Interazione tra kswapd e lmkd →