Recomposed
Performance

Comment lire n'importe quel profiler

Nov 5, 2026 · 16 min read

Comment lire n'importe quel profiler

L'intuition

Ouvrez un profiler que vous n'avez jamais utilisé, sur une plateforme que vous n'avez jamais profilée, et les onglets vous semblent déjà familiers : un nombre agrégé, deux façons de parcourir un arbre, un large graphique coloré. Ce n'est pas une coïncidence.

Presque tous les profilers CPU réduisent leur enregistrement à la même forme avant même de dessiner une interface : un arbre d'appels où chaque nœud porte deux nombres, le et le . Tout le reste à l'écran n'est qu'une vue différente construite à partir de ces deux nombres.

  • Summary : un nombre agrégé pour ce qui est sélectionné. Répond à « est-ce lent », pas à « où ».
  • Top-down : l'arbre, de la racine vers les feuilles. Répond à « qui a appelé cette chose coûteuse ».
  • Bottom-up : le même arbre, des feuilles vers la racine, trié par temps propre. Répond à « qu'est-ce qui est coûteux, peu importe qui l'a appelé ».
  • Flame chart : le même arbre encore une fois, dessiné comme des barres imbriquées, dont la largeur est proportionnelle au temps.

Quatre vues, un seul arbre sous-jacent. Apprenez cette forme une fois et les onglets cessent d'être des détails spécifiques à chaque outil. Ce sont les quatre mêmes questions posées à n'importe quel profiler que vous ouvrirez un jour.

L'exemple qui suit est une fonction accidentellement quadratique, montrée tout au long de cet article dans le System Trace d'Android Studio, basé sur Perfetto. Les vues elles-mêmes ne sont pas spécifiques à Android. Chrome DevTools et Xcode Instruments montrent la même forme sous d'autres noms d'onglets, couverts plus loin dans le tableau comparatif.

// ❌ List.contains() est un parcours linéaire, appelé une fois par id, donc
// toute la fonction coûte O(n²) à mesure que la liste grandit
fun dedupe(ids: List<String>): List<String> {
    val result = mutableListOf<String>()
    for (id in ids) {
        if (id !in result) result.add(id)
    }
    return result
}
 
// ✅ la vérification d'appartenance d'un Set est O(1), donc toute la fonction retombe à 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 apparaît comme sa propre ligne nommée dans chaque capture d'écran à venir, tout comme les appels du framework tels que AndroidOwner:onTouch ou Compose:recompose. Ceux-ci sont instrumentés automatiquement, par le framework. Votre propre code ne l'est pas, à moins que vous n'enveloppiez vous-même le site d'appel :

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

C'est trace() d'androidx.tracing, un fin wrapper autour de android.os.Trace.beginSection("dedupe") / Trace.endSection() qui gère l'appel de fin correspondant pour vous. Sans cela, le temps de dedupe est toujours là, simplement replié silencieusement dans celui de l'appelant que vous pouvez effectivement voir nommé. C'est le problème d'agrégation dont traite tout cet article, un niveau plus tôt que n'importe quel onglet de profiler.

Sûr à livrer tel quel, aussi. R8 ne supprime pas ces appels, puisqu'il ne peut pas prouver qu'un véritable appel de plateforme comme beginSection est sans effet de bord, donc ils restent dans l'APK de release dans tous les cas.

Ils sont peu coûteux de toute façon : beginSection/endSection vérifient un indicateur interne d'activation avant de faire un quelconque travail réel.

Avant Android 12 (API 31), l'OS va plus loin et désactive le traçage au niveau de l'application dans une build de release qui n'est pas débogable, ou, à partir de l'API 29, explicitement marquée profileable. Avant cela, l'appel est un véritable no-op quoi qu'il arrive.

À partir de l'API 31, le traçage est toujours activé pour chaque application, ce qui signifie seulement qu'il peut émettre des données une fois que quelque chose capture activement une trace, pas qu'il enregistre par défaut.

