gpustack-runtime 0.1.40.post1__py3-none-any.whl → 0.1.41.post1__py3-none-any.whl

gpustack_runtime/deployer/cdi/__types__.py

@@ -29,10 +29,11 @@ class ConfigDeviceNode(dict):
         self,
         path: str,
         host_path: str | None = None,
-        permissions: str | None = None,
         type_: str = "c",
         major: int | None = None,
         minor: int | None = None,
+        file_mode: int | None = None,
+        permissions: str | None = None,
         uid: int | None = None,
         gid: int | None = None,
     ):
@@ -44,14 +45,22 @@ class ConfigDeviceNode(dict):
                 The path inside the container.
             host_path:
                 The path on the host system. Optional.
-            permissions:
-                The permissions for the device. Optional.
+                None means same as path.
             type_:
-                The type of the device. Default is "c".
+                The type of the device.
             major:
                 The major number of the device. Optional.
             minor:
                 The minor number of the device. Optional.
+            file_mode:
+                The file mode for the device. Optional.
+            permissions:
+                The permissions for the device. Optional.
+                CGroup permissions of the device, candidates are one or more of
+                'r' (read), 'w' (write), 'm' (mknod).
+                'r': allows container to read from the device.
+                'w': allows container to write to the device.
+                'm': allows container to create device files that do not yet exist.
             uid:
                 The user ID for the device. Optional.
             gid:
@@ -67,13 +76,15 @@ class ConfigDeviceNode(dict):
         self["path"] = path
         if host_path is not None:
             self["hostPath"] = host_path
-        if permissions is not None:
-            self["permissions"] = permissions
         if type_ is not None:
             self["type"] = type_
         if major is not None and minor is not None:
             self["major"] = major
             self["minor"] = minor
+        if file_mode is not None:
+            self["fileMode"] = file_mode
+        if permissions is not None:
+            self["permissions"] = permissions
         if uid is not None:
             self["uid"] = uid
         if gid is not None:
@@ -177,9 +188,9 @@ class ConfigMount(dict):
     def __init__(
         self,
         host_path: str,
-        container_path: str,
-        options: list[str] | None = None,
+        container_path: str | None = None,
         type_: str | None = None,
+        options: list[str] | None = None,
     ):
         """
         Initialize a CDI mount configuration.
@@ -188,28 +199,26 @@ class ConfigMount(dict):
             host_path:
                 The path on the host system.
             container_path:
-                The path inside the container.
-            options:
-                The mount options. Optional.
+                The path inside the container. Optional.
+                None means same as host_path.
             type_:
                 The mount type. Optional.
+            options:
+                The mount options. Optional.
 
         """
         if not host_path:
             msg = "host_path cannot be empty"
             raise ValueError(msg)
-        if not container_path:
-            msg = "container_path cannot be empty"
-            raise ValueError(msg)
 
         super().__init__()
 
         self["hostPath"] = host_path
-        self["containerPath"] = container_path
-        if options is not None:
-            self["options"] = options
+        self["containerPath"] = host_path or container_path
         if type_ is not None:
             self["type"] = type_
+        if options is not None:
+            self["options"] = options
 
     @property
     def host_path(self) -> str:
@@ -333,7 +342,7 @@ class ConfigContainerEdits(dict):
     def __init__(
         self,
         env: list[str] | None = None,
-        device_nodes: list[ConfigDeviceNode | str] | None = None,
+        device_nodes: list[ConfigDeviceNode] | None = None,
         mounts: list[ConfigMount] | None = None,
         hooks: list[ConfigHook] | None = None,
     ):
@@ -360,10 +369,7 @@ class ConfigContainerEdits(dict):
         if env is not None:
             self["env"] = env
         if device_nodes is not None:
-            self["deviceNodes"] = [
-                n if not isinstance(n, str) else ConfigDeviceNode(n)
-                for n in device_nodes
-            ]
+            self["deviceNodes"] = device_nodes
         if mounts is not None:
             self["mounts"] = mounts
         if hooks is not None:
@@ -521,6 +527,7 @@ class Config(dict):
         self,
         kind: str,
         devices: list[ConfigDevice],
