Recomposed
Performance

Wie man jeden Profiler liest

Nov 5, 2026 · 14 min read

Wie man jeden Profiler liest

Die Intuition

Öffne einen Profiler, den du noch nie benutzt hast, auf einer Plattform, die du noch nie profiliert hast, und die Tabs wirken schon vertraut: eine aggregierte Zahl, zwei Wege, einen Baum zu durchlaufen, ein breites farbiges Diagramm. Das ist kein Zufall.

Fast jeder CPU-Profiler reduziert seine Aufzeichnung auf dieselbe Form, bevor er überhaupt eine UI zeichnet: einen Call Tree, in dem jeder Knoten zwei Zahlen trägt, und . Alles andere auf dem Bildschirm ist nur eine andere Ansicht, die aus diesen beiden Zahlen gebaut ist.

  • Summary: eine aggregierte Zahl für das, was gerade ausgewählt ist. Beantwortet „ist das langsam", nicht „wo."
  • Top-down: der Baum, von der Wurzel zum Blatt. Beantwortet „was hat dieses teure Ding aufgerufen."
  • Bottom-up: derselbe Baum, vom Blatt zur Wurzel, sortiert nach Self Time. Beantwortet „was ist teuer, unabhängig davon, wer es aufgerufen hat."
  • Flame Chart: wieder derselbe Baum, gezeichnet als verschachtelte Balken, Breite proportional zur Zeit.

Vier Ansichten, ein zugrunde liegender Baum. Lerne die Form einmal, und die Tabs hören auf, werkzeugspezifische Trivialitäten zu sein. Es sind dieselben vier Fragen, gestellt an jeden Profiler, den du je öffnen wirst.

Das laufende Beispiel unten ist eine versehentlich-quadratische Funktion, gezeigt durch diesen Beitrag hindurch im Perfetto-basierten System Trace von Android Studio. Die Ansichten selbst sind nicht Android-spezifisch. Chrome DevTools und Xcode Instruments zeigen dieselbe Form unter anderen Tab-Namen, behandelt später in der Vergleichstabelle.

// ❌ List.contains() ist ein linearer Scan, einmal pro id aufgerufen, also
// kostet die gesamte Funktion O(n²), während die Liste wächst
fun dedupe(ids: List<String>): List<String> {
    val result = mutableListOf<String>()
    for (id in ids) {
        if (id !in result) result.add(id)
    }
    return result
}
 
// ✅ die Membership-Prüfung eines Sets ist O(1), also fällt die gesamte Funktion auf O(n)
fun dedupe(ids: List<String>): List<String> {
    val seen = mutableSetOf<String>()
    val result = mutableListOf<String>()
    for (id in ids) {
        if (seen.add(id)) result.add(id)
    }
    return result
}

dedupe taucht in jedem Screenshot ab hier als eigene benannte Zeile auf, genau wie Framework-Aufrufe wie AndroidOwner:onTouch oder Compose:recompose. Diese werden automatisch instrumentiert, vom Framework. Dein eigener Code wird es nicht, bis du den Call Site selbst umschließt:

import androidx.tracing.trace
 
trace("dedupe") { dedupe(ids) }

Das ist trace() aus androidx.tracing, ein dünner Wrapper um android.os.Trace.beginSection("dedupe") / Trace.endSection(), der den passenden End-Aufruf für dich erledigt. Ohne ihn ist dedupes Zeit immer noch da, nur still eingefaltet in welchen Caller du auch immer tatsächlich benannt siehst. Das ist das Aggregationsproblem, um das es in diesem ganzen Beitrag geht, eine Ebene früher als jeder Profiler-Tab.

Auch unbedenklich, das so auszuliefern. R8 entfernt diese Aufrufe nicht, da es nicht beweisen kann, dass ein echter Plattform-Aufruf wie beginSection keine Seiteneffekte hat, also bleiben sie in jedem Fall in der Release-APK.

