Add new debug flags for filtering devices to open

FilterBdfPath is used only on Linux as a filter for BDF
when opening from /dev/dri/by-path

FilterDeviceId is used on both OSes as a filter for device id

Signed-off-by: Mateusz Jablonski <[email protected]>

Author: JablonskiMateusz

opencl/test/unit_test/linux/main_linux_dll.cpp

@@ -114,27 +114,51 @@ TEST_F(DrmSimpleTests, GivenTwoOpenableDevicesWhenDiscoverDevicesThenCreateTwoHw
     EXPECT_EQ(2u, hwDeviceIds.size());
 }
 
-TEST_F(DrmSimpleTests, GivenSelectedNotExistingDeviceWhenGetDeviceFdThenFail) {
+TEST_F(DrmSimpleTests, GivenSelectedNotExistingDeviceUsingForceDeviceIdFlagWhenGetDeviceFdThenFail) {
     DebugManagerStateRestore stateRestore;
-    DebugManager.flags.ForceDeviceId.set("1234");
-    VariableBackup<decltype(openFull)> backupOpenFull(&openFull);
-    openFull = testOpen;
-    openRetVal = -1;
+    DebugManager.flags.ForceDeviceId.set("invalid");
+    openFull = nullptr; // open shouldn't be called
     ExecutionEnvironment executionEnvironment;
     auto hwDeviceIds = OSInterface::discoverDevices(executionEnvironment);
     EXPECT_TRUE(hwDeviceIds.empty());
 }
 
-TEST_F(DrmSimpleTests, GivenSelectedExistingDeviceWhenGetDeviceFdThenReturnFd) {
+TEST_F(DrmSimpleTests, GivenSelectedExistingDeviceUsingForceDeviceIdFlagWhenGetDeviceFdThenReturnFd) {
     DebugManagerStateRestore stateRestore;
     DebugManager.flags.ForceDeviceId.set("0000:00:02.0");
     VariableBackup<decltype(openFull)> backupOpenFull(&openFull);
-    openRetVal = 1023; // fakeFd
-    openFull = testOpen;
+    openFull = openWithCounter;
+    openCounter = 10;
+    ExecutionEnvironment executionEnvironment;
+    auto hwDeviceIds = OSInterface::discoverDevices(executionEnvironment);
+    EXPECT_EQ(1u, hwDeviceIds.size());
+    EXPECT_NE(nullptr, hwDeviceIds[0].get());
+    EXPECT_STREQ("/dev/dri/by-path/platform-4010000000.pcie-pci-0000:00:02.0-render", lastOpenedPath.c_str());
+    EXPECT_EQ(9, openCounter); // only one opened file
+}
+
+TEST_F(DrmSimpleTests, GivenSelectedNotExistingDeviceUsingFilterBdfWhenGetDeviceFdThenFail) {
+    DebugManagerStateRestore stateRestore;
+    DebugManager.flags.FilterBdfPath.set("invalid");
+    VariableBackup<decltype(openFull)> backupOpenFull(&openFull);
+    openFull = nullptr; // open shouldn't be called
+    ExecutionEnvironment executionEnvironment;
+    auto hwDeviceIds = OSInterface::discoverDevices(executionEnvironment);
+    EXPECT_TRUE(hwDeviceIds.empty());
+}
+
+TEST_F(DrmSimpleTests, GivenSelectedExistingDeviceUsingFilterBdfWhenGetDeviceFdThenReturnFd) {
+    DebugManagerStateRestore stateRestore;
+    DebugManager.flags.FilterBdfPath.set("0000:00:02.0");
+    VariableBackup<decltype(openFull)> backupOpenFull(&openFull);
+    openFull = openWithCounter;
+    openCounter = 10;
     ExecutionEnvironment executionEnvironment;
     auto hwDeviceIds = OSInterface::discoverDevices(executionEnvironment);
     EXPECT_EQ(1u, hwDeviceIds.size());
     EXPECT_NE(nullptr, hwDeviceIds[0].get());
+    EXPECT_STREQ("/dev/dri/by-path/platform-4010000000.pcie-pci-0000:00:02.0-render", lastOpenedPath.c_str());
+    EXPECT_EQ(9, openCounter); // only one opened file
 }
 
 TEST_F(DrmSimpleTests, GivenSelectedExistingDeviceWhenOpenDirSuccedsThenHwDeviceIdsHaveProperPciPaths) {
@@ -405,16 +429,21 @@ TEST_F(DrmSimpleTests, GivenMultipleAvailableDevicesWhenCreateMultipleRootDevice
     EXPECT_STREQ("0000:00:02.0", hwDeviceIds[1]->as<HwDeviceIdDrm>()->getPciPath());
 }
 
-TEST_F(DrmSimpleTests, GivenSelectedIncorectDeviceWhenGetDeviceFdThenFail) {
+TEST_F(DrmTests, GivenSelectedIncorectDeviceByDeviceIdWhenGetDeviceFdThenFail) {
     DebugManagerStateRestore stateRestore;
-    DebugManager.flags.ForceDeviceId.set("1234");
-    VariableBackup<decltype(openFull)> backupOpenFull(&openFull);
-    openFull = testOpen;
-    openRetVal = 1024;
-    ExecutionEnvironment executionEnvironment;
+    DebugManager.flags.FilterDeviceId.set("invalid");
+    auto drm1 = DrmWrap::createDrm(*rootDeviceEnvironment);
+    EXPECT_EQ(drm1, nullptr);
+}
 
-    auto hwDeviceIds = OSInterface::discoverDevices(executionEnvironment);
-    EXPECT_TRUE(hwDeviceIds.empty());
+TEST_F(DrmTests, GivenSelectedCorrectDeviceByDeviceIdWhenGetDeviceFdThenSucceed) {
+    DebugManagerStateRestore stateRestore;
+    std::stringstream deviceIdStr;
+    deviceIdStr << std::hex << deviceId;
+
+    DebugManager.flags.FilterDeviceId.set(deviceIdStr.str());
+    auto drm1 = DrmWrap::createDrm(*rootDeviceEnvironment);
+    EXPECT_NE(drm1, nullptr);
 }
 
 TEST_F(DrmSimpleTests, givenUseVmBindFlagWhenOverrideBindSupportThenReturnProperValue) {

opencl/test/unit_test/os_interface/device_factory_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -377,6 +377,25 @@ TEST(DiscoverDevices, whenDiscoverDevicesAndForceDeviceIdIsDifferentFromTheExist
     EXPECT_FALSE(result);
 }
 
+TEST(DiscoverDevices, whenDiscoverDevicesAndFilterDifferentFromTheExistingDeviceThenReturnNullptr) {
+    DebugManagerStateRestore stateRestore;
+    DebugManager.flags.FilterDeviceId.set("invalid");
+    DebugManager.flags.FilterBdfPath.set("invalid");
+    ExecutionEnvironment executionEnviornment;
+    auto hwDeviceIds = OSInterface::discoverDevices(executionEnviornment);
+    EXPECT_TRUE(hwDeviceIds.empty());
+}
+
+TEST(DiscoverDevices, whenDiscoverDevicesAndFilterDifferentFromTheExistingDeviceThenPrepareDeviceEnvironmentsReturnsFalse) {
+    DebugManagerStateRestore stateRestore;
+    DebugManager.flags.FilterDeviceId.set("invalid");
+    DebugManager.flags.FilterBdfPath.set("invalid");
+    ExecutionEnvironment executionEnviornment;
+
+    auto result = DeviceFactory::prepareDeviceEnvironments(executionEnviornment);
+    EXPECT_FALSE(result);
+}
+
 using UltDeviceFactoryTest = DeviceFactoryTest;
 
 TEST_F(UltDeviceFactoryTest, givenExecutionEnvironmentWhenCreatingUltDeviceFactoryThenMockMemoryManagerIsAllocated) {

opencl/test/unit_test/os_interface/windows/wddm20_tests.cpp

@@ -1232,6 +1232,15 @@ TEST(WddmGfxPartitionTests, givenInternalFrontWindowHeapWhenAllocatingSmallOrBig
     }
 }
 
+TEST_F(Wddm20Tests, givenWddmWhenDiscoverDevicesAndFilterDeviceIdIsTheSameAsTheExistingDeviceThenReturnTheAdapter) {
+    DebugManagerStateRestore stateRestore;
+    DebugManager.flags.FilterDeviceId.set("1234"); // Existing device Id
+    ExecutionEnvironment executionEnvironment;
+    auto hwDeviceIds = OSInterface::discoverDevices(executionEnvironment);
+    EXPECT_EQ(1u, hwDeviceIds.size());
+    EXPECT_NE(nullptr, hwDeviceIds[0].get());
+}
+
 TEST_F(Wddm20Tests, givenWddmWhenDiscoverDevicesAndForceDeviceIdIsTheSameAsTheExistingDeviceThenReturnTheAdapter) {
     DebugManagerStateRestore stateRestore;
     DebugManager.flags.ForceDeviceId.set("1234"); // Existing device Id

opencl/test/unit_test/test_files/igdrcl.config

@@ -32,6 +32,8 @@ GenerateAubFilePerProcessId = 0
 EnableSWTags = 0
 DumpSWTagsBXML = 0
 ForceDeviceId = unk
+FilterDeviceId = unk
+FilterBdfPath = unk
 LoadBinarySipFromFile = unk
 InjectInternalBuildOptions = unk
 OverrideCsrAllocationSize = -1

shared/source/debug_settings/debug_variables_base.inl

@@ -75,6 +75,8 @@ DECLARE_DEBUG_VARIABLE(bool, AllowPatchingVfeStateInCommandLists, false, "true:
 DECLARE_DEBUG_VARIABLE(bool, PrintMemoryRegionSizes, false, "print memory bank type, instance and it's size")
 DECLARE_DEBUG_VARIABLE(bool, UpdateCrossThreadDataSize, false, "Turn on cross thread data size calculation for PATCH TOKEN binary")
 DECLARE_DEBUG_VARIABLE(std::string, ForceDeviceId, std::string("unk"), "DeviceId selected for testing")
+DECLARE_DEBUG_VARIABLE(std::string, FilterDeviceId, std::string("unk"), "Device id filter, adapter matching device id will be opened. Ignored when unk.")
+DECLARE_DEBUG_VARIABLE(std::string, FilterBdfPath, std::string("unk"), "Linux-only, BDF path filter, only matching paths will be opened. Ignored when unk.")
 DECLARE_DEBUG_VARIABLE(std::string, LoadBinarySipFromFile, std::string("unk"), "Select binary file to load SIP kernel raw binary. When file named *_header.* exists, it is used as header")
 DECLARE_DEBUG_VARIABLE(std::string, InjectInternalBuildOptions, std::string("unk"), "Appends internal build options string to user modules")
 DECLARE_DEBUG_VARIABLE(int64_t, OverrideMultiStoragePlacement, -1, "-1: disable, 0+: tile mask, each bit corresponds to tile")

shared/source/dll/linux/drm_neo_create.cpp

@@ -11,6 +11,7 @@
 #include "shared/source/gmm_helper/gmm_helper.h"
 #include "shared/source/helpers/hw_helper.h"
 #include "shared/source/helpers/hw_info.h"
+#include "shared/source/os_interface/device_factory.h"
 #include "shared/source/os_interface/linux/drm_neo.h"
 #include "shared/source/os_interface/linux/drm_null_device.h"
 
@@ -45,6 +46,9 @@ Drm *Drm::create(std::unique_ptr<HwDeviceIdDrm> &&hwDeviceId, RootDeviceEnvironm
         printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "%s", "FATAL: Cannot query device ID parameter!\n");
         return nullptr;
     }
+    if (!DeviceFactory::isAllowedDeviceId(drmObject->deviceId, DebugManager.flags.FilterDeviceId.get())) {
+        return nullptr;
+    }
 
     // Get HW Revision (I915_drm.h)
     ret = drmObject->getDeviceRevID(drmObject->revisionId);

shared/source/os_interface/device_factory.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -206,4 +206,12 @@ bool (*DeviceFactory::createMemoryManagerFunc)(ExecutionEnvironment &) = [](Exec
     return executionEnvironment.initializeMemoryManager();
 };
 
+bool DeviceFactory::isAllowedDeviceId(uint32_t deviceId, const std::string &deviceIdString) {
+    if (deviceIdString != "unk") {
+        char *endptr = nullptr;
+        auto reqDeviceId = strtoul(deviceIdString.c_str(), &endptr, 16);
+        return (static_cast<uint32_t>(reqDeviceId) == deviceId);
+    }
+    return true;
+}
 } // namespace NEO

shared/source/os_interface/device_factory.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -28,5 +28,6 @@ class DeviceFactory {
 
     static std::unique_ptr<Device> (*createRootDeviceFunc)(ExecutionEnvironment &executionEnvironment, uint32_t rootDeviceIndex);
     static bool (*createMemoryManagerFunc)(ExecutionEnvironment &executionEnvironment);
+    static bool isAllowedDeviceId(uint32_t deviceId, const std::string &deviceIdString);
 };
 } // namespace NEO

shared/source/os_interface/linux/drm_neo.cpp

@@ -597,6 +597,11 @@ std::vector<std::unique_ptr<HwDeviceId>> Drm::discoverDevices(ExecutionEnvironme
                 }
             }
 
+            if (DebugManager.flags.FilterBdfPath.get() != "unk") {
+                if (devicePathView.find(DebugManager.flags.FilterBdfPath.get().c_str()) == std::string::npos) {
+                    continue;
+                }
+            }
             if (DebugManager.flags.ForceDeviceId.get() != "unk") {
                 if (devicePathView.find(DebugManager.flags.ForceDeviceId.get().c_str()) == std::string::npos) {
                     continue;

shared/source/os_interface/windows/wddm/adapter_factory.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -9,6 +9,7 @@
 
 #include "shared/source/debug_settings/debug_settings_manager.h"
 #include "shared/source/helpers/debug_helpers.h"
+#include "shared/source/os_interface/device_factory.h"
 #include "shared/source/utilities/stackvec.h"
 
 #include <cstdlib>
@@ -24,13 +25,8 @@ bool canUseAdapterBasedOnDriverDesc(const char *driverDescription) {
 }
 
 bool isAllowedDeviceId(uint32_t deviceId) {
-    if (DebugManager.flags.ForceDeviceId.get() == "unk") {
-        return true;
-    }
-
-    char *endptr = nullptr;
-    auto reqDeviceId = strtoul(DebugManager.flags.ForceDeviceId.get().c_str(), &endptr, 16);
-    return (static_cast<uint32_t>(reqDeviceId) == deviceId);
+    return DeviceFactory::isAllowedDeviceId(deviceId, DebugManager.flags.FilterDeviceId.get()) &&
+           DeviceFactory::isAllowedDeviceId(deviceId, DebugManager.flags.ForceDeviceId.get());
 }
 
 } // namespace NEO