Collecter et afficher des traces

Cette page fournit des instructions détaillées pour collecter des traces Perfetto à utiliser avec Wattson et pour analyser les données d'alimentation résultantes dans l'interface utilisateur de Perfetto.

Il existe de nombreuses façons de collecter une trace Perfetto, mais les méthodes présentées sur cette page incluent les exigences et les workflows spécifiques pour générer une trace compatible avec Wattson.

Configuration minimale requise

Pour vérifier que Wattson dispose des métadonnées requises pour fonctionner correctement, vous devez collecter des traces à partir d'un appareil exécutant une version récente. Les versions minimales pour l'estimation de la consommation d'énergie du processeur et du GPU varient selon l'appareil.

Collecter une trace Perfetto à partir de la ligne de commande

Cette section présente un exemple de workflow pour collecter des traces Perfetto à utiliser avec Wattson. Toutes les commandes listées dans les étapes suivantes sont destinées à être émises à partir de l'hôte Android Debug Bridge (adb).

1. Configurez et démarrez la trace en créant un fichier de configuration Perfetto sur l'appareil. Vous trouverez un exemple de configuration dans wattson.cfg dans l'arborescence source.

   La configuration minimale doit inclure les événements de trace suivants :

   # Polls CPU freq/idle state at the start of trace
   data_sources: {
      config {
         name: "linux.sys_stats"
         sys_stats_config {
            # Large period so polling doesn't happen continuously
            # Intent is just to poll once upfront
            cpufreq_period_ms: 100000000
            cpuidle_period_ms: 100000000
         }
      }
   }
   data_sources: {
      config {
         name: "linux.ftrace"
         ftrace_config {
            ftrace_events: "devfreq/devfreq_frequency"
            ftrace_events: "cpuhp/cpuhp_enter"
            ftrace_events: "cpuhp/cpuhp_exit"
            ftrace_events: "cpuhp/cpuhp_multi_enter"
            ftrace_events: "power/cpu_frequency"
            ftrace_events: "power/cpu_idle"
            ftrace_events: "power/suspend_resume"
         }
      }
   }
   

2. Pour activer les estimations de la consommation d'énergie du cache L3, activez l'événement fttrace/print :

   adb shell perfetto --txt -c /data/misc/perfetto-configs/wattson.cfg --background-wait -o /data/misc/perfetto-traces/trace
   
   # Optional
   adb shell simpleperf stat -a -e arm_dsu_0/l3d_cache/,arm_dsu_0/bus_access/ --interval 10
   

3. (Facultatif) Définissez le début de la fenêtre Wattson, un repère intégré à la trace Perfetto qui indique le début de l'enregistrement. Ce repère ajoute une précision supplémentaire à la mesure Wattson.

   # Optional
   adb shell "echo 'I|0|wattson_start' >/sys/kernel/tracing/trace_marker"
   

4. Exécutez la charge de travail qui vous intéresse.

5. (Facultatif) Activez l'événement de trace ftrace/print pour définir la fin de la fenêtre Wattson :

   # Optional
   adb shell "echo 'I|0|wattson_stop' >/sys/kernel/tracing/trace_marker"
   

6. Videz les tampons de trace et extrayez le fichier de trace Perfetto :

   adb shell killall -w perfetto
   adb pull /data/misc/perfetto-traces/trace my_perfetto_trace.pb
   

Collecter une trace Perfetto à l'aide de l'interface utilisateur de Perfetto

Pour collecter des traces à l'aide de l'interface utilisateur de Perfetto , vous devez activer des paramètres spécifiques pour Wattson. Lorsque vous enregistrez une nouvelle trace dans l'interface utilisateur de Perfetto, activez les Détails de la programmation et Fréquence du processeur et états d'inactivité :

Figure 1. Boutons "Détails de la programmation" et "Fréquence du processeur et états d'inactivité".

Pour les appareils Pixel 9, sous les paramètres Ftrace, cochez la case devfreq pour activer la collecte de la fréquence de l'appareil :

