ID3D12Device ::CreatePlacedResource, méthode (d3d12.h)

Article
03/14/2023

Crée une ressource qui est placée dans un tas spécifique. Les ressources placées sont les objets de ressources les plus légers disponibles et sont les plus rapides à créer et à détruire.

Votre application peut réutiliser la mémoire vidéo en chevauchant plusieurs ressources placées et réservées Direct3D sur des régions de tas. Le modèle simple de réutilisation de la mémoire (décrit dans Remarques) existe pour clarifier la ressource qui se chevauche est valide à un moment donné. Pour optimiser la prise en charge de l’outil graphique, avec le modèle simple, l’héritage des données n’est pas pris en charge ; et l’invalidation des vignettes et des sous-ressources plus précises n’est pas prise en charge. Seule l’invalidation complète des ressources qui se chevauchent se produit.

Syntaxe

HRESULT CreatePlacedResource(
  ID3D12Heap                *pHeap,
  UINT64                    HeapOffset,
  const D3D12_RESOURCE_DESC *pDesc,
  D3D12_RESOURCE_STATES     InitialState,
  const D3D12_CLEAR_VALUE   *pOptimizedClearValue,
  REFIID                    riid,
  void                      **ppvResource
);

Paramètres

pHeap

Type : [in] ID3D12Heap*

Pointeur vers l’interface ID3D12Heap qui représente le tas dans lequel la ressource est placée.

HeapOffset

Type : UINT64

Décalage, en octets, de la ressource. HeapOffset doit être un multiple de l’alignement de la ressource, et HeapOffset plus la taille de la ressource doit être inférieur ou égal à la taille du tas. GetResourceAllocationInfo doit être utilisé pour comprendre les tailles des ressources de texture.

pDesc

Type : [in] const D3D12_RESOURCE_DESC*

Pointeur vers une structure D3D12_RESOURCE_DESC qui décrit la ressource.

InitialState

Type : D3D12_RESOURCE_STATES

État initial de la ressource, sous la forme d’une combinaison de D3D12_RESOURCE_STATES constantes d’énumération au niveau du bit .

Lorsqu’une ressource est créée avec un tas de D3D12_HEAP_TYPE_UPLOAD , InitialState doit être D3D12_RESOURCE_STATE_GENERIC_READ. Lorsqu’une ressource est créée avec un tas de D3D12_HEAP_TYPE_READBACK , InitialState doit être D3D12_RESOURCE_STATE_COPY_DEST.

pOptimizedClearValue

Type : [in, facultatif] const D3D12_CLEAR_VALUE*

Spécifie une D3D12_CLEAR_VALUE qui décrit la valeur par défaut d’une couleur claire.

pOptimizedClearValue spécifie une valeur pour laquelle les opérations claires sont les plus optimales. Lorsque la ressource créée est une texture avec les indicateurs D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET ou D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL , votre application doit choisir la valeur avec laquelle l’opération clear sera appelée le plus souvent.

Les opérations claires peuvent être appelées avec d’autres valeurs, mais ces opérations ne seront pas aussi efficaces que lorsque la valeur correspond à celle passée à la création de ressources.

pOptimizedClearValue doit avoir la valeur NULL lorsqu’il est utilisé avec D3D12_RESOURCE_DIMENSION_BUFFER.

riid

Type : REFIID

Identificateur global unique (GUID) pour l’interface de ressource. Il s’agit d’un paramètre d’entrée.

Le REFIID, ou GUID, de l’interface de la ressource peut être obtenu à l’aide de la __uuidof macro. Par exemple, __uuidof(ID3D12Resource) obtient le GUID de l’interface vers une ressource. Bien que riid soit, le plus souvent, le GUID pour ID3D12Resource, il peut s’agir de n’importe quel GUID pour n’importe quelle interface. Si l’objet de ressource ne prend pas en charge l’interface pour ce GUID, la création échoue avec E_NOINTERFACE.

ppvResource

Type : [out, optional] void**

Pointeur vers un bloc de mémoire qui reçoit un pointeur vers la ressource. ppvResource peut avoir la valeur NULL pour activer le test des fonctionnalités. Lorsque ppvResource a la valeur NULL, aucun objet n’est créé et S_FALSE est retourné lorsque pResourceDesc et d’autres paramètres sont valides.

Valeur retournée

Type : HRESULT

Cette méthode retourne E_OUTOFMEMORY si la mémoire est insuffisante pour créer la ressource. Pour obtenir d’autres valeurs de retour possibles, consultez Codes de retour Direct3D 12 .

Remarques

CreatePlacedResource est similaire au mappage complet d’une ressource réservée à un décalage dans un tas ; mais l’espace d’adressage virtuel associé à un tas peut également être réutilisé.

Les ressources placées sont plus légères à créer et à détruire que les ressources engagées. En effet, aucun tas n’est créé ni détruit pendant ces opérations. En outre, les ressources placées permettent une technique de réutilisation de la mémoire encore plus légère que la création et la destruction de ressources, c’est-à-dire la réutilisation via l’aliasing et les barrières d’aliasing. Plusieurs ressources placées peuvent se chevaucher simultanément sur le même tas, mais une seule ressource qui se chevauche peut être utilisée à la fois.

