[Frontend][RFC] Rust front-end integration (#40848)
Signed-off-by: Nick Hill <nickhill123@gmail.com> Signed-off-by: Bugen Zhao <i@bugenzhao.com> Co-authored-by: Bugen Zhao <i@bugenzhao.com>
This commit is contained in:
@@ -2,6 +2,7 @@
|
||||
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
|
||||
|
||||
import argparse
|
||||
import signal
|
||||
|
||||
import uvloop
|
||||
|
||||
@@ -110,6 +111,14 @@ def cmd_init() -> list[CLISubcommand]:
|
||||
|
||||
async def run_launch_fastapi(args: argparse.Namespace) -> None:
|
||||
"""Run the online serving layer with FastAPI (no GPU inference)."""
|
||||
|
||||
# Interrupt initialization if SIGTERM arrives before uvicorn installs
|
||||
# its own signal handlers. Once uvicorn is running it replaces this.
|
||||
def _interrupt_init(*_) -> None:
|
||||
raise KeyboardInterrupt("terminated")
|
||||
|
||||
signal.signal(signal.SIGTERM, _interrupt_init)
|
||||
|
||||
# 1. Socket binding
|
||||
listen_address, sock = setup_server(args)
|
||||
|
||||
|
||||
@@ -21,7 +21,11 @@ from vllm.v1.engine.utils import CoreEngineProcManager, launch_core_engines
|
||||
from vllm.v1.executor import Executor
|
||||
from vllm.v1.executor.multiproc_executor import MultiprocExecutor
|
||||
from vllm.v1.metrics.prometheus import setup_multiprocess_prometheus
|
||||
from vllm.v1.utils import APIServerProcessManager, wait_for_completion_or_failure
|
||||
from vllm.v1.utils import (
|
||||
APIServerProcessManager,
|
||||
RustFrontendProcessManager,
|
||||
wait_for_completion_or_failure,
|
||||
)
|
||||
|
||||
logger = init_logger(__name__)
|
||||
|
||||
@@ -81,11 +85,12 @@ class ServeSubcommand(CLISubcommand):
|
||||
)
|
||||
|
||||
# Default api_server_count if not explicitly set.
|
||||
# - Rust frontend: Use 1 (not applicable as it's multithreaded)
|
||||
# - External LB: Leave as 1 (external LB handles distribution)
|
||||
# - Hybrid LB: Use local DP size (internal LB for local ranks only)
|
||||
# - Internal LB: Use full DP size
|
||||
if args.api_server_count is None:
|
||||
if is_external_lb:
|
||||
if is_external_lb or envs.VLLM_RUST_FRONTEND_PATH:
|
||||
args.api_server_count = 1
|
||||
elif is_hybrid_lb:
|
||||
args.api_server_count = args.data_parallel_size_local or 1
|
||||
@@ -102,6 +107,11 @@ class ServeSubcommand(CLISubcommand):
|
||||
"Defaulting api_server_count to data_parallel_size (%d).",
|
||||
args.api_server_count,
|
||||
)
|
||||
elif envs.VLLM_RUST_FRONTEND_PATH and args.api_server_count > 1:
|
||||
logger.warning(
|
||||
"Ignoring --api-server-count=%d when using rust front-end process"
|
||||
)
|
||||
args.api_server_count = 1
|
||||
|
||||
# Elastic EP currently only supports running with at most one API server.
|
||||
if getattr(args, "enable_elastic_ep", False) and args.api_server_count > 1:
|
||||
@@ -114,7 +124,7 @@ class ServeSubcommand(CLISubcommand):
|
||||
|
||||
if args.api_server_count < 1:
|
||||
run_headless(args)
|
||||
elif args.api_server_count > 1:
|
||||
elif args.api_server_count > 1 or envs.VLLM_RUST_FRONTEND_PATH:
|
||||
run_multi_api_server(args)
|
||||
else:
|
||||
# Single API server (this process).
|
||||
@@ -230,9 +240,15 @@ def run_headless(args: argparse.Namespace):
|
||||
|
||||
def run_multi_api_server(args: argparse.Namespace):
|
||||
assert not args.headless
|
||||
rust_frontend_path = envs.VLLM_RUST_FRONTEND_PATH
|
||||
num_api_servers: int = args.api_server_count
|
||||
assert num_api_servers > 0
|
||||
|
||||
if rust_frontend_path and num_api_servers > 1:
|
||||
raise ValueError(
|
||||
"VLLM_RUST_FRONTEND_PATH does not support api_server_count > 1"
|
||||
)
|
||||
|
||||
if num_api_servers > 1:
|
||||
setup_multiprocess_prometheus()
|
||||
|
||||
@@ -270,7 +286,9 @@ def run_multi_api_server(args: argparse.Namespace):
|
||||
dp_rank = parallel_config.data_parallel_rank
|
||||
assert parallel_config.local_engines_only or dp_rank == 0
|
||||
|
||||
api_server_manager: APIServerProcessManager | None = None
|
||||
api_server_manager: APIServerProcessManager | RustFrontendProcessManager | None = (
|
||||
None
|
||||
)
|
||||
|
||||
from vllm.v1.engine.utils import get_engine_zmq_addresses
|
||||
|
||||
@@ -279,23 +297,34 @@ def run_multi_api_server(args: argparse.Namespace):
|
||||
with launch_core_engines(
|
||||
vllm_config, executor_class, log_stats, addresses, num_api_servers
|
||||
) as (local_engine_manager, coordinator, addresses, tensor_queue):
|
||||
# Construct common args for the APIServerProcessManager up-front.
|
||||
stats_update_address = None
|
||||
if coordinator:
|
||||
stats_update_address = coordinator.get_stats_publish_address()
|
||||
|
||||
# Start API servers.
|
||||
api_server_manager = APIServerProcessManager(
|
||||
listen_address=listen_address,
|
||||
sock=sock,
|
||||
args=args,
|
||||
num_servers=num_api_servers,
|
||||
input_addresses=addresses.inputs,
|
||||
output_addresses=addresses.outputs,
|
||||
stats_update_address=stats_update_address,
|
||||
tensor_queue=tensor_queue,
|
||||
stats_update_address = (
|
||||
coordinator.get_stats_publish_address() if coordinator else None
|
||||
)
|
||||
|
||||
if rust_frontend_path:
|
||||
# Start rust front-end process.
|
||||
api_server_manager = RustFrontendProcessManager(
|
||||
binary_path=rust_frontend_path,
|
||||
sock=sock,
|
||||
args=args,
|
||||
input_address=addresses.inputs[0],
|
||||
output_address=addresses.outputs[0],
|
||||
engine_count=parallel_config.data_parallel_size,
|
||||
stats_update_address=stats_update_address,
|
||||
)
|
||||
else:
|
||||
# Start API server(s).
|
||||
api_server_manager = APIServerProcessManager(
|
||||
listen_address=listen_address,
|
||||
sock=sock,
|
||||
args=args,
|
||||
num_servers=num_api_servers,
|
||||
input_addresses=addresses.inputs,
|
||||
output_addresses=addresses.outputs,
|
||||
stats_update_address=stats_update_address,
|
||||
tensor_queue=tensor_queue,
|
||||
)
|
||||
|
||||
# Wait for API servers.
|
||||
try:
|
||||
wait_for_completion_or_failure(
|
||||
|
||||
@@ -533,8 +533,7 @@ def validate_api_server_args(args):
|
||||
|
||||
@instrument(span_name="API server setup")
|
||||
def setup_server(args):
|
||||
"""Validate API server args, set up signal handler, create socket
|
||||
ready to serve."""
|
||||
"""Validate API server args and create the server socket."""
|
||||
|
||||
log_version_and_model(logger, VLLM_VERSION, args.model)
|
||||
log_non_default_args(args)
|
||||
@@ -560,12 +559,6 @@ def setup_server(args):
|
||||
# many concurrent requests active
|
||||
set_ulimit()
|
||||
|
||||
def signal_handler(*_) -> None:
|
||||
# Interrupt server on sigterm while initializing
|
||||
raise KeyboardInterrupt("terminated")
|
||||
|
||||
signal.signal(signal.SIGTERM, signal_handler)
|
||||
|
||||
if args.uds:
|
||||
listen_address = f"unix:{args.uds}"
|
||||
else:
|
||||
@@ -675,6 +668,13 @@ async def run_server(args, **uvicorn_kwargs) -> None:
|
||||
# Add process-specific prefix to stdout and stderr.
|
||||
decorate_logs("APIServer")
|
||||
|
||||
# Interrupt initialization if SIGTERM arrives before uvicorn installs its
|
||||
# own signal handlers. Once uvicorn is running it replaces this.
|
||||
def _interrupt_init(*_) -> None:
|
||||
raise KeyboardInterrupt("terminated")
|
||||
|
||||
signal.signal(signal.SIGTERM, _interrupt_init)
|
||||
|
||||
listen_address, sock = setup_server(args)
|
||||
await run_server_worker(listen_address, sock, args, **uvicorn_kwargs)
|
||||
|
||||
|
||||
@@ -9,6 +9,7 @@ from argparse import Namespace
|
||||
from http import HTTPStatus
|
||||
from logging import Logger
|
||||
from string import Template
|
||||
from typing import Any
|
||||
|
||||
import regex as re
|
||||
from fastapi import Request
|
||||
@@ -210,7 +211,7 @@ def get_max_tokens(
|
||||
)
|
||||
|
||||
|
||||
def log_non_default_args(args: Namespace | EngineArgs):
|
||||
def get_non_default_args(args: Namespace | EngineArgs) -> dict[str, Any]:
|
||||
from vllm.entrypoints.openai.cli_args import make_arg_parser
|
||||
|
||||
non_default_args = {}
|
||||
@@ -237,6 +238,43 @@ def log_non_default_args(args: Namespace | EngineArgs):
|
||||
"Unsupported argument type. Must be Namespace or EngineArgs instance."
|
||||
)
|
||||
|
||||
return non_default_args
|
||||
|
||||
|
||||
def _jsonify_arg_value(value: Any) -> Any:
|
||||
if value is None or isinstance(value, bool | int | float | str):
|
||||
return value
|
||||
if dataclasses.is_dataclass(value) and not isinstance(value, type):
|
||||
return {
|
||||
key: _jsonify_arg_value(val)
|
||||
for key, val in dataclasses.asdict(value).items()
|
||||
}
|
||||
if isinstance(value, dict):
|
||||
return {str(key): _jsonify_arg_value(val) for key, val in value.items()}
|
||||
if isinstance(value, tuple | list):
|
||||
return [_jsonify_arg_value(item) for item in value]
|
||||
if (model_dump := getattr(value, "model_dump", None)) is not None:
|
||||
return _jsonify_arg_value(model_dump(mode="json"))
|
||||
if (to_dict := getattr(value, "dict", None)) is not None:
|
||||
return _jsonify_arg_value(to_dict())
|
||||
return repr(value)
|
||||
|
||||
|
||||
def jsonify_non_default_args(
|
||||
args: Namespace | EngineArgs,
|
||||
*,
|
||||
exclude: set[str] | None = None,
|
||||
) -> dict[str, Any]:
|
||||
non_default_args = get_non_default_args(args)
|
||||
if exclude is not None:
|
||||
for key in exclude:
|
||||
non_default_args.pop(key, None)
|
||||
|
||||
return {key: _jsonify_arg_value(value) for key, value in non_default_args.items()}
|
||||
|
||||
|
||||
def log_non_default_args(args: Namespace | EngineArgs):
|
||||
non_default_args = get_non_default_args(args)
|
||||
logger.info("non-default args: %s", non_default_args)
|
||||
|
||||
|
||||
|
||||
+51
-1
@@ -86,6 +86,7 @@ if TYPE_CHECKING:
|
||||
MAX_JOBS: str | None = None
|
||||
NVCC_THREADS: str | None = None
|
||||
VLLM_USE_PRECOMPILED: bool = False
|
||||
VLLM_USE_PRECOMPILED_RUST: bool = False
|
||||
VLLM_SKIP_PRECOMPILED_VERSION_SUFFIX: bool = False
|
||||
VLLM_DOCKER_BUILD_CONTEXT: bool = False
|
||||
VLLM_KEEP_ALIVE_ON_ENGINE_DEATH: bool = False
|
||||
@@ -134,6 +135,8 @@ if TYPE_CHECKING:
|
||||
Q_SCALE_CONSTANT: int = 200
|
||||
K_SCALE_CONSTANT: int = 200
|
||||
V_SCALE_CONSTANT: int = 100
|
||||
VLLM_USE_RUST_FRONTEND: bool = False
|
||||
VLLM_RUST_FRONTEND_PATH: str | None = "auto"
|
||||
VLLM_SERVER_DEV_MODE: bool = False
|
||||
VLLM_V1_OUTPUT_PROC_CHUNK_SIZE: int = 128
|
||||
VLLM_MLA_DISABLE: bool = False
|
||||
@@ -514,6 +517,40 @@ def get_env_or_set_default(
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def _resolve_rust_frontend_path() -> str | None:
|
||||
"""Resolve the Rust frontend binary path.
|
||||
|
||||
Returns None if VLLM_USE_RUST_FRONTEND is not enabled.
|
||||
When enabled, resolves VLLM_RUST_FRONTEND_PATH ("auto" by default)
|
||||
to the actual binary path.
|
||||
"""
|
||||
use_rust = bool(int(os.environ.get("VLLM_USE_RUST_FRONTEND", "0")))
|
||||
raw = os.environ.get("VLLM_RUST_FRONTEND_PATH", "auto")
|
||||
|
||||
if not use_rust:
|
||||
if os.environ.get("VLLM_RUST_FRONTEND_PATH") is not None:
|
||||
logger.warning(
|
||||
"VLLM_RUST_FRONTEND_PATH is set but VLLM_USE_RUST_FRONTEND "
|
||||
"is not enabled. The Rust frontend will not be used. "
|
||||
"Set VLLM_USE_RUST_FRONTEND=1 to enable it."
|
||||
)
|
||||
return None
|
||||
|
||||
if raw.lower() in ("auto", "1", "true"):
|
||||
pkg_dir = os.path.dirname(os.path.abspath(__file__))
|
||||
candidate = os.path.join(pkg_dir, "vllm-rs")
|
||||
if os.path.isfile(candidate) and os.access(candidate, os.X_OK):
|
||||
return candidate
|
||||
|
||||
raise FileNotFoundError(
|
||||
"VLLM_RUST_FRONTEND_PATH=auto but the vllm-rs binary was "
|
||||
f"not found at {candidate}. "
|
||||
"Build with setuptools-rust or set the path explicitly."
|
||||
)
|
||||
return raw
|
||||
|
||||
|
||||
environment_variables: dict[str, Callable[[], Any]] = {
|
||||
# ================== Installation Time Env Vars ==================
|
||||
# Target device of vLLM, supporting [cuda (by default),
|
||||
@@ -551,11 +588,15 @@ environment_variables: dict[str, Callable[[], Any]] = {
|
||||
# By default this is 1.
|
||||
# If set, `MAX_JOBS` will be reduced to avoid oversubscribing the CPU.
|
||||
"NVCC_THREADS": lambda: os.getenv("NVCC_THREADS", None),
|
||||
# If set, vllm will use precompiled binaries (*.so)
|
||||
# If set, vllm will use precompiled native binaries (*.so and vllm-rs).
|
||||
"VLLM_USE_PRECOMPILED": lambda: (
|
||||
os.environ.get("VLLM_USE_PRECOMPILED", "").strip().lower() in ("1", "true")
|
||||
or bool(os.environ.get("VLLM_PRECOMPILED_WHEEL_LOCATION"))
|
||||
),
|
||||
# If set, vllm will use the precompiled Rust frontend binary (vllm-rs).
|
||||
"VLLM_USE_PRECOMPILED_RUST": lambda: (
|
||||
os.environ.get("VLLM_USE_PRECOMPILED_RUST", "").strip().lower() in ("1", "true")
|
||||
),
|
||||
# If set, skip adding +precompiled suffix to version string
|
||||
"VLLM_SKIP_PRECOMPILED_VERSION_SUFFIX": lambda: bool(
|
||||
int(os.environ.get("VLLM_SKIP_PRECOMPILED_VERSION_SUFFIX", "0"))
|
||||
@@ -1154,6 +1195,15 @@ environment_variables: dict[str, Callable[[], Any]] = {
|
||||
# If set to "0", disable LayerName opaque type for layer_name
|
||||
# parameters in custom ops. Defaults to enabled on torch >= 2.11.
|
||||
"VLLM_USE_LAYERNAME": lambda: bool(int(os.getenv("VLLM_USE_LAYERNAME", "1"))),
|
||||
# If set, use the Rust frontend binary instead of the Python API server
|
||||
# process(es).
|
||||
"VLLM_USE_RUST_FRONTEND": lambda: bool(
|
||||
int(os.getenv("VLLM_USE_RUST_FRONTEND", "0"))
|
||||
),
|
||||
# Path to the Rust frontend binary. Defaults to "auto" which discovers
|
||||
# the binary installed with the vllm package. Only used when
|
||||
# VLLM_USE_RUST_FRONTEND=1.
|
||||
"VLLM_RUST_FRONTEND_PATH": lambda: _resolve_rust_frontend_path(),
|
||||
# If set, vllm will run in development mode, which will enable
|
||||
# some additional endpoints for developing and debugging,
|
||||
# e.g. `/reset_prefix_cache`
|
||||
|
||||
@@ -75,6 +75,7 @@ class EngineCoreReadyResponse:
|
||||
max_model_len: int
|
||||
num_gpu_blocks: int
|
||||
dp_stats_address: str | None
|
||||
dtype: str | None = None
|
||||
|
||||
|
||||
class EngineCoreRequest(
|
||||
|
||||
@@ -1437,6 +1437,7 @@ class EngineCoreProc(EngineCore):
|
||||
max_model_len=self.vllm_config.model_config.max_model_len,
|
||||
num_gpu_blocks=self.vllm_config.cache_config.num_gpu_blocks or 0,
|
||||
dp_stats_address=self.frontend_stats_publish_address,
|
||||
dtype=str(self.vllm_config.model_config.dtype).removeprefix("torch."),
|
||||
)
|
||||
ready_payload = msgspec.msgpack.encode(ready_response)
|
||||
for input_socket in input_sockets:
|
||||
|
||||
+143
-2
@@ -2,6 +2,7 @@
|
||||
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
|
||||
import argparse
|
||||
import contextlib
|
||||
import json
|
||||
import multiprocessing
|
||||
import threading
|
||||
import time
|
||||
@@ -233,6 +234,146 @@ class APIServerProcessManager:
|
||||
shutdown(self.processes, timeout=timeout)
|
||||
|
||||
|
||||
class RustFrontendProcessManager:
|
||||
"""Manages a single Rust frontend subprocess.
|
||||
|
||||
Launches the Rust vllm-rs binary in 'frontend' mode, passing the
|
||||
listening socket fd and ZMQ transport addresses. Provides the same
|
||||
interface as APIServerProcessManager for process monitoring.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
binary_path: str,
|
||||
sock: Any,
|
||||
args: argparse.Namespace,
|
||||
input_address: str,
|
||||
output_address: str,
|
||||
engine_count: int,
|
||||
stats_update_address: str | None = None,
|
||||
):
|
||||
import os
|
||||
import subprocess
|
||||
|
||||
fd = sock.fileno()
|
||||
os.set_inheritable(fd, True)
|
||||
|
||||
cmd = [
|
||||
binary_path,
|
||||
"frontend",
|
||||
"--listen-fd",
|
||||
str(fd),
|
||||
"--input-address",
|
||||
input_address,
|
||||
"--output-address",
|
||||
output_address,
|
||||
"--engine-count",
|
||||
str(engine_count),
|
||||
]
|
||||
if stats_update_address is not None:
|
||||
cmd.extend(["--coordinator-address", stats_update_address])
|
||||
from vllm.entrypoints.utils import jsonify_non_default_args
|
||||
|
||||
args_json = json.dumps(
|
||||
jsonify_non_default_args(args, exclude={"api_server_count"}),
|
||||
sort_keys=True,
|
||||
)
|
||||
cmd.extend(["--args-json", args_json])
|
||||
|
||||
logger.info("Launching Rust frontend: %s", " ".join(cmd))
|
||||
self._proc = subprocess.Popen(cmd, pass_fds=(fd,))
|
||||
|
||||
# Create a process wrapper with a sentinel fd for monitoring
|
||||
self.processes: list[_SubprocessWrapper] = [
|
||||
_SubprocessWrapper(self._proc, "RustFrontend")
|
||||
]
|
||||
|
||||
self._finalizer = weakref.finalize(self, _shutdown_subprocesses, self.processes)
|
||||
|
||||
def shutdown(self, timeout: float | None = None) -> None:
|
||||
if self._finalizer.detach() is not None:
|
||||
_shutdown_subprocesses(self.processes, timeout=timeout)
|
||||
|
||||
|
||||
class _SubprocessWrapper:
|
||||
"""Wraps subprocess.Popen to provide the BaseProcess-like interface
|
||||
needed by wait_for_completion_or_failure."""
|
||||
|
||||
def __init__(self, proc, name: str):
|
||||
self._proc = proc
|
||||
self.name = name
|
||||
self.pid = proc.pid
|
||||
self._sentinel_conn: connection.Connection | None = None
|
||||
self._sentinel_send: connection.Connection | None = None
|
||||
|
||||
# Use a Pipe-based sentinel so subprocess monitoring works uniformly
|
||||
# across platforms with multiprocessing.connection.wait().
|
||||
recv, send = connection.Pipe(duplex=False)
|
||||
self._sentinel_conn = recv
|
||||
self._sentinel_send = send
|
||||
|
||||
def monitor_subprocess() -> None:
|
||||
try:
|
||||
proc.wait()
|
||||
finally:
|
||||
with contextlib.suppress(Exception):
|
||||
send.close()
|
||||
|
||||
threading.Thread(
|
||||
target=monitor_subprocess, daemon=True, name=f"{name}Monitor"
|
||||
).start()
|
||||
|
||||
@property
|
||||
def sentinel(self):
|
||||
return self._sentinel_conn
|
||||
|
||||
@property
|
||||
def exitcode(self) -> int | None:
|
||||
return self._proc.returncode if self._proc.poll() is not None else None
|
||||
|
||||
def is_alive(self) -> bool:
|
||||
return self._proc.poll() is None
|
||||
|
||||
def terminate(self):
|
||||
self._proc.terminate()
|
||||
|
||||
def join(self, timeout=None):
|
||||
with contextlib.suppress(Exception):
|
||||
self._proc.wait(timeout=timeout)
|
||||
|
||||
def __del__(self):
|
||||
with contextlib.suppress(Exception):
|
||||
if self._sentinel_conn is not None:
|
||||
self._sentinel_conn.close()
|
||||
if self._sentinel_send is not None:
|
||||
self._sentinel_send.close()
|
||||
|
||||
|
||||
def _shutdown_subprocesses(
|
||||
procs: list[_SubprocessWrapper], timeout: float | None = None
|
||||
) -> None:
|
||||
"""Shutdown subprocess wrappers (mirrors the shutdown() function)."""
|
||||
if timeout is None:
|
||||
timeout = 0.0
|
||||
timeout = max(timeout, 5.0)
|
||||
|
||||
for proc in procs:
|
||||
if proc.is_alive():
|
||||
proc.terminate()
|
||||
|
||||
deadline = time.monotonic() + timeout
|
||||
for proc in procs:
|
||||
remaining = deadline - time.monotonic()
|
||||
if remaining <= 0:
|
||||
break
|
||||
if proc.is_alive():
|
||||
proc.join(remaining)
|
||||
|
||||
for proc in procs:
|
||||
if proc.is_alive() and (pid := proc.pid) is not None:
|
||||
kill_process_tree(pid)
|
||||
|
||||
|
||||
def run_api_server_worker_proc(
|
||||
listen_address, sock, args, client_config=None, **uvicorn_kwargs
|
||||
) -> None:
|
||||
@@ -253,7 +394,7 @@ def run_api_server_worker_proc(
|
||||
|
||||
|
||||
def wait_for_completion_or_failure(
|
||||
api_server_manager: APIServerProcessManager,
|
||||
api_server_manager: "APIServerProcessManager | RustFrontendProcessManager",
|
||||
engine_manager: Union["CoreEngineProcManager", "CoreEngineActorManager"]
|
||||
| None = None,
|
||||
coordinator: "DPCoordinator | None" = None,
|
||||
@@ -274,7 +415,7 @@ def wait_for_completion_or_failure(
|
||||
logger.info("Waiting for API servers to complete ...")
|
||||
# Create a mapping of sentinels to their corresponding processes
|
||||
# for efficient lookup
|
||||
sentinel_to_proc: dict[Any, BaseProcess] = {
|
||||
sentinel_to_proc: dict[Any, BaseProcess | _SubprocessWrapper | None] = {
|
||||
proc.sentinel: proc for proc in api_server_manager.processes
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user