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
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
dedupeoben. 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.composeplay2in den Screenshots dieses Beitrags): führtChoreographer, Input Dispatch, Measure/Layout/Draw aus, und jeden deines eigenen Codes, der nie an einen anderen Thread übergeben wurde.AndroidOwner:onTouchunddedupeleben 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
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:
| Spalte | Achse | Misst |
|---|---|---|
| Wall Duration | Total, Wall-Clock | Reale verstrichene Zeit für diesen Aufruf und alles, was er aufgerufen hat |
| Wall Self Time | Self, Wall-Clock | Reale verstrichene Zeit, die der eigene Code dieses Aufrufs brauchte, nicht die seiner Callees |
| CPU Duration | Total, nur CPU | Zeit, in der ein CPU-Kern tatsächlich damit beschäftigt war, diesen Aufruf und seine Callees auszuführen |
| CPU Self Time | Self, nur CPU | Dasselbe 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
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
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
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
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_processorJeder 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.jsonDie 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.xmlMan 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 zeigt | Android Studio / Perfetto | Chrome DevTools | Xcode Instruments |
|---|---|---|---|
| Eine aggregierte Zahl für eine Auswahl | Summary | Summary | Top Functions |
| Call Tree, Wurzel zum Blatt | Top Down | Call Tree | Call Tree |
| Call Tree, Blatt zur Wurzel, nach Self Time sortiert | Bottom Up | Bottom-Up | Call Tree, Invert Call Tree checked |
| Gemergte Call Stacks, Breite = Zeit | Flame Chart (gemerged) | Main-Thread-Track (nicht gemerged, chronologisch) | Flame Graph |
| Per-Instanz, zeitlich geordnet, scriptbar | Events-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 exportzu scripten oder den Trace in ein Format zu konvertieren, das etwas anderes abfragen kann. Es gibt keine First-Party-Abkürzung in der Art, wietrace_processoreine für Android und Chrome ist.