+        container_edits: list[ConfigContainerEdits] | None = None,
         cdi_version: str = _DEFAULT_CDI_VERSION,
         annotations: dict[str, str] | None = None,
     ):
@@ -528,10 +535,17 @@ class Config(dict):
         Initialize a CDI configuration.
 
         Args:
-            kind: The kind of the CDI configuration.
-            devices: The list of devices in the CDI configuration.
-            cdi_version: The CDI version. Default is "0.5.0".
-            annotations: Optional annotations for the CDI configuration.
+            kind:
+                The kind of the CDI configuration.
+            devices:
+                The list of devices in the CDI configuration.
+            container_edits:
+                The list of container edits in the CDI configuration.
+                Applies to all devices. Optional.
+            cdi_version:
+                The CDI version. Default is "0.5.0".
+            annotations:
+                Optional annotations for the CDI configuration.
 
         """
         super().__init__()
@@ -539,6 +553,8 @@ class Config(dict):
         self["cdiVersion"] = cdi_version
         self["kind"] = kind
         self["devices"] = devices
+        if container_edits is not None:
+            self["containerEdits"] = container_edits
         if annotations is not None:
             self["annotations"] = annotations
 
@@ -564,6 +580,17 @@ class Config(dict):
         """
         return self["kind"]
 
+    @property
+    def container_edits(self) -> list[ConfigContainerEdits] | None:
+        """
+        Return the list of container edits in the CDI configuration.
+
+        Returns:
+            The list of container edits if present, else None.
+
+        """
+        return self.get("containerEdits", None)
+
     @property
     def cdi_version(self) -> str:
         """
@@ -605,12 +632,14 @@ class Config(dict):
 
 
 @lru_cache
-def manufacturer_to_config_kind(manufacturer: ManufacturerEnum) -> str | None:
+def manufacturer_to_cdi_kind(manufacturer: ManufacturerEnum) -> str | None:
     """
     Map a manufacturer to its corresponding CDI config kind,
     based on `GPUSTACK_RUNTIME_DETECT_BACKEND_MAP_RESOURCE_KEY`
     and `GPUSTACK_RUNTIME_DEPLOY_RESOURCE_KEY_MAP_CDI` envs.
 
+    It is in form of `{Vendor}/{Class}`.
+
     Args:
         manufacturer:
             The manufacturer enum.
@@ -628,6 +657,32 @@ def manufacturer_to_config_kind(manufacturer: ManufacturerEnum) -> str | None:
     return kind
 
 
+@lru_cache
+def manufacturer_to_runtime_env(manufacturer: ManufacturerEnum) -> str | None:
+    """
+    Map a manufacturer to its corresponding runtime environment variable prefix,
+    based on `GPUSTACK_RUNTIME_DETECT_BACKEND_MAP_RESOURCE_KEY`
+    and `GPUSTACK_RUNTIME_DEPLOY_RESOURCE_KEY_MAP_RUNTIME_VISIBLE_DEVICES` envs.
+
+    Args:
+        manufacturer:
+            The manufacturer enum.
+
+    Returns:
+        The corresponding runtime environment variable prefix as a string.
+        None if not found.
+
+    """
+    backend = manufacturer_to_backend(manufacturer)
+    resource_key = envs.GPUSTACK_RUNTIME_DETECT_BACKEND_MAP_RESOURCE_KEY.get(backend)
+    if not resource_key:
+        return None
+    env = envs.GPUSTACK_RUNTIME_DEPLOY_RESOURCE_KEY_MAP_RUNTIME_VISIBLE_DEVICES.get(
+        resource_key,
+    )
+    return env
+
+
 class Generator(ABC):
     """
     Base class for all CDI generators.
@@ -653,12 +708,20 @@ class Generator(ABC):
         return str(self.manufacturer)
 
     @abstractmethod
-    def generate(self, devices: Devices | None = None) -> Config | None:
+    def generate(
+        self,
+        devices: Devices | None = None,
+        include_all_devices: bool = True,
+    ) -> Config | None:
         """
         Generate the CDI specification.
 
         Args:
