Partager via

Exécution et synchronisation de listes de commandes

  • Article

Dans Microsoft Direct3D 12, le mode immédiat des versions précédentes n’est plus présent. Au lieu de cela, les applications créent des listes de commandes et des offres groupées, puis enregistrent des jeux de commandes GPU. Les files d’attente de commandes sont utilisées pour envoyer des listes de commandes à exécuter. Ce modèle permet aux développeurs d’avoir plus de contrôle sur l’utilisation efficace de l’unité de traitement graphique (GPU) et du processeur.

Vue d’ensemble de la file d’attente de

Les files d’attente de commandes Direct3D 12 remplacent la synchronisation du runtime et du pilote de la soumission de travail en mode immédiat, qui n’était pas exposée au développeur, par des API permettant de gérer explicitement la concurrence, le parallélisme et la synchronisation. Les files d’attente de commandes fournissent les améliorations suivantes pour les développeurs :

  • Permet aux développeurs d’éviter les inefficacités accidentelles causées par une synchronisation inattendue.
  • Permet aux développeurs d’introduire la synchronisation à un niveau supérieur où la synchronisation requise peut être déterminée plus efficacement et plus précisément. Cela signifie que le runtime et le pilote graphique consacrent moins de temps à l’ingénierie réactive du parallélisme.
  • Rend les opérations coûteuses plus explicites.

Ces améliorations permettent ou améliorent les scénarios suivants :

  • Parallélisme accru : les applications peuvent utiliser des files d’attente plus approfondies pour les charges de travail en arrière-plan, telles que le décodage vidéo, lorsqu’elles ont des files d’attente distinctes pour le travail au premier plan.
  • Travail asynchrone et faible priorité gpu : le modèle de file d’attente de commandes permet l’exécution simultanée d’un travail GPU de faible priorité et d’opérations atomiques qui permettent à un thread GPU de consommer les résultats d’un autre thread non synchronisé sans blocage.
  • Travail de calcul à haute priorité : cette conception permet aux scénarios qui nécessitent l’interruption du rendu 3D d’effectuer une petite quantité de travail de calcul à haute priorité afin que le résultat puisse être obtenu tôt pour un traitement supplémentaire sur le processeur.

Initialisation d’une file d’attente de commandes

Vous pouvez créer des files d’attente de commandes en appelant ID3D12Device::CreateCommandQueue. Cette méthode prend une D3D12_COMMAND_LIST_TYPE indiquant quel type de file d’attente doit être créé et, par conséquent, quel type de commandes peuvent être envoyées à cette file d’attente. N’oubliez pas que les offres groupées ne peuvent être appelées qu’à partir de listes de commandes directes et ne peuvent pas être envoyées directement à une file d’attente. Les types de file d’attente pris en charge sont les suivants :

En général, les files d’attente DIRECT et les listes de commandes acceptent n’importe quelle commande, les files d’attente COMPUTE et les listes de commandes acceptent les commandes associées au calcul et à la copie, et les files d’attente COPY et les listes de commandes acceptent uniquement les commandes de copie.

Exécution de listes de commandes

Une fois que vous avez enregistré une liste de commandes et récupéré la file d’attente de commandes par défaut ou créé une nouvelle, vous exécutez des listes de commandes en appelant ID3D12CommandQueue::ExecuteCommandLists.

Les applications peuvent envoyer des listes de commandes à n’importe quelle file d’attente de commandes à partir de plusieurs threads. Le runtime effectue le travail de sérialisation de ces demandes dans l’ordre de soumission.

Le runtime valide la liste de commandes envoyée et supprime l’appel à ExecuteCommandLists si l’une des restrictions est violée. Les appels seront supprimés pour les raisons suivantes :

Accès aux ressources à partir de plusieurs files d’attente de commandes

Le runtime impose quelques règles qui limitent l’accès aux ressources à partir de plusieurs files d’attente de commandes. Ces règles sont les suivantes :

  1. Une ressource ne peut pas être écrite dans à partir de plusieurs files d’attente de commandes simultanément. Lorsqu’une ressource est passée à un état pouvant être écrit dans une file d’attente, elle est considérée comme appartenant exclusivement à cette file d’attente et doit passer à un état lecture ou COMMON (reportez-vous à D3D12_RESOURCE_STATES) avant qu’une autre file d’attente puisse y accéder.

  2. Lorsqu’elle est en lecture, une ressource peut être lue à partir de plusieurs files d’attente de commandes simultanément, y compris entre les processus, en fonction de son état de lecture.

Pour plus d’informations sur les restrictions d’accès aux ressources et l’utilisation des barrières de ressources pour synchroniser l’accès aux ressources, consultez Utilisation de barrières de ressources pour synchroniser les états des ressources.

Synchronisation de l’exécution de la liste de commandes à l’aide de clôtures de file d’attente de commandes

La prise en charge de plusieurs files d’attente de commandes parallèles dans Direct3D 12 vous offre plus de flexibilité et de contrôle sur la hiérarchisation du travail asynchrone sur le GPU. Cette conception signifie également que les applications doivent gérer explicitement la synchronisation du travail, en particulier lorsque les listes de commandes dans une file d’attente dépendent de ressources qui sont exploitées par une autre file d’attente de commandes. Voici quelques exemples : attendre qu’une opération sur une file d’attente de calcul se termine afin que le résultat puisse être utilisé pour une opération de rendu sur la file d’attente 3D, et attendre qu’une opération 3D se termine afin qu’une opération sur la file d’attente de calcul puisse accéder à une ressource à des fins d’écriture. Pour activer la synchronisation du travail entre les files d’attente, Direct3D 12 utilise le concept de clôtures, qui sont représentées dans l’API par l’interface ID3D12Fence .

Une clôture est un entier qui représente l’unité de travail actuelle en cours de traitement. Lorsque l’application avance la clôture, en appelant ID3D12CommandQueue::Signal, l’entier est mis à jour. Les applications peuvent case activée la valeur d’une clôture et déterminer si une unité de travail a été terminée afin de déterminer si une opération ultérieure peut être démarrée.

Synchronisation des ressources accessibles par les files d’attente de commandes

Dans Direct3D 12, la synchronisation de l’état de certaines ressources est implémentée avec des barrières de ressources. À chaque barrière de ressources, une application déclare les états avant et après d’une ressource. Un exemple courant est qu’une ressource passe d’une vue de ressources de nuanceur à une vue cible de rendu. Pour la plupart, ces barrières de ressources sont gérées dans des listes de commandes. Lorsque les couches de débogage sont activées, le système applique que les états avant et après de toutes les ressources correspondent, garantissant ainsi que la ressource est dans l’état correct pour une opération particulière lors d’une transition de barrière.

Pour plus d’informations sur la synchronisation de l’état des ressources, consultez Utilisation de barrières de ressources pour synchroniser les états des ressources.

Prise en charge de la file d’attente de commandes pour les ressources en mosaïques

Les méthodes de gestion des ressources en mosaïque, qui ont été exposées via l’interface ID3D11DeviceContext2 dans Direct3D 11, sont fournies par l’interface ID3D12CommandQueue dans Direct3D 12. Ces méthodes incluent les tâches suivantes :

Méthode Description
CopyTileMappings Copie les mappages d’une ressource en mosaïque source vers une ressource en mosaïque de destination.
UpdateTileMappings Mises à jour mappages d’emplacements de vignette dans des ressources en mosaïques à des emplacements de mémoire dans un tas de ressources.

Pour plus d’informations sur l’utilisation de ressources en mosaïque dans les applications Direct3D 12, consultez Ressources en mosaïques Direct3D11.

Envoi de travail dans Direct3D 12