Objets d'état de pipeline sérialisés et dérivés en détail

Compilation des objets d’état de pipeline

D3D12 fournit l’interface Pipeline State Object (PSO) pour configurer le GPU avec les nuanceurs et l’état de rendu. Le flux de travail multiplateforme standard pour créer des PSO consiste à précompiler les nuanceurs avec DXC lors d’un processus de génération, puis à remplir un descripteur d’état de pipeline graphique ou de calcul (par exemple D3D12_GRAPHICS_PIPELINE_STATE_DESC) avec le bytecode des nuanceurs et l’état au moment de l’exécution. La validation du pilote garantit la cohérence des entrées/sorties et de l’état pour chaque étape successive du pipeline. Sur PC, la compilation des PSO à l’exécution est nécessaire, car le GPU de l’utilisateur final est généralement inconnu au moment de la génération. Le processus DXC hors connexion doit donc compiler vers un format de bytecode intermédiaire, la représentation intermédiaire basée sur LLVM, DXIL (DirectX Intermediate Language). La création du PSO à l’exécution avec l’une des API disponibles (ci-dessous) amène le pilote GPU à finaliser le code des nuanceurs en compilant le bytecode DXIL en instructions GPU, qui peuvent ensuite être exécutées sur le GPU. À l’exécution :

ID3D12RootSignature* rootSig = nullptr;
D3D12CreateRootSignature(0, shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), IID_GRAPHICS_PPV_ARGS(&rootSig));

ComPtr<ID3DBlob> vsBlob = LoadCsoFromFile(vsFilename);
ComPtr<ID3DBlob> psBlob = LoadCsoFromFile(psFilename);

D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.pRootSignature = rootSig;
psoDesc.VS             = { vsBlob->GetBufferPointer(), vsBlob->GetBufferSize() };
psoDesc.PS             = { psBlob->GetBufferPointer(), psBlob->GetBufferSize() };
psoDesc.BlendState     = { ... };
...

ID3D12PipelineState* pso = nullptr;
d3dDevice->CreateGraphicsPipelineState(&psoDesc, IID_GRAPHICS_PPV_ARGS(&pso));

// Render a rabbit, or teapot, or hopefully something cooler

API pertinentes :

Objets d’état de pipeline sérialisés

La plateforme XBOX fige la configuration matérielle, ce qui rend inutile la distribution d’une représentation intermédiaire du code des nuanceurs. Cela permet de déplacer le processus de compilation des PSO vers le moment de la génération, ce qui supprime la surcharge passée à créer des PSO au démarrage du titre. Des extensions d’API XBOX ont été ajoutées pour sérialiser les PSO dans un format de blob binaire pouvant être enregistré directement sur disque. À l’exécution, ces blobs peuvent être chargés depuis le disque et désérialisés en un état de pipeline fonctionnel. Les PSO peuvent toujours être créés à l’exécution à l’aide des fonctionnalités D3D12 standard, mais la sérialisation offre un moyen d’optimiser la vitesse de démarrage. Étant donné que les PSO sérialisés sont distribués dans les builds de package, un principe de conception essentiel est de minimiser leur empreinte mémoire. Les blobs produits par SerializeGraphicsPipelineStateX doivent être dédupliqués entre tous les PSO précompilés afin de réduire les besoins en mémoire. Les autres métadonnées sans rapport avec leur exécution sont supprimées lors de la sérialisation, ce qui empêche de resérialiser des PSO précédemment désérialisés ; une telle opération échoue avec un message de validation. Les API de sérialisation (ci-dessous) ne sont pas disponibles dans les builds commerciales. Notez que le processus utilisé pour précompiler les PSO doit utiliser un ID3D12Device créé à partir d’une bibliothèque ciblant la plateforme. La fonction D3D12CreateDevice se trouve dans le dossier toolkit de l’installation du GDK, dans d3d12_x.h pour la XBOX One ou d3d12_xs.h pour la XBOX Series X|S ; effectuez la liaison avec d3d12_x.lib ou d3d12_xs.lib en conséquence. Ces bibliothèques s’attendent à ce que les DLL du GDK soient accessibles depuis le répertoire de travail ou via la variable système PATH. Les DLL se trouvent dans le dossier bin de la version correspondante du GDK, par exemple C:\\Program Files (x86)\\Microsoft GDK\\200804\\GXDK\\bin pour August 2020 QFE 4. Au moment de la génération :

