Enable Windows Os Layer for Sysman

Adding KmdSysman with ULT

Change-Id: If080e6327171d3634a0c461c4169ea8c84461e13

level_zero/tools/source/sysman/windows/CMakeLists.txt

@@ -7,6 +7,9 @@
 set(L0_SRCS_TOOLS_SYSMAN_WINDOWS
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/os_sysman_imp.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/kmd_sys.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/kmd_sys_manager.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/kmd_sys_manager.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/os_sysman_imp.cpp)
 
 if(WIN32)

level_zero/tools/source/sysman/windows/kmd_sys.h

@@ -0,0 +1,516 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+namespace L0 {
+
+namespace KmdSysman {
+constexpr uint32_t KmdMaxBufferSize = 2048;
+constexpr uint32_t MaxPropertyBufferSize = 128;
+constexpr uint32_t PcEscapeOperation = 35;
+constexpr uint32_t KmdSysmanSuccess = 0;
+constexpr uint32_t KmdSysmanFail = 1;
+constexpr uint32_t KmdMajorVersion = 1;
+constexpr uint32_t KmdMinorVersion = 0;
+constexpr uint32_t KmdPatchNumber = 0;
+
+struct GfxSysmanMainHeaderIn {
+    uint32_t inVersion;
+    uint32_t inNumElements;
+    uint32_t inTotalsize;
+    uint8_t inBuffer[KmdMaxBufferSize];
+};
+
+struct GfxSysmanMainHeaderOut {
+    uint32_t outStatus;
+    uint32_t outNumElements;
+    uint32_t outTotalSize;
+    uint8_t outBuffer[KmdMaxBufferSize];
+};
+
+struct GfxSysmanReqHeaderIn {
+    uint32_t inRequestId;
+    uint32_t inCommand;
+    uint32_t inComponent;
+    uint32_t inCommandParam;
+    uint32_t inDataSize;
+};
+
+struct GfxSysmanReqHeaderOut {
+    uint32_t outRequestId;
+    uint32_t outComponent;
+    uint32_t outReturnCode;
+    uint32_t outDataSize;
+};
+
+enum Command {
+    Get = 0,
+    Set,
+    RegisterEvent,
+    UnregisterEvent,
+
+    MaxCommands,
+};
+
+enum Events {
+    EnergyThresholdCrossed = 0,
+    EnterD0,
+    EnterD3,
+    EnterTDR,
+    ExitTDR,
+    FrequencyThrottled,
+    CriticalTemperature,
+    TemperatureThreshold1,
+    TemperatureThreshold2,
+    ResetDeviceRequired,
+
+    MaxEvents,
+};
+
+enum Component {
+    InterfaceProperties = 0,
+    PowerComponent,
+    FrequencyComponent,
+    ActivityComponent,
+    FanComponent,
+    TemperatureComponent,
+    FpsComponent,
+    SchedulerComponent,
+    MemoryComponent,
+    PciComponent,
+
+    MaxComponents,
+};
+
+namespace Requests {
+
+enum Interface {
+    InterfaceVersion = 0,
+
+    MaxInterfaceRequests,
+};
+
+enum Power {
+    NumPowerDomains = 0,
+
+    // support / enabled
+    EnergyThresholdSupported,
+    EnergyThresholdEnabled,
+    PowerLimit1Enabled,
+    PowerLimit2Enabled,
+
+    // default fused values
+    PowerLimit1Default,
+    PowerLimit2Default,
+    PowerLimit1TauDefault,
+    PowerLimit4AcDefault,
+    PowerLimit4DcDefault,
+    EnergyThresholdDefault,
+    TdpDefault,
+    MinPowerLimitDefault,
+    MaxPowerLimitDefault,
+    EnergyCounterUnits,
+
+    // current runtime values
+    CurrentPowerLimit1,
+    CurrentPowerLimit2,
+    CurrentPowerLimit1Tau,
+    CurrentPowerLimit4Ac,
+    CurrentPowerLimit4Dc,
+    CurrentEnergyThreshold,
+    DisableEnergyThreshold,
+    CurrentEnergyCounter,
+
+    MaxPowerRequests,
+};
+
+enum Activity {
+    NumActivityDomains = 0,
+
+    // default fused values
+    ActivityCounterNumberOfBits,
+    ActivityCounterFrequency,
+    TimestampFrequency,
+
+    // current runtime values
+    CurrentActivityCounter,
+
+    MaxActivityRequests,
+};
+
+enum Temperature {
+    NumTemperatureDomains = 0,
+
+    // support / enabled
+    TempCriticalEventSupported,
+    TempThreshold1EventSupported,
+    TempThreshold2EventSupported,
+    TempCriticalEventEnabled,
+    TempThreshold1EventEnabled,
+    TempThreshold2EventEnabled,
+
+    // default fused values
+    MaxTempSupported,
+
+    // current runtime values
+    CurrentTemperature,
+
+    MaxTemperatureRequests,
+};
+
+enum Frequency {
+    NumFrequencyDomains = 0,
+
+    // support / enabled
+    FrequencyOcSupported,
+    VoltageOverrideSupported,
+    VoltageOffsetSupported,
+    HighVoltageModeSupported,
+    ExtendedOcSupported,
+    FixedModeSupported,
+    HighVoltageEnabled,
+    CanControlFrequency,
+    FrequencyThrottledEventSupported,
+
+    // default fused values
+    TjMaxDefault,
+    IccMaxDefault,
+    MaxOcFrequencyDefault,
+    MaxNonOcFrequencyDefault,
+    MaxOcVoltageDefault,
+    MaxNonOcVoltageDefault,
+    FrequencyRangeMinDefault,
+    FrequencyRangeMaxDefault,
+
+    // current runtime values
+    CurrentFrequencyTarget,
+    CurrentVoltageTarget,
+    CurrentVoltageOffset,
+    CurrentVoltageMode,
+    CurrentFixedMode,
+    CurrentTjMax,
+    CurrentIccMax,
+    CurrentVoltage,
+    CurrentRequestedFrequency,
+    CurrentTdpFrequency,
+    CurrentEfficientFrequency,
+    CurrentResolvedFrequency,
+    CurrentThrottleReasons,
+    CurrentThrottleTime,
+    CurrentFrequencyRange,
+
+    MaxFrequencyRequests,
+};
+
+enum Fans {
+    NumFanDomains = 0,
+
+    // default fused values
+    MaxFanControlPointsSupported,
+    MaxFanSpeedSupported,
+
+    // current runtime values
+    CurrentNumOfControlPoints,
+    CurrentFanPoint,
+    CurrentFanSpeed,
+
+    MaxFanRequests,
+};
+
+enum Fps {
+    NumFpsDomains = 0,
+    IsDisplayAttached,
+    InstRenderTime,
+    TimeToFlip,
+    AvgFps,
+    AvgRenderTime,
+    AvgInstFps,
+
+    MaxFpsRequests,
+};
+
+enum Scheduler {
+    NumSchedulerDomains = 0,
+
+    MaxSchedulerRequests,
+};
+
+enum Memory {
+    NumMemoryDomains = 0,
+
+    // default fused values
+    MemoryType,
+    MemoryLocation,
+    PhysicalSize,
+    StolenSize,
+    SystemSize,
+    DedicatedSize,
+    MemoryWidth,
+    NumChannels,
+    MaxBandwidth,
+
+    // current runtime values
+    CurrentBandwidthRead,
+    CurrentBandwidthWrite,
+    CurrentFreeMemorySize,
+    CurrentTotalAllocableMem,
+
+    MaxMemoryRequests
+};
+
+enum Pci {
+    NumPciDomains = 0,
+
+    // support / enabled
+    BandwidthCountersSupported,
+    PacketCountersSupported,
+    ReplayCountersSupported,
+
+    // default fused values
+    DeviceId,
+    VendorId,
+    Domain,
+    Bus,
+    Device,
+    Function,
+    Gen,
+    DevType,
+    MaxLinkWidth,
+    MaxLinkSpeed,
+    BusInterface,
+    BusWidth,
+    BarType,
+    BarIndex,
+    BarBase,
+    BarSize,
+
+    // current runtime values
+    CurrentLinkWidth,
+    CurrentLinkSpeed,
+    CurrentLinkStatus,
+    CurrentLinkQualityFlags,
+    CurrentLinkStabilityFlags,
+    CurrentLinkReplayCounter,
+    CurrentLinkPacketCounter,
+    CurrentLinkRxCounter,
+    CurrentLinkTxCounter,
+
+    MaxPciRequests,
+};
+} // namespace Requests
+
+enum FlipType {
+    MMIOFlip = 0,
+    MMIOAsyncFlip,
+    DMAFlip,
+    DMAAsyncFlip,
+
+    MaxFlipTypes,
+};
+
+enum GeneralDomainsType {
+    GeneralDomainDGPU = 0,
+    GeneralDomainHBM,
+
+    GeneralDomainMaxTypes,
+};
+
+enum TemperatureDomainsType {
+    TemperatureDomainPackage = 0,
+    TemperatureDomainDGPU,
+    TemperatureDomainHBM,
+
+    TempetatureMaxDomainTypes,
+};
+
+enum ActivityDomainsType {
+    ActitvityDomainGT = 0,
+    ActivityDomainRenderCompute,
+    ActivityDomainMedia,
+
+    ActivityDomainMaxTypes,
+};
+
+enum PciDomainsType {
+    PciCurrentDevice = 0,
+    PciParentDevice,
+    PciRootPort,
+
+    PciDomainMaxTypes,
+};
+
+enum MemoryType {
+    DDR4 = 0,
+    DDR5,
+    LPDDR5,
+    LPDDR4,
+    DDR3,
+    LPDDR3,
+    UknownMemType,
+
+    MaxMemoryTypes,
+};
+
+enum MemoryWidthType {
+    MemWidth8x = 0,
+    MemWidth16x,
+    MemWidth32x,
+
+    UnknownMemWidth,
+
+    MaxMemoryWidthTypes,
+};
+
+enum MemoryLocationsType {
+    SystemMemory = 0,
+    DeviceMemory,
+
+    UnknownMemoryLocation,
+
+    MaxMemoryLocationTypes,
+};
+
+enum PciGensType {
+    PciGen1_1 = 0,
+    PciGen2_0,
+    PciGen3_0,
+    PciGen4_0,
+
+    UnknownPciGen,
+
+    MaxPciGenTypes,
+};
+
+enum PciLinkSpeedType {
+    UnknownPciLinkSpeed = 0,
+    PciLinkSpeed2_5 = 1,
+    PciLinkSpeed5_0,
+    PciLinkSpeed8_0,
+    PciLinkSpeed16_0,
+
+    MaxPciLinkSpeedTypes,
+};
+
+enum PciLinkWidthType {
+    PciLinkWidth1x = 0,
+    PciLinkWidth2x,
+    PciLinkWidth4x,
+    PciLinkWidth8x,
+    PciLinkWidth12x,
+    PciLinkWidth16x,
+    PciLinkWidth32x,
+
+    UnknownPciLinkWidth,
+
+    MaxPciLinkWidthTypes,
+};
+
+struct KmdSysmanVersion {
+    KmdSysmanVersion() : data(0) {}
+    union {
+        struct {
+            uint32_t reservedBits : 8;
+            uint32_t majorVersion : 8;
+            uint32_t minorVersion : 8;
+            uint32_t patchNumber : 8;
+        };
+        uint32_t data;
+    };
+};
+
+struct RequestProperty {
+    RequestProperty() : requestId(0), commandId(0), componentId(0), paramInfo(0), dataSize(0) {}
+    RequestProperty(const RequestProperty &other) {
+        requestId = other.requestId;
+        commandId = other.commandId;
+        componentId = other.componentId;
+        paramInfo = other.paramInfo;
+        dataSize = other.dataSize;
+        if (other.dataSize > 0 && other.dataSize < MaxPropertyBufferSize && other.dataBuffer) {
+            memcpy_s(dataBuffer, other.dataSize, other.dataBuffer, other.dataSize);
+        }
+    }
+    RequestProperty(uint32_t _requestId,
+                    uint32_t _commandId,
+                    uint32_t _componentId,
+                    uint32_t _paramInfo,
+                    uint32_t _dataSize,
+                    uint8_t *_dataBuffer) {
+        requestId = _requestId;
+        commandId = _commandId;
+        componentId = _componentId;
+        paramInfo = _paramInfo;
+        dataSize = _dataSize;
+        if (dataSize > 0 && dataSize < MaxPropertyBufferSize && _dataBuffer) {
+            memcpy_s(dataBuffer, dataSize, _dataBuffer, dataSize);
+        }
+    }
+    RequestProperty &operator=(const RequestProperty &other) {
+        requestId = other.requestId;
+        commandId = other.commandId;
+        componentId = other.componentId;
+        paramInfo = other.paramInfo;
+        dataSize = other.dataSize;
+        if (other.dataSize > 0 && other.dataSize < MaxPropertyBufferSize && other.dataBuffer) {
+            memcpy_s(dataBuffer, other.dataSize, other.dataBuffer, other.dataSize);
+        }
+        return *this;
+    }
+    uint32_t requestId;
+    uint32_t commandId;
+    uint32_t componentId;
+    uint32_t paramInfo;
+    uint32_t dataSize;
+    uint8_t dataBuffer[MaxPropertyBufferSize];
+};
+
+struct ResponseProperty {
+    ResponseProperty() : requestId(0), returnCode(0), componentId(0), dataSize(0) {}
+    ResponseProperty(const ResponseProperty &other) {
+        requestId = other.requestId;
+        returnCode = other.returnCode;
+        componentId = other.componentId;
+        dataSize = other.dataSize;
+        if (other.dataSize > 0 && other.dataSize < MaxPropertyBufferSize && other.dataBuffer) {
+            memcpy_s(dataBuffer, other.dataSize, other.dataBuffer, other.dataSize);
+        }
+    }
+    ResponseProperty(uint32_t _requestId,
+                     uint32_t _returnCode,
+                     uint32_t _componentId,
+                     uint32_t _dataSize,
+                     uint8_t *_dataBuffer) {
+        requestId = _requestId;
+        returnCode = _returnCode;
+        componentId = _componentId;
+        dataSize = _dataSize;
+        if (dataSize > 0 && dataSize < MaxPropertyBufferSize && _dataBuffer) {
+            memcpy_s(dataBuffer, dataSize, _dataBuffer, dataSize);
+        }
+    }
+    ResponseProperty &operator=(const ResponseProperty &other) {
+        this->requestId = other.requestId;
+        this->returnCode = other.returnCode;
+        this->componentId = other.componentId;
+        this->dataSize = other.dataSize;
+        if (other.dataSize > 0 && other.dataSize < MaxPropertyBufferSize && other.dataBuffer) {
+            memcpy_s(this->dataBuffer, other.dataSize, other.dataBuffer, other.dataSize);
+        }
+        return *this;
+    }
+
+    uint32_t requestId;
+    uint32_t returnCode;
+    uint32_t componentId;
+    uint32_t dataSize;
+    uint8_t dataBuffer[MaxPropertyBufferSize];
+};
+} // namespace KmdSysman
+} // namespace L0

