Partager via

Tas partagés

  • Article

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

Aperçu du partage

Les segments partagés permettent deux choses : partager des données dans un segment entre un ou plusieurs processus, et éviter un choix non déterministe de la disposition de texture non définie pour les ressources placées dans le segment. Le partage de segments entre adaptateurs élimine également le besoin de transfert des données par le CPU.

Tant les segments que les ressources engagées peuvent être partagés. Le partage d’une ressource engagée partage en réalité le segment implicite ainsi que la description de la ressource engagée, de sorte qu’une description de ressource compatible puisse être mappée au segment depuis un autre appareil.

Toutes les méthodes sont multi-thread et héritent des sémantiques D3D11 existantes du design de partage de handle NT.

Partage de segments entre processus

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

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

Empêcher un choix non déterministe de disposition de texture non définie peut considérablement affecter les scénarios de rendu différé sur certaines GPU, donc ce n’est pas le comportement par défaut pour les ressources placées et engagées. Le rendu différé est affecté sur certaines architectures GPU parce que les dispositions de texture déterministes diminuent la bande passante mémoire effective atteinte lors du rendu simultané sur plusieurs textures cibles de rendu du même format et de la même taille. Les architectures GPU évoluent pour s’éloigner de l’exploitation des dispositions de texture non déterministes afin de prendre en charge efficacement les modèles de permutation standardisés et les dispositions standardisées pour le rendu différé.

Les segments partagés entraînent également d’autres coûts mineurs :

  • Les données de segments partagés ne peuvent pas être recyclées aussi facilement que les segments dans le processus en raison des préoccupations de divulgation d’informations, donc la mémoire physique est plus souvent remise à zéro.
  • Il y a un surcoût mineur supplémentaire pour le CPU et une utilisation accrue de la mémoire système lors de la création et de la destruction de segments partagés.

Partage de segments entre adaptateurs

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

Les segments partagés entre adaptateurs permettent à plusieurs adaptateurs de partager des données sans que le CPU ne transfère les données entre eux. Bien que les capacités des adaptateurs varient et déterminent l’efficacité avec laquelle ils peuvent échanger des données, le simple fait d’activer les copies GPU augmente la bande passante effective atteinte. Certaines dispositions de texture sont autorisées sur les segments entre adaptateurs pour prendre en charge un échange de données de texture, même si de telles dispositions de texture ne sont pas autrement prises en charge. Certaines restrictions peuvent s’appliquer à ces textures, telles que le fait de ne prendre en charge que la copie.

Le partage entre adaptateurs fonctionne avec les segments créés en appelant ID3D12Device::CreateHeap. Votre application peut alors créer des ressources via CreatePlacedResource. Cela est également autorisé par les ressources/segments créés par CreateCommittedResource mais uniquement pour les ressources D3D12_RESOURCE_DIMENSION_TEXTURE2D en disposition standard (veuillez consulter la section D3D12_RESOURCE_DIMENSION). Le partage entre adaptateurs ne fonctionne pas avec CreateReservedResource.

Pour le partage entre adaptateurs, toutes les règles habituelles de partage de ressources entre files d’attente s’appliquent. Votre application doit émettre les barrières appropriées pour garantir la synchronisation et la cohérence entre les deux adaptateurs. Votre application doit utiliser des barrières entre adaptateurs pour coordonner la planification des listes de commandes soumises à plusieurs adaptateurs. Il n’y a pas de mécanisme pour partager des ressources entre adaptateurs à travers les versions de l’API D3D. Les ressources partagées entre adaptateurs ne sont prises en charge que dans la mémoire système. Les segments/ressources partagés entre adaptateurs sont pris en charge dans les segments D3D12_HEAP_TYPE_DEFAULT et D3D12_HEAP_TYPE_CUSTOM (avec le pool de mémoire L0, et les propriétés de page CPU de type écriture-combinée). Les pilotes doivent s’assurer que les opérations de lecture/écriture GPU sur les segments partagés entre adaptateurs sont cohérentes avec les autres GPU du système. Par exemple, le pilote peut avoir besoin d’exclure les données de segment de la résidence dans les caches GPU qui ne nécessitent généralement pas d’être vidés lorsque le CPU ne peut pas accéder directement aux données du segment.

Votre application doit limiter l’utilisation des segments entre adaptateurs uniquement à ceux des scénarios qui nécessitent la fonctionnalité qu’ils fournissent. Les segments entre adaptateurs sont situés dans D3D12_MEMORY_POOL_L0, ce qui n’est pas toujours ce que GetCustomHeapProperties suggère. Ce pool de mémoire n’est pas efficace pour les architectures d’adaptateurs discrets/NUMA. De plus, les dispositions de texture les plus efficaces ne sont pas toujours disponibles.

Les limitations suivantes s’appliquent également :

  • Les indicateurs de segments liés aux niveaux de segments doivent être D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES.
  • D3D12_HEAP_FLAG_SHARED doit également être défini.
  • Soit D3D12_HEAP_TYPE_DEFAULT doit être défini, soit D3D12_HEAP_TYPE_CUSTOM avec D3D12_MEMORY_POOL_L0 et D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE doit être défini.
  • Seules les ressources avec D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER peuvent être placées sur des segments entre adaptateurs.
  • Une session protégée ne peut pas être passée lors de la création du segment lorsque D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER est spécifié

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