Choisir une tâche de capture

FIG. 01
Le sélecteur de tâches du profiler d'Android Studio. Trois d'entre elles alimentent l'arbre d'appels dont parle cet article. View Live Telemetry est un moniteur en direct, non enregistré, et le reste sont des tâches mémoire. Seules les trois sont couvertes ici.

Chaque vue de cet article provient d'un arbre d'appels, mais un arbre d'appels doit d'abord être enregistré. Android Studio propose lui seul trois façons différentes d'en enregistrer un :

  • System Trace (Capture System Activities) : le système entier, pas seulement vos propres appels, y compris le pipeline de frame (Choreographer, vsync). La tâche derrière chaque capture d'écran de cet article, et le bon choix par défaut vers lequel se tourner d'abord.
  • Find CPU Hotspots, Callstack Sample : échantillonne la pile d'appels à intervalle fixe, couvrant à la fois votre code Kotlin/Java et le code natif (via simpleperf). Moins coûteux que le traçage instrumenté, au prix de la possibilité de manquer un appel plus court que l'intervalle d'échantillonnage.
  • Find CPU Hotspots, Java/Kotlin Method Recording : instrumente chaque appel de méthode avec un véritable timestamp, pas seulement ceux que vous avez enveloppés manuellement comme dedupe ci-dessus. Cette précision coûte un surcoût assez lourd pour qu'Android recommande cinq secondes ou moins par enregistrement, et elle fausse le timing absolu, donc traitez ses nombres comme relatifs (cette exécution par rapport à telle autre), pas comme un nombre de budget de frame.

Les cinq autres tâches du sélecteur ne sont pas d'autres façons d'obtenir ce même arbre d'appels, elles résolvent des problèmes différents :

  • View Live Telemetry : pas un enregistrement, mais une lecture en direct du CPU, des threads, de la mémoire et des interactions, pour décider ce qui vaut la peine d'être capturé.
  • Analyze Memory Usage (Heap Dump) : un instantané de chaque objet vivant en mémoire, avec la taille retenue/superficielle par classe.
  • Find Memory Leaks with LeakCanary : l'analyse de fuites propre à LeakCanary, exécutée sur votre machine de développement plutôt que sur l'appareil.
  • Track Memory Consumption (Java/Kotlin Allocations) : chaque allocation et désallocation sur une fenêtre de temps, pas seulement un instantané.
  • Track Memory Consumption (Native Allocations) : la même chronologie d'allocations, pour le tas natif C/C++, échantillonnée par défaut.

Ces cinq tâches construisent une forme de données différente, un graphe mémoire ou une jauge en direct, pas un arbre d'appels. Le modèle de cet article ne s'y applique pas.

Pour le bug de dedupe() dans cet article, System Trace est le bon choix dès le départ. Tout l'enjeu est de détecter une durée qui grimpe entre les appels, et cela n'apparaît qu'une fois que vous pouvez voir le temps ordonné sur tout un enregistrement, pas sur une courte fenêtre instrumentée. Tournez-vous plutôt vers Method Recording quand la question est plus étroite : « combien de fois exactement cela a-t-il été appelé », confirmé par un nombre plutôt qu'en observant une colonne dur qui grimpe.

Quel thread, parmi quarante

Un System Trace enregistre chaque thread planifié pendant cette fenêtre, pas seulement ceux de votre application. Développez le panneau Threads sur un appareil réel et vous verrez des dizaines de lignes, la plupart étant de la comptabilité système qui ne touche jamais votre code.