-            devices: The devices to generate the CDI specification for.
+            devices:
+                The devices to generate the CDI specification for.
+                If None, all available devices are considered.
+            include_all_devices:
+                Whether to include a device entry that represents all AMD devices.
 
         Returns:
             The Config object, or None if not supported.

gpustack_runtime/deployer/cdi/__utils__.py

@@ -0,0 +1,180 @@
+from __future__ import annotations as __future_annotations__
+
+import os
+import stat
+from dataclasses import dataclass
+from pathlib import Path
+
+from dataclasses_json import dataclass_json
+
+from .__types__ import ConfigDeviceNode, ConfigMount
+
+
+@dataclass_json
+@dataclass
+class LinuxDevice:
+    """
+    Linux device information.
+
+    """
+
+    path: str
+    """
+    Path to the device file.
+    """
+    type: str
+    """
+    Device type: 'b' for block, 'c' for character, 'p' for pipe.
+    """
+    major: int
+    """
+    Major device number.
+    """
+    minor: int
+    """
+    Minor device number.
+    """
+    file_mode: int | None = None
+    """
+    File mode (permissions) of the device.
+    """
+    uid: int | None = None
+    """
+    User ID of the device owner.
+    """
+    gid: int | None = None
+    """
+    Group ID of the device owner.
+    """
+
+
+def linux_device_from_path(path: Path | str | None) -> LinuxDevice | None:
+    """
+    Get the Linux device information for a given path.
+
+    Args:
+        path:
+            The path to the device file.
+
+    Returns:
+        The LinuxDevice object, or None if the path does not exist or is not a device
+
+    """
+    if not path:
+        return None
+    if isinstance(path, str):
+        path = Path(path)
+    if not path.exists():
+        return None
+
+    path_stat = path.lstat()
+    if not path_stat:
+        return None
+
+    dev_mode = stat.S_IFMT(path_stat.st_mode)
+    match dev_mode:
+        case stat.S_IFBLK:
+            dev_type = "b"
+        case stat.S_IFCHR:
+            dev_type = "c"
+        case stat.S_IFIFO:
+            dev_type = "p"
+        case _:
+            return None
+
+    dev_number = path_stat.st_rdev
+    dev_major = os.major(dev_number)
+    dev_minor = os.minor(dev_number)
+
+    dev_file_mode = stat.S_IMODE(path_stat.st_mode)
+
+    dev_uid = path_stat.st_uid
+    dev_gid = path_stat.st_gid
+
+    return LinuxDevice(
+        path=str(path),
+        type=dev_type,
+        major=dev_major,
+        minor=dev_minor,
+        file_mode=dev_file_mode,
+        uid=dev_uid,
+        gid=dev_gid,
+    )
+
+
+def device_to_cdi_device_node(
+    path: str,
+    container_path: str | None = None,
+    permission: str = "rw",
+    no_user: bool = False,
+) -> ConfigDeviceNode | None:
+    """
+    Convert a device path to a ConfigDeviceNode.
+
+    Args:
+        path:
+            Path to the device on the host.
+        container_path:
+            Path to the device inside the container.
+        permission:
+            Permissions for the device.
+        no_user:
+            Whether to omit user and group information.
+
+    Returns:
+        The ConfigDeviceNode object.
+        None if the device does not exist.
+
+    """
+    dev = linux_device_from_path(path)
+    if not dev:
+        return None
+
+    return ConfigDeviceNode(
+        path=dev.path,
+        host_path=container_path,
+        type_=dev.type,
+        major=dev.major,
+        minor=dev.minor,
+        file_mode=dev.file_mode,
+        permissions=permission,
+        uid=None if no_user else dev.uid,
+        gid=None if no_user else dev.gid,
+    )
+
+
+def path_to_cdi_mount(
+    path: str,
+    container_path: str | None = None,
+    options: list[str] | None = None,
+) -> ConfigMount | None:
+    """
+    Convert a file/directory path to a ConfigMount.
+
+    Args:
+        path:
+            Path to the file or directory on the host.
+        container_path:
+            Path to the file or directory inside the container.
+        options:
+            Mount options.
+
+    Returns:
+        The ConfigMount object.
+        None if the path does not exist.
+
+    """
+    if not Path(path).exists():
+        return None
+
+    if container_path is None:
+        container_path = path
+
+    if options is None:
+        options = ["ro", "nosuid", "nodev", "rbind", "rprivate"]
+
+    return ConfigMount(
+        host_path=path,
+        container_path=container_path,
+        options=options,
+    )

