Detect AMD GPUs without lspci

shelling out to lspci and relying upon pciids.txt is fragile,
especially when trying to run on an old distro.  To avoid risk with
this instead parse kfd sysfs files to determine if an APU or dGPU
and build the graphics architecture.

Signed-off-by: Mario Limonciello (AMD) <superm1@kernel.org>

Author: superm1

src/cpp/server/system_info.cpp

@@ -379,7 +379,17 @@ bool SystemInfo::check_vulkan_support() {
 static std::string identify_rocm_arch_from_name(const std::string& device_name) {
     std::string device_lower = device_name;
     std::transform(device_lower.begin(), device_lower.end(), device_lower.begin(), ::tolower);
-    
+
+    // linux will pass the ISA from KFD, transform it to what the rest of lemonade expects
+    if (std::all_of(device_lower.begin(), device_lower.end(), ::isdigit)) {
+        if (device_lower.length() >= 4) {
+            std::string major = device_lower.substr(0, 2);
+            std::string minor = device_lower.substr(2, 1);
+            std::string revision = device_lower.substr(3, 1);
+            return "gfx" + major + minor + revision;
+        }
+    }
+
     if (device_lower.find("radeon") == std::string::npos) {
         return "";
     }
@@ -1290,92 +1300,85 @@ NPUInfo LinuxSystemInfo::get_npu_device() {
 
 std::vector<GPUInfo> LinuxSystemInfo::detect_amd_gpus(const std::string& gpu_type) {
     std::vector<GPUInfo> gpus;
-    
-    // Execute lspci to find GPUs
-    FILE* pipe = popen("lspci 2>/dev/null | grep -iE 'vga|3d|display'", "r");
-    if (!pipe) {
+    std::string kfd_path = "/sys/class/kfd/kfd/topology/nodes";
+
+    if (!fs::exists(kfd_path)) {
         GPUInfo gpu;
         gpu.available = false;
-        gpu.error = "Failed to execute lspci command";
+        gpu.error = "No KFD nodes found (AMD GPU driver not loaded or no GPU present)";
         gpus.push_back(gpu);
         return gpus;
     }
-    
-    char buffer[512];
-    std::vector<std::string> lspci_lines;
-    while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
-        lspci_lines.push_back(buffer);
-    }
-    pclose(pipe);
-    
-    // Parse AMD GPUs
-    for (const auto& line : lspci_lines) {
-        if (line.find("AMD") != std::string::npos || line.find("ATI") != std::string::npos) {
-            // Extract device name
-            std::string name;
-            size_t pos = line.find(": ");
-            if (pos != std::string::npos) {
-                name = line.substr(pos + 2);
-                // Remove newline
-                if (!name.empty() && name.back() == '\n') {
-                    name.pop_back();
+
+    for (const auto& node_entry : fs::directory_iterator(kfd_path)) {
+        if (!node_entry.is_directory()) continue;
+
+        std::string node_path = node_entry.path().string();
+        std::string properties_file = node_path + "/properties";
+
+        if (!fs::exists(properties_file)) continue;
+
+        std::ifstream props(properties_file);
+        if (!props.is_open()) continue;
+
+        std::string line;
+        std::string drm_render_minor;
+        std::string gfx_target_version;
+
+        bool is_gpu = false;
+
+        while (std::getline(props, line)) {
+            if (line.find("gfx_target_version") == 0) {
+                gfx_target_version = line.substr(line.find(" ") + 1);
+                gfx_target_version.erase(gfx_target_version.find_last_not_of(" \t\n\r") + 1);
+                if (!gfx_target_version.empty() && std::stoi(gfx_target_version) != 0) {
+                    is_gpu = true;
                 }
-            } else {
-                name = line;
+            } else if (line.find("drm_render_minor") == 0) {
+                drm_render_minor = line.substr(line.find(" ") + 1);
+                drm_render_minor.erase(drm_render_minor.find_last_not_of(" \t\n\r") + 1);
             }
+        }
+        props.close();
+
+        if (!is_gpu || drm_render_minor.empty() || drm_render_minor == "-1")
+            continue;
+
+
+        std::string device_path = "/sys/class/drm/renderD" + drm_render_minor + "/device/";
+        std::string board_info_path = device_path + "board_info";
+        bool is_integrated = !fs::exists(board_info_path) && fs::is_regular_file(board_info_path);
+
+        GPUInfo gpu;
+        gpu.name = gfx_target_version;
+        gpu.available = true;
+
+        // Get VRAM for discrete GPUs
+        if (!is_integrated) {
+            std::string vram_file = device_path + "/mem_info_vram_total";
+            if (!fs::exists(vram_file))
+                continue;
+            std::ifstream vram_stream(vram_file);
+            std::string vram_str;
+            std::getline(vram_stream, vram_str);
+            uint64_t vram_bytes = std::stoull(vram_str);
+            gpu.vram_gb = std::round(vram_bytes / (1024.0 * 1024.0 * 1024.0) * 10.0) / 10.0;
 
-            // Classify as discrete or integrated using keywords
-            std::string name_lower = name;
-            std::transform(name_lower.begin(), name_lower.end(), name_lower.begin(), ::tolower);
-            
-            bool is_discrete = false;
-            for (const auto& keyword : AMD_DISCRETE_GPU_KEYWORDS) {
-                if (name_lower.find(keyword) != std::string::npos) {
-                    is_discrete = true;
-                    break;
-                }
-            }
-            bool is_integrated = !is_discrete;
+            // Detect inference engines
+            std::string device_type = is_integrated ? "amd_igpu" : "amd_dgpu";
+            gpu.inference_engines = detect_inference_engines(device_type, gfx_target_version);
 
-            // Filter based on requested type
-            if ((gpu_type == "integrated" && is_integrated) || 
-                (gpu_type == "discrete" && is_discrete)) {
-                
-                GPUInfo gpu;
-                gpu.name = name;
-                gpu.available = true;
-                
-                // Get VRAM for discrete GPUs
-                if (is_discrete) {
-                    // Extract PCI ID from lspci line (first field)
-                    std::string pci_id = line.substr(0, line.find(" "));
-                    
-                    double vram = get_amd_vram_rocm_smi();
-                    if (vram == 0.0) {
-                        vram = get_amd_vram_sysfs(pci_id);
-                    }
-                    
-                    if (vram > 0.0) {
-                        gpu.vram_gb = vram;
-                    }
-                }
-                
-                // Detect inference engines
-                std::string device_type = is_integrated ? "amd_igpu" : "amd_dgpu";
-                gpu.inference_engines = detect_inference_engines(device_type, name);
-                
-                gpus.push_back(gpu);
-            }
+            gpus.push_back(gpu);
+        }
+
+        if (gpus.empty()) {
+            GPUInfo gpu;
+            gpu.available = false;
+            gpu.error = "No AMD " + gpu_type + " GPU found in KFD nodes";
+            gpus.push_back(gpu);
         }
     }
-    
-    if (gpus.empty()) {
-        GPUInfo gpu;
-        gpu.available = false;
-        gpu.error = "No AMD " + gpu_type + " GPU found";
-        gpus.push_back(gpu);
-    }
-    
+
     return gpus;
 }
 

src/lemonade/common/system_info.py

@@ -5,7 +5,7 @@
 import re
 import subprocess
 import ctypes
-import glob
+import os
 from .inference_engines import detect_inference_engines
 
 # AMD GPU classification keywords - shared across all OS implementations
@@ -555,7 +555,6 @@ def _get_gpu_vram_dxdiag_simple(self, gpu_name: str) -> float:
         """
         try:
             import tempfile
-            import os
 
             with tempfile.NamedTemporaryFile(
                 mode="w+", suffix=".txt", delete=False
@@ -917,51 +916,60 @@ def _detect_amd_gpus(self, gpu_type: str, include_inference_engines: bool = Fals
         """
         gpu_devices = []
         try:
-            lspci_output = subprocess.check_output(
-                "lspci | grep -i 'vga\\|3d\\|display'", shell=True
-            ).decode()
-
-            for line in lspci_output.split("\n"):
-                if line.strip() and "AMD" in line:
-                    name_lower = line.lower()
-
-                    # Keyword-based classification - simple and reliable
-                    is_discrete_by_name = any(
-                        kw in name_lower for kw in AMD_DISCRETE_GPU_KEYWORDS
-                    )
-                    is_integrated = not is_discrete_by_name
-
-                    # Filter based on requested type
-                    if (gpu_type == "integrated" and is_integrated) or (
-                        gpu_type == "discrete" and not is_integrated
-                    ):
-
-                        device_type = "amd_igpu" if is_integrated else "amd_dgpu"
-                        device_name = line.split(": ")[1] if ": " in line else line
-
-                        gpu_info = {
-                            "name": device_name,
-                            "available": True,
-                        }
-
-                        # Get VRAM information for discrete GPUs
-                        if not is_integrated:  # Only add VRAM for discrete GPUs
-                            vram_gb = self._get_amd_vram_rocm_smi_linux()
-                            if vram_gb == 0.0:
-                                # Fallback to sysfs - extract PCI ID from lspci line
-                                pci_id = line.split()[0] if line else ""
-                                vram_gb = self._get_amd_vram_sysfs(pci_id)
-
-                            if vram_gb > 0.0:
-                                gpu_info["vram_gb"] = vram_gb
-                            else:
-                                gpu_info["vram_gb"] = "Unknown"
+            gpu_info = {}
+            kfd_dir = "/sys/class/kfd/kfd/topology/nodes/"
+            if not os.path.isdir(kfd_dir):
+                return gpu_devices
+
+            for node in os.listdir(kfd_dir):
+                isa = 0
+                render_minor = None
+                properties_path = os.path.join(kfd_dir, node, "properties")
+                if os.path.isfile(properties_path):
+                    try:
+                        with open(properties_path, "r", encoding="utf-8") as f:
+                            for line in f:
+                                if "gfx_target_version" in line:
+                                    isa = line.split()[1].strip()
+                                if "drm_render_minor" in line:
+                                    render_minor = line.split()[1].strip()
+                    except (OSError, ValueError):
+                        continue
+                if int(isa) == 0:
+                    continue
+                gpu_info = {
+                    "name": f"AMD GPU Node {node}",
+                    "isa": isa,
+                    "drm_render_minor": render_minor,
+                    "available": True,
+                }
 
-                        if include_inference_engines:
-                            gpu_info["inference_engines"] = (
-                                self._detect_inference_engines(device_type, device_name)
-                            )
-                        gpu_devices.append(gpu_info)
+            device_path = (
+                f"/sys/class/drm/renderD{gpu_info['drm_render_minor']}/device/"
+            )
+            board_info_path = os.path.join(device_path, "board_info")
+
+            is_discrete = os.path.isfile(board_info_path)
+            is_integrated = not is_discrete
+            if (
+                is_integrated
+                and gpu_type != "integrated"
+                or (is_discrete and gpu_type != "discrete")
+            ):
+                return gpu_devices
+
+            # Filter based on requested type
+            device_type = "amd_igpu" if is_integrated else "amd_dgpu"
+
+            # Get VRAM information for discrete GPUs
+            if is_discrete:
+                gpu_info["vram_gb"] = self._get_amd_vram_sysfs(device_path)
+
+            if include_inference_engines:
+                gpu_info["inference_engines"] = self._detect_inference_engines(
+                    device_type, gpu_info["isa"]
+                )
+            gpu_devices.append(gpu_info)
 
         except Exception as e:  # pylint: disable=broad-except
             error_msg = f"AMD {gpu_type} GPU detection failed: {e}"
@@ -1216,79 +1224,21 @@ def _get_nvidia_vram_smi_linux(self) -> float:
             pass
         return 0.0
 
-    def _get_amd_vram_rocm_smi_linux(self) -> float:
-        """
-        Get AMD GPU VRAM using rocm-smi command on Linux.
-
-        Returns:
-            float: VRAM in GB, or 0.0 if detection fails
-        """
-        try:
-            output = (
-                subprocess.check_output(
-                    ["rocm-smi", "--showmeminfo", "vram", "--csv"],
-                    stderr=subprocess.DEVNULL,
-                )
-                .decode()
-                .strip()
-            )
-
-            # Parse CSV output to extract VRAM
-            lines = output.split("\n")
-            for line in lines:
-                if "Total VRAM" in line or "vram" in line.lower():
-                    # Extract numeric value (assuming it's in MB or GB)
-                    numbers = re.findall(r"\d+", line)
-                    if numbers:
-                        vram_value = int(numbers[0])
-                        # Assume MB if value is large, GB if small
-                        if vram_value > 100:  # Likely MB
-                            vram_gb = round(vram_value / 1024, 1)
-                        else:  # Likely GB
-                            vram_gb = float(vram_value)
-                        return vram_gb
-        except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
-            pass
-        return 0.0
-
-    def _get_amd_vram_sysfs(self, pci_id: str) -> float:
+    def _get_amd_vram_sysfs(self, device: str) -> float:
         """
         Get AMD GPU VRAM using sysfs on Linux.
 
         Args:
-            pci_id: PCI ID of the GPU (e.g., "0000:01:00.0")
+            device: base device path
 
         Returns:
-            float: VRAM in GB, or 0.0 if detection fails
+            float: VRAM in GBfails
         """
-        try:
-            # Try different sysfs paths for VRAM information
-            sysfs_paths = [
-                f"/sys/bus/pci/devices/{pci_id}/mem_info_vram_total",
-                "/sys/class/drm/card*/device/mem_info_vram_total",
-            ]
-
-            for path in sysfs_paths:
-                try:
-                    if "*" in path:
-                        # Handle wildcard paths
-                        matching_paths = glob.glob(path)
-                        for match_path in matching_paths:
-                            with open(match_path, "r", encoding="utf-8") as f:
-                                vram_bytes = int(f.read().strip())
-                                vram_gb = round(vram_bytes / (1024**3), 1)
-                                if vram_gb > 0:
-                                    return vram_gb
-                    else:
-                        with open(path, "r", encoding="utf-8") as f:
-                            vram_bytes = int(f.read().strip())
-                            vram_gb = round(vram_bytes / (1024**3), 1)
-                            return vram_gb
-                except (FileNotFoundError, ValueError, PermissionError):
-                    continue
-        except Exception:  # pylint: disable=broad-except
-            pass
-        return 0.0
+        path = os.path.join(device, "mem_info_vram_total")
+        with open(path, "r", encoding="utf-8") as f:
+            vram_bytes = int(f.read().strip())
+            vram_gb = round(vram_bytes / (1024**3), 1)
+        return vram_gb
 
     def _detect_inference_engines(self, device_type: str, device_name: str) -> dict:
         """