Traçage d'une composition

Les traces sont souvent les meilleures sources d'informations pour identifier un problème de performances. Elles vous permettent de formuler une hypothèse quant à la nature du problème et de savoir où commencer à chercher.

Il existe deux niveaux de traçage compatibles avec Android : le traçage système et le traçage de méthode.

Étant donné que le traçage système ne trace que les zones spécialement identifiées pour le traçage, il présente des coûts faibles et n'affecte que peu les performances de votre application. Le traçage système est idéal pour déterminer la durée d'exécution de sections spécifiques de votre code.

Le traçage de méthode suit chaque appel de fonction dans votre application. C'est une procédure très coûteuse, et qui a donc un impact important sur les performances de votre application. En revanche, elle vous donne une vue d'ensemble de ce qui se passe, des fonctions appelées et de leur fréquence d'appel.

Par défaut, les traces système n'incluent pas les fonctions modulables individuelles. Celles-ci sont disponibles dans les traces de méthode.

Nous testons actuellement une nouvelle fonctionnalité de traçage système permettant d'afficher des fonctions modulables dans les traces système. Le but est d'allier la faible intrusion du traçage système au niveau de détail du traçage de méthode dans la composition.

Configurer le traçage des compositions

Pour tester le traçage des recompositions dans votre projet, vous devez installer les versions suivantes (ou versions ultérieures) :

• Android Studio Flamingo
• Interface utilisateur de Compose: 1.3.0
• Compilateur de Compose : 1.3.0

Vous devez utiliser au moins le niveau d'API 30 sur l'appareil ou l'émulateur sur lequel vous exécutez votre traçage.

De plus, vous devez ajouter une nouvelle dépendance au traçage d'exécution Compose:

implementation("androidx.compose.runtime:runtime-tracing:1.7.5")

Si vous utilisez la nomenclature Compose, vous n'avez pas besoin de spécifier la version:

val composeBom = platform("androidx.compose:compose-bom:2024.10.01")
implementation(composeBom)
// ...

// dependency without a version
implementation("androidx.compose.runtime:runtime-tracing")

Avec cette dépendance, lorsque vous effectuez un traçage système incluant la recomposition, les fonctions modulables s'affichent automatiquement.

Exécuter un traçage système

Pour exécuter un traçage système et voir le nouveau traçage de recomposition en action, procédez comme suit :

1. Ouvrez le profileur :

   

2. Cliquez sur Chronologie du CPU.

   

3. Dans votre application, accédez à l'interface utilisateur que vous souhaitez tracer, sélectionnez Trace système, puis Enregistrer.

   

4. Utilisez votre application pour déclencher la recomposition et arrêter l'enregistrement. Une fois la trace traitée et affichée, vous devriez voir les composables dans la trace de recomposition. Vous pouvez utiliser le clavier et la souris pour zoomer et faire un panoramique sur la trace. Si vous ne savez pas comment parcourir une trace, consultez la documentation Traces d'enregistrement.

   

   Si vous double-cliquez sur un composable dans le graphique, vous êtes redirigé vers son code source.

5. Vous pouvez également voir les composables dans le graphique de flammes, avec le fichier et le numéro de ligne :

   

Mises en garde

Coûts liés à la taille de l'APK

Bien que nous cherchions à minimiser autant que possible le coût de la fonctionnalité, la taille des APK pour les applications Compose augmente à cause des chaînes de traçage intégrées que le compilateur Compose intègre dans l'APK. Cette augmentation de taille peut être relativement faible si votre application n'utilise pas beaucoup Compose, ou importante pour les applications Compose complètes. De plus, ces chaînes de traçage ne sont pas obscurcies. Elles peuvent donc apparaître dans les outils de traçage, comme indiqué précédemment. À partir de la version 1.3.0, le compilateur Compose les injecte dans toutes les applications.

Vous pouvez supprimer les chaînes de traçage de votre build de production en ajoutant la règle proguard suivante :

-assumenosideeffects public class androidx.compose.runtime.ComposerKt {

   boolean isTraceInProgress();

   void traceEventStart(int,int,int,java.lang.String);

   void traceEventStart(int,java.lang.String);

   void traceEventEnd();

}

Ces fonctions pourront changer à l'avenir, mais toute modification sera mentionnée dans les notes de version de Compose.

Notez que les conserver, même si cela augmente le coût dû à la taille de l'APK, vous permet de vous assurer que l'APK en cours de profilage est identique à celui utilisé par les utilisateurs de l'application.

Horodatage précis

Pour un profilage précis, comme pour tout test de performances, vous devez rendre l'application profileable et non-debuggable, conformément aux consignes sur les applications profilables.

Capturer une trace à partir d'un terminal

Il est possible de capturer une trace de composition à partir du terminal. Pour ce faire, vous devez suivre les étapes habituellement effectuées automatiquement par Android Studio.

Ajouter des dépendances

Tout d'abord, ajoutez les dépendances supplémentaires à votre application.

implementation("androidx.tracing:tracing-perfetto:1.0.0")
implementation("androidx.tracing:tracing-perfetto-binary:1.0.0")

Générer une commande d'enregistrement

1. Générez une commande d'enregistrement dans Perfetto.

2. Ajoutez manuellement la section de source de données track_event, comme indiqué dans l'exemple suivant:

   adb shell perfetto \
     -c - --txt \
     -o /data/misc/perfetto-traces/trace \
   <<EOF
   buffers: {
       size_kb: 63488
       fill_policy: RING_BUFFER
   }
   buffers: {
       size_kb: 2048
       fill_policy: RING_BUFFER
   }
   data_sources: {
       config {
           name: "track_event"
       }
   }
   duration_ms: 10000
   flush_period_ms: 30000
   incremental_state_config {
       clear_period_ms: 5000
   }
   EOF

Capturer une trace

1. Lancez l'application et préparez la section dont vous souhaitez effectuer le traçage.

2. Activez le traçage dans l'application en émettant une annonce.

   # set app package variable, e.g. com.google.samples.apps.nowinandroid.debug
   # can be found through `adb shell ps -ef` or `adb shell cmd package list packages`
   package=<your app process>
   
   # issue a broadcast to enable tracing
   adb shell am broadcast \
   -a androidx.tracing.perfetto.action.ENABLE_TRACING \
   $package/androidx.tracing.perfetto.TracingReceiver
   

3. Lancez la commande d'enregistrement que vous avez créée précédemment.

Ouvrir la trace

1. adb pull <location> correspond à la trace de l'appareil (emplacement spécifié dans la commande d'enregistrement).

2. Ouvrez-la dans Perfetto.

Capturer une trace avec Jetpack Macrobenchmark

Vous pouvez mesurer les performances avec Jetpack Macrobenchmark, qui fournit des traces en tant que résultats. Pour activer le traçage de composition avec les macrobenchmarks, vous devez:

1. Ajoutez ces dépendances supplémentaires au module de test Macrobenchmark:

   implementation("androidx.tracing:tracing-perfetto:1.0.0")
   implementation("androidx.tracing:tracing-perfetto-binary:1.0.0")
   

2. Ajoutez l'argument d'instrumentation androidx.benchmark.fullTracing.enable=true avant d'exécuter les benchmarks. Pour en savoir plus sur les arguments d'instrumentation Macrobenchmark, consultez Arguments d'instrumentation Macrobenchmark.

Commentaires

N'hésitez pas à nous faire part de vos commentaires sur cette fonctionnalité, des bugs que vous pourriez rencontrer et de vos demandes éventuelles. Vous pouvez nous envoyer vos commentaires via l'outil Issue Tracker.