Strumenti di valutazione rapida

Quando devi esaminare la memoria utilizzata, inizia con strumenti di valutazione di alto livello per identificare le categorie di memoria più significative.

dumpsys meminfo

Il modo più comune per ottenere una panoramica della memoria utilizzata da un'applicazione è dumpsys meminfo. Per visualizzare una suddivisione dettagliata che includa tutte le mappature della memoria, spesso è utile includere il flag -a:

adb shell dumpsys meminfo -a <package_name_or_pid>

Ecco un esempio di output di un'applicazione con un utilizzo elevato della memoria (nota l'elevato SwapPss):

** MEMINFO in pid 4562 [com.android.memorylab] **
                   Pss  Private  Private  SwapPss      Rss     Heap     Heap     Heap
                 Total    Dirty    Clean    Dirty    Total     Size    Alloc     Free
                ------   ------   ------   ------   ------   ------   ------   ------
  Native Heap      394      268       64    17440     4264    29416    18128     8040
  Dalvik Heap      165        8        0      672     8196    40949    32757     8192
 Dalvik Other       47       28        0      604     1132
        Stack      112      108        4      312      120
...
        TOTAL    33197      580      788    21920   167776    70365    50885    16232

 App Summary
                       Pss(KB)                        Rss(KB)
                        ------                         ------
           Java Heap:       12                          32608
         Native Heap:      268                           4264
                Code:      724                         125672
               Stack:      108                            120
            Graphics:        0                              0
       Private Other:      256
              System:    31829
             Unknown:                                    5112

           TOTAL PSS:    33197            TOTAL RSS:   167776       TOTAL SWAP PSS:    21920

 Objects
               Views:       15         ViewRootImpl:        1
         AppContexts:        5           Activities:        1
...