gpustack_runtime/deployer/cdi/amd.py

@@ -0,0 +1,146 @@
+from __future__ import annotations as __future_annotations__
+
+from ...detector import (
+    Devices,
+    ManufacturerEnum,
+    detect_devices,
+    filter_devices_by_manufacturer,
+)
+from .__types__ import (
+    Config,
+    ConfigContainerEdits,
+    ConfigDevice,
+    Generator,
+    manufacturer_to_cdi_kind,
+    manufacturer_to_runtime_env,
+)
+from .__utils__ import device_to_cdi_device_node
+
+
+class AMDGenerator(Generator):
+    """
+    CDI generator for AMD devices.
+    """
+
+    def __init__(self):
+        super().__init__(ManufacturerEnum.AMD)
+
+    def generate(
+        self,
+        devices: Devices | None = None,
+        include_all_devices: bool = True,
+    ) -> Config | None:
+        """
+        Generate the CDI configuration for AMD devices.
+
+        Args:
+            devices:
+                The detected devices.
+                If None, all available devices are considered.
+            include_all_devices:
+                Whether to include a device entry that represents all AMD devices.
+
+        Returns:
+            The Config object, or None if not supported.
+
+        """
+        if devices is None:
+            devices = detect_devices(manufacturer=self.manufacturer)
+        else:
+            devices = filter_devices_by_manufacturer(
+                devices,
+                manufacturer=self.manufacturer,
+            )
+
+        if not devices:
+            return None
+
+        kind = manufacturer_to_cdi_kind(self.manufacturer)
+        if not kind:
+            return None
+
+        common_device_nodes = []
+        for p in [
+            "/dev/kfd",
+        ]:
+            cdn = device_to_cdi_device_node(
+                path=p,
+            )
+            if cdn:
+                common_device_nodes.append(cdn)
+        if not common_device_nodes:
+            return None
+
+        cdi_devices: list[ConfigDevice] = []
+
+        all_device_nodes = []
+
+        for dev in devices:
+            if not dev:
+                continue
+
+            container_device_nodes = []
+
+            card_id = dev.appendix.get("card_id")
+            if card_id is not None:
+                cdn = device_to_cdi_device_node(
+                    path=f"/dev/dri/card{card_id}",
+                )
+                if not cdn:
+                    continue
+                all_device_nodes.append(cdn)
+                container_device_nodes.append(cdn)
+            renderd_id = dev.appendix.get("renderd_id")
+            if renderd_id is not None:
+                cdn = device_to_cdi_device_node(
+                    path=f"/dev/dri/renderD{renderd_id}",
+                )
+                if cdn:
+                    all_device_nodes.append(cdn)
+                    container_device_nodes.append(cdn)
+
+            # Add specific container edits for each device.
+            cdi_container_edits = ConfigContainerEdits(
+                device_nodes=container_device_nodes,
+            )
+            cdi_devices.append(
+                ConfigDevice(
+                    name=str(dev.index),
+                    container_edits=cdi_container_edits,
+                ),
+            )
+            cdi_devices.append(
+                ConfigDevice(
+                    name=dev.uuid,
+                    container_edits=cdi_container_edits,
+                ),
+            )
+
+        if not cdi_devices:
+            return None
+
+        # Add common container edits for all devices.
+        if include_all_devices:
+            cdi_devices.append(
+                ConfigDevice(
+                    name="all",
+                    container_edits=ConfigContainerEdits(
+                        device_nodes=all_device_nodes,
+                    ),
+                ),
+            )
+
+        runtime_env = manufacturer_to_runtime_env(self.manufacturer)
+
+        return Config(
+            kind=kind,
+            devices=cdi_devices,
+            container_edits=[
+                ConfigContainerEdits(
+                    env=[
+                        f"{runtime_env}=void",
+                    ],
+                    device_nodes=common_device_nodes,
+                ),
+            ],
+        )