refactor: change indexes to index

Signed-off-by: thxCode <thxcode0824@gmail.com>

Author: thxCode

docs/modules/gpustack_runtime.deployer.md

@@ -0,0 +1 @@
+::: gpustack_runtime.deployer

gpustack_runtime/cmds/detector.py

@@ -115,11 +115,7 @@ def format_devices_table(devs: Devices) -> str:
     device_lines = []
     for dev in devs:
         row_data = [
-            str(
-                dev.indexes[0]
-                if dev.indexes and len(dev.indexes) == 1
-                else ", ".join(str(i) for i in dev.indexes),
-            ),
+            dev.index,
             dev.name if dev.name else "N/A",
             f"{dev.memory_used}MiB / {dev.memory}MiB"
             if dev.memory and dev.memory_used

gpustack_runtime/detector/__types__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from enum import Enum
 from typing import Any
 
@@ -133,12 +133,13 @@ class Device:
     """
     Manufacturer of the device.
     """
-    indexes: list[int] = field(default_factory=list)
+    index: int = 0
     """
-    Indexes of the device.
-    For most devices, this field usually contains only one index.
-    However, some devices use the chip on the device as the actual device,
-    so this field may contain multiple indexes.
+    Index of the device.
+    If GPUSTACK_RUNTIME_DETECT_PHYSICAL_INDEX_PRIORITY is set to 1,
+    this will be the physical index of the device.
+    Otherwise, it will be the logical index of the device.
+    Physical index is adapted to non-virtualized devices.
     """
     name: str = ""
     """

gpustack_runtime/detector/__utils__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -87,3 +88,64 @@ def get_pci_devices(
         )
 
     return pci_devices
+
+
+@dataclass
+class DeviceFile:
+    path: Path
+    """
+    Path to the device file.
+    """
+    number: int | None = None
+    """
+    Number of the device file.
+    """
+
+
+def get_device_files(pattern: str, directory: Path = Path("/dev")) -> list[DeviceFile]:
+    r"""
+    Get device files with the given pattern.
+
+    Args:
+        pattern:
+            Pattern of the device files to search for.
+            Pattern must include a regex group for the number,
+            e.g nvidia(?P<number>\d+).
+        directory:
+            Directory to search for device files,
+            e.g /dev.
+
+    Returns:
+        List of DeviceFile objects.
+
+    """
+    if "(?P<number>" not in pattern:
+        msg = "Pattern must include a regex group for the number, e.g nvidia(?P<number>\\d+)."
+        raise ValueError(msg)
+
+    device_files = []
+    if not directory.exists():
+        return device_files
+
+    regex = re.compile(f"^{directory!s}/{pattern}$")
+    for path in directory.iterdir():
+        matched = regex.match(str(path))
+        if not matched:
+            continue
+        number = matched.group("number")
+        try:
+            number = int(number)
+        except ValueError:
+            number = None
+        device_files.append(
+            DeviceFile(
+                path=path,
+                number=number,
+            ),
+        )
+
+    # Sort by number in ascending order, None values at the end
+    return sorted(
+        device_files,
+        key=lambda df: (df.number is None, df.number),
+    )

gpustack_runtime/detector/ascend.py

@@ -81,15 +81,7 @@ def detect(self) -> Devices | None:
             for dev_card_id in card_list:
                 device_num_in_card = pydcmi.dcmi_get_device_num_in_card(dev_card_id)
                 for dev_device_id in range(device_num_in_card):
-                    dev_index = pydcmi.dcmi_get_device_logic_id(
-                        dev_card_id,
-                        dev_device_id,
-                    )
-                    dev_uuid = pydcmi.dcmi_get_device_die_v2(
-                        dev_card_id,
-                        dev_device_id,
-                        pydcmi.DCMI_DIE_TYPE_VDIE,
-                    )
+                    dev_is_vgpu = False
                     dev_virt_info = _get_device_virtual_info(
                         dev_card_id,
                         dev_device_id,
@@ -99,13 +91,15 @@ def detect(self) -> Devices | None:
                         and hasattr(dev_virt_info, "query_info")
                         and hasattr(dev_virt_info.query_info, "computing")
                     ):
+                        dev_is_vgpu = True
                         dev_cores_aicore = dev_virt_info.query_info.computing.aic
-                        dev_name = f"Ascend VDC {dev_virt_info.vdev_id}"
+                        dev_name = f"Ascend {dev_virt_info.query_info.name}"
                         dev_mem, dev_mem_used = 0, 0
                         if hasattr(dev_virt_info.query_info.computing, "memory_size"):
                             dev_mem = (
                                 dev_virt_info.query_info.computing.memory_size << 20
                             )
+                        dev_index = dev_virt_info.vdev_id
                     else:
                         dev_chip_info = pydcmi.dcmi_get_device_chip_info_v2(
                             dev_card_id,
@@ -119,6 +113,19 @@ def detect(self) -> Devices | None:
                             dev_card_id,
                             dev_device_id,
                         )
+                        dev_index = pydcmi.dcmi_get_device_logic_id(
+                            dev_card_id,
+                            dev_device_id,
+                        )
+                        if envs.GPUSTACK_RUNTIME_DETECT_PHYSICAL_INDEX_PRIORITY:
+                            dev_index = pydcmi.dcmi_get_device_phyid_from_logicid(
+                                dev_index,
+                            )
+                    dev_uuid = pydcmi.dcmi_get_device_die_v2(
+                        dev_card_id,
+                        dev_device_id,
+                        pydcmi.DCMI_DIE_TYPE_VDIE,
+                    )
                     dev_util_aicore = pydcmi.dcmi_get_device_utilization_rate(
                         dev_card_id,
                         dev_device_id,
@@ -133,6 +140,7 @@ def detect(self) -> Devices | None:
                         dev_device_id,
                     )
                     dev_appendix = {
+                        "vgpu": dev_is_vgpu,
                         "card_id": dev_card_id,
                         "device_id": dev_device_id,
                     }
@@ -152,11 +160,7 @@ def detect(self) -> Devices | None:
                     ret.append(
                         Device(
                             manufacturer=self.manufacturer,
-                            indexes=(
-                                dev_index
-                                if isinstance(dev_index, list)
-                                else [dev_index]
-                            ),
+                            index=dev_index,
                             name=dev_name,
                             uuid=dev_uuid.upper(),
                             driver_version=sys_driver_ver,

gpustack_runtime/detector/nvidia.py

@@ -9,7 +9,7 @@
 
 from .. import envs
 from .__types__ import Detector, Device, Devices, ManufacturerEnum
-from .__utils__ import get_pci_devices
+from .__utils__ import get_device_files, get_pci_devices
 
 logger = logging.getLogger(__name__)
 
@@ -82,23 +82,25 @@ def detect(self) -> Devices | None:
             dev_runtime_ver = f"{dev_runtime_ver_t[0]}.{dev_runtime_ver_t[1]}"
 
             dev_count = pynvml.nvmlDeviceGetCount()
+            dev_files = None
             for dev_idx in range(dev_count):
                 dev = pynvml.nvmlDeviceGetHandleByIndex(dev_idx)
 
-                dev_pci_info = pynvml.nvmlDeviceGetPciInfo(dev)
                 dev_is_vgpu = False
+                dev_pci_info = pynvml.nvmlDeviceGetPciInfo(dev)
                 for addr in [dev_pci_info.busIdLegacy, dev_pci_info.busId]:
                     if addr in pci_devs:
                         dev_is_vgpu = _is_vgpu(pci_devs[addr].config)
                         break
 
                 dev_index = dev_idx
                 if envs.GPUSTACK_RUNTIME_DETECT_PHYSICAL_INDEX_PRIORITY:
-                    dev_index = (
-                        dev_pci_info.bus - 1
-                        if dev_pci_info.bus > 0
-                        else dev_pci_info.bus
-                    )
+                    if dev_files is None:
+                        dev_files = get_device_files(pattern=r"nvidia(?P<number>\d+)")
+                    if len(dev_files) > dev_idx:
+                        dev_file = dev_files[dev_idx]
+                        if dev_file.number is not None:
+                            dev_index = dev_file.number
                 dev_uuid = pynvml.nvmlDeviceGetUUID(dev)
                 dev_cores = pynvml.nvmlDeviceGetNumGpuCores(dev)
                 dev_mem = pynvml.nvmlDeviceGetMemoryInfo(dev)
@@ -140,11 +142,7 @@ def detect(self) -> Devices | None:
                     ret.append(
                         Device(
                             manufacturer=self.manufacturer,
-                            indexes=(
-                                dev_index
-                                if isinstance(dev_index, list)
-                                else [dev_index]
-                            ),
+                            index=dev_index,
                             name=dev_name,
                             uuid=dev_uuid.upper(),
                             driver_version=sys_driver_ver,
@@ -176,6 +174,7 @@ def detect(self) -> Devices | None:
                 for mdev_idx in range(mdev_count):
                     mdev = pynvml.nvmlDeviceGetMigDeviceHandleByIndex(dev, mdev_idx)
 
+                    mdev_index = mdev_idx
                     mdev_uuid = pynvml.nvmlDeviceGetUUID(mdev)
                     mdev_mem = pynvml.nvmlDeviceGetMemoryInfo(mdev)
                     mdev_temp = pynvml.nvmlDeviceGetTemperature(
@@ -192,10 +191,6 @@ def detect(self) -> Devices | None:
                     mdev_ci_id = pynvml.nvmlDeviceGetComputeInstanceId(mdev)
                     mdev_appendix["compute_instance_id"] = mdev_ci_id
 
-                    mdev_index = mdev_idx
-                    if envs.GPUSTACK_RUNTIME_DETECT_PHYSICAL_INDEX_PRIORITY:
-                        mdev_index = [mdev_gi_id, mdev_ci_id]
-
                     if not mdev_name:
                         mdev_attrs = pynvml.nvmlDeviceGetAttributes(mdev)
 
@@ -272,11 +267,7 @@ def detect(self) -> Devices | None:
                     ret.append(
                         Device(
                             manufacturer=self.manufacturer,
-                            indexes=(
-                                mdev_index
-                                if isinstance(mdev_index, list)
-                                else [mdev_index]
-                            ),
+                            index=mdev_index,
                             name=mdev_name,
                             uuid=mdev_uuid.upper(),
                             driver_version=sys_driver_ver,

mkdocs.yml

@@ -46,4 +46,5 @@ copyright: Copyright © 2025, GPUStack Contributors
 nav:
   - Modules:
       - gpustack_runtime: modules/gpustack_runtime.md
-      - gpustack_runtime.detect: modules/gpustack_runtime.detect.md
+      - gpustack_runtime.detector: modules/gpustack_runtime.detector.md
+      - gpustack_runtime.deployer: modules/gpustack_runtime.deployer.md