llmapi: reduce fallback repetition and harden support-matrix sync

Centralize model feature fallback disabling and standardize the warning format. Mark supported-models.md as generated and add basic generator/data invariants to prevent silent drift.

Signed-off-by: Venky Ganesh <23023424+venkywonka@users.noreply.github.com>

Author: venkywonka

docs/source/models/supported-models.md

@@ -1,4 +1,5 @@
 (support-matrix)=
+<!-- Generated from tensorrt_llm/llmapi/model_support_matrix.py; do not edit. -->
 # Supported Models
 
 The following is a table of supported models for the PyTorch backend:

tensorrt_llm/llmapi/llm.py

@@ -261,44 +261,61 @@ def _apply_model_feature_fallbacks(self) -> None:
             return
         arch = archs[0]
 
+        def _disable_if_unsupported(
+            feature: SupportFeature,
+            *,
+            enabled: bool,
+            arg_path: str,
+            disable,
+        ) -> None:
+            # Preserve behavior: only override when user explicitly enabled it.
+            if not enabled:
+                return
+            status = get_support_status(arch, feature)
+            # Preserve behavior: unknown/untested/missing status must not disable anything.
+            if status not in (SupportStatus.NO, SupportStatus.NA):
+                return
+            logger.warning(
+                f"{arch}: {feature.value} unsupported; disabling {arg_path}")
+            disable()
+
         kv_cfg = getattr(self.args, "kv_cache_config", None)
-        if kv_cfg is not None and getattr(kv_cfg, "enable_block_reuse", False):
-            if get_support_status(
-                    arch, SupportFeature.KV_CACHE_REUSE) in (SupportStatus.NO,
-                                                             SupportStatus.NA):
-                logger.warning(
-                    f"{arch}: KV cache reuse unsupported; setting kv_cache_config.enable_block_reuse=False"
-                )
+
+        def _disable_kv_cache_reuse() -> None:
+            if kv_cfg is not None:
                 kv_cfg.enable_block_reuse = False
 
-        if getattr(self.args, "enable_chunked_prefill", False):
-            if get_support_status(
-                    arch, SupportFeature.CHUNKED_PREFILL) in (SupportStatus.NO,
-                                                              SupportStatus.NA):
-                logger.warning(
-                    f"{arch}: Chunked prefill unsupported; setting enable_chunked_prefill=False"
-                )
-                self.args.enable_chunked_prefill = False
-
-        if getattr(self.args, "enable_attention_dp", False):
-            if get_support_status(
-                    arch, SupportFeature.ATTENTION_DP) in (SupportStatus.NO,
-                                                           SupportStatus.NA):
-                logger.warning(
-                    f"{arch}: Attention DP unsupported; setting enable_attention_dp=False"
-                )
-                self.args.enable_attention_dp = False
-
-        if hasattr(self.args, "disable_overlap_scheduler") and getattr(
-                self.args, "disable_overlap_scheduler") is False:
-            if get_support_status(
-                    arch,
-                    SupportFeature.OVERLAP_SCHEDULER) in (SupportStatus.NO,
-                                                          SupportStatus.NA):
-                logger.warning(
-                    f"{arch}: Overlap scheduler unsupported; setting disable_overlap_scheduler=True"
-                )
-                self.args.disable_overlap_scheduler = True
+        _disable_if_unsupported(
+            SupportFeature.KV_CACHE_REUSE,
+            enabled=kv_cfg is not None
+            and getattr(kv_cfg, "enable_block_reuse", False),
+            arg_path="kv_cache_config.enable_block_reuse",
+            disable=_disable_kv_cache_reuse,
+        )
+
+        _disable_if_unsupported(
+            SupportFeature.CHUNKED_PREFILL,
+            enabled=getattr(self.args, "enable_chunked_prefill", False),
+            arg_path="enable_chunked_prefill",
+            disable=lambda: setattr(self.args, "enable_chunked_prefill", False),
+        )
+
+        _disable_if_unsupported(
+            SupportFeature.ATTENTION_DP,
+            enabled=getattr(self.args, "enable_attention_dp", False),
+            arg_path="enable_attention_dp",
+            disable=lambda: setattr(self.args, "enable_attention_dp", False),
+        )
+
+        # disable_overlap_scheduler is inverted: we only flip it when currently False.
+        _disable_if_unsupported(
+            SupportFeature.OVERLAP_SCHEDULER,
+            enabled=hasattr(self.args, "disable_overlap_scheduler")
+            and getattr(self.args, "disable_overlap_scheduler") is False,
+            arg_path="disable_overlap_scheduler",
+            disable=lambda: setattr(self.args, "disable_overlap_scheduler", True
+                                    ),
+        )
 
     @property
     @set_api_status("beta")