Sie sind ohnehin billig: beginSection/endSection prüfen ein internes Enabled-Flag, bevor sie irgendeine echte Arbeit verrichten.

Vor Android 12 (API 31) geht das Betriebssystem noch weiter und deaktiviert App-seitiges Tracing in einem Release-Build, der nicht debuggable ist, oder, ab API 29, explizit als profileable markiert ist. Älter als das, ist der Aufruf ein echtes No-op, ganz egal was.

Ab API 31 ist Tracing für jede App immer aktiviert, was nur bedeutet, dass es Daten ausgeben kann, sobald etwas aktiv einen Trace aufzeichnet, nicht dass es standardmäßig aufzeichnet.

Eine Capture-Aufgabe auswählen

FIG. 01
Android Studios Task Picker für den Profiler. Drei davon füttern den Call Tree, um den es in diesem Beitrag geht. View Live Telemetry ist ein live, nicht aufgezeichneter Monitor, und der Rest sind Memory-Aufgaben. Nur die drei werden hier behandelt.

Jede Ansicht in diesem Beitrag kommt aus einem Call Tree, aber ein Call Tree muss zuerst aufgezeichnet werden. Android Studio allein bietet drei verschiedene Wege, einen aufzuzeichnen:

  • System Trace (Capture System Activities): das gesamte System, nicht nur deine eigenen Aufrufe, einschließlich der Frame-Pipeline (Choreographer, Vsync). Die Aufgabe hinter jedem Screenshot in diesem Beitrag, und die richtige Standardwahl, um als Erstes danach zu greifen.
  • Find CPU Hotspots, Callstack Sample: sampelt den Call Stack in festen Intervallen, deckt sowohl deinen Kotlin/Java-Code als auch Native Code ab (über simpleperf). Weniger Overhead als instrumentiertes Tracing, um den Preis, möglicherweise einen Aufruf zu verpassen, der kürzer ist als das Sampling-Intervall.
  • Find CPU Hotspots, Java/Kotlin Method Recording: instrumentiert jeden Methodenaufruf mit einem echten Zeitstempel, nicht nur die, die du manuell umschlossen hast wie dedupe oben. Diese Präzision kostet so viel Overhead, dass Android fünf Sekunden oder weniger pro Aufzeichnung empfiehlt, und sie verzerrt absolute Zeitmessung, also behandle ihre Zahlen als relativ (dieser Lauf vs. jener Lauf), nicht als Frame-Budget-Zahl.

Die anderen fünf Aufgaben im Picker sind keine alternativen Wege, um denselben Call Tree zu bekommen, sie lösen andere Probleme:

  • View Live Telemetry: keine Aufzeichnung, sondern eine Live-Anzeige von CPU, Threads, Memory und Interaktionen, um zu entscheiden, was es wert ist, aufgezeichnet zu werden.
  • Analyze Memory Usage (Heap Dump): ein Snapshot jedes Objekts, das im Speicher lebt, mit Retained/Shallow Size pro Klasse.
  • Find Memory Leaks with LeakCanary: LeakCanarys eigene Leak-Analyse, ausgeführt auf deiner Entwicklungsmaschine statt auf dem Gerät.
  • Track Memory Consumption (Java/Kotlin Allocations): jede Allokation und Deallokation über ein Zeitfenster, nicht nur ein Snapshot.
  • Track Memory Consumption (Native Allocations): dieselbe Allokations-Timeline, für den nativen C/C++-Heap, standardmäßig gesampelt.

Alle fünf bauen eine andere Datenform, einen Memory Graph oder eine Live-Anzeige, keinen Call Tree. Das Modell dieses Beitrags trifft auf sie nicht zu.

Für den dedupe()-Bug in diesem Beitrag ist System Trace von Anfang an die richtige Wahl. Der ganze Punkt ist, eine Dauer zu erfassen, die über Aufrufe hinweg steigt, und das zeigt sich erst, wenn man Zeit über eine vollständige Aufzeichnung geordnet sehen kann, nicht über ein kurzes instrumentiertes Fenster. Greife stattdessen zu Method Recording, wenn die Frage enger ist: „wie genau oft wurde das aufgerufen", bestätigt durch eine Zahl statt durch das Abschätzen einer steigenden dur-Spalte per Augenmaß.