Il existe deux sémantiques d’utilisation des ressources placées : un modèle simple et un modèle avancé. Nous vous recommandons de choisir le modèle simple (il optimise la prise en charge de l’outil graphique dans l’écosystème diversifié de GPU), sauf si et jusqu’à ce que vous trouviez que vous avez besoin du modèle avancé pour votre application.

Modèle simple

Dans ce modèle, vous pouvez considérer qu’une ressource placée est dans l’un des deux états suivants : actif ou inactif. Il n’est pas valide pour le GPU de lire ou d’écrire à partir d’une ressource inactive. Les ressources placées sont créées à l’état inactif.

Pour activer une ressource avec une barrière d’alias dans une liste de commandes, votre application doit passer la ressource dans D3D12_RESOURCE_ALIASING_BARRIER ::p ResourceAfter. pResourceBefore peut être laissé null lors d’une activation. Toutes les ressources qui partagent de la mémoire physique avec la ressource activée deviennent désormais inactives, ce qui inclut le chevauchement des ressources placées et réservées.

Les barrières d’alias doivent être regroupées et soumises ensemble, afin d’optimiser l’efficacité.

Après l’activation, les ressources avec la cible de rendu ou les indicateurs de gabarit de profondeur doivent être initialisées davantage. Consultez les notes sur l’initialisation des ressources requises ci-dessous.

Remarques sur l’initialisation des ressources requise

Certains types de ressources nécessitent toujours une initialisation. Les ressources avec la cible de rendu ou les indicateurs de gabarit de profondeur doivent être initialisées avec une opération claire ou une collection de copies de sous-ressources complètes. Si une barrière d’aliasing a été utilisée pour désigner la transition entre deux ressources sous alias, l’initialisation doit se produire après la barrière d’aliasing. Cette initialisation est toujours requise chaque fois qu’une ressource aurait été activée dans le modèle simple.

Les ressources placées et réservées avec la cible de rendu ou les indicateurs de gabarit de profondeur doivent être initialisées avec l’une des opérations suivantes avant que d’autres opérations soient prises en charge.

Opération Effacer ; par exemple ClearRenderTargetView ou ClearDepthStencilView.
Opération DiscardResource .
Opération de copie ; par exemple CopyBufferRegion, CopyTextureRegion ou CopyResource.

Les applications doivent préférer l’opération la plus explicite qui entraîne le moins de texels modifiés. Voici quelques exemples.

L’utilisation d’une mémoire tampon de profondeur pour résoudre la visibilité des pixels nécessite généralement que chaque texel de profondeur commence à 1.0 ou 0. Par conséquent, une opération Clear doit être l’option la plus efficace pour l’initialisation de la mémoire tampon de profondeur avec alias.
Une application peut utiliser une cible de rendu avec alias comme destination pour le mappage de tonalité. Étant donné que l’application affiche chaque pixel pendant le mappage de tonalité, DiscardResource doit être l’option la plus efficace pour l’initialisation.

Modèle avancé

Dans ce modèle, vous pouvez ignorer l’abstraction d’état actif/inactif. Au lieu de cela, vous devez respecter ces règles de niveau inférieur.

Une barrière d’aliasing doit se trouver entre deux différents accès aux ressources GPU de la même mémoire physique, tant que ces accès se trouvent dans le même appel ExecuteCommandLists .
La première opération de rendu pour certains types de ressources avec alias doit toujours être une initialisation, tout comme le modèle simple.

Les opérations d’initialisation doivent se produire sur une sous-ressource entière ou sur une granularité de 64 Ko. Une initialisation de sous-ressource entière est prise en charge pour tous les types de ressources. Une granularité d’initialisation de 64 Ko, alignée sur un décalage de 64 Ko, est prise en charge pour les mémoires tampons et les textures avec la disposition de texture 64KB_UNDEFINED_SWIZZLE ou 64KB_STANDARD_SWIZZLE (reportez-vous à D3D12_TEXTURE_LAYOUT).

Remarques sur la barrière d’aliasing

La barrière d’aliasing peut définir NULL pour pResourceAfter et pResourceBefore. La définition de cohérence de la mémoire de ExecuteCommandLists et une barrière d’aliasing sont identiques, de sorte que deux accès sous alias à la même mémoire physique n’ont pas besoin d’une barrière d’aliasing lorsque les accès se trouvent dans deux appels ExecuteCommandLists différents.

Pour les modèles d’utilisation avancés D3D12, la définition de synchronisation de ExecuteCommandLists équivaut à une barrière d’aliasing. Par conséquent, les applications peuvent insérer une barrière d’aliasing entre la réutilisation de la mémoire physique ou s’assurer que les deux utilisations sous alias de la mémoire physique se produisent dans deux appels distincts à ExecuteCommandLists.

La quantité d’inactivation varie en fonction des propriétés de la ressource. Les textures avec des dispositions de mémoire non définies sont les pires cas, car la texture entière doit être inactive atomiquement. Pour deux ressources qui se chevauchent avec des dispositions définies, l’inactivation peut entraîner uniquement le chevauchement des régions alignées d’une ressource. L’héritage des données peut même être bien défini. Pour plus d’informations, consultez Alias de mémoire et héritage des données.