Barrières améliorées D3D12

​

Table des matières

1. Introduction
2. Synchronisation du GPU sur XBOX Series X|S
3. Les barrières en détail
4. Configuration
5. Différences avec la spécification PC
6. Exemples de barrières améliorées
7. Compatibilité avec les barrières de ressources héritées
8. Prise en charge dans PIX et validation

​

Introduction

• Réduction de la latence de synchronisation et des vidages de cache excessifs.
• Aucune règle mystérieuse de promotion et de dégradation.
• Aliasing des ressources rapide et flexible.
• Abandon (discard) pendant la transition de barrière.
• Lecture/écriture simultanées et autocopie.

​

Synchronisation du GPU sur XBOX Series X|S

​

Les barrières en détail

• Le tableau suivant montre comment certains indicateurs de synchronisation se traduisent en exigences de vidage (drain) ou de blocage d’étapes (consultez la section sur le pipelining). À noter : certains indicateurs de synchronisation de barrière désignent une étape générale (comme la copie), mais à l’interne, en fonction des données fournies par l’accès et la disposition, ils sont associés à des étapes précises (source de copie/destination de copie), ce qui génère des exigences de vidage/blocage plus adéquates. De plus, le tableau ci-dessous porte sur le cas des textures (pour les tampons, certaines étapes différeraient).

• Ces exigences sont ensuite analysées et transmises, avec d’autres primitives, aux fonctions SyncBottomOfPipe/SyncTopOfPipe afin de déterminer les actions de synchronisation finales (par exemple D3D12XBOX_SYNC_FLAG_PS_PARTIAL_FLUSH ou D3D12XBOX_SYNC_FLAG_IDLE). Il ne faut pas confondre ces indicateurs avec les indicateurs D3D12_BARRIER_SYNC, qui sont utilisés pour les appels de barrières améliorées.
• Ces exigences ne connaissent pas les mécanismes qui seront finalement utilisés pour les satisfaire; elles indiquent donc explicitement quel composant matériel doit être vidé/bloqué. Des composants ultérieurs pourraient constater, par exemple, que plusieurs vidages peuvent être accomplis par un seul événement EoP.

• Dans le contexte des barrières, il est utile de savoir quelles ressources correspondent à quels caches. Par exemple, si nous avons un AccessBefore de D3D12_ACCESS_RENDER_TARGET et un accès après de D3D12_ACCESS_SHADER_RESOURCE, nous voulons savoir quels caches invalider et/ou vider (si nécessaire). Le tableau suivant présente certains types de ressources fréquemment utilisés et la mémoire qu’ils utilisent.
• Les types de ressources ne sont pas le seul facteur déterminant quant aux caches utilisés par la ressource. Le type d’opération (scalaire ou vectorielle) compte également, et c’est le compilateur qui en décide. Une lecture dans un tampon de constantes, par exemple, peut passer par le chemin $K-L2 s’il s’agit d’une opération scalaire (SMEM), ou par L0-L1-L2 s’il s’agit d’une opération vectorielle (VMEM).

• Certains indicateurs de ressource et de barrière modifient les exigences de compression/décompression qui en résultent :
  • Le pilote conserve deux tables qui associent le type de ressource aux opérations de compression/décompression. L’une de ces tables concerne les ressources créées avec D3D12XBOX_RESOURCE_FLAG_FORCE_TEXTURE_COMPATIBILITY, tandis que l’autre concerne les ressources non TC.
  • Les EB introduisent D3D12_TEXTURE_BARRIER_FLAG_DISCARD qui, lorsqu’il est passé en argument à la méthode Barrier, force l’initialisation des métadonnées. Avant les EB, cela pouvait se faire au moyen d’une opération d’effacement effectuée avant la première utilisation de la ressource.
  • Les cibles de rendu et les tampons de profondeur/gabarit doivent être créés respectivement avec D3D12_RESOURCE_FLAGS_ALLOW_RENDER_TARGET et D3D12_RESOURCE_FLAGS_ALLOW_DEPTH_STENCIL pour que les surfaces de métadonnées soient allouées correctement.
  • Si vous voulez utiliser la DCC, la ressource doit être créée avec l’indicateur D3D12XBOX_RESOURCE_FLAG_ALLOW_DCC. La DCC impliquera des opérations de décompression lors de la transition d’un état d’écriture à un état de lecture, mais pas si la ressource est aussi créée avec D3D12XBOX_RESOURCE_FLAG_FORCE_TEXTURE_COMPATIBILITY.