Figure 2. Activer la fréquence de l'appareil.

Afficher la répartition par rail

Avec Perfetto, analysez les estimations de consommation d'énergie de Wattson en sélectionnant une plage de temps pour afficher les statistiques par rail, ou activez des configurations de trace spécifiques pour attribuer la consommation d'énergie au niveau du thread, du processus ou du package.

Pour interagir avec Wattson dans Perfetto :

1. Ouvrez une trace dans Perfetto.

   Si votre appareil est compatible avec Wattson, les traces Wattson sont automatiquement listées :

   

   Figure 3. Afficher les traces Wattson dans Perfetto.

2. Cliquez sur Wattson pour développer la section et afficher la répartition par rail virtuel :

   • Tous les graphiques de rail sont automatiquement mis à l'échelle sur la même valeur pour afficher la proportion entre les rails.

   • Les statistiques sont générées pour toute région sélectionnée (ou marquée) par l'utilisateur.

   • Le tableau de statistiques peut être trié en cliquant sur n'importe quel nom de colonne.

   • Les totaux estimés s'affichent directement sous les titres des colonnes.

   

   Figure 4. Estimations de rail.

Afficher la trace par attributions de thread, de processus ou de package

Si vous avez activé les traces du planificateur et que vous pouvez voir les tranches de thread dans Perfetto, vous pouvez également obtenir l'attribution de la consommation d'énergie au niveau du thread ou du processus :

1. Dans Perfetto, sélectionnez une région de tranches de thread.
2. Affichez la répartition du thread, du processus ou du package.

Comme pour les statistiques de suivi par rail, vous pouvez cliquer sur n'importe quel nom de colonne pour trier les données en fonction de cette colonne.

Analyser la répartition au niveau du thread

En plus des exigences minimales pour l'estimation de base de la consommation d'énergie, vous devez ajouter la configuration suivante à la linux.ftrace section dans le wattson.cfg pour l'attribution de la consommation d'énergie au niveau du thread :

data_sources: {
    config {
        name: "linux.ftrace"
        ftrace_config {
            ftrace_events: "sched/sched_switch"
        }
    }
}

Figure 5. Répartitions au niveau du thread.

Répartition au niveau du processus

L'attribution au niveau du processus nécessite que process_states soit activé sur les données collectées dans la trace Perfetto. Activez la source de données suivante dans votre wattson.cfg fichier de configuration :

data_sources: {
    config {
        name: "linux.process_stats"
        target_buffer: 1
        process_stats_config {
            scan_all_processes_on_start: true
        }
    }
}

Figure 6. Répartition par processus.

Répartition au niveau du package

L'attribution au niveau du package nécessite que android.packages_list soit activé sur les données collectées dans la trace Perfetto. Activez la source de données suivante dans votre wattson.cfg fichier de configuration :

data_sources {
  config {
    name: "android.packages_list"
    target_buffer: 1
  }
}

Comme pour l'attribution au niveau du thread et du processus, lorsque vous sélectionnez une plage de tranches de thread, examinez la répartition au niveau du package.

Figure 7. Répartition au niveau du thread.

Estimation de la consommation d'énergie du GPU

L'estimation de la consommation d'énergie du GPU est compatible avec les Pixel 6, 6 Pro et 6a. Pour activer l'estimation de la consommation d'énergie du GPU, activez la source de données suivante dans votre wattson.cfg fichier de configuration :

data_sources: {
  config {
    name: "linux.ftrace"
    ftrace_config {
      ftrace_events: "mali/gpu_power_state"
      ftrace_events: "power/gpu_frequency"

      # [Optional] Enable GPU Work Period (not used by Wattson, but useful for debugging)
      ftrace_events: "power/gpu_work_period"
    }
  }
}

Pour une sélection donnée, les estimations de la consommation d'énergie du GPU de Wattson s'affichent dans l'interface utilisateur de Perfetto dans l'onglet Estimations Wattson.

