structure DXGK_ALLOCATIONINFO (d3dkmddi.h)

Article
11/11/2024

La structure DXGK_ALLOCATIONINFO décrit les paramètres de création d’une allocation.

Syntaxe

typedef struct _DXGK_ALLOCATIONINFO {
  VOID                       *pPrivateDriverData;
  UINT                       PrivateDriverDataSize;
  union {
    UINT Alignment;
    struct {
      UINT16 MinimumPageSize;
      UINT16 RecommendedPageSize;
    };
  };
  SIZE_T                     Size;
  SIZE_T                     PitchAlignedSize;
  DXGK_SEGMENTBANKPREFERENCE HintedBank;
  DXGK_SEGMENTPREFERENCE     PreferredSegment;
  union {
    UINT SupportedReadSegmentSet;
    UINT MmuSet;
  };
  UINT                       SupportedWriteSegmentSet;
  UINT                       EvictionSegmentSet;
  union {
    UINT MaximumRenamingListLength;
    UINT PhysicalAdapterIndex;
  };
  HANDLE                     hAllocation;
  union {
    DXGK_ALLOCATIONINFOFLAGS         Flags;
    DXGK_ALLOCATIONINFOFLAGS_WDDM2_0 FlagsWddm2;
  };
  DXGK_ALLOCATIONUSAGEHINT   *pAllocationUsageHint;
  UINT                       AllocationPriority;
  DXGK_ALLOCATIONINFOFLAGS2  Flags2;
} DXGK_ALLOCATIONINFO;

Membres

pPrivateDriverData

[in] Pointeur vers un bloc de données privées. Ces données concernent chaque allocation et sont distinctes du membre pPrivateDriverData dans la structure DXGKARG_CREATEALLOCATION. Le pilote d’affichage en mode utilisateur (UMD) peut transmettre ces données au pilote de miniport en mode noyau (KMD). Toutefois, si Dxgkrnl transmet ces données pour décrire la surface primaire partagée ou une autre surface verrouillable, les données sont passées en tant que premier élément du tableau dans le pAllocationInfo membre de DXGKARG_CREATEALLOCATION.

PrivateDriverDataSize

[in] Taille, en octets, du bloc de données privées dans pPrivateDriverData.

Alignment

[out] Alignement requis, en octets, pour l’allocation.

MinimumPageSize

RecommendedPageSize

Size

[out] Taille, en octets, requise pour l’allocation. La valeur de taille est étendue à un multiple de la taille de page hôte native (par exemple, 4 Ko sur l’architecture x86). Le KMD spécifie la taille d’allocation au gestionnaire de mémoire vidéo (VidMm).

PitchAlignedSize

[out] Taille, en octets, de l’allocation lorsqu’elle se trouve dans un segment aligné sur le pas, qui est spécifiée par l’indicateur de champ PitchAlignment dans les indicateurs de membre de la structure DXGK_SEGMENTDESCRIPTOR du segment. Si l’allocation n’est pas prise en charge dans un segment aligné sur un pas (les GPU ne prennent généralement pas en charge ce type de segment), le pilote doit définir la valeur dans PitchAlignedSize sur zéro. Si le pilote spécifie une valeur différente de zéro dans PitchAlignedSize, la valeur doit être supérieure ou égale à la valeur dans le membre Size.

HintedBank

[out] Structure DXGK_SEGMENTBANKPREFERENCE qui spécifie les préférences de classement bancaire de KMD qui VidMm utiliser pour la mise en page de l’allocation. Si ce membre est spécifié, VidMm utilise des informations bancaires sur le segment le plus préféré, qui est spécifié par le membre SegmentId0 de la structure DXGK_SEGMENTPREFERENCE spécifiée par le membre PreferredSegment.

PreferredSegment

[out] Structure DXGK_SEGMENTPREFERENCE qui indique les identificateurs de segments préférés que les requêtes KMD qui VidMm utiliser pour la page de l’allocation.

SupportedReadSegmentSet

[out] Identificateurs de segment que le KMD peut définir dans le membre PreferredSegment pour les opérations de lecture. Les segments que ces identificateurs indiquent sont des segments que les requêtes KMD VidMm utiliser pour l’allocation de pages pour les opérations de lecture, quelles que soient les performances. La définition du bit 0 indique que le premier segment est pris en charge, la définition du bit 1 indique que le deuxième segment est pris en charge, et ainsi de suite.

Le KMD peut définir des préférences uniquement pour les segments pris en charge pour les opérations de lecture. VidMm affirme si le pilote tente de définir des préférences pour les segments non pris en charge dans le membre PreferredSegment.

MmuSet

SupportedWriteSegmentSet