• Le tableau suivant, qui associe les indicateurs de disposition aux indicateurs d’état de compression, aide à mieux comprendre comment les transitions d’entrée et de sortie peuvent entraîner des compressions/décompressions. Par exemple, passer de cible de rendu (rt) à ressource de nuanceur (sr) sur des ressources non TC nécessite une décompression, puisque rt possède plusieurs indicateurs de compression alors que sr est marqué uncompressedAll. Mais la même transition pour une ressource TC ne déclencherait pas de décompression, étant donné que sr possède un surensemble des indicateurs d’état de compression de rt.

​

La spécification définit également trois types de barrières :

• Barrières globales :
  • S’appliquent à toute la mémoire. Leur définition ne prend pas de pointeur de ressource.
  • Aucune information de disposition n’est passée en argument.
• Barrières de tampon
  • Comme leur nom l’indique, les barrières de tampon servent à effectuer la transition des ressources de type tampon.
  • Aucune disposition ni sous-ressource n’est spécifiée en paramètre (puisque les tampons n’utilisent ni l’une ni l’autre).
• Barrières de texture
  • Transition pour les ressources de texture (cibles de rendu, tampons de profondeur/gabarit, textures SRV, textures UAV, etc.).
  • La disposition est obligatoire; cette barrière peut donc déclencher des décompressions et des compressions.
  • Peut spécifier une sous-ressource précise ou une plage.
    • Pour les sous-ressources, il existe des limites en matière de décompression, puisqu’il est impossible de décompresser seulement une partie d’une ressource.

struct D3D12_BUFFER_BARRIER 
{ 
    D3D12_BARRIER_SYNC SyncBefore; 
    D3D12_BARRIER_SYNC SyncAfter; 
    D3D12_BARRIER_ACCESS AccessBefore; 
    D3D12_BARRIER_ACCESS AccessAfter; 
    ID3D12Resource *pResource;     
    UINT64 Offset;  // Must be 0 
    UINT64 Size;    // UINT64_MAX or size in bytes 
};  

struct D3D12 _GLOBAL_BARRIER 
{ 
    D3D12_BARRIER_SYNC SyncBefore; 
    D3D12_BARRIER_SYNC SyncAfter; 
    D3D12_BARRIER_ACCESS AccessBefore; 
    D3D12_BARRIER_ACCESS AccessAfter; 
}  

struct D3D12_TEXTURE_BARRIER 
{ 
    D3D12_BARRIER_SYNC SyncBefore; 
    D3D12_BARRIER_SYNC SyncAfter; 
    D3D12_BARRIER_ACCESS AccessBefore; 
    D3D12_BARRIER_ACCESS AccessAfter; 
    D3D12_BARRIER_LAYOUT LayoutBefore; 
    D3D12_BARRIER_LAYOUT LayoutAfter; 
    ID3D12Resource *pResource; 
    D3D12_BARRIER_SUBRESOURCE_RANGE Subresources; 
    D3D12_TEXTURE_BARRIER_FLAGS Flags; 
};