ComPtr<ID3D12Device> d3dDevice;
D3D12CreateDevice(nullptr, D3D_FEATURE_LEVEL_11_0, IID_GRAPHICS_PPV_ARGS(d3dDevice.ReleaseAndGetAddressOf()));
...

D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = { ... };

ID3D12PipelineState* pso = nullptr;
d3dDevice->CreateGraphicsPipelineState(&psoDesc, IID_GRAPHICS_PPV_ARGS(&pso));

D3D12XBOX_SERIALIZE_GRAPHICS_PIPELINE_STATE serializedState;
d3dDevice->SerializeGraphicsPipelineStateX(pso, D3D12XBOX_SERIALIZE_FLAGS_NONE, &serializedState);

WriteSerializedStateToFile(filename, serializedState);

À l’exécution :

ID3D12RootSignature* rootSig = nullptr;
D3D12CreateRootSignature(0, shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), IID_GRAPHICS_PPV_ARGS(&rootSig));

D3D12XBOX_SERIALIZE_GRAPHICS_PIPELINE_STATE state = ReadSerializedStateFromFile(filename);

// Assume this data is serialized very simply.
D3D12XBOX_DESERIALIZE_GRAPHICS_PIPELINE_STATE deserialized {};
deserialized.pRootSignature = rootSig;

deserialized.PacketSize     = state.pPacket->GetBufferSize();
deserialized.pPacket        = state.pPacket->GetBufferPointer();
deserialized.MetadataSize   = state.pMetadata->GetBufferSize();
deserialized.pMetadata      = state.pMetadata->GetBufferPointer();

if (state.VS != nullptr)
{
    deserialized.VS.GpuInstructionsSize = state.VS.pGpuInstructions->GetBufferSize();
    deserialized.VS.pGpuInstructions    = state.VS.pGpuInstructions->GetBufferPointer();
    deserialized.VS.MetadataSize        = state.VS.pMetadata->GetBufferSize();
    deserialized.VS.pMetadata           = state.VS.pMetadata->GetBufferPointer();
}
...

ID3D12PipelineState* pso = nullptr;
d3dDevice->DeserializeGraphicsPipelineStateX(&deserializeState, IID_GRAPHICS_PPV_ARGS(&pso));

// Render as normal

Voici une brève description du contenu de chaque élément de données sérialisées : D3D12XBOX_SERIALIZE_GRAPHICS_PIPELINE_STATE::pPacket

Informations d’exécution du processeur de commandes
État GPU pour les états de fusion/rastérisation/profondeur-gabarit
État GPU pour les paramètres RTV/DSV
État GPU pour le traitement des sommets/index, la tessellation et la sortie de flux
État GPU pour chaque étape matérielle

D3D12XBOX_SERIALIZE_GRAPHICS_PIPELINE_STATE::pMetadata

Hachage CRC32 du PSO sérialisé
Numéro de version de la structure sérialisée
Données de validation
Forme compacte des arguments de création du PSO
Configurations de la disposition d’entrée et de la sortie de flux

D3D12XBOX_SERIALIZE_SHADER::pGpuInstructions

Instructions GPU précompilées des nuanceurs matériels

D3D12XBOX_SERIALIZE_SHADER::pMetaData

Numéro de version de la structure sérialisée
Métadonnées du compilateur de nuanceurs
Informations de nuanceur PIX

API pertinentes :

Objets d’état de pipeline dérivés

Une autre fonctionnalité exposée par l’API D3D12.X est celle des objets d’état de pipeline « dérivés ». Cette fonctionnalité crée des variantes légères de PSO existants, qui ne diffèrent que par l’état matériel (état de profondeur-gabarit, état du rastériseur, état de fusion, masque d’échantillon et limites des nuanceurs). La dérivation d’un PSO entraîne une surcharge d’exécution négligeable par rapport à la compilation d’un PSO. Cela permet au développeur de créer un seul PSO, lié à un ensemble commun de nuanceurs, puis d’en décliner un nombre arbitraire de variantes en ne payant le coût d’exécution complet que pour la création du PSO initial.