Interpretazione dei dati

  • Pss Total: la dimensione del set proporzionale. Si tratta della somma di Private Dirty + Private Clean + la quota equa di memoria del processo condivisa con altri processi (come l'immagine di avvio Zygote). Questa è la metrica migliore per "quanta memoria è responsabile questa app".
  • Private Dirty: si tratta della RAM utilizzata solo dal tuo processo e che è stata modificata (o è una memoria anonima). Questo è il numero più importante per trovare le perdite, perché questa memoria non può essere eliminata.
  • Private Clean: RAM utilizzata solo dal tuo processo, ma che è una copia non modificata di un file nello spazio di archiviazione (ad esempio un file DEX). Può essere eliminato dal sistema operativo se la memoria è in esaurimento.
  • SwapPss: memoria compressa e scambiata in ZRAM. Questo può accadere perché il sistema è sottoposto a pressione della memoria o perché Android Runtime ha identificato i processi in background da compattare (spostando le pagine inutilizzate o inattive su ZRAM). Nell'esempio di dumpsys, quasi tutti i Native Heap e i Dalvik Heap sono stati spostati in ZRAM.

  • Nota importante: i valori Heap Java e Heap nativo nella sezione "Riepilogo app" rappresentano la memoria residente (fisica). Se la memoria di un'applicazione è stata compressa in ZRAM, questi valori di riepilogo specifici potrebbero apparire molto più bassi del previsto. Controlla sempre la colonna TOTAL SWAP PSS o la colonna SwapPss dettagliata per avere un quadro completo.

  • Riepilogo app: una categorizzazione di livello superiore che combina le righe dettagliate in bucket comprensibili.

  • Oggetti: utile per monitorare le istanze Activities e ViewRootImpl con leak. Se esci dall'app e forzi un GC, il conteggio di Activities dovrebbe tornare a 0.

Sezione Budget di memoria

In Android 18 e versioni successive, dumpsys meminfo stampa anche una sezione Budget di memoria quando esegue il dump di una singola app. Questa sezione legge le statistiche memcg del processo e dell'intera app (il pacchetto), quindi non è necessario trovare i file cgroup autonomamente. Ecco la sezione dell'app di esempio MemoryLab in primo piano, dopo tre tocchi di Alloca memoria Java (10 MB):

 Memory Budget
                        Process(KB)       Package(KB)
                        -----------       -----------
  Current Usage:              83820             87976
  Limit:                       none           4718592
  Limit Source:                none     MemoryLimiter
  Peak Usage:                 85136             89292
  Swap Used:                      0                 0

  Usage Breakdown
    Anonymous:                81700             81700
    File:                        96              4200
    File Mapped:                 16               616
    Shared Memory:               16                16
    Kernel:                    1580              1632
    Page Tables:                640               640
    Slab:                       439               458

  Pressure & Reclaim
    Throttle Events:              0                 0
    Refaults (Anon):              0                 0
    Refaults (File):              0                 0
  • Utilizzo attuale: memoria addebitata al memcg (memory.current). Questo è il numero che limita i budget di memoria. Nell'esempio, è aumentato di circa 36.700 kB dopo le tre allocazioni Java da 10 MB, in linea con TOTAL PSS. Il totale del pacchetto è superiore al totale del processo anche per un'app a processo singolo quando le pagine dei file memorizzati nella cache di un'esecuzione precedente non sono ancora state recuperate.
  • Limite: la soglia di recupero (memory.high) applicata al momento o none se non è presente. Nell'esempio, il pacchetto ha un limite di memoria di sistema e il processo non ha un limite proprio.
  • Origine del limite: da dove proviene il limite. AndroidManifest è un <memory-budget> dichiarato nel manifest dell'app, MemoryBudgetManager è un budget impostato dall'app in fase di runtime, MemoryLimiter è un limite di memoria di sistema e am memory-limiter è un override manuale impostato con adb.
  • Utilizzo di picco: l'addebito più elevato dalla creazione del memcg (memory.peak). Mostra N/A sui kernel che non lo supportano.
  • Swap usata: memoria compressa in ZRAM (memory.swap.current).
  • Suddivisione dell'utilizzo: i campi principali di memory.stat, come la memoria anonima e la memoria con backup su file.
  • Pressione e recupero: Eventi di limitazione conteggia il numero di volte in cui il memcg ha superato il limite memory.high. I refault conteggiano le pagine che sono state scambiate o rimosse e poi sono state nuovamente necessarie. Se questi numeri aumentano mentre utilizzi l'app, il limite è più rigido rispetto al working set dell'app.

Con il flag -a o -v, la sezione elenca anche ogni contatore non elaborato di memory.stat e memory.events.

Esercitazione: valutazione rapida con meminfo

Questo esercizio mostra come vengono visualizzati i diversi tipi di allocazioni in meminfo.

  1. Avvia l'app:

    adb shell am start -W -n com.android.memorylab/.MainActivity
    
  2. Controlla la memoria di base:

    adb shell dumpsys meminfo -s com.android.memorylab
    

    Il flag -s fornisce un riepilogo breve e conciso delle categorie di memoria.

  3. Alloca memoria Java: tocca il pulsante Alloca memoria Java (10 MB) 3 volte nell'app.

  4. Osserva la modifica: esegui di nuovo meminfo -s. Dovresti vedere il valore Java Heap aumentare di circa 30.000 kB (30 MB).

  5. Allocate Native Memory (Alloca memoria nativa): tocca una volta il pulsante Allocate Native Memory (1GB Incompressible) (Alloca memoria nativa (1 GB non comprimibile)).

  6. Osserva la modifica: esegui di nuovo meminfo -s. Il valore Native Heap ora dovrebbe mostrare un aumento significativo (~1.000.000 kB).

  7. Confronta con memcg (Android 18 e versioni successive): guarda la sezione Budget di memoria alla fine dell'output meminfo -s. Current Usage cresce insieme a TOTAL PSS dopo ogni allocazione, perché sia le allocazioni Java sia quelle native vengono addebitate al memcg dell'app.

Visualizzazione globale

Per visualizzare la memoria utilizzata nell'intero sistema, esegui:

adb shell dumpsys meminfo

In questo modo viene fornito un riepilogo dell'utilizzo della RAM, inclusa la RAM totale, la RAM libera e un elenco di processi ordinati per PSS.

Metriche di sistema principali

  • ZRAM: swap compresso nella RAM.
  • DMA-BUF: buffer di memoria condivisa e grafica. Le versioni moderne di Android utilizzano DMA-BUF in modo estensivo per il rendering della UI. Se il totale di DMA-BUF è molto elevato, esamina i processi con un utilizzo intensivo della grafica utilizzando /sys/kernel/debug/dma_buf/bufinfo.
  • RAM persa: memoria non contabilizzata dal kernel o da un processo (ad es. regioni riservate all'hardware).

Statistiche memcg

Ogni processo dell'app ha il proprio gruppo di controllo della memoria (memcg) e il kernel mantiene i totali correnti della memoria addebitata (consulta memcg per scoprire in che modo questo conteggio differisce da RSS e PSS). La lettura di questi file è economica e non disturba l'app, quindi puoi campionarli ogni secondo mentre esegui un flusso utente.

Cerca il percorso memcg di un processo dalla riga 0:: di /proc/<PID>/cgroup anziché impostare il percorso come hardcoded. Passa ogni comando del dispositivo a adb shell come una stringa tra virgolette singole in modo che la shell del dispositivo veda le virgolette:

PID=$(adb shell pidof -s <package_name>)

CG=/sys/fs/cgroup$(adb shell "sed -n 's/^0:://p' /proc/$PID/cgroup")

adb shell "cat $CG/memory.current $CG/memory.swap.current"

adb shell "grep -E '^(anon|file|workingset_refault_.*) ' $CG/memory.stat"

I file delle chiavi sono:

  • memory.current: memoria addebitata al processo, in byte. Questo è il numero limitato dai budget di memoria.
  • memory.swap.current: memoria compressa in ZRAM, in byte.
  • memory.stat: un'analisi dettagliata dell'addebito, in byte per le dimensioni. anon è la memoria anonima, ad esempio gli heap Java e nativi. file è la cache di pagina supportata da file, ad esempio codice e risorse. workingset_refault_anon e workingset_refault_file conteggiano le pagine che sono state scambiate o rimosse e poi richieste di nuovo. Un numero crescente di refault indica che il processo non ha memoria sufficiente.
  • memory.events: conteggi degli eventi relativi ai limiti di memoria. high conteggia il numero di volte in cui il processo è stato limitato per aver superato il limite di memory.high.

La directory principale del memcg del processo appartiene all'intera app (il suo UID). I suoi file includono la memoria di tutti i processi in esecuzione dell'app, oltre alle pagine dei file memorizzati nella cache rimaste dai processi precedenti dell'app che sono stati chiusi e non sono stati ancora recuperati:

adb shell "cat $CG/../memory.current"

Un'app può eseguire query sull'utilizzo del proprio cgroup in-process tramite MemoryBudgetManager. Se ricevi un errore di autorizzazione durante l'ispezione dei file cgroup di un'app da adb shell, esegui adb root su una build userdebug o un'immagine dell'emulatore senza Google Play, quindi riprova.

Per una procedura dettagliata di questi file con l'app di esempio MemoryLab, consulta Esercizio pratico: esplorazione di memcg.

showmap

Per un'analisi molto più dettagliata delle mappature della memoria di un processo, utilizza showmap. Questo strumento legge da /proc/<pid>/smaps.

adb shell showmap <pid>

showmap elenca ogni mappa di memoria nel processo. Le mappature dei tasti da cercare includono:

  • [anon:scudo:primary] o [anon:libc_malloc]: l'heap nativo. Le versioni moderne di Android utilizzano l'allocatore Scudo.
  • *.art: immagini heap Java (ad es. immagine di avvio).
  • [anon:dalvik-main space]: l'heap Java principale.
  • *.so: librerie condivise.
  • *.{oat,dex,odex,vdex}: codice DEX compilato.

Puoi ordinare l'output per trovare i consumatori di memoria privata più grandi:

# Sort by private clean + private dirty memory
adb shell showmap <pid> | awk '{print $6+$7, $0}' | sort -rn | head -n 10

Esempio di output:

 virtual                     shared   shared  private  private                   Anon      Shmem     File      Shared   Private
    size      RSS      PSS    clean    dirty    clean    dirty     swap  swapPSS HugePages PmdMapped PmdMapped Hugetlb  Hugetlb    Locked    # object
-------- -------- -------- -------- -------- -------- -------- -------- -------- --------- --------- --------- -------- -------- -------- ---- ------------------------------
2776    18176     5784     2823        0     3008      308     2468     4700     4700         0         0         0        0        0        0   47 [anon:scudo:primary]
560      952      876      657      316        0      560        0       12       12         0         0         0        0        0        0    8 /data/app/.../base.apk
448   393216      448      448        0        0        0      448        0        0         0         0         0        0        0        0    2 [anon:dalvik-main space]
...

Esercitazione: approfondimento con showmap

Scopri come identificare mappature di memoria specifiche e distinguere tra memoria pulita e dirty.

  1. Mmap Clean Memory: tocca una volta il pulsante Mmap Clean Anon Memory (10MB) nell'app MemoryLab.
  2. Recupera l'ID di processo: l'interfaccia utente dell'app mostra il relativo PID. Puoi trovarlo anche con questo comando:

    adb shell pidof com.android.memorylab
    
  3. Ispeziona con showmap:

    # Replace <PID> with the actual process ID from the previous step
    adb shell showmap <PID> | grep "memorylab-clean"
    
  4. Identifica la mappatura: dovresti vedere una mappatura anonima con l'etichetta [anon:memorylab-clean] con una dimensione virtuale di esattamente 10.240 kB. Tieni presente che il valore private dirty per questa mappa è probabilmente 0. Si tratta di memoria anonima "pulita" perché abbiamo utilizzato mmap per prenotare lo spazio virtuale, ma non vi abbiamo ancora scritto (quindi non viene consumata RAM fisica).

  5. Confronto dell'heap nativo: confronta questo con le mappature [anon:scudo:primary] che sarebbero apparse in showmap se l'avessi eseguito dopo il passaggio 5 dell'esercizio meminfo. Poiché l'allocazione nativa di 1 GB scrive effettivamente su ogni pagina, queste pagine sono "dirty" e verranno visualizzate in modo massiccio nella colonna private dirty.

  6. Suggerimento pro (oggetti di grandi dimensioni): osserva le allocazioni heap Java dell'esercizio meminfo. Poiché si tratta di array di byte da 10 MB, è probabile che vengano visualizzati in showmap come [anon:dalvik-free list large object space]. Android Runtime (ART) inserisce gli oggetti di dimensioni superiori a 12 kB in uno spazio separato per oggetti di grandi dimensioni (LOS) per evitare la frammentazione nell'heap principale.

procstats

Mentre meminfo fornisce un'istantanea nel tempo, procstats fornisce dati storici campionando periodicamente lo stato e l'utilizzo della memoria di tutte le applicazioni in esecuzione. Questo è lo strumento principale utilizzato per il monitoraggio dello stato della memoria a lungo termine e per la generazione di report sull'utilizzo della memoria nelle Impostazioni di Android.

# View stats for the last 3 hours
adb shell dumpsys procstats --hours 3

Informazioni sugli stati

L'output di procstats può essere difficile da gestire. La parte più importante sono le metriche tra parentesi accanto a ogni stato del processo:

Top: 100% (54MB-64MB-67MB / 49MB-58MB-61MB / 110MB-120MB-130MB over 4)

Il formato è: (% tempo nello stato) (minPss-avgPss-maxPss / minUss-avgUss-maxUss / minRss-avgRss-maxRss sui campioni)

  • Pss (Proportional Set Size): la memoria condivisa viene divisa proporzionalmente tra i processi.
  • Uss (Unique Set Size): memoria utilizzata solo da questo processo (equivalente a Private Clean + Private Dirty).
  • Rss (Resident Set Size): memoria fisica totale utilizzata, incluse tutte le pagine condivise (tende a un conteggio eccessivo).

Perché è importante:

  • App stabile: i valori minimo, medio e massimo sono vicini tra loro.
  • Perdita di memoria: il valore massimo è significativamente superiore al valore minimo e la media aumenta nel tempo con l'aumentare del numero di campioni.
  • Utilizzo con picchi: il valore massimo è molto più alto della media, il che indica operazioni pesanti temporanee (come l'elaborazione di immagini) che potrebbero causare errori di memoria esaurita se si verificano nel momento sbagliato.

Stati del processo

procstats monitora le app in diversi stati (spesso abbreviati):

  • Persist: processi di sistema critici sempre in esecuzione.
  • In primo piano: l'app è attualmente in primo piano e visibile all'utente.
  • ImpFg (Important Foreground): processi in background critici (come gli IME) o app con un servizio in primo piano.
  • ImpBg (Important Background): processi in background considerati importanti per il sistema.
  • Fgs/BFgs: servizi in primo piano o servizi in primo piano associati.
  • Service/ServRst: servizi in background o servizi attualmente in fase di riavvio.
  • Cached/LastAct: app memorizzate nella cache in background per un riavvio rapido. Questi processi possono essere terminati dal sistema in sicurezza.

Stato della memoria del dispositivo e statistiche sul tempo di esecuzione

procstats monitora anche il tempo trascorso dall'intero dispositivo in condizioni di pressione della memoria. Cerca la sezione Statistiche di runtime:

Run time Stats:
  SOff/Norm: +1h10m15s
   SOn/Norm: +15m20s
        Low: +2m10s
       Crit: +45s
  • SOff/SOn: schermo spento rispetto a schermo acceso.
  • Norm/Mod/Low/Crit: livelli di pressione della memoria (Normal, Moderate, Low, Critical).

Se un dispositivo trascorre molto tempo negli stati Basso o Critico, sembrerà lento perché il kernel recupera la memoria in modo aggressivo e il killer di memoria insufficiente (LMK) inizia a terminare i processi in background. Puoi quindi esaminare le statistiche per pacchetto per vedere quali app hanno un'elevata memoria utilizzata, in particolare quando il dispositivo si trova in questi stati di stress.


← Concetti | ↑ Su | Java →