tests/unittest/_torch/auto_deploy/unit/singlegpu/transformations/library/test_gemm_fusion.py (3)

268-276: Avoid overshadowing the outer ‘gm’ variable in the lambda (readability).

The lambda parameter named gm shadows the outer gm variable. Rename the parameter for clarity.

-        lambda gm: sum(is_linear_op(n, include_quantization=True) for n in gm.graph.nodes)
+        lambda g: sum(is_linear_op(n, include_quantization=True) for n in g.graph.nodes)

---

10-10: Use explicit package import for test helper

The run_test_transformed_gm and count_buffers functions are defined in
tests/unittest/_torch/auto_deploy/_utils_test/_graph_test_helpers.py, but there are no sys.path adjustments in the test tree to allow a bare _graph_test_helpers import. To prevent import errors when PYTHONPATH isn’t set, update the import to the full module path:

• File:
tests/unittest/_torch/auto_deploy/unit/singlegpu/transformations/library/test_gemm_fusion.py

• Change:

- from _graph_test_helpers import count_buffers, run_test_transformed_gm
+ from tests.unittest._torch.auto_deploy._utils_test._graph_test_helpers import \
    count_buffers, run_test_transformed_gm

If you’d rather keep the top-level import, add a conftest.py or an explicit
sys.path.insert(...) in your test setup to include _utils_test on sys.path.

---

258-267: Extract optimizer config and instantiation for clarity

Verified that InferenceOptimizer.__call__(self, cm: CachedSequenceInterface, gm: Optional[GraphModule] = None) supports optimizer(None, gm). To improve readability and make future extensions easier, pull the inline dict into a named opt_config and instantiate the optimizer in its own statement:

-    gm = torch_export_to_gm(model, args=(x,), clone=True)
-    gm_transformed = InferenceOptimizer(
-        None,
-        {
-            "fuse_gemms": {
-                "stage": "post_load_fusion",
-            },
-        },
-    )(None, gm)
+    gm = torch_export_to_gm(model, args=(x,), clone=True)
+    opt_config = {
+        "fuse_gemms": {"stage": "post_load_fusion"},
+    }
+    optimizer = InferenceOptimizer(None, opt_config)
+    gm_transformed = optimizer(None, gm)

tests/unittest/_torch/auto_deploy/unit/singlegpu/transformations/library/test_kv_cache.py (4)

16-33: Make DummyFactory.build_model deterministic and minimal.

• Set the model to eval() to avoid train-time behaviors (e.g., dropout) in tests.
• Use pass for no-op methods to be explicit.

 class DummyFactory(ModelFactory):
@@
-    def build_model(self, device: str):
-        return self._model.to(device=device)
+    def build_model(self, device: str):
+        # Ensure deterministic inference behavior in tests.
+        return self._model.to(device=device).eval()
@@
-    def _build_model(self, device: str):
-        return
+    def _build_model(self, device: str):
+        pass
@@
-    def _load_checkpoint(self, model, device):
-        return
+    def _load_checkpoint(self, model, device):
+        pass

---

40-56: Assert shape assumptions for safer head-dim math.