D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc {};
...

ID3D12PipelineState* pso = nullptr;
d3dDevice->CreateGraphicsPipelineState(&psoDesc, IID_GRAPHICS_PPV_ARGS(&pso));

D3D12XBOX_DERIVED_GRAPHICS_STATE_DESC derivedDescs[2] {};
derivedDescs[0].Type                           = D3D12XBOX_DERIVED_GRAPHICS_STATE_TYPE_DEPTH_STENCIL;
derivedDescs[0].DepthStencilDesc               = psoDesc.DepthStencilState;
derivedDescs[0].DepthStencilDesc.StencilEnable = false;

derivedDescs[1].Type                           = D3D12XBOX_DERIVED_GRAPHICS_STATE_TYPE_RASTERIZER;
derivedDescs[1].RasterizerDesc                 = psoDesc.RasterizerState;
derivedDescs[1].RasterizerDesc.DepthBias       = -1;

ID3D12PipelineState* derivedPso = nullptr;
d3dDevice->CreateDerivedGraphicsPipelineStateX(pso, 2, &derivedDescs, IID_GRAPHICS_PPV_ARGS(&derivedPso));

// Render as normal

API pertinentes :

Objets d’état de pipeline sérialisés et dérivés

Utilisés conjointement, les PSO sérialisés et dérivés offrent un avantage supplémentaire pour réduire la taille du package. Les PSO dérivés permettent aux titres de limiter le nombre de PSO sérialisés à un sous-ensemble de l’ensemble total utilisé par le titre. En dédupliquant les PSO selon les propriétés immuables vis-à-vis des substitutions des PSO dérivés, on obtient un ensemble « de base » à partir duquel tous les autres PSO du titre peuvent être dérivés. Le cas d’utilisation type de ces deux fonctionnalités serait le suivant :

Identifier les PSO présentant des combinaisons uniques de signature racine, de disposition d’entrée, d’étapes de nuanceur, de sorties de flux et de cibles de rendu.
Sérialiser cet ensemble dédupliqué de PSO de base dans un processus hors connexion et le distribuer dans le package.
Charger les PSO de base depuis un fichier au démarrage et dériver toutes les variantes de PSO nécessaires au titre.

Contraintes sur les objets d’état de pipeline dérivés

Une restriction notable des PSO dérivés est qu’ils ne peuvent pas modifier le code compilé des nuanceurs. C’est pourquoi les dispositions d’entrée, les formats des cibles de rendu et les paramètres de sortie de flux ne sont pas des options de D3D12XBOX_DERIVED_GRAPHICS_STATE_DESC, car ils nécessiteraient de modifier les instructions GPU du PSO compilé. Le pilote choisit le ou les types de données d’exportation des nuanceurs appropriés lors de la compilation du PSO ; les types d’exportation de nuanceur pris en charge sont uint, sint, unorm, snorm ou float sur 16 ou 32 bits. Le pilote sélectionne le plus petit type dont la précision est supérieure ou égale à celle de la cible de rendu, tout en étant compatible avec la configuration matérielle de fusion. Pour appliquer son choix, le pilote corrige le code compilé du nuanceur avec les instructions d’exportation appropriées, qui convertissent le type utilisé pour les opérations du nuanceur vers le type d’exportation sélectionné par le pilote. Une fois cette correction effectuée, le pilote ne modifie plus ces instructions GPU finalisées. Le choix final des instructions d’exportation des nuanceurs est déterminé par quelques facteurs clés :

Types et nombre de cibles dans lesquelles le code HLSL écrit (SV_TargetN)
Formats et nombre de cibles de rendu du PSO
Paramètre alpha-to-coverage
Paramètres de l’état de fusion