• LayoutBefore, LayourAfter : disposition de la mémoire avant et après la barrière. Détermine ce que nous allons compresser/décompresser. Utilisé uniquement par D3D12_TEXTURE_BARRIER.
• SyncBefore, SyncAfter : étape dont il faut attendre le vidage et étape à bloquer avant de poursuivre.
• AccessBefore, AccessAfter : indique quels caches nous cesserons d’utiliser et quels caches nous commencerons à utiliser à la suite de la transition.
• Subresource range — Permet de définir une plage de sous-ressources dont la barrière effectuera la transition. Utilisé uniquement par D3D12_TEXTURE_BARRIER.
• Resource — Le propriétaire de la mémoire dont nous effectuons la transition. Utilisé par D3D12_TEXTURE_BARRIER et D3D12_BUFFER_BARRIER.
• Texture Barrier flags — Les valeurs peuvent être D3D12_TEXTURE_BARRIER_FLAG_NONE et D3D12_TEXTURE_BARRIER_FLAG_DISCARD. Utilisé uniquement par D3D12_TEXTURE_BARRIER.
  • Nous utilisons l’indicateur discard lors de l’activation d’une ressource, afin que ses métadonnées soient initialisées correctement.
  • L’utilisation de cet indicateur permet aussi de regrouper l’initialisation des ressources. Les effacements peuvent se chevaucher, et les opérations de synchronisation des barrières sont regroupées.

​

Configuration

• GDK de mars 2023 ou plus récent.
• ID3D12GraphicsCommandList7 : nécessaire pour appeler la méthode Barrier. Prend une structure D3D12_BARRIER_GROUP et le numéro de groupe.

• Selon la spécification, l’interopérabilité entre les API de barrières améliorées et les D3D12_RESOURCE_STATES hérités est prise en charge. Cependant, les sous-ressources dans tout état hérité autre que D3D12_RESOURCE_STATE_COMMON doivent faire l’objet d’une transition vers D3D12_RESOURCE_STATE_COMMON avant d’être référencées au moyen d’une barrière améliorée.

• Créez un fichier vide dans le dossier Loose (répertoire de déploiement) et nommez-le D3D__DisableLegacyResourceBarrierTranslation.
• Déployez le jeu et assurez-vous que le fichier a bien été déployé sur la console.
  • Remarque : dans ce mode, le pilote ne prend pas en charge le mélange de barrières héritées et de barrières améliorées.

​

Différences avec la spécification PC

1. Sur XBOX, le vidage à la frontière d’ExecuteCommandList n’est pas émis; l’accès sans barrière n’est donc pas pris en charge.
   • Cela s’explique par des raisons de performance, puisqu’un vidage complet du GPU est coûteux.
   • Accès sans barrière dans la spécification
2. Sous-ressources. Sur PC, les métadonnées sont suivies par sous-ressource, alors que ce n’est pas notre cas. Cela signifie que l’état de compression par sous-ressource ne peut pas être suivi. Par conséquent, les changements de disposition qui impliquent une compression ou une décompression donneront des résultats différents selon que la plage de ressources couvre (ou non) la ressource entière.
   • Si une ressource dans une disposition compressée voit une ou plusieurs (mais pas toutes) de ses sous-ressources passer à une disposition non compressée, la ressource entière sera décompressée.
   • Si une ressource dans une disposition non compressée voit une ou plusieurs (mais pas toutes) de ses sous-ressources passer à une disposition compressée, la ressource entière demeure non compressée.
   • Nous prenons en charge des états de compression indépendants pour la profondeur et le gabarit, ce qui signifie que nous pouvons avoir une profondeur compressée et un gabarit non compressé, ou l’inverse.
3. Les barrières fractionnées fonctionnent, mais elles ne sont pas implémentées comme des barrières fractionnées dans le pilote. Elles sont plutôt converties en barrières immédiates. Nous effectuons cette conversion parce que les barrières fractionnées, telles que définies par D3D12, imposent un coût mémoire par ressource et sont inutilement inefficaces sur notre matériel. Cependant, la conversion en barrières immédiates n’est pas aussi efficace qu’elle pourrait l’être.
   • Cela est dû au fait que le pilote ne reçoit pas d’information complète sur la synchronisation avant et après. La conversion en barrière immédiate se fait du côté proche de la barrière (le côté éloigné est ignoré), de sorte que le pilote doit être pessimiste et bloquer à la fois le CE et le PFP, ce qui peut rendre les barrières fractionnées plus lentes que les barrières nativement immédiates.
   • Par ailleurs, historiquement, très peu de gens utilisent les barrières fractionnées avec l’API héritée.
   • Une façon de résoudre le coût mémoire par ressource à l’avenir pourrait être de permettre aux développeurs de fournir eux-mêmes cette mémoire.
   • Il est prévu de revoir l’implémentation des barrières fractionnées à l’avenir.

