Enumeración de las funcionalidades del motor de GPU

A partir de Windows 8.1, un controlador de minipuerto de pantalla debe implementar la función DxgkDdiGetNodeMetadata, que se usa para consultar las funcionalidades del motor de un nodo de GPU.

Esta información ayuda con la evaluación de cómo se programan y distribuyen las cargas de trabajo entre los nodos y mejora la capacidad de depurar aplicaciones.

Interfaz del controlador de dispositivo (DDI) de funcionalidades del motor

Esta interfaz proporciona las funcionalidades del motor de un nodo de GPU especificado:

• DxgkDdiGetNodeMetadata
• DXGKARG_GETNODEMETADATA
• DXGK_ENGINE_TYPE

El miembro DxgkDdiGetNodeMetadata proporciona un puntero a la función DxgkDdiGetNodeMetadata de la estructura DRIVER_INITIALIZATION_DATA .

Arquitectura de nodo de GPU

Cada adaptador de pantalla del sistema tiene varios motores diferentes disponibles para programar tareas. Cada motor se asigna solo a un nodo, pero cada nodo puede contener más de un motor si ese nodo está asociado a varios adaptadores, como en la configuración del adaptador de pantalla vinculado (LDA), donde se vinculan varias GPU físicas para formar una GPU virtual única, más rápida y rápida.

Los distintos nodos representan los núcleos de procesamiento asimétrico de la GPU, mientras que los motores de cada nodo representan los núcleos de procesamiento simétrico entre adaptadores. Es decir, un nodo 3D solo contiene motores 3D idénticos en varios adaptadores y nunca un tipo de motor diferente.

Dado que los motores siempre se agrupan en nodos por tipo de motor, se puede consultar la información del tipo de motor en función de un nodo especificado. Los tipos de motor que el controlador de miniporte de pantalla puede especificar se muestran en la enumeración DXGK_ENGINE_TYPE .

Implementación de ejemplo de la función de metadatos de nodo

Este código muestra cómo un controlador de minipuerto de pantalla puede implementar algunos de los tipos de motor que puede devolver la función 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;
}