> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Instruction Trace Captures > Instruction Trace Captures * [Vue d'ensemble](#itrace_overview) * [Processus de capture](#itrace_take_capture) * [Dispositions des Instruction Traces](#itrace_views) * [Résumé de la capture](#itrace_summary_view) * [Instruction Table](#itrace_instruction_table_view) * [Source](#itrace_source_view) * [Callgraph](#itrace_callgraph_view) * [Memory Regions](#itrace_memory_regions_view) * [Memory Region Details](#itrace_memory_region_details_view) * [Bonnes pratiques et limitations](#itrace_limitations) ## Vue d'ensemble Les Instruction Trace Captures vous aident à optimiser l'utilisation que fait votre titre de la mémoire et des caches d'instructions de la console. PIX enregistre des données sur chaque instruction du processeur exécutée pendant la capture. Toutes les instructions de chargement et de stockage en mémoire sont ensuite analysées à l'aide d'une simulation de cache. Les résultats de la simulation permettent de : * Identifier les fonctions qui ont provoqué le plus de défauts de cache et chargé le plus de données dans les caches. Les lignes de code source C++ et les instructions assembleur précises à l'origine d'un défaut de cache sont également identifiées. * Afficher des statistiques sur les succès et défauts de cache pour chaque cœur de processeur et chaque module. * Visualiser l'efficacité d'utilisation de chaque ligne de cache. Les Instruction Trace Captures indiquent quels octets d'une ligne de cache ont été consultés, ainsi que le code qui a accédé à chaque octet. Des informations sur les structures de données sont également fournies pour vous aider à optimiser la disposition de vos données afin d'utiliser au mieux les caches mémoire. Outre les fonctionnalités d'analyse des caches mémoire, les Instruction Trace Captures vous aident également à identifier les éventuelles inefficacités ou défauts liés à la lecture de mémoire à écriture combinée ou à l'accès à la pile d'un autre thread. ## Effectuer une capture Les Instruction Traces enregistrent des données pour un nombre spécifié d'instructions du processeur à partir du moment où la capture est lancée. Le nombre d'instructions à capturer est spécifié dans le champ **Instructions per thread to capture** du volet **CPU Instruction Trace Options** avant de démarrer une capture. Notez que le nombre d'instructions spécifié est capturé pour chaque thread s'exécutant dans le processus du titre. PIX peut également enregistrer, de manière facultative, des informations sur les types de données consultés par chaque ligne de code source et chaque instruction assembleur. Cochez la case **Track Data Types** pour ajouter les informations de type de données à la capture. Après avoir spécifié le nombre d'instructions et l'option de suivi des types, sélectionnez le bouton **Capture** pour démarrer la capture. CPU Instruction Trace ## Dispositions des Instruction Traces * [Summary](#itrace_summary_view). Fournit un résumé de la manière dont le titre interagit avec les caches de données et d'instructions de la console. * [Instruction Table](#itrace_instruction_table_view). Affiche les instructions du processeur exécutées pour une fonction donnée. Des informations sur les types de données consultés et sur les instructions assembleur ayant provoqué des défauts du cache de données sont également fournies. * [Source](#itrace_source_view). Affiche le code source C++ d'une fonction donnée. Des informations sur les types de données consultés et sur les lignes de code source ayant provoqué des défauts du cache de données sont également fournies. * [Callgraph](#itrace_callgraph_view). Affiche le graphe des appels de toutes les fonctions exécutées pendant la capture. La vue permet d'examiner diverses statistiques sur chaque appel, notamment le nombre de défauts de cache, une répartition par type d'instruction, etc. Une vue papillon des fonctions est également fournie pour parcourir les appelants et les appelés d'une fonction donnée. * [Memory Regions](#itrace_memory_regions_view). Fournit des détails sur les modèles d'accès mémoire pour un ensemble de plages d'adresses. * [Memory Region Details](#itrace_memory_region_details_view). Fournit un niveau supplémentaire d'analyse des lignes de cache en affichant les lignes de code source C++ et les instructions assembleur qui accèdent à la mémoire dans la région actuellement sélectionnée. ### Résumé de la capture Les Instruction Trace Captures s'ouvrent sur une disposition de résumé qui fournit une analyse de la manière dont le titre interagit avec la mémoire et les caches d'instructions du système. Des avertissements, par exemple sur les lectures de mémoire à écriture combinée, sont également fournis. La section *Execution Summary* de la page de résumé affiche des statistiques de base sur la capture, notamment une répartition des instructions par type et la quantité de données chargées et stockées. Résumé et statistiques de base de la capture La section *Cache Statistics* de la page de résumé affiche des statistiques sur les caches de données et d'instructions de la console. Le nombre de succès de cache, le nombre de défauts de cache et le nombre moyen de lectures de chaque ligne de cache sont indiqués. Ces chiffres donnent une idée générale du comportement du code exécuté sur un cœur en matière d'efficacité du cache, par rapport au code exécuté sur un autre cœur. Par exemple, dans l'image suivante, le taux de défauts du cache de données L1-D est relativement élevé sur le cœur 0 par rapport au cœur 2 (3 127 contre 30). Les statistiques de cache montrent également que le nombre de lectures d'une ligne de cache après son chargement dans le cache est relativement faible sur le cœur 0 par rapport au cœur 2 (\~43 contre \~3795). Un nombre élevé de défauts de données, associé à un faible nombre moyen de lectures des lignes de cache, peut indiquer une utilisation inefficace du cache. Comparaison des statistiques de cache entre les cœurs L'analyse de résumé de l'Instruction Trace comprend une liste des principales fonctions ayant provoqué des défauts L1 et L2. Les défauts L3 sont également fournis lorsque la capture a été effectuée sur un XBOX Series X Dev Kit ou un XBOX Series S Test Kit. Cliquer sur le lien hypertexte en regard d'une fonction de la liste permet d'accéder à la disposition [**Instruction Table**](#itrace_instruction_table_view), qui affiche l'ensemble des instructions assembleur exécutées lors de l'exécution de cette fonction, avec des annotations indiquant les instructions qui ont provoqué des défauts de cache. Un clic droit sur le lien hypertexte en regard d'une fonction affiche un menu contextuel permettant d'afficher le code source de la fonction, soit dans la disposition [**Source**](#itrace_source_view), soit en ouvrant le fichier source dans Visual Studio. Analyse des lignes de cache La section *Cache Line Statistics* de la vue **Summary** comprend une analyse de l'utilisation de chaque ligne de cache, en octets et en pourcentage. Plus ces chiffres sont élevés, plus vos structures de données sont disposées efficacement, ce qui se traduit par une utilisation plus efficace des lignes de cache. L'exemple suivant montre qu'environ 74 % des données chargées dans les caches de données ont été consultées (\~47 octets de chaque ligne de cache de 64 octets). La section des statistiques des lignes de cache de la page de résumé de l'Instruction Trace Une liste des fonctions ayant provoqué le chargement du plus grand nombre de lignes de cache est également fournie, ainsi que l'ensemble des fonctions ayant lu et écrit le plus de lignes de cache. Outre l'analyse de l'utilisation des lignes de cache, la vue **Summary** fournit également des informations sur d'autres problèmes potentiels de performances et de fiabilité. Ces problèmes incluent l'utilisation de mémoire à écriture combinée et les cas où un thread a accédé à la pile d'un autre thread. La vue *Warnings* située dans l'angle supérieur droit de la disposition par défaut indique quand ces problèmes se sont produits. La vue *Capture Summary* fournit davantage de détails, notamment les piles d'appels au moment où ces problèmes se sont produits. Lectures de mémoire à écriture combinée et accès à la pile entre threads ### Instruction Table La disposition **Instruction Table** permet d'examiner l'ensemble des instructions du processeur exécutées pour une fonction donnée. Le nombre d'exécutions et le nombre de défauts de cache sont indiqués pour chaque instruction exécutée. Les types de données consultés par chaque instruction sont également affichés si l'option *Track Data Types* a été sélectionnée avant le démarrage de la capture. On accède souvent à la disposition **Instruction Table** en cliquant sur un lien hypertexte en regard d'une fonction dans la disposition [**Summary**](#itrace_summary_view). Vue Instruction Table Les instructions affichées dans l'**Instruction Table** sont celles qui se sont exécutées lors de l'exécution de la fonction, et non toutes les instructions de la fonction. Plus précisément, les instructions des branches non empruntées ne sont pas affichées. Les groupes d'instructions non exécutées sont représentés par une ligne de points dans la colonne d'adresse. Par exemple, l'instruction *je* de la figure suivante a entraîné un saut qui a ignoré certaines instructions, comme l'indique la ligne de points après le saut. Une branche empruntée telle qu'affichée dans l'Instruction Table Un clic droit dans la colonne d'adresse affiche un menu contextuel qui permet d'accéder à la disposition [**Source**](#itrace_source_view) ou d'ouvrir le fichier source dans Visual Studio. Le menu contextuel de l'Instruction Table La combinaison de touches Ctrl+F permet d'afficher une zone de recherche. La zone de recherche de l'Instruction Table Le texte de l'**Instruction Table** peut être copié et collé dans un autre outil pour permettre d'autres scénarios d'analyse. Après avoir sélectionné le texte à copier, utilisez Ctrl+C pour le copier dans le Presse-papiers. Ctrl+A permet de sélectionner tout le texte de l'**Instruction Table**. ### Source La disposition **Source** permet d'examiner le code source C++ d'une fonction donnée. On accède souvent à cette disposition en cliquant sur un lien hypertexte en regard d'une fonction dans la disposition [**Summary**](#itrace_summary_view) ou en sélectionnant l'élément de menu contextuel *Goto Source* dans la disposition [**Summary**](#itrace_summary_view) ou dans la disposition [**Instruction Table**](#itrace_instruction_table_view). Go To Source Chaque ligne de code source C++ est annotée avec les instructions en langage assembleur correspondant à cette ligne, ainsi qu'avec le nombre d'exécutions et le nombre de défauts de cache de chaque instruction exécutée. Les types de données consultés par chaque instruction sont également affichés si l'option *Track Data Types* a été sélectionnée avant le démarrage de la capture. Le nom du fichier source est affiché en haut de la vue. Le fichier source ouvert est celui spécifié dans le PDB, chemin compris. Les flèches de développement et de réduction permettent d'afficher ou de masquer toutes les instructions assembleur associées à une ligne de code source donnée. Code source de l'Instruction Trace Si le fichier source C++ spécifié dans le PDB est introuvable, un message s'affiche à côté du nom du fichier source et la vue n'affiche plus que les instructions en langage assembleur. La vue **Source** dispose également d'une fonctionnalité de recherche permettant de localiser un texte précis dans le code source, comme illustré dans la figure suivante. Pour ouvrir la boîte de dialogue **Find in Source**, appuyez sur Ctrl+F. Pour trouver l'occurrence suivante du texte, appuyez sur F3. Fonctionnalité de recherche de l'Instruction Trace Le texte de la vue **Source** peut être copié et collé dans un autre outil pour permettre d'autres scénarios d'analyse. Après avoir sélectionné le texte à copier, utilisez Ctrl+C pour le copier dans le Presse-papiers. Ctrl+A permet de sélectionner tout le texte de la vue **Source**. ### Callgraph Les Instruction Traces comprennent une disposition qui affiche le graphe des appels de toutes les fonctions exécutées pendant la capture. Chaque thread sur lequel du code a été exécuté est un nœud de premier niveau de l'arborescence. Les colonnes de la vue permettent d'examiner diverses statistiques sur chaque appel, notamment le nombre de défauts de cache, une répartition par type d'instruction, etc. Les colonnes à afficher peuvent être personnalisées à l'aide du panneau *Event List Counters*. Graphe des appels de l'Instruction Trace Un clic droit sur une fonction dans le graphe des appels affiche un menu contextuel contenant plusieurs options pour explorer davantage la fonction, comme illustré dans la figure suivante. Ces options permettent notamment d'afficher un mélange de code source et de code assembleur pour la fonction, et d'ouvrir la disposition [**Memory Regions**](#itrace_memory_regions_view) limitée à la mémoire consultée par la fonction. Menu contextuel de la vue Callgraph Le graphe des appels peut être filtré sur un thread ou un cœur donné à l'aide du panneau *Event List Options*. Le panneau Event List Options de la vue Callgraph La barre de filtre en haut du graphe des appels comporte un bouton **Loops Only** qui filtre les données sur les fonctions contenant des boucles. Les boucles sont souvent des sections de code intéressantes à examiner pour détecter des problèmes de performances. Parmi les problèmes courants figurent les imbrications inutiles et le parcours inefficace de structures de données. Boucles de l'Instruction Trace Par défaut, seules sont affichées les boucles contenues dans des fonctions dont le nombre d'instructions inclusif représente au moins 1 % de toutes les instructions exécutées dans la capture. Ce seuil peut être ajusté à l'aide du paramètre *Minimum Inclusive Instruction % for loop detection*, situé dans la section *CPU Instruction Trace* de la vue **Settings**. Le paramètre Minimum Inclusive Instruction % for loop detection La vue *Butterfly*, sur le côté droit de la disposition, affiche les appelants et les appelés d'une fonction sélectionnée. Cliquer sur une ligne du graphe des appels définit cette fonction comme fonction cible dans la vue papillon. La fonction cible est affichée dans le tableau central de la vue. Le tableau supérieur répertorie tous les appelants de la fonction cible. Le tableau inférieur répertorie toutes les fonctions appelées par la fonction cible. Double-cliquer sur une fonction dans le tableau des appelants ou des appelés en fait la nouvelle fonction cible, ce qui facilite la navigation parmi les appelants et les appelés d'une série de fonctions. La vue Butterfly des Instruction Trace Captures ### Memory Regions La disposition **Memory Regions** fournit des détails sur les modèles d'accès mémoire pour un ensemble de plages d'adresses. Ces détails incluent l'ensemble des octets individuels consultés dans chaque ligne de cache, ainsi que l'ensemble des fonctions et des types de données associés à chaque accès mémoire. La disposition **Memory Regions** est surtout utile lorsque les données qu'elle affiche sont limitées à une fonction donnée. Un flux de travail courant consiste à identifier une fonction qui provoque des défauts du cache de données à l'aide de la disposition [Summary](#itrace_summary_view) ou de la disposition [Callgraph](#itrace_callgraph_view), puis à utiliser le menu contextuel de la disposition [Callgraph](#itrace_callgraph_view) pour accéder à la disposition **Memory Regions**. Dans la figure suivante, une fonction nommée *UpdateCommonObjects* a été identifiée comme fonction intéressante compte tenu du nombre élevé de défauts de cache affiché dans la disposition [Callgraph](#itrace_callgraph_view). L'élément de menu contextuel *Scope Memory Analysis to only this node* permet d'accéder à la disposition **Memory Regions**. Limitation de la vue Memory Regions à une fonction donnée Le tableau *Memory Regions* affiche l'ensemble des plages d'adresses actuellement analysées. Les colonnes disponibles incluent la taille de la région, le nombre de défauts du cache de données L2 et le pourcentage de la région mémoire qui a été consulté. La taille d'une région mémoire est généralement de 64 Ko. Les plages dont la taille est inférieure à 64 Ko indiquent un écart important entre les adresses des accès mémoire. Les boutons *!System* et *!Stack* de la barre de filtre permettent d'exclure les régions mémoire consultées uniquement par du code système ou correspondant à des accès à la pile. Les colonnes à afficher peuvent être personnalisées à l'aide du panneau *Event List Counters*. Le tableau Memory Regions La sélection d'une ligne du tableau *Memory Regions* renseigne les vues *Byte Access Map*, *Accessing functions* et *Accessed Types*. La vue *Byte Access Map* fournit des détails sur l'accès mémoire de chaque octet d'une ligne de cache. Chaque ligne de la vue représente une ligne de cache. Les 64 cases de la ligne représentent les octets individuels de la ligne. Les cases vertes représentent les octets consultés, tandis que les cases blanches représentent les octets non consultés. Le survol d'un ensemble de cases affiche une info-bulle contenant les informations de type de données, si elles sont disponibles. Ces informations sont disponibles si l'option *Track Data Types* a été sélectionnée avant le démarrage d'une capture. La *Byte Access Map* suivante montre un modèle d'accès aux données relativement inefficace (épars), comme l'indiquent le nombre relativement faible de cases vertes et les écarts importants entre les octets consultés. L'info-bulle indique que l'ensemble de cases vertes mis en surbrillance représente un accès au champ *a* d'une structure de données nommée *CommonObject*. La Byte Access Map Le tableau *Accessing Functions* répertorie l'ensemble des fonctions qui ont accédé à la mémoire dans la plage actuellement sélectionnée. Si plusieurs fonctions sont répertoriées, la sélection de l'une d'elles met à jour la *Byte Access Map* pour mettre en surbrillance les accès effectués par cette fonction. La vue *Accessed Types* répertorie l'ensemble des types de données consultés dans la plage actuellement sélectionnée. Si un type de données est une structure, la vue indique le pourcentage de fois où chaque champ de la structure a été consulté. La figure suivante montre un type dont les champs *a*, *g*, *i* et *k* ont été consultés 100 % du temps, tandis que les autres champs n'ont jamais été consultés. La liste Accessed Types Des informations sur la taille de chaque champ, ainsi que sur la taille du type lui-même, sont également fournies. Le modèle d'accès épars de la structure *CommonObject*, tel qu'indiqué à la fois dans la *Byte Access Map* et dans la liste *Accessed Functions*, représente une occasion de remanier le type de données et le code qui y accède afin d'utiliser plus efficacement les caches de données de la console. ### Memory Region Details La disposition **Memory Region Details** fournit un niveau supplémentaire d'analyse des lignes de cache grâce à la vue *Source Memory Access*. Cette vue présente le code source C++, entrelacé avec les instructions assembleur et les informations de type de données, et indique exactement quelles lignes de la fonction affectent la région mémoire. Les lignes de code source et d'assembleur mises en surbrillance en vert accèdent à des données de la région mémoire. La sélection d'une autre fonction dans la vue *Accessing Functions* met à jour la *Byte Access Map* et la vue *Source Memory Access* avec des informations propres à la fonction sélectionnée. La disposition Memory Region Details ## Bonnes pratiques et limitations L'Instruction Trace indique les défauts des caches de données L1 et L2. Les défauts L3 sont également fournis lorsque la capture a été effectuée sur un XBOX Series X Dev Kit ou un XBOX Series S Test Kit. Ces nombres apparaissent dans les différentes dispositions de la capture. Les nombres de défauts de cache sont basés sur une simulation des caches, et non sur des compteurs ou événements matériels réels. La simulation est utilisée parce que l'Instruction Trace entraîne un traitement supplémentaire pour chaque instruction exécutée, ce qui fausserait tout compteur matériel réel. Plusieurs facteurs sont toutefois à prendre en compte lors de l'analyse des données produites par la simulation de cache. * Les caches sont supposés froids ; les premiers défauts peuvent donc ne pas être exacts. * La latence de chargement des lignes n'est pas modélisée. * Les types de mémoire autres que l'écriture différée (la mémoire mise en cache par défaut) ne sont pas modélisés. * Les prérécupérateurs matériels ne sont pas modélisés. * Aucun accès mémoire spéculatif n'est modélisé, car l'exécution dans le désordre n'est pas entièrement modélisée. Notez également que l'Instruction Trace ne peut pas être utilisée si le titre est actuellement arrêté à un point d'arrêt dans le débogueur. ## Voir aussi [PIX](/fr/tools/tools-console/pix/pix) ## Related topics - [PIX sur XBOX et Windows pour les titres GDK](/fr/tools/tools-console/pix/index.md) - [Captures PIX GPU Trace sur les consoles XBOX Series](/fr/tools/tools-console/pix/gpu-trace/index.md) - [Suivi (xbtrace.exe)](/fr/tools/tools-console/commandlinetools/xbtrace.md) - [PIXBeginCapture](/fr/reference/tools/pix3/functions/pixbegincapture.md) - [PIXGetCaptureState](/fr/reference/tools/pix3/functions/pixgetcapturestate.md)