Énumération des fonctionnalités du moteur GPU

À compter de Windows 8.1, un pilote miniport d’affichage doit implémenter la fonction DxgkDdiGetNodeMetadata, qui est utilisée pour interroger les fonctionnalités du moteur d’un nœud GPU.

Ces informations facilitent l’évaluation de la façon dont les charges de travail sont planifiées et distribuées entre les nœuds, et améliorent la capacité à déboguer des applications.

Fonctionnalités du moteur, interface de pilote de périphérique (DDI)

Cette interface fournit les fonctionnalités de moteur d’un nœud GPU spécifié :

• DxgkDdiGetNodeMetadata
• DXGKARG_GETNODEMETADATA
• DXGK_ENGINE_TYPE

Un pointeur vers la fonction DxgkDdiGetNodeMetadata est fourni par le membre DxgkDdiGetNodeMetadata de la structure DRIVER_INITIALIZATION_DATA .

Architecture de nœud GPU

Chaque carte graphique sur le système dispose d’un certain nombre de moteurs différents disponibles pour planifier des tâches. Chaque moteur est affecté à un seul nœud, mais chaque nœud peut contenir plusieurs moteurs si ce nœud est associé à plusieurs adaptateurs, par exemple dans la configuration de l’adaptateur graphique lié (LDA), où plusieurs GPU physiques sont liés pour former un gpu virtuel unique, plus rapide.

Les différents nœuds représentent les cœurs de traitement asymétrique du GPU, tandis que les moteurs au sein de chaque nœud représentent les cœurs de traitement symétriques sur les cartes. Autrement dit, un nœud 3D contient uniquement des moteurs 3D identiques sur plusieurs adaptateurs, et jamais un type de moteur différent.

Étant donné que les moteurs sont toujours regroupés en nœuds par type de moteur, les informations sur le type de moteur peuvent être interrogées en fonction d’un nœud spécifié. Les types de moteur que le pilote de miniport d’affichage peut spécifier sont répertoriés dans l’énumération DXGK_ENGINE_TYPE .

Exemple d’implémentation de la fonction de métadonnées de nœud

Ce code montre comment un pilote de miniport d’affichage peut implémenter certains des types de moteur qui peuvent être retournés par la fonction DxgkDdiGetNodeMetadata .

NTSTATUS
IHVGetNodeDescription(
        IN_CONST_HANDLE                     hAdapter,
        UINT                                NodeOrdinal,
        OUT_PDXGKARG_GETNODEMETADATA        pGetNodeMetadata
        )
{
    DDI_FUNCTION();
    PAGED_CODE();

    if(NULL == pGetNodeMetadata)
    {
        return STATUS_INVALID_PARAMETER;
    }

    CAdapter *pAdapter = GetAdapterFromHandle(hAdapter);

    //Invalid handle
    if(NULL == pAdapter)
    {
        return STATUS_INVALID_PARAMETER;
    }

    //Node ordinal is out of bounds. Required to return
    //STATUS_INVALID_PARAMETER
    if(NodeOrdinal >= pAdapter->GetNumNodes())
    {
        return STATUS_INVALID_PARAMETER;
    }

    switch(pAdapter->GetEngineType(NodeOrdinal))
    {
        //This is the adapter's 3-D engine. This engine handles a large number
        //of different workloads, but it also handles the adapter's 3-D 
        //workloads. Therefore the 3-D capability is what must be exposed.
        case GPU_ENGINE_3D:
        {
            pGetNodeMetadata->EngineType = DXGK_ENGINE_TYPE_3D;
            break;
        }

        //This is the adapter's video decoding engine
        case GPU_ENGINE_VIDEO_DECODE:
        {
            pGetNodeMetadata->EngineType = DXGK_ENGINE_TYPE_VIDEO_DECODE;
            break;
        }

        //This engine is proprietary and contains no functionality that
        //fits the DXGK_ENGINE_TYPE enumeration
        case GPU_ENGINE_PROPRIETARY_ENGINE_1:
        {
            pGetNodeMetadata->EngineType = DXGK_ENGINE_TYPE_OTHER;

            //Copy over friendly name associated with this engine
            SetFriendlyNameForEngine(pGetNodeMetadata->FriendlyName,
                                     DXGK_MAX_METADATA_NAME_LENGTH,
                                     PROPRIETARY_ENGINE_1_NAME);
            break;
        }
    }

    return STATUS_SUCCESS;
}