Recupero della memoria: eliminazione e swap

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 tramite memory.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).

Gerarchia memcg di Android

  • /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

  1. Apri MemoryLab.
  2. Prendi nota del valore di memory.current.
  3. Tocca Allocate Java Memory (10MB) (Alloca memoria Java (10 MB)) più volte.
  4. Leggi di nuovo memory.current. Dovresti vedere un aumento di circa 10 MB per ogni tocco.
  5. Tocca Assegna bitmap. Controlla memory.stat per vedere l'aumento di anon.

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.

  1. Preparazione: assicurati che MemoryLab abbia alcune allocazioni (Java e bitmap).
  2. 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
            }
        }
    }
    EOF
    
  3. Pressione 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"
      
  4. Fault Back In: torna a MemoryLab. Tocca Thrash Pagecache (Refault test).

  5. 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:

Perfetto che mostra il recupero diretto e memcg

Cerca quanto segue nella traccia:

  • kswapd: cerca kswapd0 in 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 (come mm_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 che kswapd e 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.anon che di rss.file, accompagnato da eventi mm_vmscan_memcg_reclaim.

← A livello di sistema | ↑ Su | Interazione tra kswapd e lmkd →