Add guards to catch invalid configurations early (hidden_size divisible by num_heads; grouped KV valid).

     def __init__(
         self,
         *args,
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
         # Store the head dimensions explicitly
         self.num_heads = args[0]  # First argument is num_attention_heads
         self.num_kv_heads = args[2]  # Third argument is num_key_value_heads
-        self.head_dim = args[1] // self.num_heads  # hidden_size / num_heads
+        assert args[1] % self.num_heads == 0, "hidden_size must be divisible by num_heads"
+        self.head_dim = args[1] // self.num_heads  # hidden_size / num_heads
@@
-        if self.num_heads != self.num_kv_heads:
+        if self.num_heads != self.num_kv_heads:
+            assert self.num_heads % self.num_kv_heads == 0, "num_heads must be a multiple of num_kv_heads"
             self.num_key_value_groups = self.num_heads // self.num_kv_heads
         else:
             self.num_key_value_groups = None

---

108-112: Guard test on custom SDPA op availability.

Add a skip if torch.ops.auto_deploy.torch_attention_bsnd_grouped_sdpa is not present to avoid opaque failures on environments lacking the custom op.

 @torch.inference_mode()
 def test_sdpa_with_kv_cache(dtype, attn_backend, gqa_config):
     """Test the SDPA transformation with KV cache."""
     # flashinfer doesn't support float32 data type
     if attn_backend == "flashinfer" and dtype == torch.float32:
         pytest.skip("flashinfer doesn't support float32 data type")
+    if not hasattr(torch.ops, "auto_deploy") or \
+       not hasattr(torch.ops.auto_deploy, "torch_attention_bsnd_grouped_sdpa"):
+        pytest.skip("auto_deploy.torch_attention_bsnd_grouped_sdpa is not available in this build")

---

148-176: Pass dtype into CacheConfig to align cache tensor dtype with model math.

This ensures KV cache tensors are allocated with the same dtype as QKV, avoiding implicit casts or kernel mismatches across backends.

-    optimizer = InferenceOptimizer(
-        DummyFactory(model, CacheConfig()),
+    optimizer = InferenceOptimizer(
+        DummyFactory(model, CacheConfig(dtype=dtype)),
         {
             "build_model": {
                 "stage": "factory",
                 "device": "cuda",
                 "run_graph_cleanup": False,
                 "requires_clean_graph": False,
             },
             "export_to_gm": {
                 "stage": "export",
                 "strict": False,
                 "clone_state_dict": True,
                 "run_graph_cleanup": False,
                 "requires_clean_graph": False,
             },
             "cleanup_input_constraints": {
                 "stage": "post_export",
             },
             "update_in_out_nodes": {
                 "stage": "cache_init",
             },
             "insert_cached_attention": {
                 "stage": "cache_init",
                 "attn_backend": attn_backend,
             },
         },
     )  # type: ignore

tests/unittest/_torch/auto_deploy/unit/multigpu/transformations/library/test_collective_fusion.py (2)

1-2: Missing NVIDIA copyright header.

All Python sources require the current-year NVIDIA header.

Apply:

+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+#
 """Tests for basic fusion of the collective."""

---

65-73: Potential API mismatch and brittle construction; prefer explicit config object or helper.

Constructing InferenceOptimizer with a raw dict of transforms and invoking with (None, gm) tightly couples the test to internal optimizer signatures. If available, use an explicit AD config class or a helper method that takes a GM and returns a transformed GM to reduce churn when internals change.

If a helper like apply_post_load_fusion(gm, {"fuse_collectives": {...}}) exists, prefer it. Otherwise, consider a small wrapper in test utils to abstract optimizer invocation.

tensorrt_llm/_torch/auto_deploy/transform/library/fusion.py (3)

9-11: Missing NVIDIA copyright header.

Comply with repository guidelines for source headers.

Apply at file top:

+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+#
 import operator
 from collections import defaultdict
 from typing import List, Tuple

---

121-154: Graph mutation is fine; consider minor robustness improvements.

• After in-graph transformations, BaseTransform cleanup should recompile. If any transform disables cleanup, ensure to call gm.recompile() explicitly.
• Node iteration safety: you correctly DCE and prune submodules after replacements inside _insert_fused_gemm. Keep relying on post-cleanup to sanitize.

Optionally, consider returning info.is_clean=True if you know the transform preserves cleanliness and you don’t depend on shape-prop; this can skip extra canonicalization work in subsequent stages.

---

87-109: Quantized fusion path: preserve scale/buffer semantics consistently.

The implementation ensures fused scales are registered and referenced in the fused node’s kwargs. LGTM. Consider adding a small comment that unfused linear ops are fully erasable because fused scale get_attr nodes are created explicitly to avoid accidental shared references.

tensorrt_llm/_torch/auto_deploy/transform/library/rms_norm.py (3)

1-4: Missing NVIDIA copyright header.

All Python sources need the current-year NVIDIA header.

Apply at file top:

+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+#
 """Graph transform to optimize RMSNorm execution using FlashInfer."""

---

72-76: Docstring/backend list is slightly inconsistent with implementation.

Docstring mentions only "flashinfer" or "triton", but _BACKEND_OPS also exposes "torch". Either remove "torch" backend support or update the docstring to reflect it.

Apply:

-        description="Backend to use for RMSNorm computation ('flashinfer' or 'triton').",
+        description="Backend to use for RMSNorm computation ('flashinfer', 'triton', or 'torch').",

---

133-146: Pattern strictness and shape/dtype handling.

The pattern registers for bf16/fp16/fp32 which is good. To further reduce brittleness:

• Consider ignoring the exact mean dims literal via op_ignore_types so [-1] vs (-1,) variants don’t break matching.
• Keep scalar_workaround for eps.

If needed, update register_ad_pattern(..., op_ignore_types={torch.ops.aten.mean: (int, list, tuple)}) to ignore literal dims in the pattern graph.

tensorrt_llm/_torch/auto_deploy/transform/library/collectives.py (4)

1-12: Missing NVIDIA copyright header.

Add the standard header.

Apply:

+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+#
 import operator
 from typing import Tuple

---

45-53: Avoid assertions for graph shape; treat as guards to skip non-matching nodes.

Transform-time assertions can crash the pipeline on benign graphs. Replace with guard-and-continue to keep the pass resilient.

Apply:

-            # check if args are as expected
-            assert len(node.args) == 1 and not len(node.kwargs), (
-                "Unexpected args/kwargs for all_reduce"
-            )
+            # check if args are as expected
+            if not (len(node.args) == 1 and not node.kwargs):
+                # Unexpected signature; skip
+                continue

---

45-71: Iterate over a snapshot when mutating the graph.

You erase nodes during iteration. Snapshot the node list to avoid iterator invalidation in future FX versions.

Apply:

-        for node in gm.graph.nodes:
+        for node in list(gm.graph.nodes):
             if not is_op(node, torch.ops.auto_deploy.torch_dist_all_reduce):
                 continue

---

110-194: Minor consistency and cleanup improvements in RMSNorm fusion path.

• Mixed use of graph and gm.graph is confusing; use the local graph consistently.
• After rewiring, consider running DCE explicitly (BaseTransform cleanup will also handle it, but being explicit can help during debugging).

Apply:

-                    final_output_node = gm.graph.create_node(
+                    final_output_node = graph.create_node(
                         "call_function",
                         target=operator.getitem,
                         args=(fused_node, 0),
                     )
-                    add_output_node = gm.graph.create_node(
+                    add_output_node = graph.create_node(
                         "call_function",
                         target=operator.getitem,
                         args=(fused_node, 1),
                     )

Optionally, after the node rewrites:

graph.eliminate_dead_code()

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: moraxu
PR: NVIDIA/TensorRT-LLM#6303
File: tests/integration/test_lists/qa/examples_test_list.txt:494-494
Timestamp: 2025-07-28T17:06:08.621Z
Learning: In TensorRT-LLM testing, it's common to have both CLI flow tests (test_cli_flow.py) and PyTorch API tests (test_llm_api_pytorch.py) for the same model. These serve different purposes: CLI flow tests validate the traditional command-line workflow, while PyTorch API tests validate the newer LLM API backend. Both are legitimate and should coexist.

tensorrt_llm/_torch/auto_deploy/transformations/transform.py (3)

48-66: Defensive checks around transform configs.

These assignments assume self.ad_config.transforms[...] entries are objects with the listed attributes. If a dict slips through (e.g., from YAML), this will raise. Consider defensive guards or conversion.

-        if "load_weights" in self.ad_config.transforms:
-            self.ad_config.transforms[
-                "load_weights"
-            ].checkpoint_device = self.ad_config.checkpoint_device
-            self.ad_config.transforms["load_weights"].device = cm.device
+        if "load_weights" in self.ad_config.transforms:
+            lw = self.ad_config.transforms["load_weights"]
+            # Allow both object- and dict-style configs
+            try:
+                lw.checkpoint_device = self.ad_config.checkpoint_device
+                lw.device = cm.device
+            except AttributeError:
+                lw["checkpoint_device"] = self.ad_config.checkpoint_device
+                lw["device"] = getattr(cm, "device", None)

---

52-52: Guard against None cm when accessing device.

If cm is ever None (e.g., misused externally), cm.device will raise. A fast-fail assertion improves diagnostics.

     def __call__(self, cm: CachedSequenceInterface) -> nn.Module:
+        assert cm is not None, "CachedSequenceInterface (cm) must be provided"

---

82-87: Naming clarity: avoid duplicate “InferenceOptimizer” symbols across packages.

This class delegates to transform.optimizer.InferenceOptimizer under the alias ModularInferenceOptimizer. The duplication of the public name “InferenceOptimizer” in two modules is easy to confuse. Consider renaming this facade (or the alias) to “HighLevelInferenceOptimizer” or “InferenceOrchestrator” to reduce ambiguity.

tests/unittest/_torch/auto_deploy/unit/singlegpu/transformations/library/test_kv_cache.py (4)

16-34: DummyFactory is fine for tests; consider light tightening (types).

Works as a minimal stub. For readability and static checkers, consider adding type hints to the constructor.

Suggested tweak:

-class DummyFactory(ModelFactory):
+class DummyFactory(ModelFactory):
     """Dummy factory to pass cache_config for testing."""
 
-    def __init__(self, model, cache_config):
+    def __init__(self, model: torch.nn.Module, cache_config: CacheConfig):
         self._model = model
         self.cache_config = cache_config

---

36-85: Prefer reshape over view; remove unused attribute.

• Linear outputs are typically contiguous, but reshape is safer than view when contiguity assumptions change.
• num_key_value_groups is computed but never used.

Apply:

-        if self.num_heads != self.num_kv_heads:
-            self.num_key_value_groups = self.num_heads // self.num_kv_heads
-        else:
-            self.num_key_value_groups = None
+        # Number of key-value groups (unused here; omit unless needed)
 
         # Reshape to [b, s, n, h_d]
-        q = q.view(b, s, self.num_heads, self.head_dim)
-        k = k.view(b, s, self.num_kv_heads, self.head_dim)
-        v = v.view(b, s, self.num_kv_heads, self.head_dim)
+        q = q.reshape(b, s, self.num_heads, self.head_dim)
+        k = k.reshape(b, s, self.num_kv_heads, self.head_dim)
+        v = v.reshape(b, s, self.num_kv_heads, self.head_dim)

---

149-176: Leverage InitializeCache stage to avoid manual cache init in test.

Since kvcache.py provides InitializeCache, you can include it in the pipeline and drop the manual cm.initialize_caches() call, keeping tests aligned with the modular optimizer flow.

Apply this diff to extend the transform config:

             "insert_cached_attention": {
                 "stage": "cache_init",
                 "attn_backend": attn_backend,
             },
+            "initialize_cache": {
+                "stage": "cache_init",
+            },

Then remove the explicit initialization (see a companion suggestion near Line 180).

---

179-181: Avoid redundant .to('cuda') and prefer pipeline-driven cache init.

• gm is already created on CUDA via the "build_model" stage’s device="cuda".
• If you adopt the InitializeCache stage, you can eliminate manual cm.initialize_caches().

Apply:

-    gm.to("cuda")
-    cm.initialize_caches()
+    # Cache initialization handled by InitializeCache stage

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: djns99
PR: NVIDIA/TensorRT-LLM#6915
File: cpp/tensorrt_llm/kernels/cutlass_kernels/moe_gemm/moe_kernels.cu:4010-4012
Timestamp: 2025-08-14T23:23:27.420Z
Learning: For MOE (Mixture of Experts) code reviews in TensorRT-LLM, avoid repeatedly suggesting finalize fusion validation checks and safety assertions. The user djns99 has indicated these suggestions are repetitive and unwanted across multiple MOE-related changes.

tests/unittest/_torch/auto_deploy/unit/singlegpu/transformations/library/test_fuse_rmsnorm.py (1)

3-3: Fix helper import path so tests can discover run_test_transformed_gm.

The helper lives under tests/unittest/_torch/auto_deploy/_utils_test/_graph_test_helpers.py. Importing _graph_test_helpers directly will likely raise ImportError unless sys.path is tweaked elsewhere. Make _utils_test a package and import from it, or adjust sys.path.

-from _graph_test_helpers import run_test_transformed_gm
+from _utils_test._graph_test_helpers import run_test_transformed_gm

Alternatively, add a shared conftest that appends _utils_test to sys.path.

tensorrt_llm/_torch/auto_deploy/transform/library/rms_norm.py (1)

119-124: Avoid requiring CUDA for pattern registration. Use CPU dummies.

Pattern tracing doesn’t require CUDA; allocating CUDA tensors here prevents running in CPU-only CI or dev environments.

-        def dummy_args(input_dtype: torch.dtype, weight_dtype: torch.dtype, eps: float = 1e-6):
-            return [
-                torch.randn(bs, hidden_size, device="cuda", dtype=input_dtype),
-                torch.randn(hidden_size, device="cuda", dtype=weight_dtype),
-                eps,
-            ]
+        def dummy_args(input_dtype: torch.dtype, weight_dtype: torch.dtype, eps: float = 1e-6):
+            return [
+                torch.randn(bs, hidden_size, device="cpu", dtype=input_dtype),
+                torch.randn(hidden_size, device="cpu", dtype=weight_dtype),
+                eps,
+            ]

tensorrt_llm/_torch/auto_deploy/transform/interface.py (2)

57-57: Constrain attn_backend to known values (Literal/Enum) for safer config validation.

Using a plain str risks typos propagating into downstream transforms. Recommend narrowing the type to Literal or an Enum and updating the docstring accordingly.

Apply within this file:

-    attn_backend: str = Field(default="flashinfer", description="The attention backend to use.")
+    attn_backend: "Literal['flashinfer', 'triton', 'torch']" = Field(
+        default="flashinfer",
+        description="The attention backend to use. One of: 'flashinfer', 'triton', 'torch'.",
+    )

Add this import (outside the shown range):

from typing import Literal

---

1-1: Add NVIDIA copyright header (repo guideline).

Source files must carry the current-year NVIDIA header. Please prepend it at the very top of the file (before the module docstring).

+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 """The interface for all transforms.

tensorrt_llm/_torch/auto_deploy/transform/library/fusion.py (4)

92-101: Ensure complete cleanup and recompile after graph surgery.

You call eliminate_dead_code and delete_all_unused_submodules, which is good. Post-fusion, correctness relies on a recompile step; this is currently handled by post-cleanup in BaseTransform (since is_clean=False). If anyone flips run_graph_cleanup or is_clean later, this could regress. Consider explicitly calling gm.recompile() here to localize correctness to this transform.

Example:

     gm.graph.eliminate_dead_code()
     gm.delete_all_unused_submodules()
+    gm.recompile()

Also applies to: 101-116

---

148-149: Guard CUDA-specific cache flush.

torch.cuda.empty_cache() is harmless on CUDA builds but can error in CPU-only environments or test stubs. Guard with is_available() to be safe.

-        torch.cuda.empty_cache()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()

---

121-153: Minor: Unused parameters in _apply signature.

cm, factory, and shared_config are currently unused. It’s fine to keep for interface uniformity, but prefix with underscores or add a short comment to appease linters.

---

1-1: Add NVIDIA copyright header (repo guideline).

This is a production source file and should include the standard header.

+// Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import operator

tests/unittest/_torch/auto_deploy/unit/singlegpu/transformations/library/test_fuse_rmsnorm.py (1)

76-79: Redundant numerical equivalence assert; helper already checks outputs.

run_test_transformed_gm compares outputs (unless skip_output_assert=True). The extra assert here is duplicate and can be removed to keep the test focused.

-    new_input = torch.randn(4, 1024, device="cuda", dtype=torch.float16)
-    y_transformed = gm_transformed(new_input)
-    y_model = model(new_input)
-    torch.testing.assert_close(y_transformed, y_model, atol=1e-3, rtol=1e-3)
+    # Output parity is already verified by run_test_transformed_gm

tensorrt_llm/_torch/auto_deploy/transform/library/rms_norm.py (3)

1-1: Update docstring to reflect multi-backend support and add NVIDIA header.

Docstring mentions FlashInfer only, but the transform supports "flashinfer", "triton", and "torch". Also add the standard header required for source files.

+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
-"""Graph transform to optimize RMSNorm execution using FlashInfer."""
+"""Graph transform to optimize RMSNorm execution with pluggable backends.
+
+Supports backends: "flashinfer", "triton", and "torch".
+"""

---

72-75: Config doc should list all supported backends.

The description omits "torch". Align with _BACKEND_OPS to avoid confusion.

-        description="Backend to use for RMSNorm computation ('flashinfer' or 'triton').",
+        description="Backend to use for RMSNorm computation ('flashinfer', 'triton', 'torch').",

---

100-112: Validate backend once and explain failure mode.

The early ValueError is good. Consider including the provided backend value and available keys in the message (already done). Optionally, offer the SharedConfig.attn_backend as a fallback when config.backend is unset to reduce config duplication.

tensorrt_llm/_torch/auto_deploy/transformations/transform.py (2)

82-87: Share attn_backend via shared_config: good; consider centralizing SharedConfig population.

Today you set shared_config.attn_backend after constructing the optimizer. Long-term, consider building SharedConfig up-front (once) and passing it into the optimizer ctor to avoid accidental divergence when more shared fields are added.

---

1-1: Add NVIDIA copyright header (repo guideline).

Please prepend the standard header at the very top.

+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 """High-level entrypoint to transform a model into an efficient inference model."""

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: galagam
PR: NVIDIA/TensorRT-LLM#6487
File: tests/unittest/_torch/auto_deploy/unit/singlegpu/test_ad_trtllm_bench.py:1-12
Timestamp: 2025-08-06T13:58:07.506Z
Learning: In TensorRT-LLM, test files (files under tests/ directories) do not require NVIDIA copyright headers, unlike production source code files. Test files typically start directly with imports, docstrings, or code.

Learnt from: CR
PR: NVIDIA/TensorRT-LLM#0
File: CODING_GUIDELINES.md:0-0
Timestamp: 2025-08-12T10:28:57.320Z
Learning: Applies to **/*.{cpp,cxx,cc,cu,h,hpp,hxx,hh,cuh,py} : Prepend NVIDIA copyright header (current year) to all source files