detection of Intel GPU drivers corrected - 2.13 (#1532)

Author: jcchr

platform/services/installer/app/checks/resources.py

@@ -7,6 +7,7 @@
 
 import logging
 import os
+import re
 import subprocess
 from subprocess import CalledProcessError, TimeoutExpired
 
@@ -160,7 +161,33 @@ def check_gpu_driver_version(config: InstallationConfig | UpgradeConfig) -> None
     logger.debug("GPU driver version matched.")
 
 
-def _get_intel_gpus() -> str:
+def _check_intel_gpu_driver(env: dict[str, str]) -> bool:
+    """
+    Returns true if intel gpu driver is installed
+    """
+    try:
+        command = 'clinfo|grep "' + ResourcesChecksTexts.intel_gpu_arc_device_name + '"|grep Intel'
+        logger.debug(f"Getting the list of Intel GPU drivers with {command}")
+
+        clinfo_output = subprocess.check_output(  # noqa: S602  # nosec: B602
+            command,
+            stderr=subprocess.STDOUT,
+            shell=True,
+            timeout=5,
+            env=env,
+        ).decode("utf-8")
+        logger.debug(clinfo_output)
+        if ResourcesChecksTexts.intel_gpu_arc_device_name in clinfo_output:
+            return True
+
+    except (CalledProcessError, TimeoutExpired, FileNotFoundError) as err:
+        logger.debug(f"Checking the installed Intel GPU driver failed with {err}")
+        return False
+
+    return False
+
+
+def _get_intel_gpus() -> tuple[str, bool]:  # noqa: C901
     """
     MAX cards:
     Attempt to get Intel GPUs with xpu-smi
@@ -182,33 +209,49 @@ def _get_intel_gpus() -> str:
         logger.debug(xpu_output)
         if ResourcesChecksTexts.intel_gpu_no_devices in xpu_output:
             logger.debug("No devices")
-            return ""
+            return "", True
         if ResourcesChecksTexts.intel_gpu_max_card in xpu_output:
             logger.debug("Max 1100 found")
-            return xpu_output
+            return GPU_PROVIDER_INTEL_MAX, True
     except (CalledProcessError, TimeoutExpired, FileNotFoundError) as err:
         logger.debug(f"Getting the list of Intel GPU failed with {err}")
 
     # Only valid for ARC cards
+    if not _check_intel_gpu_driver(env):
+        return "", False
     try:
-        command = 'clinfo|grep "' + ResourcesChecksTexts.intel_gpu_arc_device_name + '"|grep Intel'
+        command = "lspci -nnk | grep -iA3 'VGA\|3D\|Display'"
         logger.debug(f"Getting the list of Intel ARC with {command}")
 
-        clinfo_output = subprocess.check_output(  # noqa: S602  # nosec: B602
+        lspci_output = subprocess.check_output(  # noqa: S602  # nosec: B602
             command,
             stderr=subprocess.STDOUT,
             shell=True,
             timeout=5,
             env=env,
         ).decode("utf-8")
-        logger.debug(clinfo_output)
-        if ResourcesChecksTexts.intel_gpu_arc_device_name in clinfo_output:
-            logger.debug("ARC found")
-            return clinfo_output
+        driver = ""
+        cards = lspci_output.split("--\n")
+        for card in cards:
+            drivers = re.findall(r"Kernel driver in use:\s*([^\s]+)", card)
+
+            if ResourcesChecksTexts.intel_gpu_i915_driver in drivers:
+                driver = GPU_PROVIDER_INTEL_ARC_A
+            elif ResourcesChecksTexts.intel_gpu_xe_driver in drivers:
+                driver = GPU_PROVIDER_INTEL_ARC
+
+            if driver:
+                first_line = card.split("\n")[0]
+                if "Intel Corporation Device" in first_line:
+                    logger.debug(f"Intel dGPU found: {driver}")
+                    return driver, True
+
+        logger.debug(f"Intel iGPU found: {driver}")
+        return driver, False
     except (CalledProcessError, TimeoutExpired, FileNotFoundError) as err:
         logger.debug(f"Getting the list of Intel ARC failed with {err}")
 
-    return ""
+    return "", False
 
 
 def _get_nvidia_gpus():
@@ -258,22 +301,17 @@ def check_local_gpu(config: InstallationConfig):  # noqa: ANN201
 
     # If Nvidia not found, let's look for Intel GPU
     # We prefer Intel GPU, so ignoring Nvidia if Intel GPU found
-    intel_gpus = _get_intel_gpus()
-    if not intel_gpus and not nvidia_gpus:
+    intel_gpu, isdGPU = _get_intel_gpus()
+    if not intel_gpu and not nvidia_gpus:
         raise ResourcesCheckWarning(ResourcesChecksTexts.gpu_requirements_check_error)
-    if intel_gpus:
-        if ResourcesChecksTexts.intel_gpu_max_card in intel_gpus:
-            config.gpu_provider.value = GPU_PROVIDER_INTEL_MAX
-        elif ResourcesChecksTexts.intel_gpu_arc_a_card in intel_gpus:
-            config.gpu_provider.value = GPU_PROVIDER_INTEL_ARC_A
-        else:
-            config.gpu_provider.value = GPU_PROVIDER_INTEL_ARC
-        logger.info(f"GPU provider: {config.gpu_provider.value}")
+    if intel_gpu and isdGPU:
+        config.gpu_provider.value = intel_gpu
+        logger.info(f"GPU provider (Intel dGPU): {config.gpu_provider.value}")
     elif nvidia_gpus:
         config.gpu_provider.value = GPU_PROVIDER_NVIDIA
         logger.info(f"GPU provider: {config.gpu_provider.value}")
         found_gpus = [f"{local_gpu['name']}, mem={str(local_gpu['memory_total'])}MiB" for local_gpu in nvidia_gpus]
-        logger.debug(f"Found GPUs: {', '.join(found_gpus)}")
+        logger.debug(f"Found nVidia GPUs: {', '.join(found_gpus)}")
 
         unsupported_gpus = [gpu for gpu in nvidia_gpus if gpu["memory_total"] < SUPPORTED_GPUS_MEMORY]
         if unsupported_gpus:
@@ -282,6 +320,9 @@ def check_local_gpu(config: InstallationConfig):  # noqa: ANN201
             raise UnsupportedGpuWarning(
                 ResourcesChecksTexts.gpu_requirements_check_memory.format(gpus=unsupported_gpus_str)
             )
+    elif intel_gpu:
+        config.gpu_provider.value = intel_gpu
+        logger.info(f"GPU provider (Intel iGPU): {config.gpu_provider.value}")
 
 
 def check_local_mem():  # noqa: ANN201

platform/services/installer/app/texts/checks.py

@@ -214,4 +214,5 @@ class ResourcesChecksTexts:
     intel_gpu_no_devices = "No device discovered"
     intel_gpu_max_card = "Data Center GPU Max 1100"
     intel_gpu_arc_device_name = "Device Name"
-    intel_gpu_arc_a_card = "Arc(TM) A"
+    intel_gpu_i915_driver = "i915"
+    intel_gpu_xe_driver = "xe"

platform/services/installer/tests/unit/checks/test_resources_checks.py

@@ -16,7 +16,11 @@
     UnsupportedGpuWarning,
 )
 from checks.resources import (
+    GPU_PROVIDER_INTEL_ARC,
+    GPU_PROVIDER_INTEL_ARC_A,
+    GPU_PROVIDER_INTEL_MAX,
     SUPPORTED_NVIDIA_DRIVER_VERSION,
+    _get_intel_gpus,
     check_gpu_driver_version,
     check_local_cpu,
     check_local_disk,
@@ -29,6 +33,34 @@
 from configuration_models.upgrade_config import UpgradeConfig
 from texts.checks import ResourcesChecksTexts
 
+arc_xe_description = """    03:00.0 Display controller [0380]: Intel Corporation Device [8086:e216]
+            Subsystem: Intel Corporation Device [8086:1500]
+            Kernel driver in use: xe
+            Kernel modules: xe"""
+
+arc_i915_description = """    03:00.0 Display controller [0380]: Intel Corporation Device [8086:e216]
+            Subsystem: Intel Corporation Device [8086:1500]
+            Kernel driver in use: i915
+            Kernel modules: i915"""
+
+igpu_description = """00:02.0 VGA compatible controller [0300]: Intel Corporation Raptor Lake-S GT1 [UHD Graphics 770] [8086:a780] (rev 04)
+            DeviceName: Onboard IGD
+            Subsystem: ASUSTeK Computer Inc. Raptor Lake-S GT1 [UHD Graphics 770] [1043:8882]
+            Kernel driver in use: i915"""
+
+nvidia_description = """08:00.0 VGA compatible controller [0300]: NVIDIA Corporation GA102 [GeForce RTX 3090] [10de:2204] (rev a1)
+            Subsystem: Gigabyte Technology Co., Ltd GA102 [GeForce RTX 3090] [1458:4043]
+            Kernel driver in use: nouveau
+            Kernel modules: nvidiafb, nouveau"""
+
+arc_xe_igpu_description = arc_xe_description + "\n--\n" + igpu_description
+
+arc_i915_igpu_description = arc_i915_description + "\n--\n" + igpu_description
+
+arc_xe_nvidia_description = arc_xe_description + "\n--\n" + nvidia_description
+
+nvidia_igpu_description = nvidia_description + "\n--\n" + igpu_description
+
 
 def test_check_local_cpu(mocker):
     """Check if the requirement for 12 physical cores passes successfully"""
@@ -91,36 +123,115 @@ def test_check_local_nvidia_gpu_ok(get_gpus_mock):
     assert install_config_mock.gpu_provider.value == "nvidia"
 
 
-def test_check_local_intel_gpu_ok(get_gpus_mock, get_intel_gpus_mock):
-    get_gpus_mock.return_value = []
-    get_intel_gpus_mock.return_value = "Device Name: Intel(R) Data Center GPU Max 1100"
+def test_get_intel_gpus_max_card(mocker):
+    sub_process_mock = mocker.patch(
+        "subprocess.check_output", return_value=ResourcesChecksTexts.intel_gpu_max_card.encode("utf-8")
+    )
+    gpus, _ = _get_intel_gpus()
+
+    assert GPU_PROVIDER_INTEL_MAX in gpus
+    assert sub_process_mock.call_count == 1
+
+
+def test_get_intel_gpus_arc_xe_card(mocker):
+    sub_process_mock = mocker.patch("subprocess.check_output", return_value=arc_xe_description.encode("utf-8"))
+    check_intel_gpu_driver_mock = mocker.patch("checks.resources._check_intel_gpu_driver", return_value=True)
+
+    gpus, isdGPU = _get_intel_gpus()
+
+    assert GPU_PROVIDER_INTEL_ARC in gpus
+    assert isdGPU is True
+    assert check_intel_gpu_driver_mock.call_count == 1
+    assert sub_process_mock.call_count == 2
+
+
+def test_get_intel_gpus_arc_i915_card(mocker):
+    sub_process_mock = mocker.patch("subprocess.check_output", return_value=arc_i915_description.encode("utf-8"))
+    check_intel_gpu_driver_mock = mocker.patch("checks.resources._check_intel_gpu_driver", return_value=True)
+
+    gpus, isdGPU = _get_intel_gpus()
+
+    assert GPU_PROVIDER_INTEL_ARC_A in gpus
+    assert isdGPU is True
+    assert check_intel_gpu_driver_mock.call_count == 1
+    assert sub_process_mock.call_count == 2
+
+
+def test_get_intel_gpus_arc_igpu_card(mocker):
+    sub_process_mock = mocker.patch("subprocess.check_output", return_value=arc_i915_igpu_description.encode("utf-8"))
+    check_intel_gpu_driver_mock = mocker.patch("checks.resources._check_intel_gpu_driver", return_value=True)
+
+    gpus, isdPGU = _get_intel_gpus()
+
+    assert GPU_PROVIDER_INTEL_ARC_A in gpus
+    assert isdPGU is True
+    assert check_intel_gpu_driver_mock.call_count == 1
+    assert sub_process_mock.call_count == 2
+
+
+def test_get_intel_gpus_igpu_card(mocker):
+    sub_process_mock = mocker.patch("subprocess.check_output", return_value=igpu_description.encode("utf-8"))
+    check_intel_gpu_driver_mock = mocker.patch("checks.resources._check_intel_gpu_driver", return_value=True)
+
+    gpus, isdPGU = _get_intel_gpus()
+
+    assert GPU_PROVIDER_INTEL_ARC_A in gpus
+    assert isdPGU is False
+    assert check_intel_gpu_driver_mock.call_count == 1
+    assert sub_process_mock.call_count == 2
+
+
+def test_check_local_nvidia_arc(mocker):
+    get_intel_mock = mocker.patch("checks.resources._get_intel_gpus", return_value=(GPU_PROVIDER_INTEL_ARC, True))
+    get_nvidia_mock = mocker.patch(
+        "checks.resources._get_nvidia_gpus",
+        return_value=[
+            {
+                "name": "NVIDIA GeForce RTX 3090",
+                "memory_total": 24576,
+            }
+        ],
+    )
+
     install_config_mock = InstallationConfig(interactive_mode=False, install_telemetry_stack=False)
     install_config_mock.gpu_support.value = True
     check_local_gpu(config=install_config_mock)
-    assert get_gpus_mock.call_count == 1
-    assert get_intel_gpus_mock.call_count == 1
-    assert install_config_mock.gpu_provider.value == "intel-max"
 
+    assert get_intel_mock.call_count == 1
+    assert get_nvidia_mock.call_count == 1
+    assert install_config_mock.gpu_provider.value == GPU_PROVIDER_INTEL_ARC
+
+
+def test_check_local_nvidia_igpu(mocker):
+    get_intel_mock = mocker.patch("checks.resources._get_intel_gpus", return_value=(GPU_PROVIDER_INTEL_ARC, False))
+    get_nvidia_mock = mocker.patch(
+        "checks.resources._get_nvidia_gpus",
+        return_value=(
+            [
+                {
+                    "name": "NVIDIA GeForce RTX 3090",
+                    "memory_total": 24576,
+                }
+            ]
+        ),
+    )
 
-def test_check_local_intel_gpu_arc_ok(get_gpus_mock, get_intel_gpus_mock):
-    get_gpus_mock.return_value = []
-    get_intel_gpus_mock.return_value = "Device Name Intel(R) Graphics"
     install_config_mock = InstallationConfig(interactive_mode=False, install_telemetry_stack=False)
     install_config_mock.gpu_support.value = True
     check_local_gpu(config=install_config_mock)
-    assert get_gpus_mock.call_count == 1
-    assert get_intel_gpus_mock.call_count == 1
-    assert install_config_mock.gpu_provider.value == "intel-arc"
 
+    assert get_intel_mock.call_count == 1
+    assert get_nvidia_mock.call_count == 1
+    assert install_config_mock.gpu_provider.value == "nvidia"
 
-def test_check_local_gpu_not_found(get_gpus_mock, get_intel_gpus_mock):
-    get_gpus_mock.return_value = []
-    get_intel_gpus_mock.return_value = ""
-    with pytest.raises(ResourcesCheckWarning):
-        install_config_mock = InstallationConfig(interactive_mode=False, install_telemetry_stack=False)
-        check_local_gpu(config=install_config_mock)
-    assert get_gpus_mock.call_count == 1
-    assert get_intel_gpus_mock.call_count == 1
+
+def test_get_intel_gpus_no_card(mocker):
+    sub_process_mock = mocker.patch("subprocess.check_output", return_value=b"lack of Intel gpu")
+
+    gpus = _get_intel_gpus()
+
+    assert not gpus[0]
+    assert sub_process_mock.call_count == 2
 
 
 def test_check_local_gpu_not_supported(get_gpus_mock):