Share via

IDMLBindingTable::BindInputs, méthode (directml.h)

  • Article

Lie un ensemble de ressources en tant que tenseurs d’entrée.

En cas de liaison pour un opérateur compilé, le nombre de liaisons doit correspondre exactement au nombre d’entrées de l’opérateur, y compris les tenseurs facultatifs. Cela peut être déterminé à partir de la description de l’opérateur utilisée pour créer l’opérateur. Si trop ou trop peu de liaisons sont fournies, la suppression de l’appareil se produit. Pour les tenseurs facultatifs, vous pouvez utiliser DML_BINDING_TYPE_NONE pour spécifier « aucune liaison ». Sinon, le type de liaison doit correspondre au type de tenseur lors de la création de l’opérateur.

Pour les initialiseurs d’opérateur, les liaisons d’entrée sont censées être de type DML_BINDING_TYPE_BUFFER_ARRAY avec une liaison d’entrée par opérateur à initialiser, fournie dans l’ordre dans lequel vous avez spécifié les opérateurs lors de la création ou de la réinitialisation de l’initialiseur. Chaque tableau de mémoires tampons doit avoir une taille égale au nombre d’entrées de son opérateur correspondant à initialiser. Les tenseurs d’entrée dont l’indicateur DML_TENSOR_FLAG_OWNED_BY_DML a été défini doivent être liés lors de l’initialisation. Sinon, rien ne doit être lié à ce tenseur. S’il n’y a rien à lier en tant qu’entrée pour l’initialisation d’un opérateur (c’est-à-dire qu’il n’y a pas de tenseurs avec l’indicateur DML_TENSOR_FLAG_OWNED_BY_DML défini), vous pouvez fournir nullptr ou un DML_BUFFER_ARRAY_BINDING vide pour indiquer « aucune liaison ».

Pour dissocier toutes les ressources d’entrée, fournissez un rangeCount de 0 et une valeur pour nullptrles liaisons.

Si un tenseur d’entrée a l’indicateur DML_TENSOR_FLAG_OWNED_BY_DML défini, il peut être lié uniquement lors de l’exécution d’un initialiseur d’opérateur. Sinon, si l’indicateur DML_TENSOR_FLAG_OWNED_BY_DML n’est pas défini, l’inverse est vrai : le tenseur d’entrée ne doit pas être lié lors de l’exécution de l’initialiseur, mais doit l’être lors de l’exécution de l’opérateur lui-même.

Toutes les mémoires tampons liées en tant qu’entrée doivent avoir un type de tas D3D12_HEAP_TYPE_DEFAULT, sauf lorsque l’indicateur DML_TENSOR_FLAG_OWNED_BY_DML est défini. Si le DML_TENSOR_FLAG_OWNED_BY_DML est défini pour un tenseur lié en tant qu’entrée pour un initialiseur, le type de tas de la mémoire tampon peut être D3D12_HEAP_TYPE_DEFAULT ou D3D12_HEAP_TYPE_UPLOAD.

Plusieurs liaisons sont autorisées à référencer le même ID3D12Resource dans certains cas ; Toutefois, vous devez veiller à ce qu’un opérateur lit et écrit simultanément dans la même région d’une ressource. Il existe un risque potentiel de liaison lorsque : une paire de liaisons référence la même ID3D12Resource, qu’au moins une des liaisons est impliquée dans l’écriture et que les régions tampons se croisent (se chevauchent d’au moins un octet). Les risques de liaison sont validés à l’aide des règles suivantes, à partir de DirectML 1.7.0 :

  • Lors de la liaison pour l’initialisation, une liaison d’entrée ne peut jamais référencer la même ressource que la liaison de sortie. Les entrées sont copiées dans la ressource de sortie (la ressource persistante future pour l’exécution), et la copie peut nécessiter une transition d’état de ressource.
  • Lors de la liaison pour l’exécution, une liaison d’entrée peut référencer la même ressource qu’une liaison de sortie ; toutefois, les plages de liaison respectives ne peuvent se croiser que si les régions sont identiques et si l’opérateur prend en charge l’exécution sur place.
  • Si elle est présente, une liaison persistante ne doit pas se croiser avec une liaison de sortie ou une liaison temporaire.
  • Si elle est présente, une liaison temporaire ne doit pas croiser de liaison d’entrée, de liaison de sortie ou de liaison persistante.

