From 1d4dcc81cc2f8561f4fdc7aa165bb5cdebbb41e4 Mon Sep 17 00:00:00 2001 From: Mick Date: Sat, 24 Oct 2026 09:30:04 +0800 Subject: [PATCH] [Perf] diffusion/registry: Reduce model discovery work at startup (#46043) Co-authored-by: Mick Qian --- .../multimodal_gen/runtime/models/registry.py | 98 +++++++++---------- .../multimodal_gen/test/unit/test_registry.py | 27 +++++ 2 files changed, 75 insertions(+), 50 deletions(-) diff --git a/python/sglang/multimodal_gen/runtime/models/registry.py b/python/sglang/multimodal_gen/runtime/models/registry.py index 14b54d8f6f..340323d151 100644 --- a/python/sglang/multimodal_gen/runtime/models/registry.py +++ b/python/sglang/multimodal_gen/runtime/models/registry.py @@ -7,6 +7,7 @@ import ast import importlib import os from abc import ABC, abstractmethod +from collections import deque from collections.abc import Set from dataclasses import dataclass, field from functools import lru_cache @@ -67,6 +68,8 @@ def _discover_and_register_models() -> dict[str, tuple[str, str, str]]: try: with open(filepath, "r", encoding="utf-8") as f: source = f.read() + if "EntryClass" not in source: + continue tree = ast.parse(source, filename=filename) entry_class_node = None @@ -74,64 +77,59 @@ def _discover_and_register_models() -> dict[str, tuple[str, str, str]]: # Collect all class definitions and their _aliases file_class_aliases: dict[str, list[str]] = {} - for node in ast.walk(tree): + # expressions cannot contain class/assignment statements; skip + # tensor computations while preserving breadth-first discovery + nodes = deque([tree]) + while nodes: + node = nodes.popleft() + if isinstance(node, ast.expr): + continue + nodes.extend(ast.iter_child_nodes(node)) if isinstance(node, ast.ClassDef): if first_class_def is None: first_class_def = node # Look for _aliases in the class body for class_body_node in node.body: - if isinstance(class_body_node, ast.Assign): - for target in class_body_node.targets: - if ( - isinstance(target, ast.Name) - and target.id == "_aliases" - ): - aliases = _parse_aliases_from_ast( - class_body_node.value - ) - if aliases: - file_class_aliases[node.name] = aliases - if isinstance(node, ast.Assign): - for target in node.targets: - if ( - isinstance(target, ast.Name) - and target.id == "EntryClass" + if isinstance(class_body_node, ast.Assign) and any( + isinstance(target, ast.Name) and target.id == "_aliases" + for target in class_body_node.targets ): - entry_class_node = node - break + aliases = _parse_aliases_from_ast(class_body_node.value) + if aliases: + file_class_aliases[node.name] = aliases + elif isinstance(node, ast.Assign) and any( + isinstance(target, ast.Name) and target.id == "EntryClass" + for target in node.targets + ): + entry_class_node = node - if entry_class_node and first_class_def: - model_cls_name_list = [] - value_node = entry_class_node.value + if entry_class_node is None or first_class_def is None: + continue + value_node = entry_class_node.value + if isinstance(value_node, ast.Name): + entries = [value_node] + elif isinstance(value_node, (ast.List, ast.Tuple)): + entries = value_node.elts + else: + continue - # EntryClass = ClassName - if isinstance(value_node, ast.Name): - model_cls_name_list.append(value_node.id) - # EntryClass = ["...", ClassName, ...] - elif isinstance(value_node, (ast.List, ast.Tuple)): - for elt in value_node.elts: - if isinstance(elt, ast.Constant): - model_cls_name_list.append(elt.value) - elif isinstance(elt, ast.Name): - model_cls_name_list.append(elt.id) - - if model_cls_name_list: - for model_cls_str in model_cls_name_list: - if model_cls_str in discovered_models: - logger.warning( - f"Duplicate architecture found: {model_cls_str}. It will be overwritten." - ) - model_arch = model_cls_str - discovered_models[model_arch] = ( - component, - mod_relname, - model_cls_str, - ) - # Collect aliases for this class - if model_cls_str in file_class_aliases: - class_aliases[model_cls_str] = file_class_aliases[ - model_cls_str - ] + for entry in entries: + if not isinstance(entry, (ast.Name, ast.Constant)): + continue + model_arch = ( + entry.id if isinstance(entry, ast.Name) else entry.value + ) + if model_arch in discovered_models: + logger.warning( + f"Duplicate architecture found: {model_arch}. It will be overwritten." + ) + discovered_models[model_arch] = ( + component, + mod_relname, + model_arch, + ) + if model_arch in file_class_aliases: + class_aliases[model_arch] = file_class_aliases[model_arch] except Exception as e: logger.warning(f"Could not parse {filepath} to find models: {e}") diff --git a/python/sglang/multimodal_gen/test/unit/test_registry.py b/python/sglang/multimodal_gen/test/unit/test_registry.py index b4e28a97a0..d77a0a8a7e 100644 --- a/python/sglang/multimodal_gen/test/unit/test_registry.py +++ b/python/sglang/multimodal_gen/test/unit/test_registry.py @@ -10,6 +10,7 @@ from sglang.multimodal_gen.configs.pipeline_configs.wan import ( Wan_Animate_2_14B_Config, Wan_Animate_2_14B_Distilled_Config, ) +from sglang.multimodal_gen.runtime.models import registry as model_registry @pytest.fixture(autouse=True) @@ -119,3 +120,29 @@ def test_model_id_short_name_selects_the_variant_for_a_neutral_directory(): "/models/ckpt-7f3a", model_id="Wan2.2-Animate-2-14B-Distilled-Diffusers" ) assert info.pipeline_config_cls is Wan_Animate_2_14B_Distilled_Config + + +@pytest.mark.parametrize("entry", ["Model", '[Model, "Model"]', '(Model, "Model")']) +def test_model_discovery_preserves_nested_declarations(tmp_path, monkeypatch, entry): + """Skipping expression subtrees must retain declarations under statements.""" + component = tmp_path / "dits" + component.mkdir() + (component / "example.py").write_text( + "import nonexistent_optional_backend\n" + "if True:\n" + " class Model:\n" + " _aliases = ['external.Model']\n" + " def forward(self, x):\n" + " return (x + 1) * 2\n" + f" EntryClass = {entry}\n" + ) + aliases = {} + monkeypatch.setattr(model_registry, "MODELS_PATH", str(tmp_path)) + monkeypatch.setattr(model_registry, "COMPONENT_DIRS", ["dits"]) + monkeypatch.setattr(model_registry, "_IMAGE_ENCODER_MODELS", {}) + monkeypatch.setattr(model_registry, "_ALIAS_TO_MODEL", aliases) + + # bypass the cache without changing the registry used by other tests + discovered = model_registry._discover_and_register_models.__wrapped__() + assert discovered == {"Model": ("dits", "example", "Model")} + assert aliases == {"external.Model": "Model"}