• Nous recommandons aux utilisateurs d’implémenter leurs propres copies de textures dans des nuanceurs de calcul. Ils devront bien sûr gérer les dépendances, mais cela permettrait un travail non sérialisé et plus efficace.
  • L’une des raisons pour lesquelles les copies de textures gérées par le pilote peuvent être moins performantes est qu’elles peuvent utiliser les caches CB/DB. Cela entraîne la nécessité d’effectuer une réécriture (WB) supplémentaire et d’invalider les caches CB et DB lors des transitions vers les copies de textures ou à partir de celles-ci.

​

Exemples de barrières améliorées

• Barrières de ressources de transition
• Barrières de ressources d’accès non ordonné
• Autocopie
• Barrières de ressources d’aliasing

​

Barrières de ressources de transition

auto barrier = CD3DX12_RESOURCE_BARRIER::Transition(renderTarget,
    D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,
    D3D12_RESOURCE_STATE_RENDER_TARGET);
commandList->ResourceBarrier(1, &barrier);

auto barrierSubresourceRange = CD3DX12_BARRIER_SUBRESOURCE_RANGE();

auto textureBarrier = CD3DX12_TEXTURE_BARRIER (
    D3D12_BARRIER_SYNC_COMPUTE_SHADING,
    D3D12_BARRIER_SYNC_RENDER_TARGET,
    D3D12_BARRIER_ACCESS_SHADER_RESOURCE,
    D3D12_BARRIER_ACCESS_RENDER_TARGET,
    D3D12_BARRIER_LAYOUT_SHADER_RESOURCE,
    D3D12_BARRIER_LAYOUT_RENDER_TARGET,
    renderTarget,
    barrierSubresourceRange
);

auto barrierGroup = CD3DX12_BARRIER_GROUP(1, &textureBarrier);

auto bufferBarrier = CD3DX12_BUFFER_BARRIER (
    D3D12_BARRIER_SYNC_COMPUTE_SHADING,
    D3D12_BARRIER_SYNC_STREAM_OUTPUT,
    D3D12_BARRIER_ACCESS_SHADER_RESOURCE,
    D3D12_BARRIER_ACCESS_STREAM_OUTPUT,
    m_renderTarget.Get(),
    barrierSubresourceRange
);

​

Barrières de ressources d’accès non ordonné

auto barrier = CD3DX12_RESOURCE_BARRIER::UAV(texture0);
commandList->ResourceBarrier(1, &barrier);

auto barrierSubresourceRange = CD3DX12_BARRIER_SUBRESOURCE_RANGE();

auto barrier = CD3DX12_TEXTURE_BARRIER (
    D3D12_BARRIER_SYNC_CLEAR_UNORDERED_ACCESS_VIEW,
    D3D12_BARRIER_SYNC_COMPUTE_SHADING,
    D3D12_BARRIER_ACCESS_UNORDERED_ACCESS
    D3D12_BARRIER_ACCESS_SHADER_RESOURCE,
    D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS,
    D3D12_BARRIER_LAYOUT_SHADER_RESOURCE,
    texture0,
    barrierSubresourceRange
);

auto barrierGroup = CD3DX12_BARRIER_GROUP(1, &barrier);

​

Autocopie

