Partager via

Tas partagés

  • Article

Le partage est utile pour les architectures multiprocesseurs et multi-adaptateurs.

Vue d’ensemble du partage

Les tas partagés permettent deux choses : partager des données dans un tas entre un ou plusieurs processus et empêcher un choix non déterministe de disposition de texture non définie pour les ressources placées dans le tas. Le partage de tas entre les adaptateurs élimine également la nécessité de marshaler le processeur des données.

Les tas et les ressources validées peuvent être partagés. Le partage d’une ressource validée partage en fait le tas implicite avec la description de la ressource validée, de sorte qu’une description de ressource compatible peut être mappée au tas à partir d’un autre appareil.

Toutes les méthodes sont à thread libre et héritent de la sémantique D3D11 existante de la conception de partage de handle NT.

Partage de tas entre les processus

Les tas partagés sont spécifiés avec le membre D3D12_HEAP_FLAG_SHARED de l’énumération D3D12_HEAP_FLAGS .

Les tas partagés ne sont pas pris en charge sur les tas accessibles par le processeur : D3D12_HEAP_TYPE_UPLOAD, D3D12_HEAP_TYPE_READBACK et D3D12_HEAP_TYPE_CUSTOM sans D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE.

Le fait d’éviter un choix non déterministe de disposition de texture non définie peut considérablement nuire aux scénarios de rendu différé sur certains GPU. Il ne s’agit donc pas du comportement par défaut pour les ressources placées et validées. Le rendu différé est altéré sur certaines architectures GPU, car les dispositions de texture déterministes réduisent la bande passante mémoire effective obtenue lors du rendu simultané sur plusieurs textures cibles de rendu de même format et de même taille. Les architectures GPU évoluent loin de tirer parti des dispositions de texture non déterministes afin de prendre en charge efficacement les modèles swizzle standardisés et les dispositions standardisées pour le rendu différé.

Les tas partagés s’accompagnent également d’autres coûts mineurs :

  • Les données de tas partagés ne peuvent pas être recyclées aussi flexiblement que les tas in-process en raison de problèmes de divulgation d’informations, de sorte que la mémoire physique est plus souvent zéro.
  • Il y a une surcharge supplémentaire mineure du processeur et une utilisation accrue de la mémoire système lors de la création et de la destruction des tas partagés.

Partage de tas entre les adaptateurs

Les tas partagés entre les adaptateurs sont spécifiés avec le membre D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER de l’énumération D3D12_HEAP_FLAGS .

Les tas partagés entre adaptateurs permettent à plusieurs adaptateurs de partager des données sans que le processeur marshale les données entre eux. Bien que différentes fonctionnalités d’adaptateur déterminent la façon dont les adaptateurs efficaces peuvent passer des données entre eux, le simple fait d’activer les copies GPU augmente la bande passante effective obtenue. Certaines dispositions de texture sont autorisées sur les segments d’adaptateurs croisés pour prendre en charge un échange de données de texture, même si ces dispositions de texture ne sont pas prises en charge. Certaines restrictions peuvent s’appliquer à ces textures, telles que la prise en charge de la copie uniquement.

Le partage entre adaptateurs fonctionne avec les tas créés en appelant ID3D12Device::CreateHeap. Votre application peut ensuite créer des ressources via CreatePlacedResource. Il est également autorisé par les ressources/tas créés par CreateCommittedResource , mais uniquement pour les ressources de D3D12_RESOURCE_DIMENSION_TEXTURE2D principales lignes (reportez-vous à D3D12_RESOURCE_DIMENSION). Le partage entre adaptateurs ne fonctionne pas avec CreateReservedResource.

Pour le partage entre adaptateurs, toutes les règles de partage de ressources entre files d’attente habituelles s’appliquent toujours. Votre application doit émettre les barrières appropriées pour garantir une synchronisation et une cohérence correctes entre les deux adaptateurs. Votre application doit utiliser des clôtures d’adaptateurs croisés pour coordonner la planification des listes de commandes envoyées à plusieurs adaptateurs. Il n’existe aucun mécanisme pour partager des ressources inter-adaptateurs entre les versions de l’API D3D. Les ressources partagées entre adaptateurs sont uniquement prises en charge dans la mémoire système. Les tas/ressources partagés inter-adaptateurs sont pris en charge dans les tas D3D12_HEAP_TYPE_DEFAULT et les tas de D3D12_HEAP_TYPE_CUSTOM (avec le pool de mémoireS L0 et les propriétés de page de processeur de combinaison écriture-écriture). Les pilotes doivent s’assurer que les opérations de lecture/écriture GPU sur les tas partagés inter-adaptateurs sont cohérentes avec les autres GPU sur le système. Par exemple, le pilote peut avoir besoin d’exclure les données de tas de résider dans des caches GPU qui n’ont généralement pas besoin d’être vidés lorsque le processeur ne peut pas accéder directement aux données du tas.

Votre application doit limiter l’utilisation des tas d’adaptateurs croisés aux seuls scénarios qui nécessitent les fonctionnalités qu’ils fournissent. Les tas d’adaptateurs croisés se trouvent dans D3D12_MEMORY_POOL_L0, ce qui n’est pas toujours ce que suggère GetCustomHeapProperties . Ce pool de mémoires n’est pas efficace pour les architectures d’adaptateur discrète/NUMA. De plus, les dispositions de texture les plus efficaces ne sont pas toujours disponibles.

Les limitations suivantes s'appliquent également :

  • Les indicateurs de tas liés aux niveaux de tas doivent être D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES.
  • D3D12_HEAP_FLAG_SHARED doit également être défini.
  • Les D3D12_HEAP_TYPE_DEFAULT doivent être définies ou D3D12_HEAP_TYPE_CUSTOM avec D3D12_MEMORY_POOL_L0 et D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE doivent l’être.
  • Seules les ressources avec D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER peuvent être placées sur des segments de mémoire inter-adaptateurs.
  • Une session protégée ne peut pas être passée à la création du tas quand D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER est spécifié

Pour plus d’informations sur l’utilisation de plusieurs adaptateurs, reportez-vous à la section Systèmes multi-adaptateurs .