Tools für die schnelle Bewertung

Wenn Sie die Speichernutzung untersuchen müssen, beginnen Sie mit allgemeinen Bewertungstools, um herauszufinden, welche Speicherkategorien am wichtigsten sind.

dumpsys meminfo

Die gängigste Methode, um einen Überblick über die Speichernutzung einer Anwendung zu erhalten, ist dumpsys meminfo. Wenn Sie eine detaillierte Aufschlüsselung einschließlich aller Speicherzuordnungen sehen möchten, ist es oft hilfreich, das Flag -a einzufügen:

adb shell dumpsys meminfo -a <package_name_or_pid>

Hier ist eine Beispielausgabe einer Anwendung, die unter Speicherdruck steht (beachte den hohen SwapPss-Wert):

** 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
...

Daten interpretieren

  • Pss Total: Die Proportional Set Size. Dies ist die Summe aus Private Dirty + Private Clean und dem gerechten Anteil des Speichers, den Ihr Prozess mit anderen Prozessen teilt (z. B. dem Zygote-Boot-Image). Dies ist der beste Messwert für die Frage, wie viel Speicher diese App belegt.
  • Private Dirty: Dies ist RAM, der nur von Ihrem Prozess verwendet und geändert wurde (oder anonymer Speicher). Dies ist die wichtigste Zahl für die Suche nach Lecks, da dieser Speicher nicht gelöscht werden kann.
  • Private Clean: RAM, der nur von Ihrem Prozess verwendet wird, aber eine unveränderte Kopie einer Datei im Speicher ist (z. B. eine DEX-Datei). Sie kann vom Betriebssystem gelöscht werden, wenn der Arbeitsspeicher knapp wird.
  • SwapPss: Arbeitsspeicher, der komprimiert und in ZRAM ausgelagert wurde. Dies kann entweder daran liegen, dass das System unter Speicherdruck steht, oder daran, dass die Android Runtime Hintergrundprozesse identifiziert hat, die komprimiert werden sollen (wobei ihre ungenutzten oder inaktiven Seiten in ZRAM verschoben werden). Im dumpsys-Beispiel wurden fast alle Native Heap und Dalvik Heap in den ZRAM verschoben.

  • Wichtiger Hinweis: Die Werte für Java-Heap und Nativer Heap im Abschnitt „App-Zusammenfassung“ stellen den residenten (physischen) Speicher dar. Wenn der Arbeitsspeicher einer Anwendung in ZRAM komprimiert wurde, können diese spezifischen Zusammenfassungswerte viel niedriger als erwartet ausfallen. Prüfen Sie immer die Spalte TOTAL SWAP PSS oder die detaillierte Spalte SwapPss, um sich ein vollständiges Bild zu machen.

  • App-Zusammenfassung: Eine übergeordnete Kategorisierung, bei der die detaillierten Zeilen in verständliche Gruppen zusammengefasst werden.

  • Objekte: Nützlich, um geleakte Activities- und ViewRootImpl-Instanzen zu verfolgen. Wenn Sie Ihre App beenden und eine GC erzwingen, sollte die Anzahl der Activities wieder auf 0 zurückgehen.

Abschnitt „Memory budget“

In Android 18 und höher gibt dumpsys meminfo auch einen Abschnitt Speicherbudget aus, wenn ein Dump einer einzelnen App erstellt wird. In diesem Abschnitt werden die memcg-Statistiken des Prozesses und der gesamten App (des Pakets) ausgelesen, sodass Sie die cgroup-Dateien nicht selbst suchen müssen. Hier ist der Abschnitt aus der MemoryLab-Beispiel-App im Vordergrund, nachdem dreimal auf Allocate Java Memory (10MB) (Java-Arbeitsspeicher zuweisen (10 MB)) getippt wurde:

 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
  • Aktuelle Nutzung: Der Arbeitsspeicher, der der memcg (memory.current) in Rechnung gestellt wird. Dies ist die Anzahl, die durch Arbeitsspeicherbudgets begrenzt wird. Im Beispiel stieg er nach den drei 10-MB-Java-Zuweisungen um etwa 36.700 KB, was mit TOTAL PSS übereinstimmt. Die Gesamtzahl der Pakete ist höher als die Gesamtzahl der Prozesse, auch bei einer App mit nur einem Prozess, wenn im Cache gespeicherte Dateiseiten aus einer früheren Ausführung noch nicht zurückgefordert wurden.
  • Limit: Der aktuell geltende Rückforderungsschwellenwert (memory.high) oder none, wenn kein Schwellenwert vorhanden ist. Im Beispiel hat das Paket ein Limit für den Systemspeicher und der Prozess hat kein eigenes Limit.
  • Limitquelle: Woher das Limit stammt. AndroidManifest ist ein im App-Manifest deklarierter <memory-budget>, MemoryBudgetManager ist ein von der App zur Laufzeit festgelegtes Budget, MemoryLimiter ist ein Systemspeicherlimit und am memory-limiter ist eine manuelle Überschreibung, die mit adb festgelegt wurde.
  • Spitzennutzung: Die höchste Gebühr seit der Erstellung der memcg (memory.peak). Bei Kerneln, die dies nicht unterstützen, wird N/A angezeigt.
  • Belegter Swap-Speicher: In ZRAM komprimierter Arbeitsspeicher (memory.swap.current).
  • Nutzungsaufschlüsselung: Die Hauptfelder von memory.stat, z. B. anonymer und dateibasierter Arbeitsspeicher.
  • Druck und Freigabe: Drosselungsereignisse zählt, wie oft die memcg das memory.high-Limit überschritten hat. Refaults zählt Seiten, die ausgelagert oder entfernt wurden und dann wieder benötigt wurden. Wenn diese Zahlen während der Nutzung der App steigen, ist das Limit enger als der Arbeitssatz der App.

