diff --git a/level_zero/core/source/CMakeLists.txt b/level_zero/core/source/CMakeLists.txt index 8a79b22442f99..d08b7ffcac879 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 6b3551d5de109..c7ba0bf5afc04 100644 --- a/level_zero/core/source/device/device_imp.cpp +++ b/level_zero/core/source/device/device_imp.cpp @@ -725,6 +725,19 @@ ze_result_t DeviceImp::getProperties(ze_device_properties_t *pDeviceProperties) } memcpy_s(pDeviceProperties->name, ZE_MAX_DEVICE_NAME, name.c_str(), name.length() + 1); + 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 d7d560e987a9c..d150ce84bf2e4 100644 --- a/level_zero/core/source/device/device_imp.h +++ b/level_zero/core/source/device/device_imp.h @@ -137,6 +137,9 @@ struct DeviceImp : public Device { CmdListCreateFunPtrT getCmdListCreateFunc(const ze_command_list_desc_t *desc); std::unique_ptr fabricVertex; + 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 0000000000000..b0d5b4f3b06ee --- /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 0000000000000..09829931b3470 --- /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 0000000000000..c0366681b786a --- /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/source/driver/driver_handle_imp.h b/level_zero/core/source/driver/driver_handle_imp.h index b6607a8423b64..14751ccf82070 100644 --- a/level_zero/core/source/driver/driver_handle_imp.h +++ b/level_zero/core/source/driver/driver_handle_imp.h @@ -99,7 +99,8 @@ struct DriverHandleImp : public DriverHandle { {ZE_DEVICE_MEMORY_PROPERTIES_EXT_NAME, ZE_DEVICE_MEMORY_PROPERTIES_EXT_VERSION_CURRENT}, {ZE_RAYTRACING_EXT_NAME, ZE_RAYTRACING_EXT_VERSION_CURRENT}, {ZE_CONTEXT_POWER_SAVING_HINT_EXP_NAME, ZE_POWER_SAVING_HINT_EXP_VERSION_CURRENT}, - {ZE_CACHE_RESERVATION_EXT_NAME, ZE_CACHE_RESERVATION_EXT_VERSION_CURRENT}}; + {ZE_CACHE_RESERVATION_EXT_NAME, ZE_CACHE_RESERVATION_EXT_VERSION_CURRENT}, + {ZE_DEVICE_LUID_EXT_NAME, ZE_DEVICE_LUID_EXT_VERSION_CURRENT}}; uint64_t uuidTimestamp = 0u; 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 5010044caa7b6..064c911643e91 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 0000000000000..f8e108f39ec90 --- /dev/null +++ b/level_zero/core/test/unit_tests/sources/device/device_drm/test_device.cpp @@ -0,0 +1,36 @@ +/* + * 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) { + 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); +} + +} // 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 0000000000000..dd3cb56144f34 --- /dev/null +++ b/level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device.cpp @@ -0,0 +1,135 @@ +/* + * 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) { + 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; +} + +TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureAndWDDMDriverTypeThenSuccessReturned) { + 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); +} + +TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureAndDRMDriverTypeThenUnsupportedReturned) { + 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); +} + +TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureAndAndNoOsInterfaceThenUninitReturned) { + 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); +} + +} // 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 0000000000000..a198159705240 --- /dev/null +++ b/level_zero/core/test/unit_tests/sources/device/device_wddm/test_device.cpp @@ -0,0 +1,115 @@ +/* + * 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) { + 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); +} + +} // 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 337add4cd76d0..4949f05477864 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 @@ -1102,6 +1102,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/os_interface/windows/os_context_win.cpp b/shared/source/os_interface/windows/os_context_win.cpp index 26f83de2d36be..a2a16f2dcd677 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 53ced20929df0..29276002e3d5c 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 7050834eb53cc..0f1bfe999648c 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/unit_test/os_interface/windows/wddm_tests.cpp b/shared/test/unit_test/os_interface/windows/wddm_tests.cpp index d3b796d2c77de..608616ed67d5a 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; @@ -379,6 +381,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;