Welcher Thread, von vierzig

Ein System Trace zeichnet jeden Thread auf, der während dieses Fensters geplant wurde, nicht nur die deiner App. Klappe das Threads-Panel auf einem echten Gerät auf, und du wirst Dutzende Zeilen sehen, die meisten davon System-Buchhaltung, die deinen Code nie berührt.

Drei sind relevant für einen UI-Rendering-Bug:

  • Der Main Thread, benannt nach dem Prozess deiner App (mi.composeplay2 in den Screenshots dieses Beitrags): führt Choreographer, Input Dispatch, Measure/Layout/Draw aus, und jeden deines eigenen Codes, der nie an einen anderen Thread übergeben wurde. AndroidOwner:onTouch und dedupe leben beide hier.
  • RenderThread: nimmt die Draw-Befehle, die der Main Thread erzeugt hat, und gibt sie an die GPU weiter. Seit Android 5.0 (Lollipop) vom Main Thread abgespalten, sodass ein langsamer Frame die Schuld des Main Threads sein kann, die von RenderThread, oder beides.
  • GPU Completion: wie lange die GPU selbst für einen Frame brauchte, den die beiden obigen Threads bereits übergeben hatten. Selten der erste Ort, an dem man nachschaut, aber er schließt die anderen beiden aus, wenn keiner einen offensichtlichen Stall zeigt.

Alles andere fällt in ein paar Kategorien, von denen sich fast keine als Ort eines App-Bugs eignet:

  • Binder:<pid>_<n>: der Thread-Pool, der Aufrufe zu und von System-Services behandelt. Nur zu öffnen, wenn cross-process communication selbst der vermutete Flaschenhals ist.
  • HeapTaskDaemon, Jit thread pool, Signal Catcher, Profile Saver: ART-Runtime-Haushaltung, Garbage Collection, JIT-Kompilierung, Signal-Behandlung bei Abstürzen, Profil-Persistierung. Du wirst ihre Wirkung auf deinem eigenen Thread (eine GC-Pause, die CPU-Zeit stiehlt, wie die im Abschnitt zum Events-Tab weiter unten behandelte Lücke) weit häufiger sehen, als dass du sie direkt öffnen musst.
  • Deine eigenen Hintergrund-Threads, falls deine App irgendwelche gestartet hat (der Worker-Pool eines Coroutine-Dispatchers, ein eigener ExecutorService): nur zu prüfen, sobald der Bug, dem du nachjagst, tatsächlich vom Main Thread weggezogen ist.

Auf die Zeile eines Threads zu klicken, nicht auf den Übersichtsgraphen darüber, ist das, was jede andere Ansicht in diesem Beitrag auf diesen einen Thread herunterfiltert. Summary, Top-down, Bottom-up und das Events-Tab lesen alle von dem Thread, der gerade ausgewählt ist.

Summary: eine Zahl, kein Ort

FIG. 02
Summary für den dedupe()-Burst, mit sowohl dem Zeitfenster als auch dem Thread ausgewählt. dedupe dominiert bereits die Self-Time-Spalte, obwohl seine Ancestor-Dispatch-Aufrufe immer noch die größere Wall Duration ausweisen.

Wähle nur ein Zeitfenster, und Summary bleibt fast leer, nur Time Range und Duration. Wähle auch den Thread aus, und die Tabelle „Longest running events" füllt sich, die größten einzelnen Arbeitsblöcke in dieser Auswahl.

Sechs der zwölf Aufrufe von dedupe allein füllen mehr als die Hälfte dieser Top-10-Liste, jeder davon mit einer Self Time deutlich über den Framework-Dispatch-Aufrufen, die über ihnen sitzen. Diese Framework-Aufrufe weisen trotzdem die größere Wall Duration aus, da ihre Duration dedupes eigene Zeit plus alles andere, was sie taten, einschließt.

