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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gpustack-runtime
-Version: 0.2.2.post5
+Version: 0.2.2.post7
 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.post5 → gpustack_runtime-0.2.2.post7}/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.post5'
-__version_tuple__ = version_tuple = (0, 2, 2, 'post5')
+__version__ = version = '0.2.2.post7'
+__version_tuple__ = version_tuple = (0, 2, 2, 'post7')
 try:
     from ._version_appendix import git_commit
     __commit_id__ = commit_id = git_commit

gpustack_runtime-0.2.2.post7/gpustack_runtime/_version_appendix.py

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

{gpustack_runtime-0.2.2.post5 → gpustack_runtime-0.2.2.post7}/gpustack_runtime/deployer/__types__.py

@@ -16,6 +16,7 @@ from .. import envs
 from ..detector import (
     ManufacturerEnum,
     detect_devices,
+    expand_mig_devices,
     group_devices_by_manufacturer,
     manufacturer_to_backend,
 )
@@ -1373,9 +1374,11 @@ class Deployer(ABC):
 
         self._materials = {}
 
-        group_devices = group_devices_by_manufacturer(
-            detect_devices(fast=False),
-        )
+        devices = detect_devices(fast=False)
+        if self.allowed_mig_devices:
+            devices = expand_mig_devices(devices)
+
+        group_devices = group_devices_by_manufacturer(devices)
 
         if group_devices:
             for manu, devs in group_devices.items():
@@ -1698,6 +1701,18 @@ class Deployer(ABC):
         """
         return True
 
+    @property
+    def allowed_mig_devices(self) -> bool:
+        """
+        Return whether the deployer addresses the MIG devices of a MIG-partitioned
+        card, instead of the card itself.
+
+        Returns:
+            True if addressed, False otherwise.
+
+        """
+        return True
+
     def close(self):
         if self._pool:
             self._pool.shutdown(cancel_futures=True)

{gpustack_runtime-0.2.2.post5 → gpustack_runtime-0.2.2.post7}/gpustack_runtime/deployer/kuberentes.py

@@ -325,6 +325,61 @@ def _pin_pod_for_kueue(
     }
 
 
+def _is_device_plugin_resource(resource_key: str) -> bool:
+    """
+    Report whether a resource key belongs to a device plugin resource family,
+    which is either a CDI kind ("nvidia.com/gpu") or one of its suffixed
+    variants ("nvidia.com/gpu.shared", "nvidia.com/gpu.sliced.units",
+    "nvidia.com/gpu.partitioned.mig-1g.20gb").
+    """
+    return any(
+        resource_key == cdi or resource_key.startswith(f"{cdi}.")
+        for cdi in envs.GPUSTACK_RUNTIME_DEPLOY_RESOURCE_KEY_MAP_CDI.values()
+    )
+
+
+def _resolve_privileged(container: Container) -> bool:
+    """
+    Resolve whether a container runs privileged.
+
+    Privilege is dropped when the container's devices are handed out by a
+    device plugin, which is the case for every device plugin resource family
+    and, under the KDP injection policy, for every mapped device request.
+
+    A privileged container receives all device nodes of the host, so it
+    enumerates -- and can use -- every accelerator on the node, no matter
+    which one the device plugin allocated to it. That silently undoes
+    slicing: a workload holding a single MIG device or a single memory slice
+    still sees the untouched cards next to it, and a soft-slicing limit
+    lands on whichever device comes first instead of the allocated one.
+    """
+    if not container.execution or not container.execution.privileged:
+        return False
+    if not container.resources:
+        return True
+
+    kdp = get_resource_injection_policy() == "kdp"
+    for r_k in container.resources:
+        if r_k in ("cpu", "memory"):
+            continue
+        if _is_device_plugin_resource(r_k) or (
+            kdp
+            and (
+                r_k
+                in envs.GPUSTACK_RUNTIME_DEPLOY_RESOURCE_KEY_MAP_RUNTIME_VISIBLE_DEVICES
+                or r_k == envs.GPUSTACK_RUNTIME_DEPLOY_AUTOMAP_RESOURCE_KEY
+            )
+        ):
+            clogger.info(
+                "Dropping privilege of container '%s', "
+                "as its device request '%s' is allocated by a device plugin",
+                container.name,
+                r_k,
+            )
+            return False
+    return True
+
+
 class KubernetesDeployer(EndoscopicDeployer):
     """
     Deployer implementation for Kubernetes.