// Legacy resource barriers
{
    auto barrier = CD3DX12_RESOURCE_BARRIER::Transition(texture,
        D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
        D3D12_RESOURCE_STATE_COPY_SOURCE
    );
    commandList->ResourceBarrier(1, &barrier);

    barrier = CD3DX12_RESOURCE_BARRIER::Transition(textureTmp,
        D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
        D3D12_RESOURCE_STATE_COPY_DEST
    );
    commandList->ResourceBarrier(1, &barrier);
}

// Copy top left quarter to temp texture
{
    auto locationSrc = CD3DX12_TEXTURE_COPY_LOCATION(texture, 0);
    auto locationDst = CD3DX12_TEXTURE_COPY_LOCATION(textureTmp, 0);
    commandList->CopyTextureRegion(&locationDst, boxTopLeft.left,
        boxTopLeft.top, boxTopLeft.front, &locationSrc, &boxTopLeft);

    auto barrier = CD3DX12_RESOURCE_BARRIER::Transition(texture,
        D3D12_RESOURCE_STATE_COPY_SOURCE,
        D3D12_RESOURCE_STATE_COPY_DEST
    );
    commandList->ResourceBarrier(1, &barrier);

    barrier = CD3DX12_RESOURCE_BARRIER::Transition(textureTmp,
        D3D12_RESOURCE_STATE_COPY_DEST,
        D3D12_RESOURCE_STATE_COPY_SOURCE
    );
    commandList->ResourceBarrier(1, &barrier);
}

// Copy temp texture to bottom right quarter
{
    auto locationSrc = CD3DX12_TEXTURE_COPY_LOCATION(textureTmp, 0);
    auto locationDst = CD3DX12_TEXTURE_COPY_LOCATION(texture, 0);
    commandList->CopyTextureRegion(&locationDst, boxBottomRight.left,
        boxBottomRight.top, boxBottomRight.front, &locationSrc, &boxTopLeft);

    auto barrier = CD3DX12_RESOURCE_BARRIER::Transition(texture,
        D3D12_RESOURCE_STATE_COPY_DEST,
        D3D12_RESOURCE_STATE_UNORDERED_ACCESS
    );
    commandList->ResourceBarrier(1, &barrier);

    barrier = CD3DX12_RESOURCE_BARRIER::Transition(m_textureTmp.Get(),
        D3D12_RESOURCE_STATE_COPY_SOURCE,
        D3D12_RESOURCE_STATE_UNORDERED_ACCESS
    );
    commandList->ResourceBarrier(1, &barrier);
}

// Self copy top left quarter to bottom right quarter
auto locationSrc = CD3DX12_TEXTURE_COPY_LOCATION(texture, 0);
auto locationDst = CD3DX12_TEXTURE_COPY_LOCATION(texture, 0);

commandList->CopyTextureRegion(&locationDst, boxBottomRight.left,
    boxBottomRight.top, boxBottomRight.front, &locationSrc, &boxTopLeft);

​

Barrières de ressources d’aliasing

typedef struct D3D12_RESOURCE_ALIASING_BARRIER 
{
    ID3D12Resource *pResourceBefore;
    ID3D12Resource *pResourceAfter;
} D3D12_RESOURCE_ALIASING_BARRIER;

// Transition pTex0 to COPY_SOURCE
auto tex0Barrier = CD3DX12_TEXTURE_BARRIER (
    D3D12_BARRIER_SYNC_RENDER_TARGET,
    D3D12_BARRIER_SYNC_COPY,
    D3D12_BARRIER_ACCESS_RENDER_TARGET,
    D3D12_BARRIER_ACCESS_COPY_SOURCE,
    D3D12_BARRIER_LAYOUT_RENDER_TARGET,
    D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE,
    pTex0,
    CD3DX12_BARRIER_SUBRESOURCE_RANGE(0, 1, 0, 1)
);

