diff --git a/core/os_interface/windows/device_factory_win.cpp b/core/os_interface/windows/device_factory_win.cpp
index dffc83edac..653b8245af 100644
--- a/core/os_interface/windows/device_factory_win.cpp
+++ b/core/os_interface/windows/device_factory_win.cpp
@@ -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;
         }
diff --git a/core/os_interface/windows/wddm/wddm.cpp b/core/os_interface/windows/wddm/wddm.cpp
index c7da29331d..37c76311d7 100644
--- a/core/os_interface/windows/wddm/wddm.cpp
+++ b/core/os_interface/windows/wddm/wddm.cpp
@@ -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;
     }
diff --git a/core/os_interface/windows/wddm/wddm.h b/core/os_interface/windows/wddm/wddm.h
index 5483f30a07..447cc3fb77 100644
--- a/core/os_interface/windows/wddm/wddm.h
+++ b/core/os_interface/windows/wddm/wddm.h
@@ -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();
diff --git a/core/os_interface/windows/wddm/wddm_create.cpp b/core/os_interface/windows/wddm/wddm_create.cpp
index 0973c4f2f1..4a3daec0dd 100644
--- a/core/os_interface/windows/wddm/wddm_create.cpp
+++ b/core/os_interface/windows/wddm/wddm_create.cpp
@@ -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
diff --git a/core/unit_tests/os_interface/windows/wddm_preemption_tests.cpp b/core/unit_tests/os_interface/windows/wddm_preemption_tests.cpp
index 3201bc85dd..be11742918 100644
--- a/core/unit_tests/os_interface/windows/wddm_preemption_tests.cpp
+++ b/core/unit_tests/os_interface/windows/wddm_preemption_tests.cpp
@@ -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);
diff --git a/unit_tests/gen12lp/windows/wddm_tests_gen12lp.cpp b/unit_tests/gen12lp/windows/wddm_tests_gen12lp.cpp
index 87d5a4fbce..718a668f66 100644
--- a/unit_tests/gen12lp/windows/wddm_tests_gen12lp.cpp
+++ b/unit_tests/gen12lp/windows/wddm_tests_gen12lp.cpp
@@ -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);
     }
diff --git a/unit_tests/mocks/mock_wddm.cpp b/unit_tests/mocks/mock_wddm.cpp
index 34ce4eeb88..771fe763dd 100644
--- a/unit_tests/mocks/mock_wddm.cpp
+++ b/unit_tests/mocks/mock_wddm.cpp
@@ -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));
 }
diff --git a/unit_tests/mocks/mock_wddm.h b/unit_tests/mocks/mock_wddm.h
index a04cad1e1d..e161dc0b84 100644
--- a/unit_tests/mocks/mock_wddm.h
+++ b/unit_tests/mocks/mock_wddm.h
@@ -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;
diff --git a/unit_tests/os_interface/windows/device_command_stream_tests.cpp b/unit_tests/os_interface/windows/device_command_stream_tests.cpp
index 113d45f838..133ab2455d 100644
--- a/unit_tests/os_interface/windows/device_command_stream_tests.cpp
+++ b/unit_tests/os_interface/windows/device_command_stream_tests.cpp
@@ -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);
diff --git a/unit_tests/os_interface/windows/driver_info_tests.cpp b/unit_tests/os_interface/windows/driver_info_tests.cpp
index 67bb77d8d1..ff508911ae 100644
--- a/unit_tests/os_interface/windows/driver_info_tests.cpp
+++ b/unit_tests/os_interface/windows/driver_info_tests.cpp
@@ -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()));
diff --git a/unit_tests/os_interface/windows/hw_info_config_win_tests.cpp b/unit_tests/os_interface/windows/hw_info_config_win_tests.cpp
index 5630066364..75ac90446b 100644
--- a/unit_tests/os_interface/windows/hw_info_config_win_tests.cpp
+++ b/unit_tests/os_interface/windows/hw_info_config_win_tests.cpp
@@ -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);
 }
 
diff --git a/unit_tests/os_interface/windows/wddm20_tests.cpp b/unit_tests/os_interface/windows/wddm20_tests.cpp
index 29a5a59903..e2ef477dbf 100644
--- a/unit_tests/os_interface/windows/wddm20_tests.cpp
+++ b/unit_tests/os_interface/windows/wddm20_tests.cpp
@@ -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);
-}
+}
\ No newline at end of file
diff --git a/unit_tests/os_interface/windows/wddm23_tests.cpp b/unit_tests/os_interface/windows/wddm23_tests.cpp
index 84226de18e..7040e918d9 100644
--- a/unit_tests/os_interface/windows/wddm23_tests.cpp
+++ b/unit_tests/os_interface/windows/wddm23_tests.cpp
@@ -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);
 
diff --git a/unit_tests/os_interface/windows/wddm_create.cpp b/unit_tests/os_interface/windows/wddm_create.cpp
index cb42287164..879bee59f8 100644
--- a/unit_tests/os_interface/windows/wddm_create.cpp
+++ b/unit_tests/os_interface/windows/wddm_create.cpp
@@ -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
diff --git a/unit_tests/os_interface/windows/wddm_fixture.h b/unit_tests/os_interface/windows/wddm_fixture.h
index a21f0df92b..a2fd8f3bea 100644
--- a/unit_tests/os_interface/windows/wddm_fixture.h
+++ b/unit_tests/os_interface/windows/wddm_fixture.h
@@ -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);
     }
diff --git a/unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp b/unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp
index 612d8cfd26..c0be4b9bf4 100644
--- a/unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp
+++ b/unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp
@@ -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() {
diff --git a/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp b/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
index c0a588d4cb..eacb431284 100644
--- a/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
+++ b/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
@@ -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>();
diff --git a/unit_tests/os_interface/windows/wddm_memory_manager_tests.h b/unit_tests/os_interface/windows/wddm_memory_manager_tests.h
index 9b7f894de2..34f8b20ba8 100644
--- a/unit_tests/os_interface/windows/wddm_memory_manager_tests.h
+++ b/unit_tests/os_interface/windows/wddm_memory_manager_tests.h
@@ -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);
diff --git a/unit_tests/os_interface/windows/wddm_residency_controller_tests.cpp b/unit_tests/os_interface/windows/wddm_residency_controller_tests.cpp
index f7f7e67013..568532f2d8 100644
--- a/unit_tests/os_interface/windows/wddm_residency_controller_tests.cpp
+++ b/unit_tests/os_interface/windows/wddm_residency_controller_tests.cpp
@@ -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);
diff --git a/unit_tests/windows/wddm_create_tests.cpp b/unit_tests/windows/wddm_create_tests.cpp
index 2cbbe20bad..76fe7b944f 100644
--- a/unit_tests/windows/wddm_create_tests.cpp
+++ b/unit_tests/windows/wddm_create_tests.cpp
@@ -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));
 }