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

gpustack_runtime/__init__.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 from ._version import commit_id, version, version_tuple
 

gpustack_runtime/__main__.py

@@ -1,5 +1,5 @@
 # PYTHON_ARGCOMPLETE_OK
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 import contextlib
 import sys
@@ -12,7 +12,6 @@ from gpustack_runner.cmds import LoadImagesSubCommand
 from . import deployer, detector
 from ._version import commit_id, version
 from .cmds import (
-    CDIGenerateSubCommand,
     CopyImagesSubCommand,
     CreateWorkloadSubCommand,
     DeleteWorkloadsSubCommand,
@@ -20,6 +19,7 @@ from .cmds import (
     DetectDevicesSubCommand,
     ExecSelfSubCommand,
     ExecWorkloadSubCommand,
+    GenerateCDIConfigSubCommand,
     GetDevicesTopologySubCommand,
     GetWorkloadSubCommand,
     InspectSelfSubCommand,
@@ -29,6 +29,7 @@ from .cmds import (
     LogsSelfSubCommand,
     LogsWorkloadSubCommand,
     SaveImagesSubCommand,
+    ServeDevicePluginSubCommand,
 )
 from .logging import setup_logging
 
@@ -76,7 +77,8 @@ def main():
     LogsSelfSubCommand.register(subcommand_parser)
     ExecSelfSubCommand.register(subcommand_parser)
     InspectSelfSubCommand.register(subcommand_parser)
-    CDIGenerateSubCommand.register(subcommand_parser)
+    GenerateCDIConfigSubCommand.register(subcommand_parser)
+    ServeDevicePluginSubCommand.register(subcommand_parser)
     ListImagesSubCommand.register(subcommand_parser)
     SaveImagesSubCommand.register(subcommand_parser)
     LoadImagesSubCommand.register(subcommand_parser)

gpustack_runtime/_version.py

@@ -27,8 +27,8 @@ version_tuple: VERSION_TUPLE
 __commit_id__: COMMIT_ID
 commit_id: COMMIT_ID
 
-__version__ = version = '0.1.40.post1'
-__version_tuple__ = version_tuple = (0, 1, 40, 'post1')
+__version__ = version = '0.1.41.post1'
+__version_tuple__ = version_tuple = (0, 1, 41, 'post1')
 try:
     from ._version_appendix import git_commit
     __commit_id__ = commit_id = git_commit

gpustack_runtime/_version_appendix.py

@@ -1 +1 @@
-git_commit = "74acbe5"
+git_commit = "8671a00"

gpustack_runtime/cmds/__init__.py

@@ -1,18 +1,19 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 from .deployer import (
-    CDIGenerateSubCommand,
     CreateWorkloadSubCommand,
     DeleteWorkloadsSubCommand,
     DeleteWorkloadSubCommand,
     ExecSelfSubCommand,
     ExecWorkloadSubCommand,
+    GenerateCDIConfigSubCommand,
     GetWorkloadSubCommand,
     InspectSelfSubCommand,
     InspectWorkloadSubCommand,
     ListWorkloadsSubCommand,
     LogsSelfSubCommand,
     LogsWorkloadSubCommand,
+    ServeDevicePluginSubCommand,
 )
 from .detector import DetectDevicesSubCommand, GetDevicesTopologySubCommand
 from .images import (
@@ -26,7 +27,6 @@ from .images import (
 )
 
 __all__ = [
-    "CDIGenerateSubCommand",
     "CopyImagesSubCommand",
     "CreateWorkloadSubCommand",
     "DeleteWorkloadSubCommand",
@@ -34,6 +34,7 @@ __all__ = [
     "DetectDevicesSubCommand",
     "ExecSelfSubCommand",
     "ExecWorkloadSubCommand",
+    "GenerateCDIConfigSubCommand",
     "GetDevicesTopologySubCommand",
     "GetWorkloadSubCommand",
     "InspectSelfSubCommand",
@@ -45,6 +46,7 @@ __all__ = [
     "LogsWorkloadSubCommand",
     "PlatformedImage",
     "SaveImagesSubCommand",
+    "ServeDevicePluginSubCommand",
     "append_images",
     "list_images",
 ]

gpustack_runtime/cmds/__types__.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING

gpustack_runtime/cmds/deployer.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 import asyncio
 import json
@@ -25,7 +25,10 @@ from ..deployer import (
     WorkloadStatusStateEnum,
     async_logs_self,
     async_logs_workload,
-    cdi_generate_config,
+    cdi_available_backends,
+    cdi_available_manufacturers,
+    cdi_dump_config,
+    cdi_supported_manufacturers,
     create_workload,
     delete_workload,
     exec_self,
@@ -33,9 +36,16 @@ from ..deployer import (
     get_workload,
     inspect_self,
     inspect_workload,
+    k8s_deviceplugin_serve,
     list_workloads,
 )
-from ..detector import supported_backends, supported_manufacturers
+from ..detector import (
+    ManufacturerEnum,
+    available_backends,
+    available_manufacturers,
+    backend_to_manufacturer,
+    manufacturer_to_backend,
+)
 from .__types__ import SubCommand
 
 if TYPE_CHECKING:
@@ -72,6 +82,11 @@ _IGNORE_ENVS_PREFIX = (
     "COMMAND_MODE",
     "TMPDIR",
     "GPUSTACK_",
+    "SUDO_",
+    "HOSTNAME",
+    "KUBECONFIG",
+    "MAIL",
+    "HIS",
 )
 
 _IGNORE_ENVS_SUFFIX = (
@@ -88,7 +103,7 @@ class CreateWorkloadSubCommand(SubCommand):
     Command to create a workload deployment.
     """
 
-    backend: str
+    manufacturer: ManufacturerEnum
     device: str
     command_script: str | None
     port: int
@@ -108,11 +123,19 @@ class CreateWorkloadSubCommand(SubCommand):
             help="Create a workload deployment",
         )
 
+        deploy_parser.add_argument(
+            "--manufacturer",
+            "--manu",
+            type=ManufacturerEnum,
+            help="Manufacturer to use (default: detect from current environment)",
+            choices=list(map(str, available_manufacturers())),
+        )
+
         deploy_parser.add_argument(
             "--backend",
             type=str,
             help="Backend to use (default: detect from current environment)",
-            choices=supported_backends(),
+            choices=available_backends(),
         )
 
         deploy_parser.add_argument(
@@ -188,7 +211,7 @@ class CreateWorkloadSubCommand(SubCommand):
         deploy_parser.set_defaults(func=CreateWorkloadSubCommand)
 
     def __init__(self, args: Namespace):
-        self.backend = args.backend
+        self.manufacturer = args.manufacturer
         self.device = args.device
         self.command_script = None
         self.port = args.port
@@ -201,6 +224,16 @@ class CreateWorkloadSubCommand(SubCommand):
         self.volume = args.volume
         self.extra_args = args.extra_args
 
+        if args.backend:
+            if not self.manufacturer:
+                self.manufacturer = backend_to_manufacturer(args.backend)
+            elif args.backend != manufacturer_to_backend(self.manufacturer):
+                msg = (
+                    f"The backend '{args.backend}' is not compatible with "
+                    f"the manufacturer '{args.manufacturer}'."
+                )
+                raise ValueError(msg)
+
         if not self.name or not self.image or not self.volume:
             msg = "The name, image, and volume arguments are required."
             raise ValueError(msg)
@@ -226,12 +259,13 @@ class CreateWorkloadSubCommand(SubCommand):
         ]
         resources = None
         if self.device:
-            if self.backend:
+            if self.manufacturer:
+                backend = manufacturer_to_backend(self.manufacturer)
                 resources = ContainerResources(
                     **{
                         v: self.device
                         for k, v in envs.GPUSTACK_RUNTIME_DETECT_BACKEND_MAP_RESOURCE_KEY.items()
-                        if k == self.backend
+                        if k == backend
                     },
                 )
             else:
@@ -277,6 +311,7 @@ class CreateWorkloadSubCommand(SubCommand):
             name=self.name,
             namespace=self.namespace,
             host_network=self.host_network,
+            shm_size=10 * 1 << 30,  # 10 GiB
             containers=[
                 Container(
                     restart_policy=(
@@ -957,23 +992,39 @@ class InspectSelfSubCommand(SubCommand):
         print(inspect_self())
 
 
-class CDIGenerateSubCommand(SubCommand):
+class GenerateCDIConfigSubCommand(SubCommand):
     """
     Command to generate CDI configurations.
     """
 
+    manufacturer: ManufacturerEnum
     format: str
     output: Path | None
 
     @staticmethod
     def register(parser: _SubParsersAction):
-        cdi_parser = parser.add_parser(
-            "cdi-generate",
-            help="Generate CDI configurations according to the current environment",
-            aliases=["cdi-gen"],
+        generate_parser = parser.add_parser(
+            "generate-cdi",
+            help="Generate Container Device Interface(CDI) configurations according to the current environment",
+            aliases=["gen-cdi"],
+        )
+
+        generate_parser.add_argument(
+            "--manufacturer",
+            "--manu",
+            type=ManufacturerEnum,
+            help="Manufacturer to generate (default: all)",
+            choices=list(map(str, cdi_available_manufacturers())),
         )
 
-        cdi_parser.add_argument(
+        generate_parser.add_argument(
+            "--backend",
+            type=str,
+            help="Backend to generate (default: all)",
+            choices=cdi_available_backends(),
+        )
+
+        generate_parser.add_argument(
             "--format",
             type=str,
             choices=["yaml", "json"],
@@ -981,18 +1032,29 @@ class CDIGenerateSubCommand(SubCommand):
             help="Format of the CDI configurations",
         )
 
-        cdi_parser.add_argument(
+        generate_parser.add_argument(
             "output",
             nargs=OPTIONAL,
             help="Output directory to save CDI configurations (default: current directory)",
         )
 
-        cdi_parser.set_defaults(func=CDIGenerateSubCommand)
+        generate_parser.set_defaults(func=GenerateCDIConfigSubCommand)
 
     def __init__(self, args: Namespace):
+        self.manufacturer = args.manufacturer
         self.format = args.format
         self.output = Path(args.output) if args.output else None
 
+        if args.backend:
+            if not self.manufacturer:
+                self.manufacturer = backend_to_manufacturer(args.backend)
+            elif args.backend != manufacturer_to_backend(self.manufacturer):
+                msg = (
+                    f"The backend '{args.backend}' is not compatible with "
+                    f"the manufacturer '{args.manufacturer}'."
+                )
+                raise ValueError(msg)
+
         if self.output:
             try:
                 if not self.output.exists():
@@ -1009,8 +1071,10 @@ class CDIGenerateSubCommand(SubCommand):
         print("\033[2J\033[H", end="")
 
         generated = False
-        for manu in supported_manufacturers():
-            content, path = cdi_generate_config(
+        for manu in cdi_supported_manufacturers():
+            if self.manufacturer and self.manufacturer != manu:
+                continue
+            content, path = cdi_dump_config(
                 manufacturer=manu,
                 output=self.output,
             )
@@ -1027,6 +1091,64 @@ class CDIGenerateSubCommand(SubCommand):
             print("No CDI configurations were generated.")
 
 
+class ServeDevicePluginSubCommand(SubCommand):
+    """
+    Command to serve Device Plugin.
+    """
+
+    manufacturer: ManufacturerEnum
+
+    @staticmethod
+    def register(parser: _SubParsersAction):
+        serve_parser = parser.add_parser(
+            "serve-device-plugin",
+            help="Serve Device Plugin according to the current environment",
+            aliases=[
+                "start-device-plugin",
+                "serve-dp",
+                "start-dp",
+            ],
+        )
+
+        serve_parser.add_argument(
+            "--manufacturer",
+            "--manu",
+            type=ManufacturerEnum,
+            help="Manufacturer to generate (default: all)",
+            choices=list(map(str, cdi_available_manufacturers())),
+        )
+
+        serve_parser.add_argument(
+            "--backend",
+            type=str,
+            help="Backend to generate (default: all)",
+            choices=cdi_available_backends(),
+        )
+
+        serve_parser.set_defaults(func=ServeDevicePluginSubCommand)
+
+    def __init__(self, args: Namespace):
+        self.manufacturer = args.manufacturer
+
+        if args.backend:
+            if not self.manufacturer:
+                self.manufacturer = backend_to_manufacturer(args.backend)
+            elif args.backend != manufacturer_to_backend(self.manufacturer):
+                msg = (
+                    f"The backend '{args.backend}' is not compatible with "
+                    f"the manufacturer '{args.manufacturer}'."
+                )
+                raise ValueError(msg)
+
+    def run(self):
+        print("\033[2J\033[H", end="")
+
+        k8s_deviceplugin_serve(
+            manufacturer=self.manufacturer,
+            cdi_generation_output=envs.GPUSTACK_RUNTIME_DEPLOY_CDI_SPECS_DIRECTORY,
+        )
+
+
 def format_workloads_json(sts: list[WorkloadStatus]) -> str:
     return json.dumps([st.to_dict() for st in sts], indent=2)
 

gpustack_runtime/cmds/detector.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 import json
 import os

gpustack_runtime/cmds/images.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 from gpustack_runner.cmds import (
     CopyImagesSubCommand,

gpustack_runtime/deployer/__init__.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 from typing import TYPE_CHECKING
 
@@ -31,12 +31,32 @@ from .__types__ import (
     WorkloadStatus,
     WorkloadStatusStateEnum,
 )
-from .cdi import generate_config as cdi_generate_config
+from .cdi import (
+    available_backends as cdi_available_backends,
+)
+from .cdi import (
+    available_manufacturers as cdi_available_manufacturers,
+)
+from .cdi import (
+    dump_config as cdi_dump_config,
+)
+from .cdi import (
+    generate_config as cdi_generate_config,
+)
+from .cdi import (
+    supported_manufacturers as cdi_supported_manufacturers,
+)
 from .docker import (
     DockerDeployer,
     DockerWorkloadPlan,
     DockerWorkloadStatus,
 )
+from .k8s.deviceplugin import (
+    serve as k8s_deviceplugin_serve,
+)
+from .k8s.deviceplugin import (
+    serve_async as k8s_deviceplugin_serve_async,
+)
 from .kuberentes import (
     KubernetesDeployer,
     KubernetesWorkloadPlan,
@@ -603,7 +623,11 @@ __all__ = [
     "WorkloadStatusStateEnum",
     "async_logs_self",
     "async_logs_workload",
+    "cdi_available_backends",
+    "cdi_available_manufacturers",
+    "cdi_dump_config",
     "cdi_generate_config",
+    "cdi_supported_manufacturers",
     "create_workload",
     "delete_workload",
     "exec_self",
@@ -611,6 +635,8 @@ __all__ = [
     "get_workload",
     "inspect_self",
     "inspect_workload",
+    "k8s_deviceplugin_serve",
+    "k8s_deviceplugin_serve_async",
     "list_workloads",
     "logs_self",
     "logs_workload",

gpustack_runtime/deployer/__patches__.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 import contextlib
 import copy

gpustack_runtime/deployer/__types__.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 import asyncio
 import atexit
@@ -1400,6 +1400,7 @@ class Deployer(ABC):
                     valued_uuid = (
                         ren
                         in envs.GPUSTACK_RUNTIME_DEPLOY_RUNTIME_VISIBLE_DEVICES_VALUE_UUID
+                        and manu != ManufacturerEnum.ASCEND
                     )
                     dev_uuids: list[str] = []
                     dev_indexes: list[str] = []

gpustack_runtime/deployer/__utils__.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 import base64
 import enum
@@ -176,7 +176,7 @@ def correct_runner_image(
     return corrected_image, True
 
 
-@lru_cache
+@lru_cache(maxsize=1)
 def _get_backend() -> str:
     """
     Get the first detected backend name.

gpustack_runtime/deployer/cdi/__init__.py

@@ -1,7 +1,15 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 from typing import TYPE_CHECKING, Literal
 
+from ...detector import Device, manufacturer_to_backend
+from ...detector import supported_manufacturers as detector_supported_manufacturers
+from .__types__ import Config, manufacturer_to_cdi_kind, manufacturer_to_runtime_env
+from .amd import AMDGenerator
+from .ascend import AscendGenerator
+from .hygon import HygonGenerator
+from .iluvatar import IluvatarGenerator
+from .metax import MetaXGenerator
 from .thead import THeadGenerator
 
 if TYPE_CHECKING:
@@ -10,8 +18,12 @@ if TYPE_CHECKING:
     from ...detector import ManufacturerEnum
     from .__types__ import Generator
 
-
 _GENERATORS: list[Generator] = [
+    AMDGenerator(),
+    AscendGenerator(),
+    HygonGenerator(),
+    IluvatarGenerator(),
+    MetaXGenerator(),
     THeadGenerator(),
 ]
 """
@@ -26,13 +38,13 @@ Mapping from manufacturer to CDI generator.
 """
 
 
-def generate_config(
-    manufacturer: ManufacturerEnum | str,
+def dump_config(
+    manufacturer: ManufacturerEnum,
     output: Path | None = None,
     _format: Literal["yaml", "json"] = "yaml",
 ) -> tuple[str | None, str | None]:
     """
-    Generate the CDI configuration.
+    Dump the CDI configuration.
 
     Args:
         manufacturer:
@@ -76,6 +88,75 @@ def generate_config(
     return expected, str(cdi_path)
 
 
+def generate_config(
+    device: Device,
+) -> Config | None:
+    """
+    Generate the CDI configuration for the given devices.
+
+    Args:
+        device:
+            The detected device.
+
+    Returns:
+        The Config object, or None if not supported.
+
+    """
+    gen = _GENERATORS_MAP.get(device.manufacturer)
+    if not gen:
+        return None
+
+    cfg = gen.generate(devices=[device])
+    return cfg
+
+
+def available_manufacturers() -> list[ManufacturerEnum]:
+    """
+    Get a list of available manufacturers,
+    which allow CDI generation,
+    regardless of whether they are supported or not.
+
+    Returns:
+        A list of available manufacturers.
+
+    """
+    return list(_GENERATORS_MAP.keys())
+
+
+def supported_manufacturers() -> list[ManufacturerEnum]:
+    """
+    Get a list of supported manufacturers,
+    which allow CDI generation,
+    and must be supported in the current environment.
+
+    Returns:
+        A list of supported manufacturers.
+
+    """
+    manus = detector_supported_manufacturers()
+    return [manu for manu in manus if manu in _GENERATORS_MAP]
+
+
+def available_backends() -> list[str]:
+    """
+    Get a list of available backends,
+    which allow CDI generation,
+    regardless of whether they are supported or not.
+
+    Returns:
+        A list of available backends.
+
+    """
+    return [manufacturer_to_backend(manu) for manu in _GENERATORS_MAP]
+
+
 __all__ = [
+    "Config",
+    "available_backends",
+    "available_manufacturers",
+    "dump_config",
     "generate_config",
+    "manufacturer_to_cdi_kind",
+    "manufacturer_to_runtime_env",
+    "supported_manufacturers",
 ]