Mit dem Flag -a oder -v werden im Abschnitt auch alle Rohzähler aus memory.stat und memory.events aufgeführt.

Übung: Schnelle Selektierung mit meminfo

In dieser Übung wird gezeigt, wie verschiedene Arten von Zuweisungen in meminfo angezeigt werden.

  1. App starten:

    adb shell am start -W -n com.android.memorylab/.MainActivity
    
  2. Baseline-Speicher prüfen:

    adb shell dumpsys meminfo -s com.android.memorylab
    

    Das Flag -s liefert eine kurze, prägnante Zusammenfassung der Speicherkategorien.

  3. Java-Arbeitsspeicher zuweisen: Tippen Sie in der App dreimal auf den Button Allocate Java Memory (10MB).

  4. Änderung beobachten: Führen Sie meminfo -s noch einmal aus. Der Wert für Java-Heap sollte sich um etwa 30.000 KB (30 MB) erhöhen.

  5. Nativer Arbeitsspeicher zuweisen: Tippe einmal auf den Button Nativer Arbeitsspeicher zuweisen (1 GB nicht komprimierbar).

  6. Änderung beobachten: Führen Sie meminfo -s noch einmal aus. Der Wert für Nativer Heap sollte jetzt einen massiven Anstieg (~1.000.000 KB) zeigen.

  7. Mit memcg vergleichen (Android 18 und höher): Sehen Sie sich den Abschnitt Memory Budget am Ende der meminfo -s-Ausgabe an. Die Aktuelle Nutzung steigt nach jeder Zuweisung zusammen mit dem PSS INSGESAMT, da sowohl die Java- als auch die nativen Zuweisungen der memcg der App in Rechnung gestellt werden.

Globale Ansicht

Führen Sie den folgenden Befehl aus, um die Arbeitsspeichernutzung im gesamten System zu sehen:

adb shell dumpsys meminfo

Dadurch wird eine Zusammenfassung der RAM-Nutzung ausgegeben, einschließlich des gesamten RAM, des verfügbaren RAM und einer Liste der nach PSS sortierten Prozesse.

Wichtige Systemmesswerte

  • ZRAM: Komprimierter Auslagerungsspeicher im RAM.
  • DMA-BUF: Grafik- und gemeinsam genutzte Speicherpuffer. Moderne Android-Versionen verwenden DMA-BUF in großem Umfang für das UI-Rendering. Wenn die Gesamtzahl der DMA-BUF sehr hoch ist, untersuchen Sie grafikintensive Prozesse mit /sys/kernel/debug/dma_buf/bufinfo.
  • Verlorener RAM: Arbeitsspeicher, der nicht vom Kernel oder einem Prozess berücksichtigt wird (z.B. hardware-reservierte Bereiche).

memcg-Statistiken

Jeder App-Prozess hat eine eigene Arbeitsspeicher-Kontrollgruppe (memcg) und der Kernel führt eine laufende Summe des ihm zugewiesenen Arbeitsspeichers. Informationen dazu, wie sich diese Ressourcenerfassung von RSS und PSS unterscheidet, findest du unter memcg. Das Lesen dieser Dateien ist kostengünstig und beeinträchtigt Ihre App nicht. Sie können sie also jede Sekunde abfragen, während Sie einen User-Flow ausführen.

