Analyser les trames avec des captures GPU

Les captures GPU (ou de trames) enregistrent tous les appels d’API Direct3D 12 effectués par votre application, généralement en une seule trame (veuillez consulter la section Prendre une capture GPU). PIX peut rejouer ces appels d’API pour vous montrer des informations sur les paramètres d’appel d’API, les états de pipeline et de ressources, le contenu des ressources, et plus encore.

Prendre une capture GPU

Depuis l’affichage Connexion, lancez ou attachez-vous au processus souhaité (en vous assurant que l’option Pour capture GPU pertinente est cochée).

Configurez vos options de capture GPU si nécessaire. Pour prendre la capture, cliquez soit sur le bouton Prendre une capture GPU dans PIX, soit appuyez sur Alt+Impression écran (ou F11, configurable dans les paramètres PIX). Vous verrez une miniature de la capture dans l’interface utilisateur PIX. À ce stade, vous pouvez terminer votre application si vous le souhaitez. Cliquez sur la miniature pour ouvrir la capture.

Captures programmatiques

Vous pouvez prendre une capture de manière programmatique en utilisant le WinPixEventRuntime. Pour plus de détails, consultez l’article de blog Capture programmatique.

Afficher les appels d’API avec l’affichage des événements

L’affichage Événements montre tous les appels d’API qui ont été enregistrés dans une capture GPU. Il y a une liste distincte pour chaque file d’attente Direct3D 12 (graphique, calcul ou copie) utilisée par le jeu.

La liste des événements peut être filtrée, éventuellement en utilisant des expressions régulières (cliquez sur le bouton étiqueté .*). Par défaut, elle montre uniquement les événements qui ont entraîné un travail de rendu réel pour le matériel GPU, par opposition à la simple préparation de l’état pour une utilisation par des opérations ultérieures. Pour inclure les événements non-GPU, cliquez sur le bouton étiqueté !G.

Plus d’informations sur chaque événement, telles que l’ensemble complet des paramètres d’appel d’API, sont disponibles dans l’affichage Détails de l’événement. Cet affichage est inclus par défaut dans l’onglet Pipeline, mais peut également être ajouté à votre disposition actuelle via le bouton Mode conception de disposition dans le coin supérieur droit de la fenêtre principale de PIX.

Profilage de trames

Avec une capture GPU ouverte, passez à l’onglet Vue d’ensemble. Ici, vous verrez quelques détails de base sur la capture.

Pour commencer le profilage, vous devrez collecter des données de synchronisation. Pour ce faire, cliquez sur le bouton Collecter des données de synchronisation en haut à droite de l’affichage Événements, ou cliquez sur le texte Cliquez ici pour commencer l’analyse et collecter des données de synchronisation dans l’affichage Chronologie. Cela rejoue le travail du GPU dans la capture et collecte des données de synchronisation de base telles que les Durées d’exécution (annotées avec PixEvents, si votre application en a). Une fois terminé, vous pouvez collecter des données supplémentaires pour être représentées sous forme de graphiques dans les voies de la chronologie, telles que les informations d’occupation et d’autres compteurs spécifiques au GPU.

Vous pouvez également voir des compteurs décomposés par appel d’API dans l’affichage Événements. Pour activer/désactiver les compteurs, cliquez sur le bouton Compteurs de la liste d’événements (en haut à droite de l’affichage Événements).

Données de synchronisation

Il y a deux sources d’informations de synchronisation GPU :

1. Les horodatages de début de pipeline indiquent quand le GPU commence à traiter chaque partie du travail. Notez que ces données sont disponibles uniquement lorsque vous utilisez Windows 10, version 14393 (ou supérieure) avec un pilote graphique approprié (voir l’article de blog Exigences). La collecte des données de synchronisation prend plus de temps si les horodatages de début de pipeline ne sont pas disponibles.
2. Les horodatages de fin de pipeline (EOP) indiquent quand le GPU a terminé de traiter chaque partie du travail.

Comme les GPU sont massivement parallèles et profondément pipelineés, il est courant que plusieurs parties du travail s’exécutent en même temps, et que les opérations adjacentes se chevauchent. PIX mesure le temps de deux manières différentes qui peuvent offrir un aperçu du modèle d’exécution parallèle du matériel :

