gpustack-runtime 0.2.2.post4__tar.gz → 0.2.2.post5__tar.gz

{gpustack_runtime-0.2.2.post4 → gpustack_runtime-0.2.2.post5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gpustack-runtime
-Version: 0.2.2.post4
+Version: 0.2.2.post5
 Summary: GPUStack Runtime is library for detecting GPU resources and launching GPU workloads.
 Project-URL: Homepage, https://github.com/gpustack/runtime
 Project-URL: Bug Tracker, https://github.com/gpustack/gpustack/issues

{gpustack_runtime-0.2.2.post4 → gpustack_runtime-0.2.2.post5}/gpustack_runtime/_version.py

@@ -27,8 +27,8 @@ version_tuple: VERSION_TUPLE
 __commit_id__: COMMIT_ID
 commit_id: COMMIT_ID
 
-__version__ = version = '0.2.2.post4'
-__version_tuple__ = version_tuple = (0, 2, 2, 'post4')
+__version__ = version = '0.2.2.post5'
+__version_tuple__ = version_tuple = (0, 2, 2, 'post5')
 try:
     from ._version_appendix import git_commit
     __commit_id__ = commit_id = git_commit

gpustack_runtime-0.2.2.post5/gpustack_runtime/_version_appendix.py

@@ -0,0 +1 @@
+git_commit = "fd63e6b"

{gpustack_runtime-0.2.2.post4 → gpustack_runtime-0.2.2.post5}/gpustack_runtime/detector/nvidia.py

@@ -218,6 +218,22 @@ class NVIDIADetector(Detector):
                     "mig": dev_mig_mode != pynvml.NVML_DEVICE_MIG_DISABLE,
                     "bdf": dev_bdf,
                 }
+                if dev_mig_mode != pynvml.NVML_DEVICE_MIG_DISABLE:
+                    dev_appendix["mig_devices"] = _get_mig_devices(
+                        dev,
+                        dev_idx,
+                        dev_count,
+                        dev_cc_t,
+                        sys_driver_ver,
+                        sys_runtime_ver,
+                        sys_runtime_ver_original,
+                        dev_cc,
+                        dev_temp,
+                        dev_power,
+                        dev_power_used,
+                        dev_bdf,
+                        dev_numa,
+                    )
                 if dev_numa:
                     dev_appendix["numa"] = dev_numa
 
@@ -558,6 +574,148 @@ def _get_links_state(
     }
 
 