Jede Zeile dort trägt tatsächlich vier Zahlen, nicht eine, zwei unabhängige, zusammengestapelte Achsen:

SpalteAchseMisst
Wall DurationTotal, Wall-ClockReale verstrichene Zeit für diesen Aufruf und alles, was er aufgerufen hat
Wall Self TimeSelf, Wall-ClockReale verstrichene Zeit, die der eigene Code dieses Aufrufs brauchte, nicht die seiner Callees
CPU DurationTotal, nur CPUZeit, in der ein CPU-Kern tatsächlich damit beschäftigt war, diesen Aufruf und seine Callees auszuführen
CPU Self TimeSelf, nur CPUDasselbe CPU-only-Maß, nur für den eigenen Code dieses Aufrufs

Beide Achsen laufen auf die Form des Codes hinaus, nicht auf die spezifische App. AndroidOwner:onTouch und dedupe sind die echten Namen aus dem Screenshot oben, hier in einem vereinfachten Platzhalter aufgestellt, damit der Mechanismus in zwei Zeilen sichtbar ist statt in einem echten Call Stack begraben zu sein:

fun onTouch(event: MotionEvent) = trace("AndroidOwner:onTouch") {
    recordGesture(event)   // nur ein Aufruf, genau wie der untere
    dedupe(ids)             // auch nur ein Aufruf, von hier aus. Nichts im
                            // eigenen Body von onTouch markiert einen Unterschied
}
 
fun dedupe(ids: List<String>) = trace("dedupe") {   // <- das ist der Unterschied:
                                                      //    dedupe öffnet seine EIGENE
                                                      //    Section, recordGesture
                                                      //    tut das nie
    for (id in ids) {
        if (id !in result) result.add(id)   // echte Arbeit: Wall Duration, CPU Duration
    }
    // eine GC-Pause kann überall hier hineinfallen: der Thread wird suspendiert, also
    // zählt sie weiterhin zur Wall Duration, aber nicht zur CPU Duration
}

Die beiden Aufrufe sehen von innen onTouch identisch aus, dieselbe Zeilenform, direkt nebeneinander. Was sie trennt, ist nicht die Position im Code, sondern ob der Callee seine eigene Trace-Section öffnet.

recordGesture() tut das nie, also bleibt seine Zeit in onTouchs Self Time eingefaltet, egal wie lange es läuft. dedupe() tut es, in seiner eigenen Definition unten, also beginnt der Profiler in dem Moment, in dem die Ausführung es betritt, diese Zeit gegen dedupes eigene Section zu zählen statt dagegen.

onTouchs Duration schließt trotzdem alles davon ein, GC-Pause und alles, aber seine Self Time deckt nur recordGesture() ab, den Teil, der nie an eine Child-Section übergeben hat.

Duration vs. Self ist derselbe Split, mit dem der Intuition-Abschnitt begonnen hat, Total Time vs. Self Time. Es ist genau das, was Top-down und Bottom-up als Nächstes von demselben Call Tree ablesen.

Wall vs. CPU ist die zweite Achse. Wall-Clock zählt jede Mikrosekunde, die wirklich verstrichen ist. CPU Time zählt nur die Mikrosekunden, in denen ein Kern diesen Aufruf tatsächlich ausgeführt hat. CPU Time kann die Wall Time nie überschreiten, die Lücke zwischen ihnen ist genau, wie lange der Thread mitten im Aufruf descheduled, blockiert oder pausiert war. Die GC-Pause im Snippet oben ist ein konkreter Fall dieser Lücke, weiter unten im Events-Tab-Abschnitt noch einmal behandelt.