Les règles ci-dessus supposent que deux ressources n’alias pas la même région d’un tas, donc une prudence supplémentaire est requise lors de l’utilisation de ressources placées ou réservées.

Syntaxe

void BindInputs(
                 UINT                   bindingCount,
  [in, optional] const DML_BINDING_DESC *bindings
);

Paramètres

bindingCount

Type : UINT

Ce paramètre détermine la taille du tableau de liaisons (le cas échéant).

[in, optional] bindings

Type : const DML_BINDING_DESC*

Pointeur facultatif vers un tableau constant de DML_BINDING_DESC contenant des descriptions des ressources tensorielles à lier.

Valeur de retour

None

Notes

Exemples de risques de liaison

Dans les exemples ci-dessous, les rectangles représentent une ressource de mémoire tampon référencée par au moins une liaison dans une table de liaison. Chaque ligne indique la plage d’octets potentiellement lus (R) ou écrits (W) par la liaison nommée. Tous les exemples supposent que les ressources ne partagent pas la même mémoire physique.

Exemple 1

Cet exemple montre une liaison d’entrée et de sortie référençant différentes ressources. Une paire de liaisons qui référencent des ressources différentes n’est jamais un danger, il s’agit donc toujours d’une liaison valide.

          Resource A          Resource B
          +---------------+   +---------------+
Input  0: |RRRRRRRRRRRRRRR|   |               |
Output 0: |               |   |WWWWWWWWWWWWWWW|
          +---------------+   +---------------+

Exemple 2

Cet exemple montre une liaison d’entrée et de sortie référençant différentes régions de la même ressource. Une paire de liaisons avec des régions qui ne se chevauchent pas de la même ressource n’est pas un danger lors de la liaison pour l’exécution. Il s’agit d’une liaison valide lors de la liaison pour l’exécution, mais elle n’est pas valide lors de la liaison pour l’initialisation.

          Resource A      
          +---------------+
Input  0: |RRRRRRR        |
Output 0: |       WWWWWWWW|
          +---------------+

Exemple 3

Cet exemple montre deux liaisons d’entrées qui chevauchent des plages. Une paire de liaisons en lecture seule (liaisons d’entrée et liaisons persistantes) ne peut jamais être un danger, quelle que soit l’intersection de la région de mémoire tampon, il s’agit donc toujours d’une liaison valide.

          Resource A          Resource B
          +---------------+   +---------------+
Input  0: |RRRRRRRRR      |   |               |
Input  1: |      RRRRRRRRR|   |               |
Output 0: |               |   |WWWWWWWWWWWWWWW|
          +---------------+   +---------------+

Exemple 4

Cet exemple montre une liaison d’entrée et de sortie avec des régions identiques. Cette liaison est valide si et uniquement si l’opérateur lié prend en charge l’exécution sur place et si la liaison est destinée à l’exécution.

          Resource A      
          +---------------+
Input  0: |RRRRRRRRRRRRRRR|
Output 0: |WWWWWWWWWWWWWWW|
          +---------------+

Exemple 5

La liaison suivante n’est jamais valide, quelle que soit la prise en charge de l’exécution sur place de l’opérateur, car elle implique une paire de liaisons avec des régions qui se chevauchent qui ne sont pas identiques.

          Resource A      
          +---------------+
Input  0: |RRRRRRRRRRRRR  |
Output 0: |    WWWWWWWWWWW|
          +---------------+

Configuration requise

Configuration requise

   
Plateforme cible Windows
En-tête directml.h
Bibliothèque DirectML.lib
DLL DirectML.dll

Voir aussi

Liaison dans DirectML

IDMLBindingTable