Figure 8. Estimation de la consommation d'énergie du GPU.

Questions fréquentes

Voici quelques questions fréquentes sur Wattson.

Wattson est-il censé correspondre à la sortie matérielle de mesure de la consommation d'énergie en laboratoire ?

Pour la plupart des charges de travail, l'estimation de Wattson correspond aux mesures matérielles de la consommation d'énergie en laboratoire. Toutefois, ce n'est pas toujours le cas et ce n'est pas l'objectif de Wattson.

Wattson est conçu pour valider les améliorations de la consommation d'énergie ou détecter les régressions de la consommation d'énergie sans bruit provenant de facteurs environnementaux (température), de variations d'unité à unité dans les fuites de puce (le même SoC peut avoir des fuites différentes par unité basis), ou de différences de calibration entre le matériel de mesure de la consommation d'énergie en laboratoire.

En quoi Wattson est-il plus utile que l'examen du temps processeur ou des cycles processeur ?

Le temps processeur et les cycles ne tiennent pas compte de la différence de consommation d'énergie entre les fréquences et les types de processeur (petit, moyen ou grand).

Une fréquence de processeur doublée n'entraîne pas toujours une puissance de processeur doublée ni des performances doublées.

Wattson est-il précis par rapport aux solutions matérielles ?

Nous avons comparé Wattson avec le matériel de mesure de la consommation d'énergie en laboratoire dans plusieurs cas d'utilisation fournis par plusieurs équipes. L'erreur moyenne dans Wattson est de 1 point de pourcentage et l'écart type est de 1,5 point de pourcentage. Ce niveau de corrélation est maintenu sur les tests qui durent de 10 secondes à 4 heures. Il n'y a donc pas d'augmentation progressive de l'erreur ni de masquage de l'erreur qui soit un facteur de temps.

Expériences de configuration du noyau Pixel 6

Voici quelques expériences de référence de répartitions Wattson typiques à l'aide du Pixel 6 :

• Référence
• RCU_LAZY
• HZ_1000

Wattson.cfg

Cette section fournit la configuration typique pour l'activation de Wattson sur Perfetto :

  write_into_file: true
  flush_period_ms: 30000
  file_write_period_ms: 30000

  buffers: {
      size_kb: 2048
      fill_policy: RING_BUFFER
  }
  buffers: {
      size_kb: 200000
      fill_policy: RING_BUFFER
  }

  # Needed for process level power attribution
  data_sources: {
      config {
          name: "linux.process_stats"
          target_buffer: 0
          process_stats_config {
              scan_all_processes_on_start: true
          }
      }
  }

  # Needed for package level power attribution
  data_sources: {
      config {
          name: "android.packages_list"
          target_buffer: 0
      }
  }

  # Needed for determining CPU freq/idle initial state
  data_sources: {
      config {
          name: "linux.sys_stats"
          sys_stats_config {
              cpufreq_period_ms: 100000000
              cpuidle_period_ms: 100000000
          }
      }
  }

  # Needed for estimating power and thread level power attribution
  data_sources: {
      config {
          name: "linux.ftrace"
          target_buffer: 1
          ftrace_config {
              # Minimum data sources for estimating power
              ftrace_events: "power/cpu_frequency"
              ftrace_events: "power/cpu_idle"
              ftrace_events: "power/suspend_resume"
              ftrace_events: "cpuhp/cpuhp_enter"
              ftrace_events: "cpuhp/cpuhp_exit"
              ftrace_events: "cpuhp/cpuhp_multi_enter"
              ftrace_events: "devfreq/devfreq_frequency"

              # Needed for Wattson start/stop markers
              ftrace_events: "ftrace/print"

              # Needed for thread level power attribution
              ftrace_events: "sched/sched_switch"

              # Needed for process level power attribution
              ftrace_events: "sched/sched_process_free"
              ftrace_events: "task/task_newtask"
              ftrace_events: "task/task_rename"
          }
      }
  }