Das ist für diesen spezifischen Bug immer noch nicht die richtige Ansicht. Die Tabelle begrenzt auf zehn Zeilen und sortiert nach Duration, nicht nach Aufrufreihenfolge, also schafft es nur eine Handvoll der größten der zwölf Aufrufe in die Liste, und nicht in der Reihenfolge, in der sie liefen.

Man kann erkennen, dass etwas namens dedupe teuer ist. Man kann allein aus dieser Tabelle nicht erkennen, ob diese Kosten konstant, steigend oder zufällig sind, weil Summary nie gebaut wurde, um Reihenfolge zu bewahren, nur Größenordnung.

Top-down: was das aufgerufen hat

FIG. 03
Top Down für denselben Trace. dedupe ist hier eine einzelne Zeile, Total 1.194.813µs, 61,18 % der ausgewählten Zeit des Threads, Self gleich Total, da es keine eigenen Children hat.

Top-down beginnt an der Wurzel des Call Trees (hier der Thread selbst) und expandiert nach unten in alles, was er aufgerufen hat. Jede Zeile zeigt zwei Zahlen für diesen Knoten:

  • Total: sich selbst plus alles darunter
  • Self: nur dieser Knoten, nichts, was er aufgerufen hat

dispatchInputEvent → deliverInputEvent → ViewPostImeInputStage → AndroidOwner:onTouch hinunter zu dedupe zu folgen ist die Ansicht für „ich weiß ungefähr, wo in meinem Code das passiert ist, zeig mir den Pfad, der dahin geführt hat."

Diese einzelne dedupe-Zeile ist auch die Aggregation aus dem Intuition-Abschnitt konkret gemacht: ihr Total, 1.194.813µs, ist (innerhalb der Rundung) die Summe aller zwölf einzelnen Aufrufdauern, die das Events-Tab separat aufgelistet hat. Top-down hat zwölf Aufrufe, die sich denselben Call Stack teilen, in dem Moment in eine Zeile eingefaltet, in dem man aufhört, rohe Events anzuschauen, und anfängt, einen Baum zu lesen.

Bottom-up: was teuer ist, unabhängig vom Caller

FIG. 04
Bottom Up für denselben Trace. dedupes Self-Spalte, 1.194.813µs, ist größer als die eigene, nicht zugeordnete Self Time des Threads (429.887µs, Zeit auf diesem Thread außerhalb jeder benannten Section) und jede andere Funktions-Self-Time zusammen.

Bottom-up dreht die Richtung von Top-down um: jede Zeile ist eine Funktion, und sie zu expandieren zeigt ihre Caller, nicht ihre Callees. Die Self- und Total-Werte einer Zeile werden über jede Stelle summiert, an der diese Funktion irgendwo in der Aufzeichnung aufgerufen wurde, nicht nur einen Pfad. Das ist die Ansicht für „ich weiß noch nicht, welcher Caller das Problem ist, ich will einfach die eine teuerste Funktion, Punkt."

Die Self-Spalte direkt zu scannen, die Baumposition ganz zu ignorieren, macht den Bug dieses Traces offensichtlich: dedupe allein macht mehr Self Time aus (1.194.813µs) als die eigene, nicht zugeordnete Zeit des Threads (429.887µs) und jede andere Funktions-Self-Time zusammengenommen. Würde dedupe() so weit oben in Bottom-up auftauchen, egal welcher Screen oder welche Geste es ausgelöst hat, würde das auf die Funktion selbst hindeuten, nicht darauf, wie irgendein einzelner Caller sie benutzt.

Flame Chart: derselbe Baum, als Breite gezeichnet

FIG. 05
Flame Chart für denselben Trace. Alle zwölf dedupe-Aufrufe kollabieren in den einen breiten Balken oben, dieselbe Breite wie AndroidOwner:onTouch darunter, weil sie alle denselben Call Stack teilen. Die dünnen Balken rechts davon sind nicht verwandte Blätter anderswo im Thread, keine Fragmente von dedupe.