tensorrt_llm/llmapi/model_support_matrix.py

@@ -500,6 +500,7 @@ def render_supported_models_markdown() -> str:
     """Render the full `docs/source/models/supported-models.md` content."""
     out: List[str] = []
     out.append("(support-matrix)=")
+    out.append("<!-- Generated from tensorrt_llm/llmapi/model_support_matrix.py; do not edit. -->")
     out.append("# Supported Models")
     out.append("")
     out.append("The following is a table of supported models for the PyTorch backend:")

tests/unittest/tools/test_supported_models_sync.py

@@ -21,6 +21,11 @@
 
 
 def _render_supported_models_markdown(repo_root: Path) -> str:
+    module = _load_model_support_matrix_module(repo_root)
+    return module.render_supported_models_markdown()
+
+
+def _load_model_support_matrix_module(repo_root: Path):
     module_path = repo_root / "tensorrt_llm/llmapi/model_support_matrix.py"
     spec = importlib.util.spec_from_file_location("tllm_model_support_matrix", module_path)
     if spec is None or spec.loader is None:
@@ -30,7 +35,7 @@ def _render_supported_models_markdown(repo_root: Path) -> str:
     # Needed for dataclasses/type evaluation during module exec.
     sys.modules[spec.name] = module
     spec.loader.exec_module(module)
-    return module.render_supported_models_markdown()
+    return module
 
 
 class TestSupportedModelsSync(unittest.TestCase):
@@ -50,6 +55,53 @@ def test_supported_models_md_sync(self):
             "Please regenerate it (e.g. build docs, or run the generator entrypoint in docs/source/helper.py).",
         )
 
+    def test_supported_models_matrix_invariants(self):
+        """Catch support-matrix drift early (ordering, duplication, footnotes)."""
+        repo_root = Path(__file__).resolve().parents[3]
+        module = _load_model_support_matrix_module(repo_root)
+
+        self.assertEqual(
+            set(module.KEY_MODEL_ARCH_ORDER),
+            set(module.KEY_MODEL_MATRIX.keys()),
+            "KEY_MODEL_ARCH_ORDER must match KEY_MODEL_MATRIX keys (no missing/extra rows).",
+        )
+        self.assertEqual(
+            set(module.MULTIMODAL_ARCH_ORDER),
+            set(module.MULTIMODAL_MATRIX.keys()),
+            "MULTIMODAL_ARCH_ORDER must match MULTIMODAL_MATRIX keys (no missing/extra rows).",
+        )
+
+        self.assertEqual(
+            len(module.KEY_MODEL_ARCH_ORDER),
+            len(set(module.KEY_MODEL_ARCH_ORDER)),
+            "KEY_MODEL_ARCH_ORDER contains duplicate architectures.",
+        )
+        self.assertEqual(
+            len(module.MULTIMODAL_ARCH_ORDER),
+            len(set(module.MULTIMODAL_ARCH_ORDER)),
+            "MULTIMODAL_ARCH_ORDER contains duplicate architectures.",
+        )
+
+        architectures = [m.architecture for m in module.SUPPORTED_MODELS_PYTORCH]
+        self.assertEqual(
+            len(architectures),
+            len(set(architectures)),
+            "SUPPORTED_MODELS_PYTORCH contains duplicate architectures.",
+        )
+
+        used_footnotes = set()
+        for row in module.KEY_MODEL_MATRIX.values():
+            for cell in row.values():
+                footnote = getattr(cell, "footnote", None)
+                if footnote:
+                    used_footnotes.add(footnote)
+
+        for fn in used_footnotes:
+            self.assertTrue(
+                any(note.startswith(f"{fn}:") for note in module.KEY_MODEL_FOOTNOTES),
+                f"Missing footnote definition for {fn} in KEY_MODEL_FOOTNOTES.",
+            )
+
 
 if __name__ == "__main__":
     unittest.main()