// Barrier to affect an aliasing transition from pTex0 to
// pTex1 with a layout of COPY_SOURCE
auto tex1Barrier = CD3DX12_TEXTURE_BARRIER (
    D3D12_BARRIER_SYNC_RENDER_TARGET,
    D3D12_BARRIER_SYNC_COPY,
    D3D12_BARRIER_ACCESS_NO_ACCESS,
    D3D12_BARRIER_ACCESS_COPY_SOURCE,
    D3D12_BARRIER_LAYOUT_UNDEFINED,
    D3D12_BARRIER_LAYOUT_COPY_SOURCE,
    pTex1,
    CD3DX12_BARRIER_SUBRESOURCE_RANGE(0, 1, 0, 1)
);

​

Compatibilité avec les barrières de ressources héritées

​

Exemple 1 - Génération de vidages partiels par les barrières UAV

​

Exemple 2 - Aliasing

Tout ceci montre les gains que les développeurs peuvent obtenir uniquement grâce aux barrières améliorées, sans modifier leur code. Pour voir les gains possibles lors du passage à la nouvelle API Barrier, consultez la section Exemples de barrières améliorées.

​

Prise en charge dans PIX et validation

​

Validation

• Pour les barrières améliorées, la parité de validation porte sur les scénarios couverts. Les barrières améliorées sont différentes des barrières de ressources; la validation ne reproduira donc pas exactement ce qu’elle faisait pour l’API héritée, mais garantira que toutes les propriétés avant et après sont correctes pour la transition. Par exemple :
  • S’assurer que les ressources sont dans la bonne disposition au début d’une transition.
  • Valider l’exactitude de l’utilisation de l’API (plus de détails ci-dessous).
• Pour les barrières de ressources héritées (traduites), la validation offre la parité avec la validation actuelle des barrières de ressources.

• Le périphérique sous-jacent prend en charge les barrières améliorées
• Il ne s’agit pas d’une liste de commandes de type bundle
• Avertissement si un compte (de groupes ou de barrières par groupe) est nul
• Vérification que les sous-ressources de la barrière de texture correspondent aux limites des sous-ressources de la texture
• Le type de barrière correspond au type de ressource
• LayoutBefore et AccessBefore correspondent à la disposition et à l’accès connus ou présumés de la ressource.
• SyncBefore, AccessBefore et LayoutBefore sont compatibles.
• SyncAfter, AccessAfter et LayoutAfter sont compatibles.
• Les barrières de fin de fractionnement correspondent aux barrières de début de fractionnement précédentes.
• Les barrières fractionnées de tampon et D3D12_BARRIER_LAYOUT_COMMON ne franchissent pas les frontières d’ExecuteCommandLists.
  • Probablement un avertissement plutôt qu’une erreur, en raison des tolérances héritées

TextD3D12 ERROR: [0xA7900038] ID3D12CommandQueue(Graphics)::ExecuteCommandLists: Resource is being transitioned from legacy to enhanced barriers but is not in the state D3D12_RESOURCE_STATE_COMMON as is required.
Current State is: D3D12_RESOURCE_STATE_RENDER_TARGET
|  -Group Index:   0
|  -Barrier Index: 0
|  -Barrier
|   |  -SyncBefore:   D3D12_BARRIER_SYNC_RENDER_TARGET
|   |  -SyncAfter:    D3D12_BARRIER_SYNC_COMPUTE_SHADING
|   |  -AccessBefore: D3D12_BARRIER_ACCESS_RENDER_TARGET
|   |  -AccessAfter:  D3D12_BARRIER_ACCESS_UNORDERED_ACCESS
|   |  -LayoutBefore: D3D12_BARRIER_LAYOUT_RENDER_TARGET
|   |  -LayoutAfter:  D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS
|   |  -pResource:    (0x0000000200200C00) "<untitled>"
|   |  -Subresources
|   |    |  -IndexOrFirstMipLevel: 4294967295
|   |    |  -NumMipLevels:         0
|   |    |  -FirstArraySlice:      0
|   |    |  -NumArraySlices:       0
|   |    |  -FirstPlane:           0
|   |    |  -NumPlanes:            0
|   |  -Flags: D3D12_TEXTURE_BARRIER_FLAG_NONE (0x00000000)