diff --git a/level_zero/core/source/CMakeLists.txt b/level_zero/core/source/CMakeLists.txt index 27c536e1ce..cd43755d25 100644 --- a/level_zero/core/source/CMakeLists.txt +++ b/level_zero/core/source/CMakeLists.txt @@ -35,6 +35,7 @@ set(L0_RUNTIME_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/debug_manager/debug_manager.cpp ${CMAKE_CURRENT_SOURCE_DIR}/device${BRANCH_DIR_SUFFIX}device_imp_helper.cpp ${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 c67a6639ee..e54c6818e1 100644 --- a/level_zero/core/source/device/device_imp.cpp +++ b/level_zero/core/source/device/device_imp.cpp @@ -731,6 +731,19 @@ ze_result_t DeviceImp::getProperties(ze_device_properties_t *pDeviceProperties) } memcpy_s(pDeviceProperties->name, name.length(), name.c_str(), name.length()); + 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 cb4edc881a..6b681254f0 100644 --- a/level_zero/core/source/device/device_imp.h +++ b/level_zero/core/source/device/device_imp.h @@ -132,6 +132,9 @@ struct DeviceImp : public Device { using CmdListCreateFunPtrT = L0::CommandList *(*)(uint32_t, Device *, NEO::EngineGroupType, ze_command_list_flags_t, ze_result_t &); CmdListCreateFunPtrT getCmdListCreateFunc(const ze_command_list_desc_t *desc); + 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(ze_command_queue_desc_t &desc); NEO::EngineGroupsT subDeviceCopyEngineGroups{}; 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..6d2622fcff --- /dev/null +++ b/level_zero/core/source/device/device_imp_drm_or_wddm/device_imp.cpp @@ -0,0 +1,37 @@ +/* + * 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::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; + } 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/source/driver/driver_handle_imp.h b/level_zero/core/source/driver/driver_handle_imp.h index 0a0df1ec49..d3b19eca46 100644 --- a/level_zero/core/source/driver/driver_handle_imp.h +++ b/level_zero/core/source/driver/driver_handle_imp.h @@ -94,7 +94,8 @@ struct DriverHandleImp : public DriverHandle { {ZE_PCI_PROPERTIES_EXT_NAME, ZE_PCI_PROPERTIES_EXT_VERSION_CURRENT}, {ZE_MEMORY_COMPRESSION_HINTS_EXT_NAME, ZE_MEMORY_COMPRESSION_HINTS_EXT_VERSION_CURRENT}, {ZE_MEMORY_FREE_POLICIES_EXT_NAME, ZE_MEMORY_FREE_POLICIES_EXT_VERSION_CURRENT}, - {ZE_DEVICE_MEMORY_PROPERTIES_EXT_NAME, ZE_DEVICE_MEMORY_PROPERTIES_EXT_VERSION_CURRENT}}; + {ZE_DEVICE_MEMORY_PROPERTIES_EXT_NAME, ZE_DEVICE_MEMORY_PROPERTIES_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 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..f8e108f39e --- /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 0000000000..9c66285067 --- /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; + std::memcpy(&luid, luidData.data(), luidData.size() * sizeof(uint8_t)); + 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}; + std::memcpy(&luid, &deviceLuidProperties.luid, sizeof(ze_device_luid_ext_t)); + 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 0000000000..648ccdab02 --- /dev/null +++ b/level_zero/core/test/unit_tests/sources/device/device_wddm/test_device.cpp @@ -0,0 +1,88 @@ +/* + * 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/mock_gdi/mock_gdi.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_wddm.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/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 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; + std::memcpy(&luid, &deviceLuidProperties.luid, sizeof(ze_device_luid_ext_t)); + 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 699c839647..80b75529ac 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 0454dcca86..b8822e1c20 100644 --- a/shared/source/os_interface/windows/os_context_win.cpp +++ b/shared/source/os_interface/windows/os_context_win.cpp @@ -51,6 +51,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 4fac6f0a94..d3f3b1744f 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); MOCKABLE_VIRTUAL bool isDebuggableContext() { return debuggableContext; }; protected: diff --git a/shared/test/common/os_interface/windows/wddm_fixture.h b/shared/test/common/os_interface/windows/wddm_fixture.h index 7d13fc24a6..de05364590 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() override { 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 6cd3244536..dd94002053 100644 --- a/shared/test/unit_test/os_interface/windows/wddm_tests.cpp +++ b/shared/test/unit_test/os_interface/windows/wddm_tests.cpp @@ -10,6 +10,7 @@ #include "shared/test/common/test_macros/hw_test.h" namespace NEO { +std::unique_ptr createHwDeviceIdFromAdapterLuid(OsEnvironmentWin &osEnvironment, LUID adapterLuid); using WddmTests = WddmTestWithMockGdiDll; @@ -122,6 +123,18 @@ TEST_F(WddmTests, whenGetAdapterLuidThenLuidIsReturned) { EXPECT_TRUE(luid.HighPart == 0 && luid.LowPart == 0); } +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; + std::memcpy(&luid, luidData.data(), luidData.size() * sizeof(uint8_t)); + EXPECT_NE(luid, (uint64_t)0); +} + uint64_t waitForSynchronizationObjectFromCpuCounter = 0u; NTSTATUS __stdcall waitForSynchronizationObjectFromCpuNoOp(const D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMCPU *waitStruct) {