@@ -1048,7 +1103,7 @@ class KubernetesDeployer(EndoscopicDeployer):
                     run_as_user=c.execution.run_as_user,
                     run_as_group=c.execution.run_as_group,
                     read_only_root_filesystem=c.execution.readonly_rootfs,
-                    privileged=c.execution.privileged,
+                    privileged=_resolve_privileged(c),
                     capabilities=(
                         kubernetes.client.V1Capabilities(
                             add=c.execution.capabilities.add,
@@ -1308,6 +1363,15 @@ class KubernetesDeployer(EndoscopicDeployer):
     def allowed_runtime_uuid_values(self) -> bool:
         return get_resource_injection_policy() != "kdp"
 
+    @property
+    def allowed_mig_devices(self) -> bool:
+        # On Kubernetes a partitioner (e.g. the GPUStack Operator's device
+        # manager) owns MIG: it creates and destroys the instances on demand,
+        # so the card is the item to hold on to, and a pod asks for a slice of
+        # it by resource rather than by addressing an instance that may not
+        # outlive the request.
+        return False
+
     def _prepare_mirrored_deployment(self):
         """
         Prepare for mirrored deployment.

{gpustack_runtime-0.2.2.post5 → gpustack_runtime-0.2.2.post7}/gpustack_runtime/detector/__init__.py

@@ -291,6 +291,42 @@ def filter_devices_by_manufacturer(
     return [dev for dev in devices or [] if dev.manufacturer == manufacturer]
 
 
+def expand_mig_devices(devices: Devices | None) -> Devices:
+    """
+    Replace every MIG-partitioned card with its MIG devices.
+
+    Detection reports the physical card and carries its MIG devices in the
+    `mig_devices` appendix, because where a partitioner (e.g. the GPUStack
+    Operator's device manager) owns MIG, the instances come and go and the
+    card is the only stable inventory item. Callers that address MIG devices
+    themselves need them as devices instead: a MIG-enabled card cannot run a
+    workload, only its instances can.
+
+    A MIG-enabled card with no instances is kept as-is: there is nothing to
+    address yet, and dropping it would make the card disappear from the
+    inventory.
+
+    Args:
+        devices:
+            A list of devices to be expanded.
+
+    Returns:
+        A list of devices where MIG-partitioned cards are substituted by their
+        MIG devices.
+
+    """
+    expanded: Devices = []
+    for dev in devices or []:
+        mig_devs = (dev.appendix or {}).get("mig_devices")
+        if not mig_devs:
+            expanded.append(dev)
+            continue
+        expanded.extend(
+            Device(manufacturer=dev.manufacturer, **mig_dev) for mig_dev in mig_devs
+        )
+    return expanded
+
+
 __all__ = [
     "Device",
     "DeviceMemoryStatusEnum",
@@ -302,6 +338,7 @@ __all__ = [
     "backend_to_manufacturer",
     "detect_backend",
     "detect_devices",
+    "expand_mig_devices",
     "filter_devices_by_manufacturer",
     "get_devices_topologies",
     "group_devices_by_manufacturer",

{gpustack_runtime-0.2.2.post5 → gpustack_runtime-0.2.2.post7}/gpustack_runtime/detector/__types__.py

@@ -461,6 +461,42 @@ def reduce_devices_distances(
     return result
 
 
+def index_mig_devices(
+    devices: Devices,
+    mig_devices: dict[int, list[dict]],
+    slots: int,
+) -> None:
+    """
+    Number the given cards' MIG devices in place.
+
+    A MIG device carries no driver-side inventory index, so its index is
+    synthetic: every card owns a block of `slots` indexes, and the blocks
+    start above the largest index the physical cards report. The reported
+    index may be the card's minor number
+    (`GPUSTACK_RUNTIME_DETECT_PHYSICAL_INDEX_PRIORITY`), which is not bound by
+    the card count, hence the offset is measured from the reported indexes
+    instead of the count. Sizing a block by the slots a card can host, rather
+    than by the MIG devices it currently has, keeps a card's numbering
+    independent of its neighbours: partitioning one card never renumbers
+    another's MIG devices.
+
+    Args:
+        devices:
+            The detected physical cards, already indexed.
+        mig_devices:
+            The MIG devices to number, keyed by the enumeration index of the
+            card hosting them. Each entry's `index` is the driver slot it was
+            found at, which the block offset is added to.
+        slots:
+            The number of MIG devices a card can host, i.e. the block size.
+
+    """
+    base = max((dev.index for dev in devices), default=-1) + 1
+    for dev_idx, migs in mig_devices.items():
+        for mig in migs:
+            mig["index"] += base + dev_idx * slots
+
+
 class Detector(ABC):
     """
     Base class for all detectors.

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

@@ -11,7 +11,14 @@ from functools import lru_cache
 from .. import envs
 from ..logging import debug_log_exception, debug_log_warning
 from . import DeviceMemoryStatusEnum, Topology, pynvml
-from .__types__ import Detector, Device, Devices, ManufacturerEnum, TopologyDistanceEnum
+from .__types__ import (
+    Detector,
+    Device,
+    Devices,
+    ManufacturerEnum,
+    TopologyDistanceEnum,
+    index_mig_devices,
+)
 from .__utils__ import (
     PCIDevice,
     bitmask_to_str,
@@ -113,6 +120,13 @@ class NVIDIADetector(Detector):
                 sys_runtime_ver_original,
             )
 
+            # MIG devices of every MIG-enabled card, keyed by the card's
+            # enumeration index, and the largest number of MIG devices a card
+            # can host: both are needed to number them once every card is
+            # detected, see index_mig_devices.
+            devs_mig_devices: dict[int, list[dict]] = {}
+            devs_mig_slots = 0
+
             dev_count = pynvml.nvmlDeviceGetCount()
             for dev_idx in range(dev_count):
                 dev = pynvml.nvmlDeviceGetHandleByIndex(dev_idx)
@@ -219,10 +233,13 @@ class NVIDIADetector(Detector):
                     "bdf": dev_bdf,
                 }
                 if dev_mig_mode != pynvml.NVML_DEVICE_MIG_DISABLE:
-                    dev_appendix["mig_devices"] = _get_mig_devices(
+                    dev_mig_slots = 0
+                    with contextlib.suppress(pynvml.NVMLError):
+                        dev_mig_slots = pynvml.nvmlDeviceGetMaxMigDeviceCount(dev)
+                    devs_mig_slots = max(devs_mig_slots, dev_mig_slots)
+                    dev_mig_devices = _get_mig_devices(
                         dev,
-                        dev_idx,
-                        dev_count,
+                        dev_mig_slots,
                         dev_cc_t,
                         sys_driver_ver,
                         sys_runtime_ver,
@@ -234,6 +251,8 @@ class NVIDIADetector(Detector):
                         dev_bdf,
                         dev_numa,
                     )
+                    dev_appendix["mig_devices"] = dev_mig_devices
+                    devs_mig_devices[dev_idx] = dev_mig_devices
                 if dev_numa:
                     dev_appendix["numa"] = dev_numa
 
@@ -262,6 +281,8 @@ class NVIDIADetector(Detector):
                         appendix=dev_appendix,
                     ),
                 )
+
+            index_mig_devices(ret, devs_mig_devices, devs_mig_slots)
         except pynvml.NVMLError:
             debug_log_exception(logger, "Failed to fetch devices")
             raise
@@ -576,8 +597,7 @@ def _get_links_state(
 
 def _get_mig_devices(
     dev,
-    dev_idx: int,
-    dev_count: int,
+    dev_mig_slots: int,
     dev_cc_t,
     sys_driver_ver,
     sys_runtime_ver,
@@ -595,10 +615,14 @@ def _get_mig_devices(
     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.
+
+    Each entry's `index` is the driver slot the MIG device was found at:
+    index_mig_devices turns it into the device index once every card is
+    detected.
     """
     ret: list[dict] = []
     with contextlib.suppress(pynvml.NVMLError):
-        for mdev_idx in range(pynvml.nvmlDeviceGetMaxMigDeviceCount(dev)):
+        for mdev_idx in range(dev_mig_slots):
             mdev = None
             with contextlib.suppress(pynvml.NVMLError):
                 mdev = pynvml.nvmlDeviceGetMigDeviceHandleByIndex(dev, mdev_idx)
@@ -694,7 +718,7 @@ def _get_mig_devices(
 
             ret.append(
                 {
-                    "index": mdev_idx + dev_count * (dev_idx + 1),
+                    "index": mdev_idx,
                     "name": mdev_name,
                     "uuid": mdev_uuid,
                     "driver_version": sys_driver_ver,

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

@@ -18,6 +18,7 @@ from .__types__ import (
     ManufacturerEnum,
     Topology,
     TopologyDistanceEnum,
+    index_mig_devices,
 )
 from .__utils__ import (
     PCIDevice,
@@ -120,6 +121,13 @@ class THeadDetector(Detector):
                     sys_runtime_ver_original,
                 )
 
+            # MIG devices of every MIG-enabled card, keyed by the card's
+            # enumeration index, and the largest number of MIG devices a card
+            # can host: both are needed to number them once every card is
+            # detected, see index_mig_devices.
+            devs_mig_devices: dict[int, list[dict]] = {}
+            devs_mig_slots = 0
+
             dev_count = pyhgml.hgmlDeviceGetCount()
             for dev_idx in range(dev_count):
                 dev = pyhgml.hgmlDeviceGetHandleByIndex(dev_idx)
@@ -219,11 +227,13 @@ class THeadDetector(Detector):
                     "bdf": dev_bdf,
                 }
                 if dev_mig_mode != pyhgml.HGML_DEVICE_MIG_DISABLE:
-                    dev_appendix["mig_devices"] = _get_mig_devices(
+                    dev_mig_slots = 0
+                    with contextlib.suppress(pyhgml.HGMLError):
+                        dev_mig_slots = pyhgml.hgmlDeviceGetMaxMigDeviceCount(dev)
+                    devs_mig_slots = max(devs_mig_slots, dev_mig_slots)
+                    dev_mig_devices = _get_mig_devices(
                         dev,
-                        dev_idx,
-                        dev_count,
-                        dev_cc_t,
+                        dev_mig_slots,
                         sys_driver_ver,
                         sys_runtime_ver,
                         sys_runtime_ver_original,
@@ -234,6 +244,8 @@ class THeadDetector(Detector):
                         dev_bdf,
                         dev_numa,
                     )
+                    dev_appendix["mig_devices"] = dev_mig_devices
+                    devs_mig_devices[dev_idx] = dev_mig_devices
                 if dev_numa:
                     dev_appendix["numa"] = dev_numa
 
@@ -260,6 +272,7 @@ class THeadDetector(Detector):
                     ),
                 )
 
+            index_mig_devices(ret, devs_mig_devices, devs_mig_slots)
         except pyhgml.HGMLError:
             debug_log_exception(logger, "Failed to fetch devices")
             raise
@@ -541,8 +554,7 @@ def _get_links_state(
 
 def _get_mig_devices(
     dev,
-    dev_idx: int,
-    dev_count: int,
+    dev_mig_slots: int,
     sys_driver_ver,
     sys_runtime_ver,
     sys_runtime_ver_original,
@@ -559,10 +571,14 @@ def _get_mig_devices(
     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.
+
+    Each entry's `index` is the driver slot the MIG device was found at:
+    index_mig_devices turns it into the device index once every card is
+    detected.
     """
     ret: list[dict] = []
     with contextlib.suppress(pyhgml.HGMLError):
-        for mdev_idx in range(pyhgml.hgmlDeviceGetMaxMigDeviceCount(dev)):
+        for mdev_idx in range(dev_mig_slots):
             mdev = None
             with contextlib.suppress(pyhgml.HGMLError):
                 mdev = pyhgml.hgmlDeviceGetMigDeviceHandleByIndex(dev, mdev_idx)
@@ -669,7 +685,7 @@ def _get_mig_devices(
 
             ret.append(
                 {
-                    "index": mdev_idx + dev_count * (dev_idx + 1),
+                    "index": mdev_idx,
                     "name": mdev_name,
                     "uuid": mdev_uuid,
                     "driver_version": sys_driver_ver,

gpustack_runtime-0.2.2.post7/tests/gpustack_runtime/deployer/test_privileged.py

@@ -0,0 +1,137 @@
+import pytest
+
+from gpustack_runtime.deployer.__types__ import (
+    Container,
+    ContainerExecution,
+    ContainerResources,
+)
+from gpustack_runtime.deployer.kuberentes import _resolve_privileged
+
+
+def _container(privileged: bool | None, resources: dict | None = None) -> Container:
+    container_resources = None
+    if resources is not None:
+        container_resources = ContainerResources()
+        container_resources.update(resources)
+    return Container(
+        name="default",
+        image="gpustack/runner:latest",
+        execution=(
+            ContainerExecution(privileged=privileged)
+            if privileged is not None
+            else None
+        ),
+        resources=container_resources,
+    )
+
+
+@pytest.mark.parametrize(
+    "name, privileged, resources, policy, expected",
+    [
+        (
+            "no execution",
+            None,
+            None,
+            "env",
+            False,
+        ),
+        (
+            "not requested",
+            False,
+            {"nvidia.com/devices": "0"},
+            "env",
+            False,
+        ),
+        (
+            "no resources",
+            True,
+            None,
+            "env",
+            True,
+        ),
+        (
+            "non-device resources only",
+            True,
+            {"cpu": "2", "memory": "4Gi"},
+            "env",
+            True,
+        ),
+        (
+            "specific whole cards, env injection",
+            True,
+            {"cpu": "2", "nvidia.com/devices": "0,1"},
+            "env",
+            True,
+        ),
+        (
+            "all devices, env injection",
+            True,
+            {"nvidia.com/devices": "all"},
+            "env",
+            True,
+        ),
+        (
+            "specific whole cards, kdp injection",
+            True,
+            {"nvidia.com/devices": "0,1"},
+            "kdp",
+            False,
+        ),
+        (
+            "auto-mapped devices, kdp injection",
+            True,
+            {"gpustack.ai/devices": "0"},
+            "kdp",
+            False,
+        ),
+        (
+            "exclusive whole card",
+            True,
+            {"nvidia.com/gpu": "1"},
+            "env",
+            False,
+        ),
+        (
+            "soft slice",
+            True,
+            {
+                "nvidia.com/gpu.sliced": "1",
+                "nvidia.com/gpu.sliced.memory-percentage": "50",
+                "nvidia.com/gpu.sliced.cores-percentage": "50",
+            },
+            "env",
+            False,
+        ),
+        (
+            "hard partition",
+            True,
+            {
+                "nvidia.com/gpu.partitioned": "1",
+                "nvidia.com/gpu.partitioned.mig-1g.20gb": "1",
+            },
+            "env",
+            False,
+        ),
+        (
+            "non-NVIDIA soft slice",
+            True,
+            {"amd.com/gpu.sliced": "1"},
+            "env",
+            False,
+        ),
+        (
+            "resource key merely prefixed by a CDI kind",
+            True,
+            {"nvidia.com/gpu-alike": "1"},
+            "env",
+            True,
+        ),
+    ],
+)
+def test_resolve_privileged(name, privileged, resources, policy, expected, monkeypatch):
+    monkeypatch.setattr(
+        "gpustack_runtime.deployer.kuberentes.get_resource_injection_policy",
+        lambda: policy,
+    )
+    actual = _resolve_privileged(_container(privileged, resources))
+    assert actual == expected, f"case {name} expected {expected}, but got {actual}"

gpustack_runtime-0.2.2.post7/tests/gpustack_runtime/detector/test_mig_devices.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from gpustack_runtime.detector import (
+    Device,
+    ManufacturerEnum,
+    expand_mig_devices,
+)
+from gpustack_runtime.detector.__types__ import index_mig_devices
+
+
+def _card(index: int, uuid: str, mig_devices: list[dict] | None = None) -> Device:
+    appendix: dict = {"mig": mig_devices is not None}
+    if mig_devices is not None:
+        appendix["mig_devices"] = mig_devices
+    return Device(
+        manufacturer=ManufacturerEnum.NVIDIA,
+        index=index,
+        name="NVIDIA A100-SXM4-40GB",
+        uuid=uuid,
+        memory=40960,
+        appendix=appendix,
+    )
+
+
+def _mig(slot: int, uuid: str) -> dict:
+    # As detection reports it: "index" is the driver slot, numbered later.
+    return {
+        "index": slot,
+        "name": "1g.5gb",
+        "uuid": uuid,
+        "memory": 4864,
+        "appendix": {"vgpu": True, "sliced": True, "mig": True},
+    }
+
+
+def test_index_mig_devices_numbers_above_the_cards():
+    cards = [_card(0, "GPU-0"), _card(1, "GPU-1")]
+    mig_devices = {0: [_mig(0, "MIG-0-0"), _mig(1, "MIG-0-1")]}
+
+    index_mig_devices(cards, mig_devices, 8)
+
+    assert [m["index"] for m in mig_devices[0]] == [2, 3]
+
+
+def test_index_mig_devices_keeps_the_blocks_apart():
+    # Every card partitioned to the maximum: with a block per card, no two MIG
+    # devices can land on the same index however many cards there are.
+    cards = [_card(i, f"GPU-{i}") for i in range(2)]
+    mig_devices = {
+        dev_idx: [_mig(slot, f"MIG-{dev_idx}-{slot}") for slot in range(7)]
+        for dev_idx in range(2)
+    }
+
+    index_mig_devices(cards, mig_devices, 8)
+
+    indexes = [card.index for card in cards] + [
+        mig["index"] for migs in mig_devices.values() for mig in migs
+    ]
+    assert len(indexes) == len(set(indexes))
+
+
+def test_index_mig_devices_clears_physical_indexes():
+    # Physical indexes are minor numbers when physical index priority is on,
+    # so they are not bound by the card count: numbering from the count would
+    # collide with the cards themselves.
+    cards = [_card(2, "GPU-2"), _card(3, "GPU-3")]
+    mig_devices = {
+        0: [_mig(0, "MIG-2-0"), _mig(1, "MIG-2-1")],
+        1: [_mig(0, "MIG-3-0")],
+    }
+
+    index_mig_devices(cards, mig_devices, 8)
+
+    assert [m["index"] for m in mig_devices[0]] == [4, 5]
+    assert [m["index"] for m in mig_devices[1]] == [12]
+
+
+def test_index_mig_devices_isolates_a_cards_numbering():
+    # Destroying an instance on one card must not renumber another's.
+    cards = [_card(0, "GPU-0"), _card(1, "GPU-1")]
+    full = {
+        0: [_mig(slot, f"MIG-0-{slot}") for slot in range(3)],
+        1: [_mig(0, "MIG-1-0")],
+    }
+    partitioned = {0: [_mig(0, "MIG-0-0")], 1: [_mig(0, "MIG-1-0")]}
+
+    index_mig_devices(cards, full, 8)
+    index_mig_devices(cards, partitioned, 8)
+
+    assert full[1][0]["index"] == partitioned[1][0]["index"]
+
+
+def test_expand_mig_devices_substitutes_the_card():
+    cards = [
+        _card(0, "GPU-0", [_mig(0, "MIG-0-0"), _mig(1, "MIG-0-1")]),
+        _card(1, "GPU-1"),
+    ]
+    index_mig_devices(cards, {0: cards[0].appendix["mig_devices"]}, 8)
+
+    expanded = expand_mig_devices(cards)
+
+    assert [dev.uuid for dev in expanded] == ["MIG-0-0", "MIG-0-1", "GPU-1"]
+    assert [dev.index for dev in expanded] == [2, 3, 1]
+    assert all(dev.manufacturer == ManufacturerEnum.NVIDIA for dev in expanded)
+    assert expanded[0].memory == 4864
+
+
+def test_expand_mig_devices_keeps_an_unpartitioned_card():
+    # MIG enabled, no GPU instance yet: nothing to address, keep the card.
+    cards = [_card(0, "GPU-0", [])]
+
+    assert expand_mig_devices(cards) == cards
+
+
+def test_expand_mig_devices_tolerates_no_devices():
+    assert expand_mig_devices(None) == []

gpustack_runtime-0.2.2.post5/gpustack_runtime/_version_appendix.py

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