Ein Flame Chart zeichnet genau denselben Call Tree als Bild: jeder Knoten ist ein horizontaler Balken, Breite proportional zur Zeit, über seinem Parent gestapelt, Wurzel unten. Breitere Balken sind teurer, visuell, ohne eine einzige Zahl zu lesen.

dedupe zwölfmal aufgerufen zu werden erzeugt hier nicht zwölf Balken, genau wie bei Top-down. Jeder Aufruf, der sich diesen Stack teilt, faltet sich in den einen Balken oben.

Zwei verschiedene Dinge teilen sich diesen Namen

Das Flame-Chart-Tab von Android Studio und Perfetto merged jeden Aufruf mit demselben Stack in einen Balken, dieselbe Aggregation, die Top-down und Bottom-up auch machen, nur als Breite statt als Zahl gezeichnet. Der Main-Thread-Track von Chrome DevTools sieht ähnlich aus, ist aber überhaupt nicht gemerged, jede Box ist ein echter Aufruf an seiner echten chronologischen Position.

Das eine als das andere zu lesen ist ein leichter Fehler. Ein Chrome-artiger Track kann einen über die Zeit steigenden Bug per Augenmaß zeigen. Ein gemergtes Flame-Chart-Tab kann das nicht, weil jeder Aufruf schon in einen Balken eingefaltet wurde, bevor er gezeichnet wurde.

Das Eine, das keine dieser Ansichten dir gibt

FIG. 06
12 dedupe()-Aufrufe, nach Namen sortiert, dieselbe Reihenfolge, in der sie liefen. Duration steigt von 1,72ms auf einen Peak von 273,88ms, pendelt sich dann im Bereich 150-190ms ein, die quadratische Explosion (mit GC-Rauschen darüber gelegt), unsichtbar in allen vier aggregierten Ansichten oben.

Führe dedupe() auf einer wachsenden Liste aus und gib jedem Aufruf einen etwas längeren Input. Summary gibt dir eine Summe. Top-down und Bottom-up geben dir ein Total/Self-Paar pro eindeutigem Aufrufpfad, nicht pro Aufruf. Das gemergte Flame-Chart-Tab faltet jeden Aufruf in einen Balken.

Alle vier Ansichten haben bereits das eine Informationsstück weggeworfen, das eine versehentlich-quadratische Funktion auf frischer Tat erwischen würde: die eigene Dauer jedes einzelnen Aufrufs, in der Reihenfolge, in der er passiert ist.

Diese Daten existieren immer noch. Jeder Profiler zeichnet einen Zeitstempel und eine Dauer pro Aufruf auf, es ist nur nicht das, was irgendeine der vier aggregierten Ansichten dir zeigen will.

In Android Studio ist die Lösung Sortierung, nicht Abfrage: das Events-Tab (neben Bottom Up, sobald man einen Thread auswählt) listet jede benannte Section auf diesem Thread auf. Sortiere nach Name, und jeder dedupe-Aufruf clustert zusammen in Start-Time-Reihenfolge, Wall Duration direkt daneben, ohne SQL.

Von oben nach unten gelesen bedeutet eine flache Duration-Spalte, dass die Kosten pro Aufruf konstant sind. Eine steigende ist die quadratische Explosion, sichtbar in dem Moment, in dem man aufhört zu aggregieren und jeden Aufruf für sich anschaut.

Dieser Anstieg ist allerdings nicht perfekt glatt, und der Wall-vs-CPU-Split aus dem Summary-Abschnitt erklärt, warum. dedupe() alloziert bei jedem Aufruf eine wachsende Liste, und ab einer bestimmten Größe löst das echte Garbage-Collection-Pausen aus, Zeit, in der der Thread descheduled sitzt, nicht Zeit, die er mit Rechnen verbringt.

Wall Duration zählt diese Pause. CPU Duration nicht. Die größten Aufrufe zeigen eine merklich breitere Wall-vs-CPU-Lücke als die kleinsten, GC-Druck, der sich auf die echten quadratischen Kosten aufstapelt. Das ist genau, wie ein echter Device-Trace aussieht, sobald die saubere idealisierte Kurve auf einen echten Heap trifft.

