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 iNative Heape iDalvik Heapsono 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
SwapPssdettagliata 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
ActivitieseViewRootImplcon leak. Se esci dall'app e forzi un GC, il conteggio diActivitiesdovrebbe 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 ononese 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 eam memory-limiterè un override manuale impostato conadb. - Utilizzo di picco: l'addebito più elevato dalla creazione del memcg
(
memory.peak). MostraN/Asui 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.
Avvia l'app:
adb shell am start -W -n com.android.memorylab/.MainActivityControlla la memoria di base:
adb shell dumpsys meminfo -s com.android.memorylabIl flag
-sfornisce un riepilogo breve e conciso delle categorie di memoria.Alloca memoria Java: tocca il pulsante Alloca memoria Java (10 MB) 3 volte nell'app.
Osserva la modifica: esegui di nuovo
meminfo -s. Dovresti vedere il valore Java Heap aumentare di circa 30.000 kB (30 MB).Allocate Native Memory (Alloca memoria nativa): tocca una volta il pulsante Allocate Native Memory (1GB Incompressible) (Alloca memoria nativa (1 GB non comprimibile)).
Osserva la modifica: esegui di nuovo
meminfo -s. Il valore Native Heap ora dovrebbe mostrare un aumento significativo (~1.000.000 kB).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_anoneworkingset_refault_fileconteggiano 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.highconteggia il numero di volte in cui il processo è stato limitato per aver superato il limite dimemory.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.
- Mmap Clean Memory: tocca una volta il pulsante Mmap Clean Anon Memory (10MB) nell'app MemoryLab.
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.memorylabIspeziona con showmap:
# Replace <PID> with the actual process ID from the previous step adb shell showmap <PID> | grep "memorylab-clean"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 utilizzatommapper prenotare lo spazio virtuale, ma non vi abbiamo ancora scritto (quindi non viene consumata RAM fisica).Confronto dell'heap nativo: confronta questo con le mappature
[anon:scudo:primary]che sarebbero apparse inshowmapse l'avessi eseguito dopo il passaggio 5 dell'eserciziomeminfo. 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.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 inshowmapcome[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 →