[out] Identificateurs de segment que le KMD peut définir dans le membre PreferredSegment pour les opérations d’écriture. Les segments que ces identificateurs indiquent sont des segments que les requêtes KMD qui VidMm utiliser pour l’allocation de pages pour les opérations d’écriture, quelles que soient les performances. La définition du bit 0 indique que le premier segment est pris en charge, la définition du bit 1 indique que le deuxième segment est pris en charge, et ainsi de suite.

Le KMD ne peut définir les préférences que pour les segments pris en charge pour les opérations d’écriture. VidMm affirme si le pilote tente de définir des préférences pour les segments non pris en charge dans le membre PreferredSegment.

EvictionSegmentSet

[out] Identificateurs de segments qui peuvent être utilisés pour l’éviction. La définition du bit 0 indique que le premier segment peut être utilisé pour l’éviction, définir le bit 1 indique que le deuxième segment peut être utilisé pour l’éviction, et ainsi de suite.

Seuls les segments d’ouverture peuvent être spécifiés par ce membre. Si le pilote spécifie des segments valides à utiliser pour l’éviction, VidMm tente d’allouer des ressources dans ces segments d’ouverture pour accélérer le processus d’éviction. Si le pilote spécifie 0, VidMm appelle le pilote pour transférer le contenu d’une allocation directement à la mémoire système paginée sans mapper les pages sous-jacentes via un segment d’ouverture.

MaximumRenamingListLength

[out] Longueur maximale de la liste de renommage pour l’allocation. Pour plus d’informations sur la liste de renommage, consultez Demande de renommer uned’allocation.

Prise en charge de ce membre démarré avec Windows 10 et WDDM v2.

PhysicalAdapterIndex

[out] Index de l’adaptateur physique.

Prise en charge de ce membre démarré avec Windows 10 et WDDM v2.

hAllocation

[out] Handle de l’allocation. Le KMD doit définir ce membre sur une valeur qu’il peut utiliser pour faire référence à sa structure de suivi privé pour l’allocation.

Flags

[out] Structure DXGK_ALLOCATIONINFOFLAGS qui identifie les propriétés d’une allocation dans les indicateurs de champ binaire. Ces propriétés indiquent le type d’allocation à créer. Le KMD spécifie ces indicateurs pour VidMm. Les pilotes qui ciblent une version WDDM antérieure à WDDM 2.0 doivent utiliser indicateurs; pilotes qui ciblent n’importe quelle version WDDM >= WDDM 2.0 doivent utiliser FlagsWddm2.

FlagsWddm2

[out] Structure DXGK_ALLOCATIONINFOFLAGS_WDDM2_0 qui identifie les propriétés d’une allocation dans les indicateurs de champ binaire. Ces propriétés indiquent le type d’allocation à créer. Le KMD spécifie ces indicateurs pour VidMm. Les pilotes qui ciblent une version WDDM >= WDDM 2.0 doivent utiliser FlagsWddm2; les pilotes qui ciblent une version WDDM antérieure à WDDM 2.0 doivent utiliser indicateurs.

pAllocationUsageHint

[out] Pointeur vers une structure DXGK_ALLOCATIONUSAGEHINT utilisée par le gestionnaire de mémoire pour déterminer comment utiliser l’allocation.

AllocationPriority

[out] Valeur UINT qui spécifie le niveau de priorité de départ de l’allocation.

Le pilote détermine le niveau de priorité approprié pour chaque allocation. Pour plus d’informations sur les niveaux de priorité, consultez la section Remarques de la fonction pfnSetPriorityCb. Si le niveau de priorité pour les allocations n’est pas un problème pour le pilote, le pilote doit définir tous les niveaux de priorité sur D3DDDI_ALLOCATIONPRIORITY_NORMAL. Notez que 0 est une priorité d’allocation initiale non valide.

Flags2

[out] Structure DXGK_ALLOCATIONINFOFLAGS2 qui contient des propriétés supplémentaires pour une allocation. Prise en charge à partir de Windows 11 (WDDM 3.0).

Remarques

Avec WDDM v2, la structure DXGK_ALLOCATIONINFO a été modifiée afin que le jeu de segments de lecture et d’écriture ne soit plus différencié. Lors de la création d’une surface, VidMm ignore la valeur SupportedReadSegmentSet et utilise uniquement le jeu de segments fourni par SupportedWriteSegmentSet. Les pilotes doivent s’assurer que cette valeur représente avec précision l’ensemble de segments qui peut être utilisé par l’allocation à son objectif prévu.

Ignorer le jeu de segments de lecture pris en charge ne signifie pas qu’il n’est plus pris en charge, mais simplement qu’il ne doit plus y avoir de différence entre ces jeux et VidMm sera autorisé à choisir un segment approprié pour toute allocation à partir d’un seul ensemble de segments.