Die Query-Ebene ist auch nicht werkzeugspezifisch

Android Studios Events-Tab reicht aus, wenn man sich einen Trace einmal per Augenmaß anschaut. Es reicht nicht mehr aus, sobald sich die Form der Frage ändert:

  • Vergleiche die dedupe-Dauern dieses Laufs mit der Baseline von letzter Woche.
  • Filtere über einen Trace mit zehntausenden Events statt 281.
  • Lies einen Trace, der überhaupt nicht aus Android Studio kam.

Dafür ist die SQL-Ebene tatsächlich da, um dieselbe Frage zu scripten, die Events manuell beantwortet.

Zwei Dinge zuerst: die Trace-Datei selbst, exportiert aus Android Studios Past Recordings-Tab (Export recording, nicht jeder Capture-Typ unterstützt das), und trace_processor lokal installiert:

curl -LO https://get.perfetto.dev/trace_processor
chmod +x ./trace_processor

Jeder Trace teilt sich dieselbe slice-Tabelle, also fragt query.sql sie direkt:

SELECT ts, dur FROM slice WHERE name = 'dedupe' ORDER BY ts;
# liest einen von Android aufgezeichneten Trace
trace_processor query -f query.sql android-trace.perfetto-trace
 
# liest einen Trace, den Chrome DevTools als JSON exportiert hat, dieselbe Query, dieselben Tabellen
trace_processor query -f query.sql chrome-trace.json

Die Datei ist optional. Für eine einmalige Query, überspringe sie und gib das SQL direkt als String an:

trace_processor query android-trace.perfetto-trace \
  "SELECT ts, dur FROM slice WHERE name = 'dedupe' ORDER BY ts"

Perfettos trace_processor parst sowohl einen Android-System-Trace als auch Chrome DevTools' exportiertes JSON-Trace (das Trace Event Format, das Chrome seit chrome://tracing verwendet) in dieselben slice/track/thread-SQL-Tabellen. Die obige Query läuft unverändert gegen beide Dateien. Die SQL-Ebene war nie Android-spezifisch, sie ist nur zufällig das Werkzeug, das Android mitliefert.

Xcode Instruments hat kein Äquivalent. xctrace export holt dir strukturierte Daten aus einer .trace-Datei, aber per XPath gegen das Inhaltsverzeichnis der Trace-Tabelle, in XML, nicht SQL:

xctrace export --input recording.trace \
  --xpath '/trace-toc/run[@number="1"]/data/table[@schema="time-profile"]' \
  --output time-profile.xml

Man kann auf diesem Weg immer noch eine per-Instanz, zeitlich geordnete Liste bekommen. Es ist nur ein Script, das man selbst gegen XML schreiben muss, statt eine Query gegen eine Datenbank, die schon die richtigen Spalten hat.

Welche Ansicht, in welchem Werkzeug

Was es zeigtAndroid Studio / PerfettoChrome DevToolsXcode Instruments
Eine aggregierte Zahl für eine AuswahlSummarySummaryTop Functions
Call Tree, Wurzel zum BlattTop DownCall TreeCall Tree
Call Tree, Blatt zur Wurzel, nach Self Time sortiertBottom UpBottom-UpCall Tree, Invert Call Tree checked
Gemergte Call Stacks, Breite = ZeitFlame Chart (gemerged)Main-Thread-Track (nicht gemerged, chronologisch)Flame Graph
Per-Instanz, zeitlich geordnet, scriptbarEvents-Tab (manuell), trace_processor (SQL, scriptbar)trace_processor (SQL, via JSON-Import)xctrace export (XPath → XML, kein SQL)

Wann man zu einem Profiler greift