En rendu opaque (fusion désactivée), le ou les types de sortie peuvent être n’importe lequel des types d’exportation de nuanceur pris en charge : uint, sint, unorm, snorm ou float sur 16 ou 32 bits. La valeur est exportée depuis le nuanceur, convertie dans le type de la cible de rendu par le Color Block (CB), puis écrite en mémoire. Lorsque la fusion est activée, le pilote est contraint de limiter les types d’exportation des nuanceurs à float sur 16 ou 32 bits, car ce sont les seuls types pris en charge que le CB accepte comme entrées de l’opération de fusion. La valeur fusionnée est ensuite convertie dans le type de la cible de rendu et écrite en mémoire. Ces détails entraînent des contraintes subtiles sur les substitutions d’état de fusion applicables aux PSO dérivés. L’état de fusion substitué peut rendre les exigences d’exportation du PSO dérivé incompatibles avec le choix d’instruction d’exportation déterminé lors de la compilation du PSO de base et intégré par correction dans les instructions GPU. Si une exportation calculée diffère entre le PSO de base et le PSO dérivé, une erreur de validation est levée. Voici quelques exemples qui entraînent des types d’exportation incompatibles et échoueraient à la validation : Exemple 1 -

    - Base PSO writes float4 to a DXGI_FORMAT_R32G32_FLOAT format with no blending
    - Driver selects RG export of 32-bit float
    - Derived PSO enables blending, using source alpha in blend equation (destination factor == 1)
    - Result: Shader doesn't export alpha - CB expects alpha export

Exemple 2 -

    - Base PSO writes float4 to DXGI_FORMAT_R16G16B16A16_UNORM with no blending
    - Driver selects RGBA export of 16-bit UNORM
    - Derived PSO enables blending
    - Result: Shader exports UNORM format - CB expects 16 or 32-bit floats

Exemple 3 -

    - Base PSO writes float2 to DXGI_FORMAT_R32G32_FLOAT format with RenderTargetWriteMask == D3D12_COLOR_WRITE_ENABLE_RED
    - Driver selects R export of 32-bit float
    - Derived PSO changes RenderTargetWriteMask == D3D12_COLOR_WRITE_ENABLE_ALL
    - Result: Shader exports only red - artifacts in green

Les PSO sérialisés vous conviennent-ils ?

Bien que les PSO sérialisés aient été créés pour réduire la taille des packages et les coûts d’exécution liés au contenu des nuanceurs de jeu, la création et la maintenance d’une telle étape de génération représentent un coût de développement non négligeable. Les développeurs constatent souvent que la distribution de nuanceurs précompilés avec un DXIL supprimé offre des performances suffisantes pour leurs besoins, une approche souvent déjà prise en charge par les pipelines de contenu existants. Le back-end du pilote XBOX a été optimisé avec plusieurs mécanismes de mise en cache afin de réduire les besoins en mémoire à l’exécution et le temps de compilation des PSO pour faciliter cette approche. Selon le contenu des nuanceurs d’un titre, les développeurs peuvent trouver une méthode préférable en matière de taille de package, de mémoire à l’exécution ou de temps de compilation des PSO. Éviter la maintenance d’un pipeline de contenu de sérialisation des PSO est un autre point à prendre en compte. Tester les deux options avec le contenu de votre titre vous donnera une idée plus claire du meilleur choix pour votre titre.

GDK and Game Engines Integration

Steam porting guide

Game Principles

Core Features

Console Features

Objets d'état de pipeline sérialisés et dérivés en détail

Compilation des objets d’état de pipeline

Objets d’état de pipeline sérialisés

Objets d’état de pipeline dérivés

Objets d’état de pipeline sérialisés et dérivés

Contraintes sur les objets d’état de pipeline dérivés

Les PSO sérialisés vous conviennent-ils ?

​Compilation des objets d’état de pipeline

​Objets d’état de pipeline sérialisés

​Objets d’état de pipeline dérivés

​Objets d’état de pipeline sérialisés et dérivés

​Contraintes sur les objets d’état de pipeline dérivés

​Les PSO sérialisés vous conviennent-ils ?

Compilation des objets d’état de pipeline

Objets d’état de pipeline sérialisés

Objets d’état de pipeline dérivés

Objets d’état de pipeline sérialisés et dérivés

Contraintes sur les objets d’état de pipeline dérivés

Les PSO sérialisés vous conviennent-ils ?