level_zero/tools/source/sysman/windows/kmd_sys_manager.cpp

@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/source/sysman/windows/kmd_sys_manager.h"
+
+#include "gfxEscape.h"
+
+namespace L0 {
+struct PcEscapeInfo {
+    GFX_ESCAPE_HEADER_T headerGfx;
+    uint32_t escapeOpInput;
+    uint32_t escapeErrorType;
+
+    uint32_t dataInSize;
+    uint64_t pDataIn;
+
+    uint32_t dataOutSize;
+    uint64_t pDataOut;
+};
+
+uint32_t sumOfBufferData(void *pBuffer, uint32_t bufferSize) {
+    uint32_t index;
+    uint32_t ulCheckSum;
+    uint32_t numOfUnsignedLongs = bufferSize / sizeof(uint32_t);
+    uint32_t *pElement = static_cast<uint32_t *>(pBuffer);
+
+    ulCheckSum = 0;
+    for (index = 0; index < numOfUnsignedLongs; index++) {
+        ulCheckSum += *pElement;
+        pElement++;
+    }
+
+    return ulCheckSum;
+}
+
+KmdSysManager::KmdSysManager(NEO::Wddm *pWddm) {
+    pWddmAccess = pWddm;
+}
+
+KmdSysManager *KmdSysManager::create(NEO::Wddm *pWddm) {
+    return new KmdSysManager(pWddm);
+}
+ze_result_t KmdSysManager::requestSingle(KmdSysman::RequestProperty &inputRequest, KmdSysman::ResponseProperty &outputResponse) {
+    KmdSysman::GfxSysmanMainHeaderIn inMainHeader;
+    KmdSysman::GfxSysmanMainHeaderOut outMainHeader;
+
+    memset(&inMainHeader, 0, sizeof(KmdSysman::GfxSysmanMainHeaderIn));
+    memset(&outMainHeader, 0, sizeof(KmdSysman::GfxSysmanMainHeaderOut));
+
+    std::vector<KmdSysman::RequestProperty> vectorInput;
+    vectorInput.push_back(inputRequest);
+
+    if (!parseBufferIn(&inMainHeader, vectorInput)) {
+        return ZE_RESULT_ERROR_INVALID_SIZE;
+    }
+
+    KmdSysman::KmdSysmanVersion versionKmd;
+    versionKmd.data = 0;
+    versionKmd.majorVersion = KmdSysman::KmdMajorVersion;
+    versionKmd.minorVersion = KmdSysman::KmdMinorVersion;
+    versionKmd.patchNumber = KmdSysman::KmdPatchNumber;
+
+    inMainHeader.inVersion = versionKmd.data;
+    uint64_t inPointerToLongInt = reinterpret_cast<uint64_t>(&inMainHeader);
+    uint64_t outPointerToLongInt = reinterpret_cast<uint64_t>(&outMainHeader);
+    auto status = escape(KmdSysman::PcEscapeOperation, inPointerToLongInt, sizeof(KmdSysman::GfxSysmanMainHeaderIn),
+                         outPointerToLongInt, sizeof(KmdSysman::GfxSysmanMainHeaderOut));
+
+    if (status) {
+        std::vector<KmdSysman::ResponseProperty> vecOutput;
+        if (!parseBufferOut(&outMainHeader, vecOutput)) {
+            return ZE_RESULT_ERROR_INVALID_SIZE;
+        }
+
+        if (vecOutput.size() > 0) {
+            outputResponse = vecOutput[0];
+        } else {
+            return ZE_RESULT_ERROR_INVALID_SIZE;
+        }
+
+        return (outputResponse.returnCode == KmdSysman::KmdSysmanSuccess) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_NOT_AVAILABLE;
+    }
+
+    return (status) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+ze_result_t KmdSysManager::requestMultiple(std::vector<KmdSysman::RequestProperty> &inputRequest, std::vector<KmdSysman::ResponseProperty> &outputResponse) {
+    KmdSysman::GfxSysmanMainHeaderIn inMainHeader;
+    KmdSysman::GfxSysmanMainHeaderOut outMainHeader;
+
+    if (inputRequest.size() == 0) {
+        return ZE_RESULT_ERROR_INVALID_NULL_HANDLE;
+    }
+
+    memset(&inMainHeader, 0, sizeof(KmdSysman::GfxSysmanMainHeaderIn));
+    memset(&outMainHeader, 0, sizeof(KmdSysman::GfxSysmanMainHeaderOut));
+
+    if (!parseBufferIn(&inMainHeader, inputRequest)) {
+        return ZE_RESULT_ERROR_INVALID_SIZE;
+    }
+
+    KmdSysman::KmdSysmanVersion versionKmd;
+    versionKmd.data = 0;
+    versionKmd.majorVersion = 1;
+    versionKmd.minorVersion = 0;
+    versionKmd.patchNumber = 0;
+
+    inMainHeader.inVersion = versionKmd.data;
+    uint64_t inPointerToLongInt = reinterpret_cast<uint64_t>(&inMainHeader);
+    uint64_t outPointerToLongInt = reinterpret_cast<uint64_t>(&outMainHeader);
+    auto status = escape(KmdSysman::PcEscapeOperation, inPointerToLongInt, sizeof(KmdSysman::GfxSysmanMainHeaderIn),
+                         outPointerToLongInt, sizeof(KmdSysman::GfxSysmanMainHeaderOut));
+
+    if (status) {
+        if (!parseBufferOut(&outMainHeader, outputResponse)) {
+            return ZE_RESULT_ERROR_INVALID_SIZE;
+        }
+
+        if (outputResponse.size() == 0) {
+            return ZE_RESULT_ERROR_INVALID_SIZE;
+        }
+    }
+
+    return (status) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_INVALID_ARGUMENT;
+}
+
+bool KmdSysManager::escape(uint32_t escapeOp, uint64_t pDataIn, uint32_t dataInSize, uint64_t pDataOut, uint32_t dataOutSize) {
+    if (pWddmAccess) {
+        D3DKMT_ESCAPE escapeCommand = {0};
+        PcEscapeInfo pcEscape = {0};
+        escapeCommand.Flags.HardwareAccess = 0;
+        escapeCommand.Flags.Reserved = 0;
+        escapeCommand.hAdapter = (D3DKMT_HANDLE)0;
+        escapeCommand.hContext = (D3DKMT_HANDLE)0;
+        escapeCommand.hDevice = (D3DKMT_HANDLE)pWddmAccess->getDevice();
+        escapeCommand.pPrivateDriverData = &pcEscape;
+        escapeCommand.PrivateDriverDataSize = sizeof(pcEscape);
+        escapeCommand.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
+
+        pcEscape.headerGfx.EscapeCode = GFX_ESCAPE_PWRCONS_CONTROL;
+        pcEscape.escapeErrorType = 0;
+        pcEscape.escapeOpInput = escapeOp;
+        pcEscape.headerGfx.Size = sizeof(pcEscape) - sizeof(pcEscape.headerGfx);
+
+        pcEscape.pDataIn = pDataIn;
+        pcEscape.pDataOut = pDataOut;
+
+        pcEscape.dataInSize = dataInSize;
+        pcEscape.dataOutSize = dataOutSize;
+        void *pBuffer = &pcEscape;
+        pBuffer = reinterpret_cast<uint8_t *>(pBuffer) + sizeof(pcEscape.headerGfx);
+        pcEscape.headerGfx.CheckSum = sumOfBufferData(pBuffer, pcEscape.headerGfx.Size);
+
+        auto status = pWddmAccess->escape(escapeCommand);
+        if (status == STATUS_SUCCESS) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool KmdSysManager::parseBufferIn(KmdSysman::GfxSysmanMainHeaderIn *pInMainHeader, std::vector<KmdSysman::RequestProperty> &vectorInput) {
+    memset(pInMainHeader, 0, sizeof(KmdSysman::GfxSysmanMainHeaderIn));
+    for (uint32_t i = 0; i < vectorInput.size(); i++) {
+        KmdSysman::GfxSysmanReqHeaderIn headerIn;
+        headerIn.inRequestId = vectorInput[i].requestId;
+        headerIn.inCommand = vectorInput[i].commandId;
+        headerIn.inComponent = vectorInput[i].componentId;
+        headerIn.inCommandParam = vectorInput[i].paramInfo;
+        headerIn.inDataSize = vectorInput[i].dataSize;
+
+        if ((pInMainHeader->inTotalsize + sizeof(KmdSysman::GfxSysmanReqHeaderIn)) >= KmdSysman::KmdMaxBufferSize) {
+            memset(pInMainHeader, 0, sizeof(KmdSysman::GfxSysmanMainHeaderIn));
+            return false;
+        }
+
+        if ((pInMainHeader->inTotalsize + sizeof(KmdSysman::GfxSysmanReqHeaderIn) + headerIn.inDataSize) >= KmdSysman::KmdMaxBufferSize) {
+            memset(pInMainHeader, 0, sizeof(KmdSysman::GfxSysmanMainHeaderIn));
+            return false;
+        }
+
+        uint8_t *pBuff = reinterpret_cast<uint8_t *>(&pInMainHeader->inBuffer[pInMainHeader->inTotalsize]);
+        memcpy_s(pBuff, sizeof(KmdSysman::GfxSysmanReqHeaderIn), &headerIn, sizeof(KmdSysman::GfxSysmanReqHeaderIn));
+
+        pBuff += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
+        pInMainHeader->inTotalsize += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
+
+        if (headerIn.inDataSize > 0) {
+            memcpy_s(pBuff, headerIn.inDataSize, vectorInput[i].dataBuffer, headerIn.inDataSize);
+            pInMainHeader->inTotalsize += headerIn.inDataSize;
+        }
+
+        pInMainHeader->inNumElements++;
+    }
+
+    return true;
+}
+
+bool KmdSysManager::parseBufferOut(KmdSysman::GfxSysmanMainHeaderOut *pOutMainHeader, std::vector<KmdSysman::ResponseProperty> &vectorOutput) {
+    uint8_t *pBuff = reinterpret_cast<uint8_t *>(pOutMainHeader->outBuffer);
+    uint32_t totalSize = 0;
+    vectorOutput.clear();
+    for (uint32_t i = 0; i < pOutMainHeader->outNumElements; i++) {
+        KmdSysman::ResponseProperty propertyResponse;
+        KmdSysman::GfxSysmanReqHeaderOut headerOut;
+
+        memcpy_s(&headerOut, sizeof(KmdSysman::GfxSysmanReqHeaderOut), pBuff, sizeof(KmdSysman::GfxSysmanReqHeaderOut));
+
+        propertyResponse.requestId = headerOut.outRequestId;
+        propertyResponse.returnCode = headerOut.outReturnCode;
+        propertyResponse.componentId = headerOut.outComponent;
+        propertyResponse.dataSize = headerOut.outDataSize;
+
+        pBuff += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
+
+        if (headerOut.outDataSize > 0) {
+            memcpy_s(propertyResponse.dataBuffer, headerOut.outDataSize, pBuff, headerOut.outDataSize);
+            pBuff += headerOut.outDataSize;
+        }
+
+        vectorOutput.push_back(propertyResponse);
+
+        totalSize += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
+        totalSize += headerOut.outDataSize;
+    }
+
+    if (totalSize != pOutMainHeader->outTotalSize) {
+        vectorOutput.clear();
+        return false;
+    }
+
+    return true;
+}
+
+} // namespace L0

level_zero/tools/source/sysman/windows/kmd_sys_manager.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "shared/source/os_interface/windows/os_interface.h"
+#include "shared/source/os_interface/windows/wddm/wddm.h"
+
+#include "level_zero/tools/source/sysman/windows/kmd_sys.h"
+#include "level_zero/ze_api.h"
+#include "level_zero/zet_api.h"
+
+#include <string>
+#include <vector>
+
+namespace L0 {
+class KmdSysManager {
+  public:
+    static KmdSysManager *create(NEO::Wddm *pWddm);
+    KmdSysManager() = default;
+    ~KmdSysManager() = default;
+
+    MOCKABLE_VIRTUAL ze_result_t requestSingle(KmdSysman::RequestProperty &In, KmdSysman::ResponseProperty &Out);
+    ze_result_t requestMultiple(std::vector<KmdSysman::RequestProperty> &vIn, std::vector<KmdSysman::ResponseProperty> &vOut);
+
+  private:
+    MOCKABLE_VIRTUAL bool escape(uint32_t escapeOp, uint64_t pDataIn, uint32_t dataInSize, uint64_t pDataOut, uint32_t dataOutSize);
+
+    bool parseBufferIn(KmdSysman::GfxSysmanMainHeaderIn *pIn, std::vector<KmdSysman::RequestProperty> &vIn);
+    bool parseBufferOut(KmdSysman::GfxSysmanMainHeaderOut *pOut, std::vector<KmdSysman::ResponseProperty> &vOut);
+
+    KmdSysManager(NEO::Wddm *pWddm);
+    NEO::Wddm *pWddmAccess = nullptr;
+};
+} // namespace L0

level_zero/tools/source/sysman/windows/os_sysman_imp.cpp

@@ -10,9 +10,41 @@
 namespace L0 {
 
 ze_result_t WddmSysmanImp::init() {
+    Device *pDevice = nullptr;
+    if (pParentSysmanImp != nullptr) {
+        pDevice = Device::fromHandle(pParentSysmanImp->hCoreDevice);
+    } else if (pParentSysmanDeviceImp != nullptr) {
+        pDevice = Device::fromHandle(pParentSysmanDeviceImp->hCoreDevice);
+    } else {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+    UNRECOVERABLE_IF(nullptr == pDevice);
+
+    NEO::OSInterface &OsInterface = pDevice->getOsInterface();
+    pWddm = OsInterface.get()->getWddm();
+    pKmdSysManager = KmdSysManager::create(pWddm);
+    UNRECOVERABLE_IF(nullptr == pKmdSysManager);
+
     return ZE_RESULT_SUCCESS;
 }
 
+NEO::Wddm &WddmSysmanImp::getWddm() {
+    UNRECOVERABLE_IF(nullptr == pWddm);
+    return *pWddm;
+}
+
+KmdSysManager &WddmSysmanImp::getKmdSysManager() {
+    UNRECOVERABLE_IF(nullptr == pKmdSysManager);
+    return *pKmdSysManager;
+}
+
+WddmSysmanImp::~WddmSysmanImp() {
+    if (nullptr != pKmdSysManager) {
+        delete pKmdSysManager;
+        pKmdSysManager = nullptr;
+    }
+}
+
 OsSysman *OsSysman::create(SysmanImp *pParentSysmanImp) {
     WddmSysmanImp *pWddmSysmanImp = new WddmSysmanImp(pParentSysmanImp);
     return static_cast<OsSysman *>(pWddmSysmanImp);

level_zero/tools/source/sysman/windows/os_sysman_imp.h

@@ -7,23 +7,34 @@
 
 #pragma once
 #include "shared/source/helpers/non_copyable_or_moveable.h"
+#include "shared/source/os_interface/windows/os_interface.h"
+#include "shared/source/os_interface/windows/wddm/wddm.h"
 
 #include "level_zero/tools/source/sysman/sysman_imp.h"
+#include "level_zero/tools/source/sysman/windows/kmd_sys.h"
+#include "level_zero/tools/source/sysman/windows/kmd_sys_manager.h"
 
 namespace L0 {
 
 class WddmSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
   public:
+    WddmSysmanImp() = default;
     WddmSysmanImp(SysmanImp *pParentSysmanImp) : pParentSysmanImp(pParentSysmanImp){};
     WddmSysmanImp(SysmanDeviceImp *pParentSysmanDeviceImp) : pParentSysmanDeviceImp(pParentSysmanDeviceImp){};
-    ~WddmSysmanImp() override = default;
+    ~WddmSysmanImp() override;
 
     ze_result_t init() override;
 
+    KmdSysManager &getKmdSysManager();
+    NEO::Wddm &getWddm();
+
+  protected:
+    KmdSysManager *pKmdSysManager = nullptr;
+
   private:
-    WddmSysmanImp() = delete;
     SysmanImp *pParentSysmanImp = nullptr;
     SysmanDeviceImp *pParentSysmanDeviceImp = nullptr;
+    NEO::Wddm *pWddm = nullptr;
 };
 
 } // namespace L0