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
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
dedupeci-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.composeplay2dans les captures d'écran de cet article) : exécuteChoreographer, 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:onTouchetdedupevivent 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
ExecutorServicepersonnalisé) : à 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
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 :
| Colonne | Axe | Mesure |
|---|---|---|
| Wall Duration | Total, temps réel | Temps écoulé réel pour cet appel et tout ce qu'il a appelé |
| Wall Self Time | Propre, temps réel | Temps écoulé réel que le code propre de cet appel a pris, pas celui de ses callees |
| CPU Duration | Total, CPU seul | Temps pendant lequel un cœur CPU était effectivement occupé à exécuter cet appel et ses callees |
| CPU Self Time | Propre, CPU seul | La 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
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
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
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
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
dedupede 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_processorChaque 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.jsonLe 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.xmlVous 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 montre | Android Studio / Perfetto | Chrome DevTools | Xcode Instruments |
|---|---|---|---|
| Un nombre agrégé pour une sélection | Summary | Summary | Top Functions |
| Arbre d'appels, de la racine aux feuilles | Top Down | Call Tree | Call Tree |
| Arbre d'appels, des feuilles à la racine, trié par temps propre | Bottom Up | Bottom-Up | Call Tree, Invert Call Tree activé |
| Piles d'appels fusionnées, largeur = temps | Flame Chart (fusionné) | piste du thread principal (non fusionnée, chronologique) | Flame Graph |
| Par instance, ordonné dans le temps, scriptable | Onglet 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 exportou de convertir la trace dans un format que quelque chose d'autre peut interroger. Il n'existe pas de raccourci natif comme l'esttrace_processorpour Android et Chrome.