Trois comptent pour un bug de rendu d'UI :

  • Le thread principal, nommé d'après le processus de votre application (mi.composeplay2 dans les captures d'écran de cet article) : exécute Choreographer, la distribution des entrées, measure/layout/draw, et tout votre propre code qui n'a jamais été délégué à un autre thread. AndroidOwner:onTouch et dedupe vivent tous les deux ici.
  • RenderThread : prend les commandes de dessin que le thread principal a produites et les transmet au GPU. Séparé du thread principal depuis Android 5.0 (Lollipop), donc une frame lente peut être la faute du thread principal, de RenderThread, ou des deux.
  • GPU completion : combien de temps le GPU lui-même a pris sur une frame que les deux threads ci-dessus ont déjà transmise. Rarement le premier endroit à regarder, mais cela écarte les deux autres quand aucun des deux ne montre de blocage évident.

Tout le reste tombe dans quelques catégories, dont presque aucune n'est l'endroit où se cache un bug d'application :

  • Binder:<pid>_<n> : le pool de threads qui gère les appels vers et depuis les services système. À ouvrir seulement si la communication inter-processus elle-même est le goulot d'étranglement suspecté.
  • HeapTaskDaemon, Jit thread pool, Signal Catcher, Profile Saver : maintenance du runtime ART, garbage collection, compilation JIT, gestion des signaux de crash, persistance de profil. Vous verrez leur effet sur votre propre thread (une pause GC qui vole du temps CPU, comme l'écart couvert dans la section sur l'onglet Events plus loin) bien plus souvent que vous n'aurez besoin de les ouvrir directement.
  • Vos propres threads en arrière-plan, si votre application en a démarré (le pool de workers d'un dispatcher de coroutine, un ExecutorService personnalisé) : à vérifier seulement une fois que le bug que vous poursuivez s'est effectivement déplacé hors du thread principal.

Cliquer sur la ligne d'un thread, pas sur le graphique d'ensemble au-dessus, est ce qui filtre chaque autre vue de cet article jusqu'à ce seul thread. Summary, Top-down, Bottom-up et l'onglet Events lisent tous le thread actuellement sélectionné.

Summary : un nombre, pas d'emplacement

FIG. 02
Summary pour la salve de dedupe(), avec à la fois la plage de temps et le thread sélectionnés. dedupe domine déjà la colonne Self Time, même si ses appels de dispatch ancêtres affichent encore le plus grand Wall Duration.

Sélectionnez juste une plage de temps et Summary reste presque vide, seulement Time Range et Duration. Sélectionnez aussi le thread, et le tableau « Longest running events » se remplit, les plus gros morceaux individuels de travail dans cette sélection.

Six des douze appels de dedupe remplissent seuls plus de la moitié de ce top 10, chacun avec un Self Time bien supérieur aux appels de dispatch du framework situés au-dessus d'eux. Ces appels du framework affichent néanmoins encore le plus grand Wall Duration, puisque leur Duration inclut le temps propre de dedupe plus tout le reste qu'ils ont fait.

Chaque ligne y porte en réalité quatre nombres, pas un, deux axes indépendants empilés ensemble :

ColonneAxeMesure
Wall DurationTotal, temps réelTemps écoulé réel pour cet appel et tout ce qu'il a appelé
Wall Self TimePropre, temps réelTemps écoulé réel que le code propre de cet appel a pris, pas celui de ses callees
CPU DurationTotal, CPU seulTemps pendant lequel un cœur CPU était effectivement occupé à exécuter cet appel et ses callees
CPU Self TimePropre, CPU seulLa même mesure CPU seul, mais juste pour le code propre de cet appel

Les deux axes tiennent à la forme du code, pas à l'application spécifique. AndroidOwner:onTouch et dedupe sont les vrais noms de la capture d'écran ci-dessus, repris ici dans une version simplifiée pour que le mécanisme soit visible en deux lignes plutôt qu'enseveli dans une véritable pile d'appels :

fun onTouch(event: MotionEvent) = trace("AndroidOwner:onTouch") {
    recordGesture(event)   // juste un appel, comme celui ci-dessous
    dedupe(ids)             // aussi juste un appel, d'ici. Rien dans
                            // le corps même de onTouch ne marque de différence
}
 
fun dedupe(ids: List<String>) = trace("dedupe") {   // <- voici la différence :
                                                      //    dedupe ouvre SA PROPRE
                                                      //    section, recordGesture
                                                      //    ne le fait jamais
    for (id in ids) {
        if (id !in result) result.add(id)   // travail réel : Wall Duration, CPU Duration
    }
    // une pause GC peut survenir n'importe où ici : le thread est suspendu, donc elle
    // compte toujours dans le Wall Duration, mais pas dans le CPU Duration
}

Les deux appels semblent identiques depuis l'intérieur de onTouch, même forme de ligne, juste l'un à côté de l'autre. Ce qui les sépare n'est pas une position dans le code, c'est le fait que le callee ouvre ou non sa propre section de trace.

recordGesture() ne le fait jamais, donc son temps reste replié dans le Self Time de onTouch peu importe combien de temps il s'exécute. dedupe() le fait, dans sa propre définition ci-dessous, donc à l'instant où l'exécution y entre, le profiler commence à compter ce temps dans la propre section de dedupe au lieu de celle de l'appelant.

La Duration de onTouch inclut toujours tout cela, pause GC comprise, mais son Self Time ne couvre que recordGesture(), la partie qui n'a jamais été déléguée à une section enfant.

Duration contre Self est le même découpage que celui ouvert dans la section Intuition, temps total contre temps propre. C'est exactement ce que Top-down et Bottom-up lisent ensuite sur ce même arbre d'appels.

Wall contre CPU est le second axe. Le temps réel compte chaque microseconde qui s'est réellement écoulée. Le temps CPU compte seulement les microsecondes pendant lesquelles un cœur exécutait effectivement cet appel. Le temps CPU ne peut jamais dépasser le temps réel, l'écart entre les deux est exactement la durée pendant laquelle le thread a passé du temps déplanifié, bloqué, ou en pause en plein appel. La pause GC dans l'extrait ci-dessus est un cas concret de cet écart, couvert à nouveau plus loin dans la section sur l'onglet Events.

Ce n'est toujours pas la vue pour ce bug précis, cependant. Le tableau se limite à dix lignes et trie par durée, pas par ordre d'appel, donc seule une poignée des douze appels, les plus importants, apparaît dans la liste, et pas dans l'ordre où ils se sont produits.

Vous pouvez dire qu'une chose nommée dedupe est coûteuse. Vous ne pouvez pas dire si ce coût est constant, croissant, ou aléatoire à partir de ce seul tableau, parce que Summary n'a jamais été conçu pour préserver l'ordre, seulement l'ampleur.

Top-down : qui a appelé ceci

FIG. 03
Top Down pour la même trace. dedupe est une seule ligne ici, Total 1 194 813µs, 61,18 % du temps sélectionné du thread, Self égal à Total puisqu'il n'a pas d'enfants propres.

Top-down commence à la racine de l'arbre d'appels (le thread lui-même ici) et se déploie vers le bas dans tout ce qu'il a appelé. Chaque ligne montre deux nombres pour ce nœud :

  • Total : lui-même plus tout ce qui est en dessous
  • Self : juste ce nœud, rien de ce qu'il a appelé

Suivre dispatchInputEvent → deliverInputEvent → ViewPostImeInputStage → AndroidOwner:onTouch jusqu'à dedupe est la vue pour « je sais à peu près où dans mon code cela s'est produit, montre-moi le chemin qui y a mené ».

Cette seule ligne dedupe est aussi l'agrégation de la section Intuition rendue concrète : son Total, 1 194 813µs, est (à l'erreur d'arrondi près) la somme des douze durées d'appel individuelles que l'onglet Events listait séparément. Top-down a replié douze appels partageant la même pile d'appels en une seule ligne au moment où vous avez arrêté de regarder des événements bruts et commencé à lire un arbre.

Bottom-up : qu'est-ce qui est coûteux, peu importe l'appelant

FIG. 04
Bottom Up pour la même trace. La colonne Self de dedupe, 1 194 813µs, est plus grande que le temps propre non attribué du thread lui-même (429 887µs, temps sur ce thread hors de toute section nommée) et que toutes les autres fonctions mises ensemble.

Bottom-up inverse le sens de Top-down : chaque ligne est une fonction, et la développer montre ses appelants, pas ses callees. Les chiffres Self et Total sur une ligne sont additionnés sur chaque endroit où cette fonction a été appelée dans tout l'enregistrement, pas seulement sur un chemin. C'est la vue pour « je ne sais pas encore quel appelant est le problème, je veux juste la fonction la plus coûteuse, point final ».

Parcourir directement la colonne Self, en ignorant totalement la position dans l'arbre, rend le bug de cette trace évident : dedupe seul représente plus de temps propre (1 194 813µs) que le temps propre non attribué du thread (429 887µs) et toutes les autres fonctions combinées. Si dedupe() apparaissait aussi haut dans Bottom-up peu importe quel écran ou quel geste le déclenche, cela pointerait vers la fonction elle-même, pas vers la façon dont un appelant particulier l'utilise.

Flame chart : le même arbre, dessiné comme une largeur

FIG. 05
Flame Chart pour la même trace. Les douze appels de dedupe s'effondrent dans cette seule large barre en haut, de même largeur que AndroidOwner:onTouch en dessous, parce qu'ils partagent tous la pile d'appels identique. Les barres fines à sa droite sont des feuilles sans rapport ailleurs sur le thread, pas des fragments de dedupe.

Un flame chart dessine exactement le même arbre d'appels comme une image : chaque nœud est une barre horizontale, de largeur proportionnelle au temps, empilée au-dessus de son parent, racine en bas. Les barres plus larges sont plus coûteuses, visuellement, sans lire un seul nombre.

dedupe appelé douze fois ne produit pas douze barres ici, tout comme dans Top-down. Chaque appel partageant cette pile se replie dans la seule barre du haut.

Deux choses différentes partagent ce nom

L'onglet Flame Chart d'Android Studio et de Perfetto fusionne chaque appel ayant la même pile en une seule barre, la même agrégation que font Top-down et Bottom-up, simplement dessinée comme une largeur plutôt que comme un nombre. La piste du thread principal de Chrome DevTools se ressemble mais n'est pas du tout fusionnée, chaque boîte est un appel réel à sa position chronologique réelle.

Lire l'un comme l'autre est une erreur facile à faire. Une piste de style Chrome peut montrer un bug qui grimpe au fil du temps, à l'œil nu. Un onglet de flame chart fusionné ne le peut pas, parce que chaque appel a déjà été replié en une seule barre avant même d'être dessiné.

La seule chose qu'aucune de ces vues ne vous donne

FIG. 06
12 appels de dedupe(), triés par nom, dans le même ordre où ils se sont produits. La Duration grimpe de 1,72ms à un pic de 273,88ms, puis se stabilise entre 150 et 190ms, l'explosion quadratique (avec du bruit de GC superposé), invisible dans les quatre vues agrégées ci-dessus.

Exécutez dedupe() sur une liste qui grandit et fournissez-lui une entrée légèrement plus longue à chaque appel. Summary vous donne un seul total. Top-down et Bottom-up vous donnent une seule paire Total/Self par chemin d'appel unique, pas par appel. L'onglet Flame Chart fusionné replie chaque appel en une seule barre.

Les quatre vues ont déjà jeté la seule information qui montrerait une fonction accidentellement quadratique en flagrant délit : la durée propre de chaque appel individuel, dans l'ordre où il s'est produit.

Cette donnée existe toujours. Chaque profiler enregistre un timestamp et une durée par appel, ce n'est simplement pas ce que les quatre vues agrégées choisissent de vous montrer.

Dans Android Studio, la solution est de trier, pas d'interroger : l'onglet Events (à côté de Bottom Up, une fois qu'un thread est sélectionné) liste chaque section nommée sur ce thread. Triez par Name, et chaque appel dedupe se regroupe dans l'ordre du Start Time, Wall Duration juste à côté, sans aucun SQL impliqué.

Lu de haut en bas, une colonne de durée plate signifie que le coût par appel est constant. Une colonne qui grimpe est l'explosion quadratique, visible à l'instant où vous arrêtez d'agréger et regardez chaque appel pour lui-même.

Cette montée n'est toutefois pas parfaitement lisse, et le découpage Wall contre CPU de la section Summary explique pourquoi. dedupe() alloue une liste qui grandit à chaque appel, et au-delà d'une certaine taille, cela déclenche de véritables pauses de garbage collection, du temps pendant lequel le thread est déplanifié, pas du temps qu'il passe à calculer.

Wall Duration compte cette pause. CPU Duration ne la compte pas. Les plus grands appels affichent un écart wall-vs-CPU nettement plus large que les plus petits, la pression du GC s'ajoutant au véritable coût quadratique. C'est exactement à quoi ressemble une trace sur un appareil réel une fois que la courbe idéalisée propre rencontre un vrai tas mémoire.

La couche de requête n'est pas non plus spécifique à un outil

L'onglet Events d'Android Studio suffit quand vous regardez une trace, une fois, à l'œil. Il cesse de suffire au moment où la question change de forme :

  • Comparer les durées de dedupe de cette exécution à celles d'une base de référence de la semaine dernière.
  • Filtrer à travers une trace avec des dizaines de milliers d'événements au lieu de 281.
  • Lire une trace qui ne vient pas du tout d'Android Studio.

C'est à cela que sert réellement la couche SQL, scripter la même question à laquelle Events répond manuellement.

Deux choses d'abord : le fichier de trace lui-même, exporté depuis l'onglet Past Recordings d'Android Studio (Export recording, pas tous les types de capture ne le prennent en charge), et trace_processor installé localement :

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

Chaque trace partage la même table slice, donc query.sql l'interroge simplement directement :

SELECT ts, dur FROM slice WHERE name = 'dedupe' ORDER BY ts;
# lit une trace capturée sur Android
trace_processor query -f query.sql android-trace.perfetto-trace
 
# lit une trace que Chrome DevTools a exportée en JSON, même requête, mêmes tables
trace_processor query -f query.sql chrome-trace.json

Le fichier est optionnel. Pour une requête ponctuelle, passez-le et transmettez le SQL directement comme chaîne de caractères :

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

Le trace_processor de Perfetto parse à la fois une trace système Android et le JSON exporté par Chrome DevTools (le Trace Event Format que Chrome utilise depuis chrome://tracing) dans les mêmes tables SQL slice/track/thread. La requête ci-dessus s'exécute sans modification contre l'un ou l'autre fichier. La couche SQL n'a jamais été spécifique à Android, c'est simplement l'outil qu'Android fournit.

Xcode Instruments n'a pas d'équivalent. xctrace export vous donne des données structurées à partir d'un fichier .trace, mais par XPath contre la table des matières de la trace, en XML, pas en SQL :

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

Vous pouvez tout de même obtenir une liste par instance, ordonnée dans le temps, de cette façon. C'est simplement un script que vous écrivez vous-même contre du XML plutôt qu'une requête contre une base de données qui a déjà les bonnes colonnes.

Quelle vue, dans quel outil

Ce que ça montreAndroid Studio / PerfettoChrome DevToolsXcode Instruments
Un nombre agrégé pour une sélectionSummarySummaryTop Functions
Arbre d'appels, de la racine aux feuillesTop DownCall TreeCall Tree
Arbre d'appels, des feuilles à la racine, trié par temps propreBottom UpBottom-UpCall Tree, Invert Call Tree activé
Piles d'appels fusionnées, largeur = tempsFlame Chart (fusionné)piste du thread principal (non fusionnée, chronologique)Flame Graph
Par instance, ordonné dans le temps, scriptableOnglet Events (manuel), trace_processor (SQL, scriptable)trace_processor (SQL, via import JSON)xctrace export (XPath → XML, pas de SQL)

Quand se tourner vers un profiler

Un profiler répond à « pourquoi est-ce lent », pas à « est-ce lent ». Cette question arrive habituellement d'abord, d'ailleurs : une porte de CI signalant une régression, un collègue disant qu'un geste semble saccadé, une métrique de frames perdues qui grimpe en production. Ouvrir un profiler avant que ce signal n'existe revient à lire des arbres d'appels pour un problème dont vous n'avez pas encore confirmé la réalité.

C'est aussi lent volontairement, pas par accident. Capturer une trace, choisir une tâche de capture, lire quatre vues agrégées, puis écrire une requête pour la seule chose qu'elles ne montrent pas, prend des minutes d'attention concentrée par trace.

Ce coût a du sens une fois, pour un diagnostic. Il ne s'adapte pas à une exécution sur chaque commit.

C'est la vraie ligne de démarcation : le diagnostic (pourquoi) reste manuel, la détection (est-ce que ça a régressé) n'a pas besoin de l'être. Enveloppez l'appel suspect dans la même section de trace nommée qu'un profiler lit déjà, puis enregistrez sa durée à chaque exécution de CI au lieu d'attendre que quelqu'un le remarque :

// enregistre la durée propre de dedupe() à chaque exécution de CI, via la même
// section de trace nommée que lit chaque capture d'écran de profiler de cet article
@Test
fun dedupeDuration() = benchmarkRule.measureRepeated(
    packageName = "com.example.app",
    metrics = listOf(TraceSectionMetric("dedupe", TraceSectionMetric.Mode.Sum)),
    iterations = 10,
    setupBlock = { startActivityAndWait() },
) {
    triggerTheFlowThatCallsDedupe()
}

Cela produit un nombre, pas un verdict. Le résultat de chaque exécution doit toujours être comparé à une base de référence stockée pour décider d'une réussite ou d'un échec. Le profiler n'est ouvert qu'une fois cette comparaison échouée, pour répondre au pourquoi, ce qui est la question dont traite réellement le reste de cet article.

Variations et compromis

  • L'agrégation est le comportement par défaut, pas un bug. Chacune des quatre vues principales existe spécifiquement pour effondrer les appels répétés en un seul nombre, parce que c'est ce qui rend « qu'est-ce qui est lent » répondable en moins d'une seconde pour les 95 % des cas où le coût par appel est réellement constant. Le bug de boucle quadratique ci-dessus est exactement les 5 % restants, le cas où agréger l'ordre par appel masque la forme réelle du problème.
  • Ce modèle mental est spécifique au profilage CPU/temps réel. Un arbre d'appels avec temps propre/total est la forme partagée derrière les profilers CPU par échantillonnage et par traçage. Le graphique de taille retenue d'un profiler de tas mémoire ou la décomposition par étape de pipeline d'un profiler de frames GPU est une forme de données véritablement différente. Les quatre mêmes noms d'onglets sont parfois réutilisés par convention, mais ils ne sont pas construits à partir du même arbre sous-jacent, donc le mappage de cet article ne s'y applique pas.
  • Ne pas avoir de couche SQL est un vrai coût, pas un détail. Si vous avez besoin de la réponse par instance, ordonnée dans le temps, sur iOS et que vous ne voulez pas parser du XML à la main, les options honnêtes sont de scripter contre la sortie de xctrace export ou de convertir la trace dans un format que quelque chose d'autre peut interroger. Il n'existe pas de raccourci natif comme l'est trace_processor pour Android et Chrome.
Keep reading

Related reads

Recevez les nouveaux articles par e-mail