1. La Durée d’exécution est mesurée de l’horodatage de début de pipeline à l’horodatage de fin de pipeline de chaque partie séparée du travail. Lorsqu’ils sont mesurés de cette manière, les éléments de travail GPU qui s’exécutent en parallèle avec les éléments précédents peuvent apparaître plus longs que s’ils étaient exécutés isolément, en raison de la concurrence sur le GPU.
2. La Durée EOP est mesurée de l’horodatage de fin de pipeline (EOP) de l’élément précédent à l’horodatage EOP de cet élément. Les éléments de travail qui s’exécutent en parallèle avec les éléments précédents apparaîtront donc plus courts que s’ils étaient exécutés isolément, et certains éléments peuvent même être signalés comme ayant une durée nulle s’ils ont été entièrement exécutés en parallèle avec l’élément précédent.

L’affichage Chronologie affiche une ou plusieurs voies montrant la synchronisation de chaque opération GPU. Il y a une voie séparée contenant les données de Durée EOP pour chaque file d’attente (graphique, calcul ou copie) utilisée par le jeu, plus une seule voie montrant les données de Durée d’exécution (lorsqu’elles sont disponibles) combinées à travers toutes les files d’attente.

Compteurs GPU et occupation

PIX expose des compteurs de performance spécifiques au matériel fournis par les IHVs via un plugin GPU. Ces compteurs peuvent être activés et collectés soit dans l’affichage Compteurs de la liste d’événements (bouton pour activer en haut à droite de l’affichage Événements) soit dans l’affichage Compteurs de la chronologie (bouton pour activer en haut à droite de l’affichage Chronologie).

Sur certains GPU, PIX peut également recueillir des informations sur l’occupation. Les GPU sont généralement construits comme une hiérarchie de blocs répétés, où chaque niveau peut partager une ressource. Par exemple, un GPU imaginaire pourrait être structuré comme ceci :

Les GPU exécutent les shaders en divisant le travail du shader en vagues (elles sont également appelées warps ou fronts de vagues). Dans le diagramme ci-dessus, chaque bloc bleu est capable d’exécuter une vague. Chaque bloc vert pourrait exécuter jusqu’à quatre vagues.

Comme tous les blocs bleus partagent un ensemble unique de registres, si une charge de travail a besoin de tous les registres, alors une seule vague à la fois peut s’exécuter dans le bloc vert. Dans ce cas, l’occupation du bloc vert serait de 1, sur une occupation totale possible de 4.

À tout moment, tous les blocs verts pourraient exécuter un nombre différent de vagues. Parmi les quatre blocs verts ci-dessus, l’un pourrait exécuter 3 vagues, un autre 2 vagues, et le restant 1 vague. PIX résume toutes ces données en une seule valeur : l’occupation maximale, qui serait de 3 dans cet exemple.

C’est présenté dans PIX dans la voie Occupation, qui montre l’occupation maximale, séparée par étape de shader. C’est une indication de la quantité de travail que le GPU est capable de faire en parallèle : des barres plus hautes montrent une meilleure utilisation du GPU.

Débogage des problèmes de rendu

Avec une capture GPU ouverte, passez à l’onglet Pipeline. Cet onglet contient un affichage Événements, plusieurs affichages d’inspecteur d’état et de ressources, et un affichage Pipeline.

La sélection d’un événement dans l’affichage Événements remplit divers affichages, notamment l’affichage Pipeline, qui peut être utilisé pour inspecter les signatures de racine, l’état du pipeline et les ressources liées. L’affichage Pipeline est également le point d’entrée dans le Débogage de shader.

Afficher les objets, paramètres et état Direct3D 12

Après avoir sélectionné un événement dans l’affichage Événements, les affichages État et Pipeline (trouvés dans l’onglet Pipeline) montrent les détails de l’état Direct3D au moment de cet événement. Là, vous pouvez voir quelles ressources sont liées au pipeline, le code shader, les entrées, les sorties, et les rendertarget(s) actuellement liées.

Débogage de shader

Après avoir sélectionné un événement approprié et exécuté l’analyse, vous pouvez déboguer vos shaders. Dans l’affichage Pipeline, il y a plusieurs façons d’initier le débogage de shader :