+def _get_mig_devices(
+    dev,
+    dev_idx: int,
+    dev_count: int,
+    dev_cc_t,
+    sys_driver_ver,
+    sys_runtime_ver,
+    sys_runtime_ver_original,
+    dev_cc,
+    dev_temp,
+    dev_power,
+    dev_power_used,
+    dev_bdf: str,
+    dev_numa,
+) -> list[dict]:
+    """
+    Enumerate the card's current MIG devices with the same detail a plain
+    device carries (profile name, uuid, compute/memory utilization, memory
+    health, temperature and power), returned as appendix entries of the
+    physical card rather than standalone devices. Empty when MIG is enabled
+    but no GPU instances exist yet.
+    """
+    ret: list[dict] = []
+    with contextlib.suppress(pynvml.NVMLError):
+        for mdev_idx in range(pynvml.nvmlDeviceGetMaxMigDeviceCount(dev)):
+            mdev = None
+            with contextlib.suppress(pynvml.NVMLError):
+                mdev = pynvml.nvmlDeviceGetMigDeviceHandleByIndex(dev, mdev_idx)
+            if not mdev:
+                continue
+
+            mdev_uuid = pynvml.nvmlDeviceGetUUID(mdev)
+
+            mdev_mem = 0
+            mdev_mem_used = 0
+            mdev_mem_status = DeviceMemoryStatusEnum.HEALTHY
+            with contextlib.suppress(pynvml.NVMLError):
+                mdev_mem_info = pynvml.nvmlDeviceGetMemoryInfo(mdev)
+                mdev_mem = byte_to_mebibyte(mdev_mem_info.total)
+                mdev_mem_used = byte_to_mebibyte(mdev_mem_info.used)
+                if not envs.GPUSTACK_RUNTIME_DETECT_NO_HEALTH_CHECK:
+                    mdev_mem_ecc_errors = pynvml.nvmlDeviceGetMemoryErrorCounter(
+                        mdev,
+                        pynvml.NVML_MEMORY_ERROR_TYPE_UNCORRECTED,
+                        pynvml.NVML_AGGREGATE_ECC,
+                        pynvml.NVML_MEMORY_LOCATION_SRAM,
+                    )
+                    if mdev_mem_ecc_errors > 0:
+                        mdev_mem_status = DeviceMemoryStatusEnum.UNHEALTHY
+
+            mdev_appendix = {
+                "arch_family": _get_arch_family(dev_cc_t),
+                "vgpu": True,
+                "sliced": True,
+                "mig": True,
+                "bdf": dev_bdf,
+            }
+            if dev_numa:
+                mdev_appendix["numa"] = dev_numa
+
+            mdev_gi_id = pynvml.nvmlDeviceGetGpuInstanceId(mdev)
+            mdev_appendix["gpu_instance_id"] = mdev_gi_id
+            mdev_ci_id = pynvml.nvmlDeviceGetComputeInstanceId(mdev)
+            mdev_appendix["compute_instance_id"] = mdev_ci_id
+
+            mdev_cores_util = _get_sm_util_from_gpm_metrics(dev, mdev_gi_id)
+
+            mdev_name = ""
+            mdev_cores = None
+            mdev_gi = pynvml.nvmlDeviceGetGpuInstanceById(dev, mdev_gi_id)
+            mdev_ci = pynvml.nvmlGpuInstanceGetComputeInstanceById(
+                mdev_gi,
+                mdev_ci_id,
+            )
+            mdev_gi_info = pynvml.nvmlGpuInstanceGetInfo(mdev_gi)
+            mdev_ci_info = pynvml.nvmlComputeInstanceGetInfo(mdev_ci)
+            for dev_gi_prf_id in range(pynvml.NVML_GPU_INSTANCE_PROFILE_COUNT):
+                try:
+                    dev_gi_prf = pynvml.nvmlDeviceGetGpuInstanceProfileInfo(
+                        dev,
+                        dev_gi_prf_id,
+                    )
+                    if dev_gi_prf.id != mdev_gi_info.profileId:
+                        continue
+                except pynvml.NVMLError:
+                    continue
+
+                gi_mem = round(math.ceil(dev_gi_prf.memorySizeMB >> 10))
+                gi_prf_name = getattr(dev_gi_prf, "name", None)
+                mdev_name = (
+                    gi_prf_name.removeprefix("MIG ")
+                    if gi_prf_name
+                    else f"{dev_gi_prf.sliceCount}g.{gi_mem}gb"
+                )
+
+                for dev_ci_prf_id in range(
+                    pynvml.NVML_COMPUTE_INSTANCE_PROFILE_COUNT,
+                ):
+                    for dev_cig_prf_id in range(
+                        pynvml.NVML_COMPUTE_INSTANCE_ENGINE_PROFILE_COUNT,
+                    ):
+                        try:
+                            mdev_ci_prf = (
+                                pynvml.nvmlGpuInstanceGetComputeInstanceProfileInfo(
+                                    mdev_gi,
+                                    dev_ci_prf_id,
+                                    dev_cig_prf_id,
+                                )
+                            )
+                            if mdev_ci_prf.id != mdev_ci_info.profileId:
+                                continue
+                        except pynvml.NVMLError:
+                            continue
+                        mdev_cores = mdev_ci_prf.multiprocessorCount
+                        break
+
+                break
+
+            ret.append(
+                {
+                    "index": mdev_idx + dev_count * (dev_idx + 1),
+                    "name": mdev_name,
+                    "uuid": mdev_uuid,
+                    "driver_version": sys_driver_ver,
+                    "runtime_version": sys_runtime_ver,
+                    "runtime_version_original": sys_runtime_ver_original,
+                    "compute_capability": dev_cc,
+                    "cores": mdev_cores,
+                    "cores_utilization": mdev_cores_util,
+                    "memory": mdev_mem,
+                    "memory_used": mdev_mem_used,
+                    "memory_utilization": get_utilization(mdev_mem_used, mdev_mem),
+                    "memory_status": mdev_mem_status,
+                    "temperature": dev_temp,
+                    "power": dev_power,
+                    "power_used": dev_power_used,
+                    "appendix": mdev_appendix,
+                },
+            )
+    return ret
+
+
 def _get_arch_family(dev_cc_t: list[int]) -> str:
     """
     Get the architecture family based on the CUDA compute capability.

{gpustack_runtime-0.2.2.post4 → gpustack_runtime-0.2.2.post5}/gpustack_runtime/detector/thead.py

@@ -162,220 +162,104 @@ class THeadDetector(Detector):
 
                 dev_index = dev_idx
 
-                # With MIG disabled, treat as a single device.
+                # Report the physical card, whether or not MIG is enabled.
+                # MIG instances are partitioned on demand by the operator's
+                # device-manager; they are not separate allocatable devices
+                # in this inventory. A MIG-enabled card is marked ``mig``
+                # in the appendix instead.
 
-                if dev_mig_mode == pyhgml.HGML_DEVICE_MIG_DISABLE:
-                    dev_name = pyhgml.hgmlDeviceGetName(dev)
+                dev_name = pyhgml.hgmlDeviceGetName(dev)
 
-                    dev_uuid = pyhgml.hgmlDeviceGetUUID(dev)
+                dev_uuid = pyhgml.hgmlDeviceGetUUID(dev)
 
-                    dev_cores = None
-                    with contextlib.suppress(pyhgml.HGMLError):
-                        dev_cores = pyhgml.hgmlDeviceGetNumGpuCores(dev)
-
-                    dev_cores_util = None
-                    with contextlib.suppress(pyhgml.HGMLError):
-                        dev_util_rates = pyhgml.hgmlDeviceGetUtilizationRates(dev)
-                        dev_cores_util = dev_util_rates.gpu
-                    if dev_cores_util is None:
-                        debug_log_warning(
-                            logger,
-                            "Failed to get device %d cores utilization, setting to 0",
-                            dev_index,
-                        )
-                        dev_cores_util = 0
+                dev_cores = None
+                with contextlib.suppress(pyhgml.HGMLError):
+                    dev_cores = pyhgml.hgmlDeviceGetNumGpuCores(dev)
 
-                    dev_mem = 0
-                    dev_mem_used = 0
-                    dev_mem_status = DeviceMemoryStatusEnum.HEALTHY
-                    with contextlib.suppress(pyhgml.HGMLError):
-                        dev_mem_info = pyhgml.hgmlDeviceGetMemoryInfo(dev)
-                        dev_mem = byte_to_mebibyte(  # byte to MiB
-                            dev_mem_info.total,
-                        )
-                        dev_mem_used = byte_to_mebibyte(  # byte to MiB
-                            dev_mem_info.used,
-                        )
-                        if not envs.GPUSTACK_RUNTIME_DETECT_NO_HEALTH_CHECK:
-                            dev_mem_ecc_errors = pyhgml.hgmlDeviceGetMemoryErrorCounter(
-                                dev,
-                                pyhgml.HGML_MEMORY_ERROR_TYPE_UNCORRECTED,
-                                pyhgml.HGML_VOLATILE_ECC,
-                                pyhgml.HGML_MEMORY_LOCATION_DRAM,
-                            )
-                            if dev_mem_ecc_errors > 0:
-                                dev_mem_status = DeviceMemoryStatusEnum.UNHEALTHY
-
-                    dev_is_vgpu = False
-                    if dev_bdf:
-                        dev_is_vgpu = get_physical_function_by_bdf(dev_bdf) != dev_bdf
-
-                    dev_appendix = {
-                        "vgpu": dev_is_vgpu,
-                        "bdf": dev_bdf,
-                    }
-                    if dev_numa:
-                        dev_appendix["numa"] = dev_numa
-
-                    ret.append(
-                        Device(
-                            manufacturer=self.manufacturer,
-                            index=dev_index,
-                            name=dev_name,
-                            uuid=dev_uuid,
-                            driver_version=sys_driver_ver,
-                            runtime_version=sys_runtime_ver,
-                            runtime_version_original=sys_runtime_ver_original,
-                            compute_capability=dev_cc,
-                            cores=dev_cores,
-                            cores_utilization=dev_cores_util,
-                            memory=dev_mem,
-                            memory_used=dev_mem_used,
-                            memory_utilization=get_utilization(dev_mem_used, dev_mem),
-                            memory_status=dev_mem_status,
-                            temperature=dev_temp,
-                            power=dev_power,
-                            power_used=dev_power_used,
-                            appendix=dev_appendix,
-                        ),
+                dev_cores_util = None
+                with contextlib.suppress(pyhgml.HGMLError):
+                    dev_util_rates = pyhgml.hgmlDeviceGetUtilizationRates(dev)
+                    dev_cores_util = dev_util_rates.gpu
+                if dev_cores_util is None:
+                    debug_log_warning(
+                        logger,
+                        "Failed to get device %d cores utilization, setting to 0",
+                        dev_index,
                     )
+                    dev_cores_util = 0
 
-                    continue
-
-                # Otherwise, get MIG devices.
-
-                mdev_name = ""
-                mdev_cores = None
-                mdev_count = pyhgml.hgmlDeviceGetMaxMigDeviceCount(dev)
-                for mdev_idx in range(mdev_count):
-                    mdev = None
-                    with contextlib.suppress(pyhgml.HGMLError):
-                        mdev = pyhgml.hgmlDeviceGetMigDeviceHandleByIndex(dev, mdev_idx)
-                    if not mdev:
-                        continue
-
-                    mdev_index = mdev_idx + dev_count * (dev_idx + 1)
-                    mdev_uuid = pyhgml.hgmlDeviceGetUUID(mdev)
-
-                    mdev_mem = 0
-                    mdev_mem_used = 0
-                    mdev_mem_status = DeviceMemoryStatusEnum.HEALTHY
-                    with contextlib.suppress(pyhgml.HGMLError):
-                        mdev_mem_info = pyhgml.hgmlDeviceGetMemoryInfo(mdev)
-                        mdev_mem = byte_to_mebibyte(  # byte to MiB
-                            mdev_mem_info.total,
-                        )
-                        mdev_mem_used = byte_to_mebibyte(  # byte to MiB
-                            mdev_mem_info.used,
+                dev_mem = 0
+                dev_mem_used = 0
+                dev_mem_status = DeviceMemoryStatusEnum.HEALTHY
+                with contextlib.suppress(pyhgml.HGMLError):
+                    dev_mem_info = pyhgml.hgmlDeviceGetMemoryInfo(dev)
+                    dev_mem = byte_to_mebibyte(  # byte to MiB
+                        dev_mem_info.total,
+                    )
+                    dev_mem_used = byte_to_mebibyte(  # byte to MiB
+                        dev_mem_info.used,
+                    )
+                    if not envs.GPUSTACK_RUNTIME_DETECT_NO_HEALTH_CHECK:
+                        dev_mem_ecc_errors = pyhgml.hgmlDeviceGetMemoryErrorCounter(
+                            dev,
+                            pyhgml.HGML_MEMORY_ERROR_TYPE_UNCORRECTED,
+                            pyhgml.HGML_VOLATILE_ECC,
+                            pyhgml.HGML_MEMORY_LOCATION_DRAM,
                         )
-                        if not envs.GPUSTACK_RUNTIME_DETECT_NO_HEALTH_CHECK:
-                            mdev_mem_ecc_errors = (
-                                pyhgml.hgmlDeviceGetMemoryErrorCounter(
-                                    mdev,
-                                    pyhgml.HGML_MEMORY_ERROR_TYPE_UNCORRECTED,
-                                    pyhgml.HGML_AGGREGATE_ECC,
-                                    pyhgml.HGML_MEMORY_LOCATION_SRAM,
-                                )
-                            )
-                            if mdev_mem_ecc_errors > 0:
-                                mdev_mem_status = DeviceMemoryStatusEnum.UNHEALTHY
-
-                    mdev_appendix = {
-                        "vgpu": True,
-                        "sliced": True,
-                        "bdf": dev_bdf,
-                    }
-                    if dev_numa:
-                        mdev_appendix["numa"] = dev_numa
-
-                    mdev_gi_id = pyhgml.hgmlDeviceGetGpuInstanceId(mdev)
-                    mdev_appendix["gpu_instance_id"] = mdev_gi_id
-                    mdev_ci_id = pyhgml.hgmlDeviceGetComputeInstanceId(mdev)
-                    mdev_appendix["compute_instance_id"] = mdev_ci_id
-
-                    mdev_cores_util = _get_sm_util_from_gpm_metrics(dev, mdev_gi_id)
-
-                    mdev_gi = pyhgml.hgmlDeviceGetGpuInstanceById(dev, mdev_gi_id)
-                    mdev_ci = pyhgml.hgmlGpuInstanceGetComputeInstanceById(
-                        mdev_gi,
-                        mdev_ci_id,
+                        if dev_mem_ecc_errors > 0:
+                            dev_mem_status = DeviceMemoryStatusEnum.UNHEALTHY
+
+                dev_is_vgpu = False
+                if dev_bdf:
+                    dev_is_vgpu = get_physical_function_by_bdf(dev_bdf) != dev_bdf
+
+                dev_appendix = {
+                    "vgpu": dev_is_vgpu,
+                    "mig": dev_mig_mode != pyhgml.HGML_DEVICE_MIG_DISABLE,
+                    "bdf": dev_bdf,
+                }
+                if dev_mig_mode != pyhgml.HGML_DEVICE_MIG_DISABLE:
+                    dev_appendix["mig_devices"] = _get_mig_devices(
+                        dev,
+                        dev_idx,
+                        dev_count,
+                        dev_cc_t,
+                        sys_driver_ver,
+                        sys_runtime_ver,
+                        sys_runtime_ver_original,
+                        dev_cc,
+                        dev_temp,
+                        dev_power,
+                        dev_power_used,
+                        dev_bdf,
+                        dev_numa,
                     )
-                    mdev_gi_info = pyhgml.hgmlGpuInstanceGetInfo(mdev_gi)
-                    mdev_ci_info = pyhgml.hgmlComputeInstanceGetInfo(mdev_ci)
-                    for dev_gi_prf_id in range(
-                        pyhgml.HGML_GPU_INSTANCE_PROFILE_COUNT,
-                    ):
-                        try:
-                            dev_gi_prf = pyhgml.hgmlDeviceGetGpuInstanceProfileInfo(
-                                dev,
-                                dev_gi_prf_id,
-                            )
-                            if dev_gi_prf.id != mdev_gi_info.profileId:
-                                continue
-                        except pyhgml.HGMLError:
-                            continue
+                if dev_numa:
+                    dev_appendix["numa"] = dev_numa
+
+                ret.append(
+                    Device(
+                        manufacturer=self.manufacturer,
+                        index=dev_index,
+                        name=dev_name,
+                        uuid=dev_uuid,
+                        driver_version=sys_driver_ver,
+                        runtime_version=sys_runtime_ver,
+                        runtime_version_original=sys_runtime_ver_original,
+                        compute_capability=dev_cc,
+                        cores=dev_cores,
+                        cores_utilization=dev_cores_util,
+                        memory=dev_mem,
+                        memory_used=dev_mem_used,
+                        memory_utilization=get_utilization(dev_mem_used, dev_mem),
+                        memory_status=dev_mem_status,
+                        temperature=dev_temp,
+                        power=dev_power,
+                        power_used=dev_power_used,
+                        appendix=dev_appendix,
+                    ),
+                )
 
-                        for dev_ci_prf_id in range(
-                            pyhgml.HGML_COMPUTE_INSTANCE_PROFILE_COUNT,
-                        ):
-                            for dev_cig_prf_id in range(
-                                pyhgml.HGML_COMPUTE_INSTANCE_ENGINE_PROFILE_COUNT,
-                            ):
-                                try:
-                                    mdev_ci_prf = pyhgml.hgmlGpuInstanceGetComputeInstanceProfileInfo(
-                                        mdev_gi,
-                                        dev_ci_prf_id,
-                                        dev_cig_prf_id,
-                                    )
-                                    if mdev_ci_prf.id != mdev_ci_info.profileId:
-                                        continue
-                                except pyhgml.HGMLError:
-                                    continue
-
-                                ci_slice = _get_compute_instance_slice(dev_ci_prf_id)
-                                gi_slice = _get_gpu_instance_slice(dev_gi_prf_id)
-                                if ci_slice == gi_slice:
-                                    if hasattr(dev_gi_prf, "name"):
-                                        mdev_name = dev_gi_prf.name
-                                    else:
-                                        gi_mem = round(
-                                            math.ceil(dev_gi_prf.memorySizeMB >> 10),
-                                        )
-                                        mdev_name = f"{gi_slice}g.{gi_mem}gb"
-                                elif hasattr(mdev_ci_prf, "name"):
-                                    mdev_name = mdev_ci_prf.name
-                                else:
-                                    gi_mem = round(
-                                        math.ceil(dev_gi_prf.memorySizeMB >> 10),
-                                    )
-                                    mdev_name = f"{ci_slice}u.{gi_slice}g.{gi_mem}gb"
-
-                                mdev_cores = mdev_ci_prf.multiprocessorCount
-
-                                break
-
-                    ret.append(
-                        Device(
-                            manufacturer=self.manufacturer,
-                            index=mdev_index,
-                            name=mdev_name,
-                            uuid=mdev_uuid,
-                            driver_version=sys_driver_ver,
-                            runtime_version=sys_runtime_ver,
-                            runtime_version_original=sys_runtime_ver_original,
-                            compute_capability=dev_cc,
-                            cores=mdev_cores,
-                            cores_utilization=mdev_cores_util,
-                            memory=mdev_mem,
-                            memory_used=mdev_mem_used,
-                            memory_utilization=get_utilization(mdev_mem_used, mdev_mem),
-                            memory_status=mdev_mem_status,
-                            temperature=dev_temp,
-                            power=dev_power,
-                            power_used=dev_power_used,
-                            appendix=mdev_appendix,
-                        ),
-                    )
         except pyhgml.HGMLError:
             debug_log_exception(logger, "Failed to fetch devices")
             raise
@@ -655,6 +539,158 @@ def _get_links_state(
     }
 
 
+def _get_mig_devices(
+    dev,
+    dev_idx: int,
+    dev_count: int,
+    sys_driver_ver,
+    sys_runtime_ver,
+    sys_runtime_ver_original,
+    dev_cc,
+    dev_temp,
+    dev_power,
+    dev_power_used,
+    dev_bdf: str,
+    dev_numa,
+) -> list[dict]:
+    """
+    Enumerate the card's current MIG devices with the same detail a plain
+    device carries (profile name, uuid, compute/memory utilization, memory
+    health, temperature and power), returned as appendix entries of the
+    physical card rather than standalone devices. Empty when MIG is enabled
+    but no GPU instances exist yet.
+    """
+    ret: list[dict] = []
+    with contextlib.suppress(pyhgml.HGMLError):
+        for mdev_idx in range(pyhgml.hgmlDeviceGetMaxMigDeviceCount(dev)):
+            mdev = None
+            with contextlib.suppress(pyhgml.HGMLError):
+                mdev = pyhgml.hgmlDeviceGetMigDeviceHandleByIndex(dev, mdev_idx)
+            if not mdev:
+                continue
+
+            mdev_uuid = pyhgml.hgmlDeviceGetUUID(mdev)
+
+            mdev_mem = 0
+            mdev_mem_used = 0
+            mdev_mem_status = DeviceMemoryStatusEnum.HEALTHY
+            with contextlib.suppress(pyhgml.HGMLError):
+                mdev_mem_info = pyhgml.hgmlDeviceGetMemoryInfo(mdev)
+                mdev_mem = byte_to_mebibyte(mdev_mem_info.total)
+                mdev_mem_used = byte_to_mebibyte(mdev_mem_info.used)
+                if not envs.GPUSTACK_RUNTIME_DETECT_NO_HEALTH_CHECK:
+                    mdev_mem_ecc_errors = pyhgml.hgmlDeviceGetMemoryErrorCounter(
+                        mdev,
+                        pyhgml.HGML_MEMORY_ERROR_TYPE_UNCORRECTED,
+                        pyhgml.HGML_AGGREGATE_ECC,
+                        pyhgml.HGML_MEMORY_LOCATION_SRAM,
+                    )
+                    if mdev_mem_ecc_errors > 0:
+                        mdev_mem_status = DeviceMemoryStatusEnum.UNHEALTHY
+
+            mdev_appendix = {
+                "vgpu": True,
+                "sliced": True,
+                "mig": True,
+                "bdf": dev_bdf,
+            }
+            if dev_numa:
+                mdev_appendix["numa"] = dev_numa
+
+            mdev_gi_id = pyhgml.hgmlDeviceGetGpuInstanceId(mdev)
+            mdev_appendix["gpu_instance_id"] = mdev_gi_id
+            mdev_ci_id = pyhgml.hgmlDeviceGetComputeInstanceId(mdev)
+            mdev_appendix["compute_instance_id"] = mdev_ci_id
+
+            mdev_cores_util = _get_sm_util_from_gpm_metrics(dev, mdev_gi_id)
+
+            mdev_name = ""
+            mdev_cores = None
+            mdev_gi = pyhgml.hgmlDeviceGetGpuInstanceById(dev, mdev_gi_id)
+            mdev_ci = pyhgml.hgmlGpuInstanceGetComputeInstanceById(
+                mdev_gi,
+                mdev_ci_id,
+            )
+            mdev_gi_info = pyhgml.hgmlGpuInstanceGetInfo(mdev_gi)
+            mdev_ci_info = pyhgml.hgmlComputeInstanceGetInfo(mdev_ci)
+            for dev_gi_prf_id in range(pyhgml.HGML_GPU_INSTANCE_PROFILE_COUNT):
+                try:
+                    dev_gi_prf = pyhgml.hgmlDeviceGetGpuInstanceProfileInfo(
+                        dev,
+                        dev_gi_prf_id,
+                    )
+                    if dev_gi_prf.id != mdev_gi_info.profileId:
+                        continue
+                except pyhgml.HGMLError:
+                    continue
+
+                for dev_ci_prf_id in range(
+                    pyhgml.HGML_COMPUTE_INSTANCE_PROFILE_COUNT,
+                ):
+                    for dev_cig_prf_id in range(
+                        pyhgml.HGML_COMPUTE_INSTANCE_ENGINE_PROFILE_COUNT,
+                    ):
+                        try:
+                            mdev_ci_prf = (
+                                pyhgml.hgmlGpuInstanceGetComputeInstanceProfileInfo(
+                                    mdev_gi,
+                                    dev_ci_prf_id,
+                                    dev_cig_prf_id,
+                                )
+                            )
+                            if mdev_ci_prf.id != mdev_ci_info.profileId:
+                                continue
+                        except pyhgml.HGMLError:
+                            continue
+
+                        ci_slice = _get_compute_instance_slice(dev_ci_prf_id)
+                        gi_slice = _get_gpu_instance_slice(dev_gi_prf_id)
+                        if ci_slice == gi_slice:
+                            if hasattr(dev_gi_prf, "name"):
+                                mdev_name = dev_gi_prf.name
+                            else:
+                                gi_mem = round(
+                                    math.ceil(dev_gi_prf.memorySizeMB >> 10),
+                                )
+                                mdev_name = f"{gi_slice}g.{gi_mem}gb"
+                        elif hasattr(mdev_ci_prf, "name"):
+                            mdev_name = mdev_ci_prf.name
+                        else:
+                            gi_mem = round(
+                                math.ceil(dev_gi_prf.memorySizeMB >> 10),
+                            )
+                            mdev_name = f"{ci_slice}u.{gi_slice}g.{gi_mem}gb"
+
+                        mdev_cores = mdev_ci_prf.multiprocessorCount
+
+                        break
+
+                break
+
+            ret.append(
+                {
+                    "index": mdev_idx + dev_count * (dev_idx + 1),
+                    "name": mdev_name,
+                    "uuid": mdev_uuid,
+                    "driver_version": sys_driver_ver,
+                    "runtime_version": sys_runtime_ver,
+                    "runtime_version_original": sys_runtime_ver_original,
+                    "compute_capability": dev_cc,
+                    "cores": mdev_cores,
+                    "cores_utilization": mdev_cores_util,
+                    "memory": mdev_mem,
+                    "memory_used": mdev_mem_used,
+                    "memory_utilization": get_utilization(mdev_mem_used, mdev_mem),
+                    "memory_status": mdev_mem_status,
+                    "temperature": dev_temp,
+                    "power": dev_power,
+                    "power_used": dev_power_used,
+                    "appendix": mdev_appendix,
+                },
+            )
+    return ret
+
+
 def _get_gpu_instance_slice(dev_gi_prf_id: int) -> int:
     """
     Get the number of slices for a given GPU Instance Profile ID.

gpustack_runtime-0.2.2.post4/gpustack_runtime/_version_appendix.py

@@ -1 +0,0 @@
-git_commit = "c736814"