Ein Profiler beantwortet „warum ist das langsam", nicht „ist das langsam." Diese Frage kommt normalerweise zuerst, von anderswo: ein CI-Gate, das eine Regression markiert, ein Teammitglied, das sagt, eine Geste fühle sich ruckelig an, eine Dropped-Frame-Metrik, die in Produktion steigt. Einen Profiler zu öffnen, bevor dieses Signal existiert, bedeutet, Call Trees für ein Problem zu lesen, dessen Existenz man noch nicht bestätigt hat.

Es ist auch absichtlich langsam, nicht aus Zufall. Einen Trace aufzuzeichnen, eine Capture-Aufgabe auszuwählen, vier aggregierte Ansichten zu lesen und dann eine Query für das eine Ding zu schreiben, das sie nicht zeigen, sind Minuten konzentrierter Aufmerksamkeit pro Trace.

Dieser Aufwand macht einmalig Sinn, zur Diagnose. Er skaliert nicht auf einen Lauf bei jedem Commit.

Das ist die eigentliche Grenze: Diagnose (warum) bleibt manuell, Erkennung (ist das eine Regression) muss es nicht. Umschließe den verdächtigen Aufruf mit derselben benannten Trace-Section, die ein Profiler schon liest, und zeichne dann seine Dauer bei jedem CI-Lauf auf, statt zu warten, dass jemand es merkt:

// zeichnet dedupe()s eigene Dauer bei jedem CI-Lauf auf, über dieselbe benannte
// Trace-Section, die jeder Profiler-Screenshot in diesem Beitrag liest
@Test
fun dedupeDuration() = benchmarkRule.measureRepeated(
    packageName = "com.example.app",
    metrics = listOf(TraceSectionMetric("dedupe", TraceSectionMetric.Mode.Sum)),
    iterations = 10,
    setupBlock = { startActivityAndWait() },
) {
    triggerTheFlowThatCallsDedupe()
}

Das erzeugt eine Zahl, kein Urteil. Das Ergebnis jedes Laufs muss immer noch gegen eine gespeicherte Baseline verglichen werden, um Pass oder Fail zu entscheiden. Der Profiler wird erst geöffnet, sobald dieser Vergleich fehlschlägt, um das Warum zu beantworten, was die Frage ist, um die es im Rest dieses Beitrags eigentlich geht.

Varianten und Trade-offs

  • Aggregation ist die Standardeinstellung, kein Bug. Jede der vier Hauptansichten existiert speziell, um wiederholte Aufrufe in eine Zahl zu kollabieren, weil das „was ist langsam" in unter einer Sekunde beantwortbar macht, für die 95 % der Fälle, in denen die Kosten pro Aufruf tatsächlich konstant sind. Der quadratische-Loop-Bug oben ist genau die anderen 5 %, der Fall, in dem das Weg-Aggregieren der Pro-Aufruf-Reihenfolge die tatsächliche Form des Problems verdeckt.
  • Dieses mentale Modell ist speziell für CPU/Wall-Time-Profiling. Ein Call Tree mit Self/Total Time ist die gemeinsame Form hinter sampelnden und tracenden CPU-Profilern. Der Retained-Size-Graph eines Heap-Profilers oder die Pipeline-Stage-Aufschlüsselung eines GPU-Frame-Profilers ist eine wirklich andere Datenform. Dieselben vier Tab-Namen werden manchmal konventionell wiederverwendet, aber sie sind nicht aus demselben zugrunde liegenden Baum gebaut, also übertragt sich die Zuordnung dieses Beitrags nicht auf sie.
  • Keine SQL-Ebene zu haben ist ein echter Kosten, keine Trivialität. Wenn man die per-Instanz, zeitlich geordnete Antwort auf iOS braucht und XML nicht von Hand parsen will, sind die ehrlichen Optionen, gegen die Ausgabe von xctrace export zu scripten oder den Trace in ein Format zu konvertieren, das etwas anderes abfragen kann. Es gibt keine First-Party-Abkürzung in der Art, wie trace_processor eine für Android und Chrome ist.
Keep reading

Related reads

Neue Beiträge direkt in dein Postfach