From 33a587c7048d877fb617f55b02be05ee9712762b Mon Sep 17 00:00:00 2001 From: "Spruit, Neil R" Date: Fri, 15 Jul 2022 01:28:43 +0000 Subject: [PATCH] L0 to read Device LUID from the WDDM driver given Debug Variable - Added Support for reading the Device LUID of the given device used in Windows WDDM given EnableL0ReadLUIDExtension=1. - Added inital support for passing back the NodeMask of 1. Signed-off-by: Spruit, Neil R --- level_zero/core/source/CMakeLists.txt | 1 + level_zero/core/source/device/device_imp.cpp | 14 ++ level_zero/core/source/device/device_imp.h | 3 + .../device/device_imp_drm/device_imp.cpp | 16 ++ .../device_imp_drm_or_wddm/device_imp.cpp | 36 +++++ .../device/device_imp_wddm/device_imp.cpp | 28 ++++ .../unit_tests/sources/device/CMakeLists.txt | 1 + .../sources/device/device_drm/test_device.cpp | 49 ++++++ .../device/device_drm_or_wddm/test_device.cpp | 143 ++++++++++++++++++ .../device/device_wddm/test_device.cpp | 117 ++++++++++++++ .../unit_tests/sources/device/test_device.cpp | 9 ++ .../debug_settings/debug_variables_base.inl | 1 + .../os_interface/windows/os_context_win.cpp | 17 +++ .../os_interface/windows/os_context_win.h | 1 + .../os_interface/windows/wddm_fixture.h | 32 ++++ shared/test/common/test_files/igdrcl.config | 1 + .../os_interface/windows/wddm_tests.cpp | 13 ++ 17 files changed, 482 insertions(+) create mode 100644 level_zero/core/source/device/device_imp_drm/device_imp.cpp create mode 100644 level_zero/core/source/device/device_imp_drm_or_wddm/device_imp.cpp create mode 100644 level_zero/core/source/device/device_imp_wddm/device_imp.cpp create mode 100644 level_zero/core/test/unit_tests/sources/device/device_drm/test_device.cpp create mode 100644 level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device.cpp create mode 100644 level_zero/core/test/unit_tests/sources/device/device_wddm/test_device.cpp diff --git a/level_zero/core/source/CMakeLists.txt b/level_zero/core/source/CMakeLists.txt index 6205b66c9c..fe00642916 100644 --- a/level_zero/core/source/CMakeLists.txt +++ b/level_zero/core/source/CMakeLists.txt @@ -37,6 +37,7 @@ set(L0_RUNTIME_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/device/bcs_split.cpp ${CMAKE_CURRENT_SOURCE_DIR}/device/bcs_split.h ${CMAKE_CURRENT_SOURCE_DIR}/device/device.h + ${CMAKE_CURRENT_SOURCE_DIR}/device/device_imp_${DRIVER_MODEL}/device_imp.cpp ${CMAKE_CURRENT_SOURCE_DIR}/device/device_imp.cpp ${CMAKE_CURRENT_SOURCE_DIR}/device/device_imp.h ${CMAKE_CURRENT_SOURCE_DIR}/driver/driver_handle.h diff --git a/level_zero/core/source/device/device_imp.cpp b/level_zero/core/source/device/device_imp.cpp index ffac5aab7d..81b786d230 100644 --- a/level_zero/core/source/device/device_imp.cpp +++ b/level_zero/core/source/device/device_imp.cpp @@ -724,6 +724,20 @@ ze_result_t DeviceImp::getProperties(ze_device_properties_t *pDeviceProperties) name.assign(driverInfo->getDeviceName(name).c_str()); } memcpy_s(pDeviceProperties->name, ZE_MAX_DEVICE_NAME, name.c_str(), name.length() + 1); + if (NEO::DebugManager.flags.EnableL0ReadLUIDExtension.get()) { + if (pDeviceProperties->pNext) { + ze_base_properties_t *extendedProperties = reinterpret_cast(pDeviceProperties->pNext); + if (extendedProperties->stype == ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES) { + ze_device_luid_ext_properties_t *deviceLuidProperties = + reinterpret_cast(extendedProperties); + ze_result_t result = queryDeviceLuid(deviceLuidProperties); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + deviceLuidProperties->nodeMask = 1; + } + } + } return ZE_RESULT_SUCCESS; } diff --git a/level_zero/core/source/device/device_imp.h b/level_zero/core/source/device/device_imp.h index 61684e8f57..26725c54a8 100644 --- a/level_zero/core/source/device/device_imp.h +++ b/level_zero/core/source/device/device_imp.h @@ -138,6 +138,9 @@ struct DeviceImp : public Device { CmdListCreateFunPtrT getCmdListCreateFunc(const ze_command_list_desc_t *desc); FabricVertex *fabricVertex = nullptr; + ze_result_t queryDeviceLuid(ze_device_luid_ext_properties_t *deviceLuidProperties); + ze_result_t setDeviceLuid(ze_device_luid_ext_properties_t *deviceLuidProperties); + protected: void adjustCommandQueueDesc(uint32_t &ordinal, uint32_t &index); NEO::EngineGroupType getEngineGroupTypeForOrdinal(uint32_t ordinal) const; diff --git a/level_zero/core/source/device/device_imp_drm/device_imp.cpp b/level_zero/core/source/device/device_imp_drm/device_imp.cpp new file mode 100644 index 0000000000..b0d5b4f3b0 --- /dev/null +++ b/level_zero/core/source/device/device_imp_drm/device_imp.cpp @@ -0,0 +1,16 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/core/source/device/device_imp.h" + +namespace L0 { + +ze_result_t DeviceImp::queryDeviceLuid(ze_device_luid_ext_properties_t *deviceLuidProperties) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +} // namespace L0 \ No newline at end of file diff --git a/level_zero/core/source/device/device_imp_drm_or_wddm/device_imp.cpp b/level_zero/core/source/device/device_imp_drm_or_wddm/device_imp.cpp new file mode 100644 index 0000000000..09829931b3 --- /dev/null +++ b/level_zero/core/source/device/device_imp_drm_or_wddm/device_imp.cpp @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/core/source/device/device_imp.h" + +#include "shared/source/command_stream/command_stream_receiver.h" +#include "shared/source/os_interface/os_interface.h" +#include "shared/source/os_interface/windows/hw_device_id.h" +#include "shared/source/os_interface/windows/os_context_win.h" +#include "shared/source/os_interface/windows/wddm/wddm.h" + +namespace L0 { + +ze_result_t DeviceImp::queryDeviceLuid(ze_device_luid_ext_properties_t *deviceLuidProperties) { + NEO::Device *activeDevice = getActiveDevice(); + if (activeDevice->getRootDeviceEnvironment().osInterface) { + NEO::DriverModelType driverType = neoDevice->getRootDeviceEnvironment().osInterface->getDriverModel()->getDriverModelType(); + if (driverType == NEO::DriverModelType::WDDM) { + NEO::CommandStreamReceiver *csr = activeDevice->getDefaultEngine().commandStreamReceiver; + NEO::OsContextWin *context = static_cast(&csr->getOsContext()); + std::vector luidData; + context->getDeviceLuidArray(luidData, ZE_MAX_DEVICE_LUID_SIZE_EXT); + std::copy_n(luidData.begin(), ZE_MAX_DEVICE_LUID_SIZE_EXT, std::begin(deviceLuidProperties->luid.id)); + return ZE_RESULT_SUCCESS; + } else { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + } + return ZE_RESULT_ERROR_UNINITIALIZED; +} + +} // namespace L0 \ No newline at end of file diff --git a/level_zero/core/source/device/device_imp_wddm/device_imp.cpp b/level_zero/core/source/device/device_imp_wddm/device_imp.cpp new file mode 100644 index 0000000000..c0366681b7 --- /dev/null +++ b/level_zero/core/source/device/device_imp_wddm/device_imp.cpp @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/core/source/device/device_imp.h" + +#include "shared/source/command_stream/command_stream_receiver.h" +#include "shared/source/os_interface/os_context.h" +#include "shared/source/os_interface/windows/hw_device_id.h" +#include "shared/source/os_interface/windows/os_context_win.h" +#include "shared/source/os_interface/windows/wddm/wddm.h" + +namespace L0 { + +ze_result_t DeviceImp::queryDeviceLuid(ze_device_luid_ext_properties_t *deviceLuidProperties) { + NEO::Device *activeDevice = getActiveDevice(); + NEO::CommandStreamReceiver *csr = activeDevice->getDefaultEngine().commandStreamReceiver; + NEO::OsContextWin *context = static_cast(&csr->getOsContext()); + std::vector luidData; + context->getDeviceLuidArray(luidData, ZE_MAX_DEVICE_LUID_SIZE_EXT); + std::copy_n(luidData.begin(), ZE_MAX_DEVICE_LUID_SIZE_EXT, std::begin(deviceLuidProperties->luid.id)); + return ZE_RESULT_SUCCESS; +} + +} // namespace L0 \ No newline at end of file diff --git a/level_zero/core/test/unit_tests/sources/device/CMakeLists.txt b/level_zero/core/test/unit_tests/sources/device/CMakeLists.txt index 5010044caa..064c911643 100644 --- a/level_zero/core/test/unit_tests/sources/device/CMakeLists.txt +++ b/level_zero/core/test/unit_tests/sources/device/CMakeLists.txt @@ -9,5 +9,6 @@ target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test_device.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_device_pci_speed_info.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_device_pci_speed_info.h + ${CMAKE_CURRENT_SOURCE_DIR}/device_${DRIVER_MODEL}/test_device.cpp ) add_subdirectories() diff --git a/level_zero/core/test/unit_tests/sources/device/device_drm/test_device.cpp b/level_zero/core/test/unit_tests/sources/device/device_drm/test_device.cpp new file mode 100644 index 0000000000..2fa49cd7e5 --- /dev/null +++ b/level_zero/core/test/unit_tests/sources/device/device_drm/test_device.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2020-2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/test/common/mocks/mock_device.h" +#include "shared/test/common/mocks/mock_driver_info.h" +#include "shared/test/common/mocks/mock_driver_model.h" +#include "shared/test/common/test_macros/hw_test.h" + +#include "level_zero/core/source/driver/driver_handle_imp.h" +#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" +#include "level_zero/core/test/unit_tests/mocks/mock_built_ins.h" +#include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h" + +#include "gtest/gtest.h" + +namespace L0 { +namespace ult { + +using LuidDeviceTest = Test; + +TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureAndDRMDriverTypeThenUnsupportedReturned) { + DebugManager.flags.EnableL0ReadLUIDExtension.set(true); + neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new NEO::OSInterface()); + neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::make_unique()); + ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; + ze_device_luid_ext_properties_t deviceLuidProperties = {ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES}; + deviceProperties.pNext = &deviceLuidProperties; + ze_result_t result = device->getProperties(&deviceProperties); + EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + DebugManager.flags.EnableL0ReadLUIDExtension.set(false); +} + +TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureAndDebugVariableFalseThenSuccessReturned) { + DebugManager.flags.EnableL0ReadLUIDExtension.set(false); + neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new NEO::OSInterface()); + neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::make_unique()); + ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; + ze_device_luid_ext_properties_t deviceLuidProperties = {ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES}; + deviceProperties.pNext = &deviceLuidProperties; + ze_result_t result = device->getProperties(&deviceProperties); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); +} + +} // namespace ult +} // namespace L0 \ No newline at end of file diff --git a/level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device.cpp b/level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device.cpp new file mode 100644 index 0000000000..fd8b11ae42 --- /dev/null +++ b/level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device.cpp @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/os_interface/windows/gdi_interface.h" +#include "shared/source/os_interface/windows/hw_device_id.h" +#include "shared/source/os_interface/windows/os_context_win.h" +#include "shared/source/os_interface/windows/os_environment_win.h" +#include "shared/source/os_interface/windows/wddm/wddm.h" +#include "shared/test/common/helpers/engine_descriptor_helper.h" +#include "shared/test/common/mocks/mock_device.h" +#include "shared/test/common/mocks/mock_driver_info.h" +#include "shared/test/common/mocks/mock_driver_model.h" +#include "shared/test/common/test_macros/hw_test.h" + +#include "level_zero/core/source/driver/driver_handle_imp.h" +#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" +#include "level_zero/core/test/unit_tests/mocks/mock_built_ins.h" +#include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h" + +#include "gtest/gtest.h" + +namespace L0 { +namespace ult { + +#define ADAPTER_HANDLE_WDDM_FAKE (static_cast(0x40001234)) + +struct CloseAdapterMock { + static NTSTATUS(APIENTRY closeAdapter)( + const D3DKMT_CLOSEADAPTER *closeAdapter) { + return STATUS_SUCCESS; + } +}; + +struct MockHwDeviceIdWddm : public HwDeviceIdWddm { + using HwDeviceIdWddm::osEnvironment; + MockHwDeviceIdWddm(D3DKMT_HANDLE adapterIn, LUID adapterLuidIn, OsEnvironment *osEnvironmentIn, std::unique_ptr umKmDataTranslator) : HwDeviceIdWddm(adapterIn, adapterLuidIn, osEnvironmentIn, std::move(umKmDataTranslator)) {} +}; + +class MockDriverModelWDDMLUID : public NEO::Wddm { + public: + MockDriverModelWDDMLUID(std::unique_ptr &&hwDeviceId, RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(std::move(hwDeviceId), rootDeviceEnvironment) { + } + bool init() { + return true; + } + + bool isDriverAvaliable() override { + return false; + } + + bool skipResourceCleanup() { + return true; + } + + MockDriverModelWDDMLUID(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(std::make_unique(ADAPTER_HANDLE_WDDM_FAKE, LUID{0x12, 0x1234}, rootDeviceEnvironment.executionEnvironment.osEnvironment.get(), std::make_unique()), rootDeviceEnvironment) { + if (!rootDeviceEnvironment.executionEnvironment.osEnvironment.get()) { + rootDeviceEnvironment.executionEnvironment.osEnvironment = std::make_unique(); + } + static_cast(this->hwDeviceId.get())->osEnvironment = rootDeviceEnvironment.executionEnvironment.osEnvironment.get(); + OsEnvironmentWin *osEnvWin = reinterpret_cast(static_cast(this->hwDeviceId.get())->osEnvironment); + osEnvWin->gdi.get()->closeAdapter.mFunc = CloseAdapterMock::closeAdapter; + } +}; + +class MockOsContextWin : public OsContextWin { + public: + MockOsContextWin(MockDriverModelWDDMLUID &wddm, uint32_t contextId, const EngineDescriptor &engineDescriptor) + : OsContextWin(wddm, contextId, engineDescriptor) {} +}; + +using LuidDeviceTest = Test; + +TEST_F(LuidDeviceTest, givenOsContextWinAndGetLUIDArrayThenLUIDisValid) { + DebugManager.flags.EnableL0ReadLUIDExtension.set(true); + auto luidMock = new MockDriverModelWDDMLUID(*neoDevice->executionEnvironment->rootDeviceEnvironments[0]); + auto defaultEngine = defaultHwInfo->capabilityTable.defaultEngineType; + OsContextWin osContext(*luidMock, 0u, EngineDescriptorHelper::getDefaultDescriptor({defaultEngine, EngineUsage::Regular})); + std::vector luidData; + size_t arraySize = 8; + osContext.getDeviceLuidArray(luidData, arraySize); + uint64_t luid = 0; + memcpy_s(&luid, sizeof(uint64_t), luidData.data(), sizeof(uint8_t) * luidData.size()); + EXPECT_NE(luid, (uint64_t)0); + delete luidMock; + DebugManager.flags.EnableL0ReadLUIDExtension.set(false); +} + +TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureAndWDDMDriverTypeThenSuccessReturned) { + DebugManager.flags.EnableL0ReadLUIDExtension.set(true); + auto defaultEngine = defaultHwInfo->capabilityTable.defaultEngineType; + auto luidMock = new MockDriverModelWDDMLUID(*neoDevice->executionEnvironment->rootDeviceEnvironments[0]); + neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new NEO::OSInterface()); + neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr(luidMock)); + MockOsContextWin mockContext(*luidMock, 0u, EngineDescriptorHelper::getDefaultDescriptor({defaultEngine, EngineUsage::Regular})); + auto &deviceRegularEngines = neoDevice->getRegularEngineGroups(); + auto &deviceEngine = deviceRegularEngines[0].engines[0]; + auto csr = deviceEngine.commandStreamReceiver; + csr->setupContext(mockContext); + ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; + ze_device_luid_ext_properties_t deviceLuidProperties = {ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES}; + deviceProperties.pNext = &deviceLuidProperties; + ze_result_t result = device->getProperties(&deviceProperties); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + uint64_t luid = 0; + LUID adapterLuid{0x12, 0x1234}; + memcpy_s(&luid, sizeof(uint64_t), &deviceLuidProperties.luid, sizeof(deviceLuidProperties.luid)); + uint32_t lowLUID = luid & 0xFFFFFFFF; + uint32_t highLUID = ((luid & 0xFFFFFFFF00000000) >> 32); + EXPECT_EQ(lowLUID, (uint32_t)adapterLuid.LowPart); + EXPECT_EQ(highLUID, (uint32_t)adapterLuid.HighPart); + EXPECT_NE(deviceLuidProperties.nodeMask, (uint32_t)0); + DebugManager.flags.EnableL0ReadLUIDExtension.set(false); +} + +TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureAndDRMDriverTypeThenUnsupportedReturned) { + DebugManager.flags.EnableL0ReadLUIDExtension.set(true); + neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new NEO::OSInterface()); + neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::make_unique()); + ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; + ze_device_luid_ext_properties_t deviceLuidProperties = {ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES}; + deviceProperties.pNext = &deviceLuidProperties; + ze_result_t result = device->getProperties(&deviceProperties); + EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + DebugManager.flags.EnableL0ReadLUIDExtension.set(false); +} + +TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureAndAndNoOsInterfaceThenUninitReturned) { + DebugManager.flags.EnableL0ReadLUIDExtension.set(true); + neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(nullptr); + ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; + ze_device_luid_ext_properties_t deviceLuidProperties = {ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES}; + deviceProperties.pNext = &deviceLuidProperties; + ze_result_t result = device->getProperties(&deviceProperties); + EXPECT_EQ(result, ZE_RESULT_ERROR_UNINITIALIZED); + DebugManager.flags.EnableL0ReadLUIDExtension.set(false); +} + +} // namespace ult +} // namespace L0 \ No newline at end of file diff --git a/level_zero/core/test/unit_tests/sources/device/device_wddm/test_device.cpp b/level_zero/core/test/unit_tests/sources/device/device_wddm/test_device.cpp new file mode 100644 index 0000000000..a3b20b4017 --- /dev/null +++ b/level_zero/core/test/unit_tests/sources/device/device_wddm/test_device.cpp @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/command_container/implicit_scaling.h" +#include "shared/source/command_stream/wait_status.h" +#include "shared/source/device/root_device.h" +#include "shared/source/helpers/bindless_heaps_helper.h" +#include "shared/source/helpers/hw_helper.h" +#include "shared/source/helpers/hw_info.h" +#include "shared/source/helpers/preamble.h" +#include "shared/source/os_interface/hw_info_config.h" +#include "shared/source/os_interface/os_inc_base.h" +#include "shared/source/os_interface/os_time.h" +#include "shared/source/os_interface/windows/hw_device_id.h" +#include "shared/source/os_interface/windows/os_context_win.h" +#include "shared/source/os_interface/windows/os_environment_win.h" +#include "shared/source/os_interface/windows/wddm/wddm.h" +#include "shared/source/os_interface/windows/wddm/wddm_interface.h" +#include "shared/test/common/helpers/debug_manager_state_restore.h" +#include "shared/test/common/helpers/engine_descriptor_helper.h" +#include "shared/test/common/helpers/mock_hw_info_config_hw.h" +#include "shared/test/common/libult/ult_command_stream_receiver.h" +#include "shared/test/common/mock_gdi/mock_gdi.h" +#include "shared/test/common/mocks/mock_compilers.h" +#include "shared/test/common/mocks/mock_device.h" +#include "shared/test/common/mocks/mock_driver_info.h" +#include "shared/test/common/mocks/mock_driver_model.h" +#include "shared/test/common/mocks/mock_memory_manager.h" +#include "shared/test/common/mocks/mock_os_context.h" +#include "shared/test/common/mocks/mock_sip.h" +#include "shared/test/common/mocks/mock_wddm.h" +#include "shared/test/common/mocks/ult_device_factory.h" +#include "shared/test/common/mocks/windows/mock_gdi_interface.h" +#include "shared/test/common/test_macros/hw_test.h" + +#include "level_zero/core/source/cache/cache_reservation.h" +#include "level_zero/core/source/cmdqueue/cmdqueue_imp.h" +#include "level_zero/core/source/context/context_imp.h" +#include "level_zero/core/source/driver/driver_handle_imp.h" +#include "level_zero/core/source/driver/host_pointer_manager.h" +#include "level_zero/core/source/image/image.h" +#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" +#include "level_zero/core/test/unit_tests/mocks/mock_built_ins.h" +#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h" +#include "level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h" +#include "level_zero/core/test/unit_tests/mocks/mock_context.h" +#include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h" +#include "level_zero/core/test/unit_tests/mocks/mock_memory_manager.h" + +#include "gtest/gtest.h" + +namespace NEO { +std::unique_ptr createHwDeviceIdFromAdapterLuid(OsEnvironmentWin &osEnvironment, LUID adapterLuid); +} // namespace NEO + +namespace L0 { +namespace ult { + +struct LuidDeviceTest : public ::testing::Test { + void SetUp() override {} + void TearDown() override {} +}; + +TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureThenLuidAndNodeMaskSetForWDDMDriverType) { + DebugManager.flags.EnableL0ReadLUIDExtension.set(true); + NEO::MockDevice *neoDevice = nullptr; + std::unique_ptr> driverHandle; + L0::Device *device = nullptr; + WddmMock *luidMock = nullptr; + + auto gdi = new MockGdi(); + auto osEnvironment = new OsEnvironmentWin(); + osEnvironment->gdi.reset(gdi); + + auto mockBuiltIns = new MockBuiltins(); + auto executionEnvironment = MockDevice::prepareExecutionEnvironment(NEO::defaultHwInfo.get(), 0u); + executionEnvironment->prepareRootDeviceEnvironments(1); + executionEnvironment->rootDeviceEnvironments[0]->builtins.reset(mockBuiltIns); + executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get()); + + executionEnvironment->osEnvironment.reset(osEnvironment); + auto osInterface = new OSInterface(); + luidMock = new WddmMock(*executionEnvironment->rootDeviceEnvironments[0]); + LUID adapterLuid = {0x12, 0x1234}; + luidMock->hwDeviceId = NEO::createHwDeviceIdFromAdapterLuid(*osEnvironment, adapterLuid); + executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(osInterface); + executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr(luidMock)); + luidMock->init(); + neoDevice = NEO::MockDevice::createWithExecutionEnvironment(NEO::defaultHwInfo.get(), executionEnvironment, 0u); + + NEO::DeviceVector devices; + devices.push_back(std::unique_ptr(neoDevice)); + driverHandle = std::make_unique>(); + driverHandle->initialize(std::move(devices)); + device = driverHandle->devices[0]; + + ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; + ze_device_luid_ext_properties_t deviceLuidProperties = {ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES}; + deviceProperties.pNext = &deviceLuidProperties; + ze_result_t result = device->getProperties(&deviceProperties); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + uint64_t luid = 0; + memcpy_s(&luid, sizeof(uint64_t), &deviceLuidProperties.luid, sizeof(deviceLuidProperties.luid)); + uint32_t lowLUID = luid & 0xFFFFFFFF; + uint32_t highLUID = ((luid & 0xFFFFFFFF00000000) >> 32); + EXPECT_EQ(lowLUID, (uint32_t)adapterLuid.LowPart); + EXPECT_EQ(highLUID, (uint32_t)adapterLuid.HighPart); + EXPECT_NE(deviceLuidProperties.nodeMask, (uint32_t)0); + DebugManager.flags.EnableL0ReadLUIDExtension.set(false); +} + +} // namespace ult +} // namespace L0 \ No newline at end of file diff --git a/level_zero/core/test/unit_tests/sources/device/test_device.cpp b/level_zero/core/test/unit_tests/sources/device/test_device.cpp index 0e267568e9..97e91fa933 100644 --- a/level_zero/core/test/unit_tests/sources/device/test_device.cpp +++ b/level_zero/core/test/unit_tests/sources/device/test_device.cpp @@ -1148,6 +1148,15 @@ TEST_F(DeviceTest, givenNodeOrdinalFlagWhenCallAdjustCommandQueueDescThenDescOrd EXPECT_EQ(desc.ordinal, expectedOrdinal); } +using InvalidExtensionTest = DeviceTest; +TEST_F(InvalidExtensionTest, givenInvalidExtensionPropertiesDuringDeviceGetPropertiesThenPropertiesIgnoredWithSuccess) { + ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; + ze_device_properties_t invalidExtendedProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; + deviceProperties.pNext = &invalidExtendedProperties; + ze_result_t result = device->getProperties(&deviceProperties); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); +} + HWTEST_F(DeviceTest, givenNodeOrdinalFlagWhenCallAdjustCommandQueueDescThenDescOrdinalAndDescIndexProperlySet) { DebugManagerStateRestore restore; struct MockHwHelper : NEO::HwHelperHw { diff --git a/shared/source/debug_settings/debug_variables_base.inl b/shared/source/debug_settings/debug_variables_base.inl index 3b63a3129e..66a8cc198d 100644 --- a/shared/source/debug_settings/debug_variables_base.inl +++ b/shared/source/debug_settings/debug_variables_base.inl @@ -331,6 +331,7 @@ DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionDisablePrefetcher, -1, "-1: defa DECLARE_DEBUG_VARIABLE(bool, DirectSubmissionPrintBuffers, false, "Print address of submitted command buffers") /*FEATURE FLAGS*/ +DECLARE_DEBUG_VARIABLE(bool, EnableL0ReadLUIDExtension, false, "Enables Support for L0 Extension for reading the LUID from WDDM.") DECLARE_DEBUG_VARIABLE(bool, USMEvictAfterMigration, false, "Evict USM allocation after implicit migration to GPU") DECLARE_DEBUG_VARIABLE(bool, EnableNV12, true, "Enables NV12 extension") DECLARE_DEBUG_VARIABLE(bool, EnablePackedYuv, true, "Enables cl_packed_yuv extension") diff --git a/shared/source/os_interface/windows/os_context_win.cpp b/shared/source/os_interface/windows/os_context_win.cpp index 26f83de2d3..a2a16f2dcd 100644 --- a/shared/source/os_interface/windows/os_context_win.cpp +++ b/shared/source/os_interface/windows/os_context_win.cpp @@ -52,6 +52,23 @@ void OsContextWin::reInitializeContext() { UNRECOVERABLE_IF(!wddm.createContext(*this)); }; +void OsContextWin::getDeviceLuidArray(std::vector &luidData, size_t arraySize) { + auto *wddm = this->getWddm(); + auto *hwDeviceID = wddm->getHwDeviceId(); + auto luid = hwDeviceID->getAdapterLuid(); + luidData.reserve(arraySize); + for (size_t i = 0; i < arraySize; i++) { + char *luidArray = nullptr; + if (i < 4) { + luidArray = (char *)&luid.LowPart; + luidData.emplace(luidData.end(), luidArray[i]); + } else { + luidArray = (char *)&luid.HighPart; + luidData.emplace(luidData.end(), luidArray[i - 4]); + } + } +}; + OsContextWin::~OsContextWin() { if (contextInitialized && (false == this->wddm.skipResourceCleanup())) { wddm.getWddmInterface()->destroyHwQueue(hardwareQueue.handle); diff --git a/shared/source/os_interface/windows/os_context_win.h b/shared/source/os_interface/windows/os_context_win.h index 53ced20929..29276002e3 100644 --- a/shared/source/os_interface/windows/os_context_win.h +++ b/shared/source/os_interface/windows/os_context_win.h @@ -35,6 +35,7 @@ class OsContextWin : public OsContext { MOCKABLE_VIRTUAL WddmResidencyController &getResidencyController() { return residencyController; } static OsContext *create(OSInterface *osInterface, uint32_t contextId, const EngineDescriptor &engineDescriptor); void reInitializeContext() override; + void getDeviceLuidArray(std::vector &luidData, size_t arraySize); protected: void initializeContext() override; diff --git a/shared/test/common/os_interface/windows/wddm_fixture.h b/shared/test/common/os_interface/windows/wddm_fixture.h index 7050834eb5..0f1bfe9996 100644 --- a/shared/test/common/os_interface/windows/wddm_fixture.h +++ b/shared/test/common/os_interface/windows/wddm_fixture.h @@ -61,6 +61,38 @@ struct WddmFixture : public Test { MockWddmResidentAllocationsContainer *mockTemporaryResources; }; +struct WddmFixtureLuid : public Test { + void SetUp() override { + MockExecutionEnvironmentGmmFixture::setUp(); + rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[0].get(); + osEnvironment = new OsEnvironmentWin(); + gdi = new MockGdi(); + osEnvironment->gdi.reset(gdi); + executionEnvironment->osEnvironment.reset(osEnvironment); + wddm = static_cast(Wddm::createWddm(nullptr, *rootDeviceEnvironment)); + rootDeviceEnvironment->osInterface = std::make_unique(); + rootDeviceEnvironment->osInterface->setDriverModel(std::unique_ptr(wddm)); + rootDeviceEnvironment->memoryOperationsInterface = std::make_unique(wddm); + osInterface = rootDeviceEnvironment->osInterface.get(); + auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo); + wddm->init(); + auto hwInfo = rootDeviceEnvironment->getHardwareInfo(); + auto engine = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0]; + osContext = std::make_unique(*osInterface->getDriverModel()->as(), 0u, EngineDescriptorHelper::getDefaultDescriptor(engine, preemptionMode)); + osContext->ensureContextInitialized(); + mockTemporaryResources = static_cast(wddm->temporaryResources.get()); + } + + WddmMock *wddm = nullptr; + OSInterface *osInterface; + RootDeviceEnvironment *rootDeviceEnvironment = nullptr; + OsEnvironmentWin *osEnvironment = nullptr; + std::unique_ptr osContext; + + MockGdi *gdi = nullptr; + MockWddmResidentAllocationsContainer *mockTemporaryResources; +}; + struct WddmFixtureWithMockGdiDll : public GdiDllFixture, public MockExecutionEnvironmentGmmFixture { void setUp() { MockExecutionEnvironmentGmmFixture::setUp(); diff --git a/shared/test/common/test_files/igdrcl.config b/shared/test/common/test_files/igdrcl.config index 5a3721eedc..53e530d0ff 100644 --- a/shared/test/common/test_files/igdrcl.config +++ b/shared/test/common/test_files/igdrcl.config @@ -104,6 +104,7 @@ DirectSubmissionDisableCacheFlush = -1 DirectSubmissionDisableMonitorFence = -1 DirectSubmissionPrintBuffers = 0 DirectSubmissionMaxRingBuffers = -1 +EnableL0ReadLUIDExtension = 0 USMEvictAfterMigration = 0 EnableDirectSubmissionController = -1 DirectSubmissionControllerTimeout = -1 diff --git a/shared/test/unit_test/os_interface/windows/wddm_tests.cpp b/shared/test/unit_test/os_interface/windows/wddm_tests.cpp index b912089b18..b351cdc34f 100644 --- a/shared/test/unit_test/os_interface/windows/wddm_tests.cpp +++ b/shared/test/unit_test/os_interface/windows/wddm_tests.cpp @@ -6,11 +6,13 @@ */ #include "shared/source/gmm_helper/gmm.h" +#include "shared/source/helpers/string.h" #include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/os_interface/windows/wddm_fixture.h" #include "shared/test/common/test_macros/hw_test.h" namespace NEO { +std::unique_ptr createHwDeviceIdFromAdapterLuid(OsEnvironmentWin &osEnvironment, LUID adapterLuid); using WddmTests = WddmTestWithMockGdiDll; @@ -386,6 +388,17 @@ TEST_F(WddmTests, GivenPlatformNotSupportEvictIfNecessaryWhenAdjustingEvictNeede bool value = wddm->adjustEvictNeededParameter(false); EXPECT_TRUE(value); } +using WddmOsContextDeviceLuidTests = WddmFixtureLuid; +TEST_F(WddmFixtureLuid, givenValidOsContextAndLuidDataRequestThenValidDataReturned) { + LUID adapterLuid = {0x12, 0x1234}; + wddm->hwDeviceId = NEO::createHwDeviceIdFromAdapterLuid(*osEnvironment, adapterLuid); + std::vector luidData; + size_t arraySize = 8; + osContext->getDeviceLuidArray(luidData, arraySize); + uint64_t luid = 0; + memcpy_s(&luid, sizeof(uint64_t), luidData.data(), sizeof(uint8_t) * luidData.size()); + EXPECT_NE(luid, (uint64_t)0); +} uint64_t waitForSynchronizationObjectFromCpuCounter = 0u;