1. Sélectionnez l’entrée Shader sous l’étape de shader souhaitée, et cliquez sur le bouton de lecture vert. Avant de commencer la session de débogage, assurez-vous de configurer les paramètres de shader appropriés (par exemple, les ID d’instance et de sommet pour les vertex shaders, ou les coordonnées de pixel pour les pixel shaders).
2. Cliquez avec le bouton droit dans un visualiseur de ressource (par exemple, la sortie VS ou un SRV/UAV/RTV) et sélectionnez l’option Déboguer appropriée.
3. Cliquez sur le bouton Déboguer pixel dans l’affichage Détails de pixel lors de la visualisation d’une ressource appropriée (par exemple, SRV/UAV/RTV).

Modifier le shader & continuer

Le code shader HLSL peut être édité directement à l’intérieur de PIX, vous permettant de voir immédiatement l’effet de vos changements sur les résultats de rendu ou les performances. Cela peut être utile pour prototyper et optimiser les shaders, car cela peut considérablement réduire le temps de retour lorsque vous essayez différentes idées.

Après avoir sélectionné un shader, vous pouvez éditer son code comme vous le souhaitez, puis cliquez sur Modifier>Appliquer. D’autres affichages (comme OM RTV 0) se mettront à jour pour montrer l’effet de votre changement. Vous pourriez trouver utile de placer plusieurs instances de l’affichage Pipeline les unes à côté des autres pour voir les résultats de rendertarget en même temps que vous éditez le code shader.

Si vous perdez le fil de ce que vous avez exactement changé, cliquez avec le bouton droit sur le code shader, et choisissez Diff avec l’original.

Déboguer les visualiseurs

Les visualiseurs de rendertarget sont disponibles dans l’affichage Pipeline lors de l’inspection du contenu d’une rendertarget. Le visualiseur d’image par défaut affiche simplement l’image normalement, et peut être modifié en sélectionnant une visualisation différente dans l’affichage Visualisation.

Historique des pixels

Pour toute ressource semblable à un pixel (par exemple, RTVs, UAVs, ou tampons de profondeur), vous pouvez voir toutes les opérations qui ont affecté un pixel particulier en utilisant Historique des pixels. Cela peut être accédé en cliquant avec le bouton droit sur le pixel souhaité, et en sélectionnant Afficher l’historique des pixels, ou en cliquant sur le bouton Historique des pixels dans l’affichage Détails du pixel.

Avertissements et notes diverses

• Il n’est pas toujours possible pour PIX de réussir à prendre une capture GPU si un jeu appelle Direct3D 12 de manière incorrecte. PIX fait de son mieux pour être robuste même en cas de schémas d’utilisation incorrects, mais il s’agit inévitablement parfois d’un cas de garbage in, garbage out. Si vous avez des difficultés à prendre des captures GPU, essayez d’utiliser le D3D12 Debug Layer et la validation basée sur le GPU pour trouver et corriger les mauvais appels d’API.
• Les captures GPU Windows ne sont généralement pas portables entre différents matériels GPU et versions de pilotes. Dans la plupart des cas, une capture prise sur une machine se jouera correctement sur d’autres GPU similaires de la même famille matérielle, et les captures de certains jeux peuvent même fonctionner sur des GPU de fabricants totalement différents, mais il est également possible que quelque chose d’aussi trivial qu’une mise à jour de pilote puisse casser la compatibilité avec les anciennes captures. PIX ne peut garantir la réussite de la lecture que lorsque le GPU et le pilote sont exactement les mêmes, donc PIX avertira avant de commencer l’analyse s’il n’y a pas de correspondance parfaite. Passez outre cet avertissement à vos propres risques.
• PIX a un support limité pour plusieurs GPU. Il jouera toujours les captures GPU sur un seul adaptateur, indépendamment du nombre d’adaptateurs utilisés par l’application. PIX vous permet de sélectionner l’adaptateur de lecture à partir d’une option déroulante dans la barre d’outils PIX. PIX tentera de sélectionner automatiquement l’adaptateur de lecture si l’application n’a utilisé qu’un seul adaptateur.
• Pour les charges de travail ExecuteIndirect non déterministes, vous pourriez vouloir activer le paramètre Utiliser les tampons d’argument ExecuteIndirect au moment de la lecture.