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

Windows: discover devices in DeviceFactory::getDevices 

Related-To: NEO-4208

Change-Id: I19a969066b76770a194164bcdf39c7b1ac74c06d
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski 2020-02-07 10:29:56 +01:00 committed by sys_ocldev
parent 08ca548f1a
commit b5535ec547
20 changed files with 71 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/os_interface/windows/device_factory_win.cpp
View File

@ -33,7 +33,11 @@ bool DeviceFactory::getDevices(size_t &numDevices, ExecutionEnvironment &executi
auto hardwareInfo = executionEnvironment.getMutableHardwareInfo();
for (auto rootDeviceIndex = 0u; rootDeviceIndex < numRootDevices; rootDeviceIndex++) {
std::unique_ptr<Wddm> wddm(Wddm::createWddm(*executionEnvironment.rootDeviceEnvironments[rootDeviceIndex].get()));
auto hwDeviceId = Wddm::discoverDevices();
if (!hwDeviceId) {
return false;
}
std::unique_ptr<Wddm> wddm(Wddm::createWddm(std::move(hwDeviceId), *executionEnvironment.rootDeviceEnvironments[rootDeviceIndex].get()));
if (!wddm->init(*hardwareInfo)) {
return false;
}

15
core/os_interface/windows/wddm/wddm.cpp
View File

@ -61,7 +61,8 @@ Wddm::GetSystemInfoFcn Wddm::getSystemInfo = getGetSystemInfo();
Wddm::VirtualAllocFcn Wddm::virtualAllocFnc = getVirtualAlloc();
Wddm::VirtualFreeFcn Wddm::virtualFreeFnc = getVirtualFree();
Wddm::Wddm(RootDeviceEnvironment &rootDeviceEnvironment) : rootDeviceEnvironment(rootDeviceEnvironment) {
Wddm::Wddm(std::unique_ptr<HwDeviceId> hwDeviceIdIn, RootDeviceEnvironment &rootDeviceEnvironment) : hwDeviceId(std::move(hwDeviceIdIn)), rootDeviceEnvironment(rootDeviceEnvironment) {
UNRECOVERABLE_IF(!hwDeviceId);
featureTable.reset(new FeatureTable());
workaroundTable.reset(new WorkaroundTable());
gtSystemInfo.reset(new GT_SYSTEM_INFO);
@ -80,19 +81,7 @@ Wddm::~Wddm() {
UNRECOVERABLE_IF(temporaryResources.get())
}
bool Wddm::openAdapter() {
hwDeviceId = discoverDevices();
if (!hwDeviceId) {
return false;
}
return true;
}
bool Wddm::init(HardwareInfo &outHardwareInfo) {
if (!openAdapter()) {
return false;
}
if (!queryAdapterInfo()) {
return false;
}

5
core/os_interface/windows/wddm/wddm.h
View File

@ -60,7 +60,7 @@ class Wddm {
virtual ~Wddm();
static Wddm *createWddm(RootDeviceEnvironment &rootDeviceEnvironment);
static Wddm *createWddm(std::unique_ptr<HwDeviceId> hwDeviceId, RootDeviceEnvironment &rootDeviceEnvironment);
bool init(HardwareInfo &outHardwareInfo);
MOCKABLE_VIRTUAL bool evict(const D3DKMT_HANDLE *handleList, uint32_t numOfHandles, uint64_t &sizeToTrim);
@ -187,8 +187,7 @@ class Wddm {
std::unique_ptr<GmmMemory> gmmMemory;
uintptr_t minAddress = 0;
Wddm(RootDeviceEnvironment &rootDeviceEnvironment);
MOCKABLE_VIRTUAL bool openAdapter();
Wddm(std::unique_ptr<HwDeviceId> hwDeviceId, RootDeviceEnvironment &rootDeviceEnvironment);
MOCKABLE_VIRTUAL bool waitOnGPU(D3DKMT_HANDLE context);
bool createDevice(PreemptionMode preemptionMode);
bool createPagingQueue();

4
core/os_interface/windows/wddm/wddm_create.cpp
View File

@ -8,7 +8,7 @@
#include "core/os_interface/windows/wddm/wddm.h"
namespace NEO {
Wddm *Wddm::createWddm(RootDeviceEnvironment &rootDeviceEnvironment) {
return new Wddm(rootDeviceEnvironment);
Wddm *Wddm::createWddm(std::unique_ptr<HwDeviceId> hwDeviceId, RootDeviceEnvironment &rootDeviceEnvironment) {
return new Wddm(std::move(hwDeviceId), rootDeviceEnvironment);
}
} // namespace NEO

2
core/unit_tests/os_interface/windows/wddm_preemption_tests.cpp
View File

@ -30,7 +30,7 @@ class WddmPreemptionTests : public Test<WddmFixtureWithMockGdiDll> {
}
void createAndInitWddm(unsigned int forceReturnPreemptionRegKeyValue) {
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get()));
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(wddm);
executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);

2
unit_tests/gen12lp/windows/wddm_tests_gen12lp.cpp
View File

@ -24,7 +24,7 @@ struct Gen12LpWddmTest : public GdiDllFixture, ::testing::Test {
executionEnvironment = std::make_unique<MockExecutionEnvironment>();
executionEnvironment->initGmm();
rootDeviceEnvironment = std::make_unique<RootDeviceEnvironment>(*executionEnvironment);
wddm.reset(static_cast<WddmMock *>(Wddm::createWddm(*rootDeviceEnvironment)));
wddm.reset(static_cast<WddmMock *>(Wddm::createWddm(nullptr, *rootDeviceEnvironment)));
gmmMemory = new ::testing::NiceMock<GmockGmmMemory>(executionEnvironment->getGmmClientContext());
wddm->gmmMemory.reset(gmmMemory);
}

10
unit_tests/mocks/mock_wddm.cpp
View File

@ -18,9 +18,8 @@
using namespace NEO;
WddmMock::WddmMock(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(rootDeviceEnvironment) {
WddmMock::WddmMock(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(std::make_unique<HwDeviceId>(ADAPTER_HANDLE, LUID{}, std::make_unique<Gdi>()), rootDeviceEnvironment) {
this->temporaryResources = std::make_unique<MockWddmResidentAllocationsContainer>(this);
this->hwDeviceId = std::make_unique<HwDeviceId>(0, LUID{}, std::make_unique<Gdi>());
}
WddmMock::~WddmMock() {
@ -198,13 +197,6 @@ void WddmMock::setHwContextId(unsigned long hwContextId) {
this->hwContextId = hwContextId;
}
bool WddmMock::openAdapter() {
if (getAdapter() == 0) {
this->hwDeviceId = std::make_unique<HwDeviceId>(ADAPTER_HANDLE, LUID{}, std::make_unique<Gdi>());
}
return true;
}
void WddmMock::resetGdi(Gdi *gdi) {
this->hwDeviceId = std::make_unique<HwDeviceId>(ADAPTER_HANDLE, LUID{}, std::unique_ptr<Gdi>(gdi));
}

1
unit_tests/mocks/mock_wddm.h
View File

@ -69,7 +69,6 @@ class WddmMock : public Wddm {
bool isKmDafEnabled() const override;
void setKmDafEnabled(bool state);
void setHwContextId(unsigned long hwContextId);
bool openAdapter() override;
void setHeap32(uint64_t base, uint64_t size);
GMM_GFX_PARTITIONING *getGfxPartitionPtr();
bool waitFromCpu(uint64_t lastFenceValue, const MonitoredFence &monitoredFence) override;

8
unit_tests/os_interface/windows/device_command_stream_tests.cpp
View File

@ -143,7 +143,7 @@ using DeviceCommandStreamTest = ::Test<MockAubCenterFixture>;
TEST_F(DeviceCommandStreamTest, CreateWddmCSR) {
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto wddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get());
auto wddm = Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get());
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(static_cast<WddmMock *>(wddm));
executionEnvironment->initializeMemoryManager();
@ -155,7 +155,7 @@ TEST_F(DeviceCommandStreamTest, CreateWddmCSR) {
TEST_F(DeviceCommandStreamTest, CreateWddmCSRWithAubDump) {
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto wddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get());
auto wddm = Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get());
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(static_cast<WddmMock *>(wddm));
executionEnvironment->initializeMemoryManager();
@ -818,7 +818,7 @@ HWTEST_F(WddmSimpleTest, givenDefaultWddmCsrWhenItIsCreatedThenBatchingIsTurnedO
DebugManager.flags.CsrDispatchMode.set(0);
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
std::unique_ptr<MockDevice> device(Device::create<MockDevice>(executionEnvironment, 0u));
auto wddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get());
auto wddm = Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get());
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(wddm);
executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
@ -827,7 +827,7 @@ HWTEST_F(WddmSimpleTest, givenDefaultWddmCsrWhenItIsCreatedThenBatchingIsTurnedO
}
HWTEST_F(WddmDefaultTest, givenFtrWddmHwQueuesFlagWhenCreatingCsrThenPickWddmVersionBasingOnFtrFlag) {
auto wddm = Wddm::createWddm(*pDevice->executionEnvironment->rootDeviceEnvironments[0].get());
auto wddm = Wddm::createWddm(nullptr, *pDevice->executionEnvironment->rootDeviceEnvironments[0].get());
pDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
pDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(wddm);
pDevice->executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);

2
unit_tests/os_interface/windows/driver_info_tests.cpp
View File

@ -126,7 +126,7 @@ TEST(DriverInfo, givenInitializedOsInterfaceWhenCreateDriverInfoThenReturnDriver
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
std::unique_ptr<OSInterface> osInterface(new OSInterface());
osInterface->get()->setWddm(Wddm::createWddm(rootDeviceEnvironment));
osInterface->get()->setWddm(Wddm::createWddm(nullptr, rootDeviceEnvironment));
EXPECT_NE(nullptr, osInterface->get()->getWddm());
std::unique_ptr<DriverInfo> driverInfo(DriverInfo::create(osInterface.get()));

2
unit_tests/os_interface/windows/hw_info_config_win_tests.cpp
View File

@ -66,7 +66,7 @@ void HwInfoConfigTestWindows::SetUp() {
osInterface.reset(new OSInterface());
std::unique_ptr<Wddm> wddm(Wddm::createWddm(*rootDeviceEnvironment));
std::unique_ptr<Wddm> wddm(Wddm::createWddm(nullptr, *rootDeviceEnvironment));
wddm->init(outHwInfo);
}

106
unit_tests/os_interface/windows/wddm20_tests.cpp
View File

@ -90,8 +90,17 @@ TEST_F(Wddm20Tests, givenNullPageTableManagerAndRenderCompressedResourceWhenMapp
EXPECT_TRUE(wddm->mapGpuVirtualAddress(&allocation));
}
TEST(WddmDiscoverDevices, WhenNoHwDeviceIdIsProvidedToWddmThenWddmIsNotCreated) {
struct MockWddm : public Wddm {
MockWddm(std::unique_ptr<HwDeviceId> hwDeviceIdIn, RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(std::move(hwDeviceIdIn), rootDeviceEnvironment) {}
};
TEST(Wddm20EnumAdaptersTest, WhenAdapterDescriptionContainsDCHDAndgdrclPathDoesntContainDchDThenAdapterIsNotOpened) {
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
EXPECT_THROW(auto wddm = std::make_unique<MockWddm>(nullptr, rootDeviceEnvironment), std::exception);
}
TEST(WddmDiscoverDevices, WhenAdapterDescriptionContainsDCHDAndgdrclPathDoesntContainDchDThenNoDeviceIsDiscovered) {
VariableBackup<const wchar_t *> descriptionBackup(&UltIDXGIAdapter1::description);
descriptionBackup = L"Intel DCH-D";
VariableBackup<const wchar_t *> igdrclPathBackup(&SysCalls::igdrclFilePath);
@ -99,40 +108,19 @@ TEST(Wddm20EnumAdaptersTest, WhenAdapterDescriptionContainsDCHDAndgdrclPathDoesn
auto hwDeviceId = Wddm::discoverDevices();
EXPECT_EQ(nullptr, hwDeviceId.get());
struct MockWddm : Wddm {
using Wddm::openAdapter;
MockWddm(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(rootDeviceEnvironment) {}
};
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
auto wddm = std::make_unique<MockWddm>(rootDeviceEnvironment);
bool isOpened = wddm->openAdapter();
EXPECT_FALSE(isOpened);
}
TEST(Wddm20EnumAdaptersTest, WhenAdapterDescriptionContainsDCHIAndgdrclPathDoesntContainDchIThenAdapterIsNotOpened) {
TEST(WddmDiscoverDevices, WhenAdapterDescriptionContainsDCHIAndgdrclPathDoesntContainDchIThenNoDeviceIsDiscovered) {
VariableBackup<const wchar_t *> descriptionBackup(&UltIDXGIAdapter1::description);
descriptionBackup = L"Intel DCH-I";
VariableBackup<const wchar_t *> igdrclPathBackup(&SysCalls::igdrclFilePath);
igdrclPathBackup = L"intel_dch.inf";
struct MockWddm : Wddm {
using Wddm::openAdapter;
MockWddm(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(rootDeviceEnvironment) {}
};
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
auto wddm = std::make_unique<MockWddm>(rootDeviceEnvironment);
bool isOpened = wddm->openAdapter();
EXPECT_FALSE(isOpened);
auto hwDeviceId = Wddm::discoverDevices();
EXPECT_EQ(nullptr, hwDeviceId.get());
}
TEST(Wddm20EnumAdaptersTest, WhenAdapterDescriptionContainsDCHDAndgdrclPathContainsDchDThenAdapterIsOpened) {
TEST(WddmDiscoverDevices, WhenAdapterDescriptionContainsDCHDAndgdrclPathContainsDchDThenAdapterIsDiscovered) {
VariableBackup<const wchar_t *> descriptionBackup(&UltIDXGIAdapter1::description);
descriptionBackup = L"Intel DCH-D";
VariableBackup<const wchar_t *> igdrclPathBackup(&SysCalls::igdrclFilePath);
@ -140,21 +128,9 @@ TEST(Wddm20EnumAdaptersTest, WhenAdapterDescriptionContainsDCHDAndgdrclPathConta
auto hwDeviceId = Wddm::discoverDevices();
EXPECT_NE(nullptr, hwDeviceId.get());
struct MockWddm : Wddm {
using Wddm::openAdapter;
MockWddm(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(rootDeviceEnvironment) {}
};
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
auto wddm = std::make_unique<MockWddm>(rootDeviceEnvironment);
bool isOpened = wddm->openAdapter();
EXPECT_TRUE(isOpened);
}
TEST(Wddm20EnumAdaptersTest, WhenAdapterDescriptionContainsDCHIAndgdrclPathContainsDchIThenAdapterIsOpened) {
TEST(Wddm20EnumAdaptersTest, WhenAdapterDescriptionContainsDCHIAndgdrclPathContainsDchIThenAdapterIsDiscovered) {
VariableBackup<const wchar_t *> descriptionBackup(&UltIDXGIAdapter1::description);
descriptionBackup = L"Intel DCH-I";
VariableBackup<const wchar_t *> igdrclPathBackup(&SysCalls::igdrclFilePath);
@ -162,18 +138,6 @@ TEST(Wddm20EnumAdaptersTest, WhenAdapterDescriptionContainsDCHIAndgdrclPathConta
auto hwDeviceId = Wddm::discoverDevices();
EXPECT_NE(nullptr, hwDeviceId.get());
struct MockWddm : Wddm {
using Wddm::openAdapter;
MockWddm(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(rootDeviceEnvironment) {}
};
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
auto wddm = std::make_unique<MockWddm>(rootDeviceEnvironment);
bool isOpened = wddm->openAdapter();
EXPECT_TRUE(isOpened);
}
TEST(Wddm20EnumAdaptersTest, expectTrue) {
@ -186,7 +150,7 @@ TEST(Wddm20EnumAdaptersTest, expectTrue) {
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
std::unique_ptr<Wddm> wddm(Wddm::createWddm(rootDeviceEnvironment));
std::unique_ptr<Wddm> wddm(Wddm::createWddm(nullptr, rootDeviceEnvironment));
bool success = wddm->init(outHwInfo);
EXPECT_TRUE(success);
@ -204,7 +168,7 @@ TEST(Wddm20EnumAdaptersTest, givenEmptyHardwareInfoWhenEnumAdapterIsCalledThenCa
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
std::unique_ptr<Wddm> wddm(Wddm::createWddm(rootDeviceEnvironment));
std::unique_ptr<Wddm> wddm(Wddm::createWddm(nullptr, rootDeviceEnvironment));
bool success = wddm->init(outHwInfo);
EXPECT_TRUE(success);
@ -229,7 +193,7 @@ TEST(Wddm20EnumAdaptersTest, givenUnknownPlatformWhenEnumAdapterIsCalledThenFals
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
std::unique_ptr<Wddm> wddm(Wddm::createWddm(rootDeviceEnvironment));
std::unique_ptr<Wddm> wddm(Wddm::createWddm(nullptr, rootDeviceEnvironment));
auto ret = wddm->init(outHwInfo);
EXPECT_FALSE(ret);
@ -1080,7 +1044,7 @@ TEST_F(WddmGfxPartitionTest, initGfxPartitionHeapStandard64KBSplit) {
struct MockWddm : public Wddm {
using Wddm::gfxPartition;
MockWddm(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(rootDeviceEnvironment) {}
MockWddm(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(Wddm::discoverDevices(), rootDeviceEnvironment) {}
};
MockWddm wddm(*executionEnvironment->rootDeviceEnvironments[0].get());
@ -1096,31 +1060,27 @@ TEST_F(WddmGfxPartitionTest, initGfxPartitionHeapStandard64KBSplit) {
EXPECT_EQ(wddm.gfxPartition.Standard64KB.Base + rootDeviceIndex * heapStandard64KBSize, gfxPartition.getHeapBase(HeapIndex::HEAP_STANDARD64KB));
}
TEST_F(Wddm20Tests, givenWddmWhenOpenAdapterAndForceDeviceIdIsTheSameAsTheExistingDeviceThenReturnTrue) {
TEST_F(Wddm20Tests, givenWddmWhenDiscoverDevicesAndForceDeviceIdIsTheSameAsTheExistingDeviceThenReturnTheAdapter) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.ForceDeviceId.set("1234"); // Existing device Id
struct MockWddm : public Wddm {
using Wddm::openAdapter;
MockWddm(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(rootDeviceEnvironment) {}
};
MockWddm wddm(*executionEnvironment->rootDeviceEnvironments[0].get());
bool result = wddm.openAdapter();
EXPECT_TRUE(result);
auto hwDeviceId = Wddm::discoverDevices();
EXPECT_NE(nullptr, hwDeviceId);
}
TEST_F(Wddm20Tests, givenWddmWhenOpenAdapterAndForceDeviceIdIsDifferentFromTheExistingDeviceThenReturnFalse) {
TEST(WddmDiscoverDevices, whenDiscoverDevicesAndForceDeviceIdIsDifferentFromTheExistingDeviceThenReturnNullptr) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.ForceDeviceId.set("1111");
struct MockWddm : public Wddm {
using Wddm::openAdapter;
auto hwDeviceId = Wddm::discoverDevices();
EXPECT_EQ(nullptr, hwDeviceId);
}
MockWddm(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(rootDeviceEnvironment) {}
};
TEST(WddmDiscoverDevices, whenDiscoverDevicesAndForceDeviceIdIsDifferentFromTheExistingDeviceThenGetDevicesReturnsFalse) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.ForceDeviceId.set("1111");
size_t numDevices = 0u;
ExecutionEnvironment executionEnviornment;
MockWddm wddm(*executionEnvironment->rootDeviceEnvironments[0].get());
bool result = wddm.openAdapter();
auto result = DeviceFactory::getDevices(numDevices, executionEnviornment);
EXPECT_FALSE(result);
}
@ -1267,4 +1227,4 @@ TEST(HwDeviceId, whenHwDeviceIdIsDestroyedThenAdapterIsClosed) {
}
EXPECT_EQ(1u, GdiWithMockedCloseFunc::closeAdapterCalled);
EXPECT_EQ(adapter, GdiWithMockedCloseFunc::closeAdapterCalledArgPassed);
}
}

2
unit_tests/os_interface/windows/wddm23_tests.cpp
View File

@ -26,7 +26,7 @@ struct Wddm23TestsWithoutWddmInit : public ::testing::Test, GdiDllFixture {
GdiDllFixture::SetUp();
executionEnvironment = platform()->peekExecutionEnvironment();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get()));
osInterface = std::make_unique<OSInterface>();
osInterface->get()->setWddm(wddm);

4
unit_tests/os_interface/windows/wddm_create.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -8,7 +8,7 @@
#include "unit_tests/mocks/mock_wddm.h"
namespace NEO {
Wddm *Wddm::createWddm(RootDeviceEnvironment &rootDeviceEnvironment) {
Wddm *Wddm::createWddm(std::unique_ptr<HwDeviceId> hwDeviceId, RootDeviceEnvironment &rootDeviceEnvironment) {
return new WddmMock(rootDeviceEnvironment);
}
} // namespace NEO

6
unit_tests/os_interface/windows/wddm_fixture.h
View File

@ -30,7 +30,7 @@ namespace NEO {
struct WddmFixture : ::testing::Test {
void SetUp() override {
executionEnvironment = platform()->peekExecutionEnvironment();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get()));
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(wddm);
executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
@ -57,7 +57,7 @@ struct WddmFixtureWithMockGdiDll : public GdiDllFixture {
void SetUp() override {
executionEnvironment = platform()->peekExecutionEnvironment();
GdiDllFixture::SetUp();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get()));
wddmMockInterface = new WddmMockInterface20(*wddm);
wddm->wddmInterface.reset(wddmMockInterface);
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
@ -89,7 +89,7 @@ struct WddmFixtureWithMockGdiDll : public GdiDllFixture {
struct WddmInstrumentationGmmFixture {
void SetUp() {
executionEnvironment = platform()->peekExecutionEnvironment();
wddm.reset(static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get())));
wddm.reset(static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get())));
gmmMem = new ::testing::NiceMock<GmockGmmMemory>(executionEnvironment->getGmmClientContext());
wddm->gmmMemory.reset(gmmMem);
}

7
unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp
View File

@ -26,13 +26,8 @@ class WddmWithKmDafMock : public Wddm {
using Wddm::featureTable;
using Wddm::mapGpuVirtualAddress;
WddmWithKmDafMock(RootDeviceEnvironment &rootDeviceEnvironment, Gdi *mockGdi) : Wddm(rootDeviceEnvironment) {
WddmWithKmDafMock(RootDeviceEnvironment &rootDeviceEnvironment, Gdi *mockGdi) : Wddm(std::make_unique<HwDeviceId>(ADAPTER_HANDLE, LUID{}, std::unique_ptr<Gdi>(mockGdi)), rootDeviceEnvironment) {
kmDafListener.reset(new KmDafListenerMock);
this->hwDeviceId = std::make_unique<HwDeviceId>(ADAPTER_HANDLE, LUID{}, std::unique_ptr<Gdi>(mockGdi));
}
bool openAdapter() override {
return true;
}
KmDafListenerMock &getKmDafListenerMock() {

6
unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@ -38,7 +38,7 @@ void WddmMemoryManagerFixture::SetUp() {
GdiDllFixture::SetUp();
executionEnvironment = platform()->peekExecutionEnvironment();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get()));
if (platformDevices[0]->capabilityTable.ftrRenderCompressedBuffers || platformDevices[0]->capabilityTable.ftrRenderCompressedImages) {
GMM_TRANSLATIONTABLE_CALLBACKS dummyTTCallbacks = {};
executionEnvironment->rootDeviceEnvironments[0]->pageTableManager.reset(GmmPageTableMngr::create(nullptr, 0, &dummyTTCallbacks));
@ -109,7 +109,7 @@ TEST(WddmAllocationTest, givenMemoryPoolWhenPassedToWddmAllocationConstructorThe
TEST(WddmMemoryManagerExternalHeapTest, externalHeapIsCreatedWithCorrectBase) {
HardwareInfo *hwInfo;
auto executionEnvironment = getExecutionEnvironmentImpl(hwInfo, 1);
std::unique_ptr<WddmMock> wddm(static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get())));
std::unique_ptr<WddmMock> wddm(static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get())));
uint64_t base = 0x56000;
uint64_t size = 0x9000;
wddm->setHeap32(base, size);
@ -838,7 +838,7 @@ TEST_F(WddmMemoryManagerTest, GivenUnAlignedPointerAndSizeWhenAllocate32BitMemor
TEST_F(WddmMemoryManagerTest, getSystemSharedMemory) {
executionEnvironment->prepareRootDeviceEnvironments(4u);
for (auto i = 0u; i < 4u; i++) {
auto mockWddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[i].get());
auto mockWddm = Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[i].get());
auto hwInfo = *platformDevices[0];
mockWddm->init(hwInfo);
executionEnvironment->rootDeviceEnvironments[i]->osInterface = std::make_unique<OSInterface>();

2
unit_tests/os_interface/windows/wddm_memory_manager_tests.h
View File

@ -48,7 +48,7 @@ class MockWddmMemoryManagerFixture {
executionEnvironment = platform()->peekExecutionEnvironment();
gdi = new MockGdi();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get()));
wddm->resetGdi(gdi);
constexpr uint64_t heap32Base = (is32bit) ? 0x1000 : 0x800000000000;
wddm->setHeap32(heap32Base, 1000 * MemoryConstants::pageSize - 1);

10
unit_tests/os_interface/windows/wddm_residency_controller_tests.cpp
View File

@ -68,7 +68,7 @@ struct WddmResidencyControllerTest : ::testing::Test {
void SetUp() {
executionEnvironment = std::make_unique<MockExecutionEnvironment>();
rootDeviceEnvironment = std::make_unique<RootDeviceEnvironment>(*executionEnvironment);
wddm = std::unique_ptr<WddmMock>(static_cast<WddmMock *>(Wddm::createWddm(*rootDeviceEnvironment)));
wddm = std::unique_ptr<WddmMock>(static_cast<WddmMock *>(Wddm::createWddm(nullptr, *rootDeviceEnvironment)));
auto hwInfo = *platformDevices[0];
wddm->init(hwInfo);
mockOsContextWin = std::make_unique<MockOsContextWin>(*wddm, osContextId, 0, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false);
@ -89,7 +89,7 @@ struct WddmResidencyControllerWithGdiTest : ::testing::Test {
void SetUp() {
executionEnvironment = std::make_unique<MockExecutionEnvironment>();
rootDeviceEnvironment = std::make_unique<RootDeviceEnvironment>(*executionEnvironment);
wddm = std::unique_ptr<WddmMock>(static_cast<WddmMock *>(Wddm::createWddm(*rootDeviceEnvironment)));
wddm = std::unique_ptr<WddmMock>(static_cast<WddmMock *>(Wddm::createWddm(nullptr, *rootDeviceEnvironment)));
gdi = new MockGdi();
wddm->resetGdi(gdi);
auto hwInfo = *platformDevices[0];
@ -146,7 +146,7 @@ struct WddmResidencyControllerWithGdiAndMemoryManagerTest : ::testing::Test {
void SetUp() {
executionEnvironment = platform()->peekExecutionEnvironment();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get()));
auto hwInfo = *platformDevices[0];
wddm->init(hwInfo);
gdi = new MockGdi();
@ -182,7 +182,7 @@ TEST(WddmResidencyController, givenWddmResidencyControllerWhenItIsConstructedThe
MockExecutionEnvironment executionEnvironment;
executionEnvironment.prepareRootDeviceEnvironments(1);
auto gdi = new MockGdi();
auto wddm = std::unique_ptr<WddmMock>{static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment.rootDeviceEnvironments[0].get()))};
auto wddm = std::unique_ptr<WddmMock>{static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment.rootDeviceEnvironments[0].get()))};
wddm->resetGdi(gdi);
auto hwInfo = *platformDevices[0];
wddm->init(hwInfo);
@ -202,7 +202,7 @@ TEST(WddmResidencyController, givenWddmResidencyControllerWhenRegisterCallbackTh
MockExecutionEnvironment executionEnvironment;
executionEnvironment.prepareRootDeviceEnvironments(1);
auto gdi = new MockGdi();
auto wddm = std::unique_ptr<WddmMock>{static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment.rootDeviceEnvironments[0].get()))};
auto wddm = std::unique_ptr<WddmMock>{static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment.rootDeviceEnvironments[0].get()))};
wddm->resetGdi(gdi);
auto hwInfo = *platformDevices[0];
wddm->init(hwInfo);

3
unit_tests/windows/wddm_create_tests.cpp
View File

@ -19,6 +19,7 @@ using namespace NEO;
TEST(wddmCreateTests, givenInputVersionWhenCreatingThenCreateRequestedObject) {
MockExecutionEnvironment executionEnvironment;
RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
std::unique_ptr<Wddm> wddm(Wddm::createWddm(rootDeviceEnvironment));
auto hwDeviceId = Wddm::discoverDevices();
std::unique_ptr<Wddm> wddm(Wddm::createWddm(std::move(hwDeviceId), rootDeviceEnvironment));
EXPECT_EQ(typeid(*wddm.get()), typeid(Wddm));
}