Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert "Support for L0 to read Device LUID from the WDDM driver using ext Pro... 

This reverts commit 8124bff387.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation 2022-07-23 07:25:45 +02:00 committed by Compute-Runtime-Automation
parent 8124bff387
commit ead3a95be3
16 changed files with 1 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
level_zero/core/source/CMakeLists.txt
View File

@ -35,7 +35,6 @@ 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

13
level_zero/core/source/device/device_imp.cpp
View File

@ -731,19 +731,6 @@ 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<ze_base_properties_t *>(pDeviceProperties->pNext);
if (extendedProperties->stype == ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES) {
ze_device_luid_ext_properties_t *deviceLuidProperties =
reinterpret_cast<ze_device_luid_ext_properties_t *>(extendedProperties);
ze_result_t result = queryDeviceLuid(deviceLuidProperties);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
deviceLuidProperties->nodeMask = 1;
}
}
return ZE_RESULT_SUCCESS;
}

3
level_zero/core/source/device/device_imp.h
View File

@ -132,9 +132,6 @@ 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{};

16
level_zero/core/source/device/device_imp_drm/device_imp.cpp
View File

@ -1,16 +0,0 @@
/*
* 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

37
level_zero/core/source/device/device_imp_drm_or_wddm/device_imp.cpp
View File

@ -1,37 +0,0 @@
/*
* 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<NEO::OsContextWin *>(&csr->getOsContext());
std::vector<uint8_t> 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

28
level_zero/core/source/device/device_imp_wddm/device_imp.cpp
View File

@ -1,28 +0,0 @@
/*
* 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<NEO::OsContextWin *>(&csr->getOsContext());
std::vector<uint8_t> 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

3
level_zero/core/source/driver/driver_handle_imp.h
View File

@ -94,8 +94,7 @@ 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_LUID_EXT_NAME, ZE_DEVICE_LUID_EXT_VERSION_CURRENT}};
{ZE_DEVICE_MEMORY_PROPERTIES_EXT_NAME, ZE_DEVICE_MEMORY_PROPERTIES_EXT_VERSION_CURRENT}};
uint64_t uuidTimestamp = 0u;

1
level_zero/core/test/unit_tests/sources/device/CMakeLists.txt
View File

@ -9,6 +9,5 @@ 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()

36
level_zero/core/test/unit_tests/sources/device/device_drm/test_device.cpp
View File

@ -1,36 +0,0 @@
/*
* 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<DeviceFixture>;
TEST_F(LuidDeviceTest, givenLuidDevicePropertiesStructureAndDRMDriverTypeThenUnsupportedReturned) {
neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new NEO::OSInterface());
neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::make_unique<NEO::MockDriverModelDRM>());
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

135
level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device.cpp
View File

@ -1,135 +0,0 @@
/*
* 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<D3DKMT_HANDLE>(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> umKmDataTranslator) : HwDeviceIdWddm(adapterIn, adapterLuidIn, osEnvironmentIn, std::move(umKmDataTranslator)) {}
};
class MockDriverModelWDDMLUID : public NEO::Wddm {
public:
MockDriverModelWDDMLUID(std::unique_ptr<HwDeviceIdWddm> &&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<MockHwDeviceIdWddm>(ADAPTER_HANDLE_WDDM_FAKE, LUID{0x12, 0x1234}, rootDeviceEnvironment.executionEnvironment.osEnvironment.get(), std::make_unique<UmKmDataTranslator>()), rootDeviceEnvironment) {
if (!rootDeviceEnvironment.executionEnvironment.osEnvironment.get()) {
rootDeviceEnvironment.executionEnvironment.osEnvironment = std::make_unique<OsEnvironmentWin>();
}
static_cast<MockHwDeviceIdWddm *>(this->hwDeviceId.get())->osEnvironment = rootDeviceEnvironment.executionEnvironment.osEnvironment.get();
OsEnvironmentWin *osEnvWin = reinterpret_cast<OsEnvironmentWin *>(static_cast<MockHwDeviceIdWddm *>(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<DeviceFixture>;
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<uint8_t> 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<DriverModel>(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<NEO::MockDriverModelDRM>());
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

88
level_zero/core/test/unit_tests/sources/device/device_wddm/test_device.cpp
View File

@ -1,88 +0,0 @@
/*
* 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<HwDeviceIdWddm> 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<Mock<L0::DriverHandleImp>> 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<DriverModel>(luidMock));
luidMock->init();
neoDevice = NEO::MockDevice::createWithExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get(), executionEnvironment, 0u);
NEO::DeviceVector devices;
devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
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

9
level_zero/core/test/unit_tests/sources/device/test_device.cpp
View File

@ -1102,15 +1102,6 @@ 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<FamilyType> {

17
shared/source/os_interface/windows/os_context_win.cpp
View File

@ -51,23 +51,6 @@ void OsContextWin::reInitializeContext() {
UNRECOVERABLE_IF(!wddm.createContext(*this));
};
void OsContextWin::getDeviceLuidArray(std::vector<uint8_t> &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);

1
shared/source/os_interface/windows/os_context_win.h
View File

@ -35,7 +35,6 @@ 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<uint8_t> &luidData, size_t arraySize);
MOCKABLE_VIRTUAL bool isDebuggableContext() { return debuggableContext; };
protected:

32
shared/test/common/os_interface/windows/wddm_fixture.h
View File

@ -61,38 +61,6 @@ struct WddmFixture : public Test<MockExecutionEnvironmentGmmFixture> {
MockWddmResidentAllocationsContainer *mockTemporaryResources;
};
struct WddmFixtureLuid : public Test<MockExecutionEnvironmentGmmFixture> {
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<WddmMock *>(Wddm::createWddm(nullptr, *rootDeviceEnvironment));
rootDeviceEnvironment->osInterface = std::make_unique<OSInterface>();
rootDeviceEnvironment->osInterface->setDriverModel(std::unique_ptr<DriverModel>(wddm));
rootDeviceEnvironment->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(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<OsContextWin>(*osInterface->getDriverModel()->as<Wddm>(), 0u, EngineDescriptorHelper::getDefaultDescriptor(engine, preemptionMode));
osContext->ensureContextInitialized();
mockTemporaryResources = static_cast<MockWddmResidentAllocationsContainer *>(wddm->temporaryResources.get());
}
WddmMock *wddm = nullptr;
OSInterface *osInterface;
RootDeviceEnvironment *rootDeviceEnvironment = nullptr;
OsEnvironmentWin *osEnvironment = nullptr;
std::unique_ptr<OsContextWin> osContext;
MockGdi *gdi = nullptr;
MockWddmResidentAllocationsContainer *mockTemporaryResources;
};
struct WddmFixtureWithMockGdiDll : public GdiDllFixture, public MockExecutionEnvironmentGmmFixture {
void SetUp() override {
MockExecutionEnvironmentGmmFixture::SetUp();

13
shared/test/unit_test/os_interface/windows/wddm_tests.cpp
View File

@ -10,7 +10,6 @@
#include "shared/test/common/test_macros/hw_test.h"
namespace NEO {
std::unique_ptr<HwDeviceIdWddm> createHwDeviceIdFromAdapterLuid(OsEnvironmentWin &osEnvironment, LUID adapterLuid);
using WddmTests = WddmTestWithMockGdiDll;
@ -123,18 +122,6 @@ 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<uint8_t> 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) {