Suchen Sie den memcg-Pfad eines Prozesses in der Zeile 0:: von /proc/<PID>/cgroup, anstatt den Pfad hartzucodieren. Übergeben Sie jeden Gerätebefehl als einzelnen String in Anführungszeichen an adb shell, damit die Geräte-Shell die Anführungszeichen sieht:

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"

Die wichtigsten Dateien sind:

  • memory.current: Dem Prozess in Rechnung gestellter Arbeitsspeicher in Byte. Dies ist die Anzahl, die durch Speicherbudgets begrenzt wird.
  • memory.swap.current: In ZRAM komprimierter Arbeitsspeicher in Byte.
  • memory.stat: Eine Aufschlüsselung der Gebühr, in Byte für Größen. anon ist anonymer Speicher, z. B. Java- und native Heaps. file ist der dateibasierte Seitencache, z. B. Code und Ressourcen. workingset_refault_anon und workingset_refault_file zählen Seiten, die ausgelagert oder entfernt wurden und dann wieder benötigt wurden. Steigende Refault-Zahlen bedeuten, dass der Prozess zu wenig Arbeitsspeicher hat.
  • memory.events: Anzahl der Ereignisse, bei denen das Arbeitsspeicherlimit erreicht wurde. high zählt, wie oft der Prozess gedrosselt wurde, weil er das memory.high-Limit überschritten hat.

Das übergeordnete Verzeichnis der memcg des Prozesses gehört zur gesamten App (ihrer UID). Die Dateien enthalten den Arbeitsspeicher aller laufenden Prozesse der App sowie im Cache gespeicherte Dateiseiten, die von früheren Prozessen der App übrig geblieben sind, die beendet und noch nicht wieder freigegeben wurden:

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

Eine App kann ihre eigene cgroup-Nutzung prozessintern über MemoryBudgetManager abfragen. Wenn du beim Prüfen der cgroup-Dateien einer App über adb shell einen Berechtigungsfehler erhältst, führe adb root auf einem userdebug-Build oder einem Emulator-Image ohne Google Play aus und versuche es dann noch einmal.

Eine geführte Anleitung zu diesen Dateien mit der MemoryLab-Beispiel-App finden Sie unter Praktische Übung: memcg erkunden.

showmap

Eine detailliertere Aufschlüsselung der Speicherzuordnungen eines Prozesses erhalten Sie mit showmap. Dieses Tool liest aus /proc/<pid>/smaps.

adb shell showmap <pid>

showmap listet alle Speicherzuordnungen im Prozess auf. Zu den wichtigsten Zuordnungen gehören:

  • [anon:scudo:primary] oder [anon:libc_malloc]: Der native Heap. Moderne Android-Versionen verwenden den Scudo-Allocator.
  • *.art: Java-Heap-Images (z.B. Boot-Image).
  • [anon:dalvik-main space]: Der Haupt-Java-Heap.
  • *.so: Gemeinsam genutzte Bibliotheken.
  • *.{oat,dex,odex,vdex}: Kompilierter DEX-Code.

Sie können die Ausgabe sortieren, um die größten privaten Arbeitsspeicherverbraucher zu finden:

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

Beispielausgabe:

 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]
...

Übungsaufgabe: Die App im Detail mit showmap

Hier erfahren Sie, wie Sie bestimmte Speicherzuordnungen identifizieren und zwischen sauberem und schmutzigem Speicher unterscheiden.

  1. Mmap Clean Memory: Tippe einmal auf die Schaltfläche Mmap Clean Anon Memory (10MB) in der MemoryLab App.
  2. Prozess-ID abrufen: Die PID der Anwendung wird in der Benutzeroberfläche angezeigt. Sie können sie auch mit diesem Befehl finden:

    adb shell pidof com.android.memorylab
    
  3. Mit „showmap“ prüfen:

    # Replace <PID> with the actual process ID from the previous step
    adb shell showmap <PID> | grep "memorylab-clean"
    
  4. Zuordnung identifizieren: Sie sollten eine anonyme Zuordnung mit der Bezeichnung [anon:memorylab-clean] und einer virtuellen Größe von genau 10.240 KB sehen. Beachten Sie, dass der Wert für private dirty für diese Zuordnung wahrscheinlich 0 ist. Dies ist ein „sauberer“ anonymer Arbeitsspeicher, da wir mmap verwendet haben, um den virtuellen Speicherplatz zu reservieren, aber noch nichts hineingeschrieben haben. Es wird also kein physischer RAM verbraucht.

  5. Vergleich des nativen Heaps: Vergleichen Sie dies mit den [anon:scudo:primary]-Zuordnungen, die in showmap angezeigt worden wären, wenn Sie es nach Schritt 5 der meminfo-Übung ausgeführt hätten. Da bei dieser nativen Zuweisung von 1 GB tatsächlich auf jede Seite geschrieben wird, sind diese Seiten „dirty“ und werden in der Spalte private dirty stark hervorgehoben.

  6. Profitipp (große Objekte): Beachten Sie die Java-Heap-Zuweisungen aus der Übung meminfo. Da es sich um 10-MB-Byte-Arrays handelt, werden sie in showmap wahrscheinlich als [anon:dalvik-free list large object space] angezeigt. Die Android Runtime (ART) legt Objekte, die größer als 12 KB sind, in einem separaten Large Object Space (LOS) ab, um eine Fragmentierung im Haupt-Heap zu vermeiden.

procstats

Während meminfo einen Snapshot zu einem bestimmten Zeitpunkt liefert, bietet procstats Verlaufsdaten, indem der Status und die Arbeitsspeichernutzung aller laufenden Anwendungen regelmäßig erfasst werden. Dies ist das primäre Tool für die langfristige Überwachung des Speicherzustands und die Grundlage für die Berichte zur Speichernutzung in den Android-Einstellungen.

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

Informationen zu den Statuswerten

Die Ausgabe von procstats kann überwältigend sein. Der wichtigste Teil sind die Messwerte in Klammern neben jedem Prozessstatus:

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

Das Format ist: (% Zeit im Status) (minPss-avgPss-maxPss / minUss-avgUss-maxUss / minRss-avgRss-maxRss über Stichproben)

  • Pss (Proportional Set Size): Der gemeinsam genutzte Arbeitsspeicher wird proportional auf die Prozesse aufgeteilt.
  • Uss (Unique Set Size): Arbeitsspeicher, der nur von diesem Prozess verwendet wird (entspricht „Private Clean“ + „Private Dirty“).
  • Rss (Resident Set Size): Gesamter verwendeter physischer Arbeitsspeicher, einschließlich aller freigegebenen Seiten (wird tendenziell zu hoch gezählt).

Warum das wichtig ist:

  • Stabile App: Die Werte für „Min.“, „Durchschnitt“ und „Max.“ liegen nahe beieinander.
  • Speicherleck: Der Höchstwert ist deutlich höher als der Mindestwert und der Durchschnitt steigt im Laufe der Zeit mit zunehmender Anzahl von Stichproben an.
  • Spitzen in der Nutzung: Der Maximalwert ist viel höher als der Durchschnittswert. Das deutet auf vorübergehende, rechenintensive Vorgänge (z. B. Bildverarbeitung) hin, die zu OOM-Fehlern führen können, wenn sie zum falschen Zeitpunkt auftreten.

Prozessstatus

procstats verfolgt Apps in mehreren Status (oft abgekürzt):

  • Persist: Kritische Systemprozesse, die immer ausgeführt werden.
  • Top: Die App befindet sich derzeit im Vordergrund und ist für den Nutzer sichtbar.
  • ImpFg (Important Foreground): Kritische Hintergrundprozesse (z. B. IMEs) oder Apps mit einem Dienst im Vordergrund.
  • ImpBg (Important Background): Hintergrundprozesse, die für das System als wichtig erachtet werden.
  • Fgs / BFgs: Dienste im Vordergrund oder gebundene Dienste im Vordergrund.
  • Service / ServRst: Hintergrunddienste oder Dienste, die gerade neu gestartet werden.
  • Cached / LastAct: Apps, die im Hintergrund im Cache gespeichert sind, um einen schnellen Neustart zu ermöglichen. Diese können vom System sicher beendet werden.

Gerätespeicherstatus und Laufzeitstatistiken

procstats erfasst auch, wie viel Zeit das gesamte Gerät unter Speicherdruck verbracht hat. Suchen Sie nach dem Abschnitt Laufzeitstatistiken:

Run time Stats:
  SOff/Norm: +1h10m15s
   SOn/Norm: +15m20s
        Low: +2m10s
       Crit: +45s
  • SOff / SOn: Screen Off (Display aus) im Vergleich zu Screen On (Display an).
  • Norm / Mod / Low / Crit: Arbeitsspeicherauslastung (Normal, Moderate, Low, Critical).

Wenn ein Gerät viel Zeit im Zustand Niedrig oder Kritisch verbringt, fühlt es sich träge an, da der Kernel aggressiv Arbeitsspeicher freigibt und der Low Memory Killer (LMK) Hintergrundprozesse beendet. Anschließend können Sie sich die Statistiken pro Paket ansehen, um herauszufinden, welche Apps besonders dann eine hohe Speichernutzung aufweisen, wenn das Gerät in diesen überlasteten Zuständen ist.


← Konzepte | ↑ Nach oben | Java →