From 31a15db08891e9f2a30e48d1337101a62667a409 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Wed, 30 Jul 2025 17:32:06 +0800
Subject: [PATCH 01/48] add CUDAGraphModelEngine

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../pyexecutor/cuda_graph_model_engine.py     | 282 ++++++++++++++++++
 .../_torch/pyexecutor/cuda_graph_runner.py    | 139 ---------
 .../_torch/pyexecutor/model_engine.py         | 211 ++-----------
 3 files changed, 304 insertions(+), 328 deletions(-)
 create mode 100644 tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
 delete mode 100644 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
new file mode 100644
index 00000000000..96ef0b163bd
--- /dev/null
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
@@ -0,0 +1,282 @@
+import bisect
+import contextlib
+import threading
+import weakref
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
+
+import torch
+
+from ..expert_statistic import ExpertStatistic
+from ..utils import make_weak_ref, set_piecewise_cuda_graph_flag
+from .resource_manager import ResourceManager, ResourceManagerType
+from .scheduler import ScheduledRequests
+
+if TYPE_CHECKING:
+    from .model_engine import PyTorchModelEngine
+
+# A large prime number used for dummy request IDs to avoid collisions
+CUDA_GRAPH_DUMMY_REQUEST_ID = (1 << 64) - 1
+
+
+class graph_capturing_local(threading.local):
+
+    def __init__(self):
+        self.is_graph_capturing = False
+
+
+_local = graph_capturing_local()
+
+
+def set_graph_capturing(enable: bool):
+    _local.is_graph_capturing = enable
+
+
+def is_graph_capturing() -> bool:
+    return _local.is_graph_capturing
+
+
+@contextlib.contextmanager
+def capturing_cuda_graph_context():
+    """A context manager to safely set and unset graph capturing flags."""
+    set_graph_capturing(True)
+    set_piecewise_cuda_graph_flag(False)
+    try:
+        yield
+    finally:
+        set_graph_capturing(False)
+        set_piecewise_cuda_graph_flag(True)
+
+
+class CUDAGraphModelEngine:
+    """
+    Manages the lifecycle and execution of CUDA graphs for the model engine.
+
+    This unified class handles high-level orchestration (padding, eligibility)
+    and low-level execution (capturing, resource management, replaying) for
+    multiple graphs, keyed by batch size.
+    """
+    WARMUP_STEPS = 2
+
+    def __init__(self, engine: "PyTorchModelEngine"):
+        self.engine_ref = weakref.ref(engine)
+
+        # High-level configuration
+        config = engine.pytorch_backend_config
+        self.enabled = config.use_cuda_graph
+        self.padding_enabled = config.cuda_graph_padding_enabled
+        self.supported_batch_sizes = engine._cuda_graph_batch_sizes
+        self.max_supported_batch_size = engine._max_cuda_graph_batch_size
+
+        # Low-level state, storing resources per batch size
+        self.graphs: Dict[int, torch.cuda.CUDAGraph] = {}
+        self.static_inputs: Dict[int, Dict[str, torch.Tensor]] = {}
+        self.graph_outputs: Dict[int, Callable[[], Optional[torch.Tensor]]] = {}
+        self.graph_metadata: Dict[int, Dict[str, Any]] = {}
+        self.memory_pool = engine._cuda_graph_mem_pool
+        self.padding_dummy_request: Optional["Request"] = None
+
+    def __del__(self):
+        self.clear()
+
+    def _get_engine(self) -> "PyTorchModelEngine":
+        """Safely dereferences the weak reference to the engine."""
+        engine = self.engine_ref()
+        if engine is None:
+            raise RuntimeError(
+                "The parent PyTorchModelEngine has been garbage collected.")
+        return engine
+
+    def execute(self, batch: ScheduledRequests, inputs: Dict[str, Any],
+                forward_fn: Callable) -> Optional[torch.Tensor]:
+        """
+        Runs the model via a CUDA graph or captures it if needed.
+
+        Returns the model output tensor if a graph was run, otherwise None.
+        """
+        if not self._can_run_graph(batch):
+            return None
+
+        batch_size = len(batch.generation_requests)
+
+        if batch_size not in self.graphs:
+            if batch_size in self.supported_batch_sizes:
+                self._capture_graph(batch_size, forward_fn, inputs)
+            else:
+                return None
+
+        return self._run_graph(batch_size, inputs)
+
+    def _capture_graph(self, batch_size: int, forward_fn: Callable,
+                       initial_inputs: Dict[str, Any]):
+        """Captures the forward pass for a given batch size."""
+        engine = self._get_engine()
+
+        max_tokens_per_req = 1
+        if engine.is_spec_decode:
+            max_tokens_per_req += engine.spec_config.max_draft_len
+
+        static_tensors = {
+            "input_ids":
+            torch.ones((batch_size * max_tokens_per_req, ),
+                       device="cuda",
+                       dtype=torch.int32),
+            "position_ids":
+            torch.zeros((
+                1,
+                batch_size * max_tokens_per_req,
+            ),
+                        device="cuda",
+                        dtype=torch.int32),
+        }
+        if engine.use_mrope:
+            static_tensors["mrope_position_deltas"] = torch.zeros(
+                (batch_size, 1), device="cuda", dtype=torch.int32)
+        self.static_inputs[batch_size] = static_tensors
+
+        capture_inputs = initial_inputs.copy()
+        capture_inputs.update(static_tensors)
+
+        self.graph_metadata[batch_size] = {
+            "attn_metadata": initial_inputs["attn_metadata"],
+            "spec_metadata": initial_inputs.get("spec_metadata"),
+        }
+
+        graph = torch.cuda.CUDAGraph()
+        with capturing_cuda_graph_context():
+            for _ in range(self.WARMUP_STEPS):
+                forward_fn(capture_inputs)
+
+            with torch.cuda.graph(graph, pool=self.memory_pool):
+                output = forward_fn(capture_inputs)
+
+        self.graphs[batch_size] = graph
+        self.graph_outputs[batch_size] = make_weak_ref(output)
+        self.memory_pool = graph.pool()
+
+    def _run_graph(self, batch_size: int,
+                   current_inputs: Dict[str, Any]) -> Optional[torch.Tensor]:
+        """Replays a previously captured graph."""
+        stored_meta = self.graph_metadata[batch_size]
+        assert current_inputs["attn_metadata"] is stored_meta["attn_metadata"]
+        if stored_meta["spec_metadata"] is not None:
+            assert current_inputs.get(
+                "spec_metadata") is stored_meta["spec_metadata"]
+
+        static_tensors = self.static_inputs[batch_size]
+
+        input_ids = current_inputs["input_ids"]
+        seqlen = input_ids.shape[0]
+        static_tensors["input_ids"][:seqlen].copy_(input_ids)
+
+        position_ids = current_inputs["position_ids"]
+        static_tensors["position_ids"][:, :seqlen].copy_(position_ids)
+
+        if "mrope_position_deltas" in static_tensors:
+            static_tensors["mrope_position_deltas"].copy_(
+                current_inputs["mrope_position_deltas"])
+
+        self.graphs[batch_size].replay()
+        output_ref = self.graph_outputs[batch_size]
+
+        return output_ref()
+
+    def _can_run_graph(self, batch: ScheduledRequests) -> bool:
+        """Checks if the current batch is eligible for CUDA graph execution."""
+        engine = self._get_engine()
+        if not self.enabled or not batch.can_run_cuda_graph:
+            return False
+
+        if hasattr(engine, 'iter_counter') and ExpertStatistic.set_iter(
+                engine.iter_counter):
+            return False
+
+        if engine.enable_attention_dp and engine.mapping.tp_size > 1:
+            batch_size = len(batch.generation_requests)
+            all_rank_info = engine.dist.tp_allgather(
+                [batch.can_run_cuda_graph, batch_size])
+
+            is_all_gen_only = all(info[0] for info in all_rank_info)
+            is_all_bs_equal = all(info[1] == all_rank_info[0][1]
+                                  for info in all_rank_info)
+
+            if not is_all_gen_only or not is_all_bs_equal:
+                return False
+
+        return True
+
+    def _round_up_batch_size(self, batch_size: int) -> int:
+        """Finds the smallest supported graph batch size >= the given size."""
+        if not self.supported_batch_sizes:
+            return 0
+        idx = bisect.bisect_left(self.supported_batch_sizes, batch_size)
+        if idx == len(self.supported_batch_sizes):
+            return 0
+        return self.supported_batch_sizes[idx]
+
+    @contextlib.contextmanager
+    def pad_batch(self, scheduled_requests: ScheduledRequests,
+                  resource_manager: ResourceManager):
+        """Context manager to pad a batch to a graph-compatible size."""
+        engine = self._get_engine()
+        kv_cache_manager = resource_manager.get_resource_manager(
+            engine.kv_cache_manager_key)
+
+        padding_size = 0
+        if self.padding_enabled and self._can_run_graph(scheduled_requests):
+            current_batch_size = len(scheduled_requests.generation_requests)
+
+            if current_batch_size >= self.max_supported_batch_size:
+                # Already at or beyond max size, no padding up
+                padded_batch_size = current_batch_size
+            else:
+                padded_batch_size = self._round_up_batch_size(
+                    current_batch_size)
+
+            if padded_batch_size > 0 and padded_batch_size != current_batch_size:
+                padding_size = padded_batch_size - current_batch_size
+
+                if current_batch_size + padding_size > engine.batch_size:
+                    padding_size = 0
+
+                if padding_size > 0:
+                    if self.padding_dummy_request is None:
+                        if kv_cache_manager.get_num_free_blocks() > 0:
+                            spec_res_mgr = resource_manager.get_resource_manager(
+                                ResourceManagerType.SPEC_RESOURCE_MANAGER)
+                            self.padding_dummy_request = kv_cache_manager.add_dummy_requests(
+                                [CUDA_GRAPH_DUMMY_REQUEST_ID],
+                                is_gen=True,
+                                max_num_draft_tokens=engine.max_draft_len,
+                                use_mrope=engine.use_mrope,
+                                max_beam_width=engine.max_beam_width)[0]
+                            self.padding_dummy_request.is_cuda_graph_dummy = True
+                            if spec_res_mgr:
+                                spec_res_mgr.add_dummy_requests(
+                                    [CUDA_GRAPH_DUMMY_REQUEST_ID])
+                        else:
+                            padding_size = 0
+
+                    if self.padding_dummy_request:
+                        scheduled_requests.generation_requests.extend(
+                            [self.padding_dummy_request] * padding_size)
+                    else:
+                        padding_size = 0
+
+        try:
+            yield scheduled_requests
+        finally:
+            if padding_size > 0:
+                scheduled_requests.generation_requests = scheduled_requests.generation_requests[:
+                                                                                                -padding_size]
+
+    def clear(self):
+        """Releases all captured graphs and the associated memory pool."""
+        for graph in self.graphs.values():
+            graph.reset()
+        self.graphs.clear()
+        self.static_inputs.clear()
+        self.graph_outputs.clear()
+        self.graph_metadata.clear()
+        del self.memory_pool
+        self.memory_pool = None
+        torch.cuda.empty_cache()
diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
deleted file mode 100644
index 241fc1447ce..00000000000
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ /dev/null
@@ -1,139 +0,0 @@
-import threading
-from typing import Any, Callable, Dict, Optional, Tuple
-
-import torch
-
-from ..attention_backend.interface import AttentionMetadata
-from ..speculative.interface import SpecMetadata
-from ..utils import make_weak_ref, set_piecewise_cuda_graph_flag
-
-
-class graph_capturing_local(threading.local):
-
-    def __init__(self):
-        self.is_graph_capturing = False
-
-
-_local = graph_capturing_local()
-
-
-def set_graph_capturing(enable: bool):
-    _local.is_graph_capturing = enable
-
-
-def is_graph_capturing() -> bool:
-    return _local.is_graph_capturing
-
-
-class DecodingCUDAGraphRunner:
-
-    def __init__(
-        self,
-        batch_size: int,
-        device: str,
-        attn_metadata: AttentionMetadata,
-        spec_metadata: Optional[SpecMetadata] = None,
-        use_mrope: bool = False,
-    ) -> None:
-        """
-        Stores a CUDA graph and its associated input buffers.
-
-        Each CUDA graph runner is associated with an AttentionMetadata object
-        if flashinfer is being used. Make sure to call attn_metadata.prepare()
-        before run()!
-
-        Note that torch.compile w/ mode reduce-overhead supports CUDA graphs
-        with memory pool sharing. However, we have our own manager here because,
-        at the time of writing this, torch.compile takes way too long to warmup
-        graphs compared to doing it manually (not to mention, custom ops from
-        e.g. FlashInfer cause graph breaks).
-        """
-        self.batch_size = batch_size
-
-        # [CUDA graph spec decode padding]
-        # We pad input IDs/position IDs to the maximum draft length (token per request).
-        # We're forced to do this because we cannot reallocate inputs over many graph runs.
-        token_per_request = spec_metadata.max_draft_len + 1 if spec_metadata is not None else 1
-
-        # Using ones instead of zeros prevents NaNs in e.g. Deepseek
-        self.input_ids = torch.ones((batch_size * token_per_request, ),
-                                    device=device,
-                                    dtype=torch.int32)
-        self.position_ids = torch.zeros((1, batch_size * token_per_request),
-                                        device=device,
-                                        dtype=torch.int32)
-        self.mrope_position_deltas = torch.zeros(
-            (batch_size,
-             1), device=device, dtype=torch.int32) if use_mrope else None
-
-        self.attn_metadata = attn_metadata
-        self.spec_metadata = spec_metadata
-        self._output = None
-        self._graph = None
-        self.optional_extra_model_inputs = ["mrope_position_deltas"]
-
-    def __del__(self):
-        self._graph.reset()
-
-    def capture(
-        self,
-        forward_fn: Callable[[Dict[str, Any]], torch.Tensor],
-        pool: Optional[Tuple[int, int]] = None,
-    ) -> Tuple[int, int]:
-        self._graph = torch.cuda.CUDAGraph()
-        inputs = {
-            "attn_metadata": self.attn_metadata,
-            "input_ids": self.input_ids,
-            "position_ids": self.position_ids,
-            "inputs_embeds": None,
-            "spec_metadata": self.spec_metadata,
-            "mrope_position_deltas": self.mrope_position_deltas,
-        }
-
-        # We have to do warm up runs to initialize PyTorch's
-        # internal states according to the docs:
-        # https://pytorch.org/docs/stable/notes/cuda.html#cuda-graph-semantics
-        # This also lets us initialize states in the attn_metadata.
-        set_graph_capturing(True)
-        set_piecewise_cuda_graph_flag(False)
-        for _ in range(2):
-            forward_fn(inputs)
-        with torch.cuda.graph(self._graph, pool=pool):
-            output = forward_fn(inputs)
-        set_graph_capturing(False)
-        set_piecewise_cuda_graph_flag(True)
-        # Mark weak ref here. The output tensor should be freed properly.
-        self._output = make_weak_ref(output)
-        return self._graph.pool()
-
-    def needs_capture(self) -> bool:
-        return self._output is None
-
-    def run(self, inputs: Dict[str, Any]) -> torch.Tensor:
-        assert "input_ids" in inputs
-        assert "position_ids" in inputs
-        assert "attn_metadata" in inputs
-
-        attn_metadata = inputs["attn_metadata"]
-        assert attn_metadata is self.attn_metadata, (
-            "attn_metadata does not match the attn_metadata instance that was used to "
-            "capture this graph.")
-
-        if "spec_metadata" in inputs:
-            spec_metadata = inputs["spec_metadata"]
-            assert spec_metadata is self.spec_metadata, (
-                "spec_metadata does not match the spec_metadata instance that was used to "
-                "capture this graph.")
-
-        input_ids = inputs["input_ids"]
-        position_ids = inputs["position_ids"]
-        seqlen = input_ids.shape[0]
-        self.input_ids[:seqlen].copy_(input_ids)
-        self.position_ids[:, :seqlen].copy_(position_ids)
-        if "mrope_position_deltas" in inputs:
-            self.mrope_position_deltas[:self.batch_size].copy_(
-                inputs["mrope_position_deltas"])
-
-        assert self._output is not None and self._graph is not None
-        self._graph.replay()
-        return self._output
diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index 2ba4cafeda3..8094538f9f6 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -1,4 +1,3 @@
-import bisect
 import contextlib
 import functools
 import gc
@@ -54,7 +53,7 @@
                      with_model_extra_attrs)
 from .config import LoadFormat, PyTorchConfig
 from .config_utils import is_mla
-from .cuda_graph_runner import DecodingCUDAGraphRunner
+from .cuda_graph_model_engine import CUDAGraphModelEngine
 from .layerwise_nvtx_marker import LayerwiseNvtxMarker
 from .resource_manager import (BaseResourceManager, KVCacheManager,
                                ResourceManager, ResourceManagerType)
@@ -421,6 +420,9 @@ def __init__(
         self.kv_cache_manager_key = ResourceManagerType.KV_CACHE_MANAGER
         self.lora_model_config: Optional[LoraModelConfig] = None
         self.cuda_graph_dummy_request = None
+        self.cuda_graph_model_engine = CUDAGraphModelEngine(
+            self
+        ) if self._run_cuda_graphs or self._torch_compile_piecewise_cuda_graph else None
 
         # Setup the local cache indirection buffer only once and reuse it.
         # This way it can also be used for CUDA graphs.
@@ -724,9 +726,10 @@ def disable_optimization(backend: Backend):
                     logger.info(
                         f"Run generation only CUDA graph warmup for batch size={bs}"
                     )
-                    self.forward(batch,
-                                 new_tensors_device=None,
-                                 resource_manager=resource_manager)
+                    self.cuda_graph_model_engine.execute(
+                        batch,
+                        new_tensors_device=None,
+                        resource_manager=resource_manager)
                     torch.cuda.synchronize()
 
                 if self._torch_compile_piecewise_cuda_graph and self._torch_compile_enabled:
@@ -810,148 +813,6 @@ def _set_up_spec_metadata(
             is_draft_model=self.is_draft_model)
         return self.spec_metadata
 
-    def _get_padded_batch(
-            self,
-            scheduled_requests: ScheduledRequests,
-            kv_cache_manager,
-            spec_resource_manager: Optional[BaseResourceManager] = None) -> int:
-        can_run_cuda_graph = scheduled_requests.can_run_cuda_graph
-        batch_size = scheduled_requests.batch_size
-        # The number of sequences in the batch is the number of prompts times the beam width.
-        new_batch_size = batch_size * self.max_beam_width
-        if self._run_cuda_graphs and self.enable_attention_dp and self.mapping.tp_size > 1:
-            graph_batch_size = self.dist.tp_allgather(
-                [can_run_cuda_graph, batch_size])
-            all_can_graph = all(graph_batch[0]
-                                for graph_batch in graph_batch_size)
-            if all_can_graph:
-                new_batch_size = max(gen_only_batch[1]
-                                     for gen_only_batch in graph_batch_size)
-
-        if (not self._run_cuda_graphs or not self._cuda_graph_padding_enabled
-                or not can_run_cuda_graph
-                or new_batch_size > self._max_cuda_graph_batch_size):
-            return 0
-
-        padded_batch_size = self._round_up_batch_size(new_batch_size)
-        if batch_size == padded_batch_size:
-            return 0
-
-        padding_size = padded_batch_size - batch_size
-        if padding_size + scheduled_requests.batch_size > self.batch_size:
-            return 0
-
-        # No padding if it would create too many concurrent requests.
-        # This is not strictly required, but we should probably
-        # respect the requirement just in case that changes in the future.
-        if self.cuda_graph_dummy_request is None:
-            available_blocks = kv_cache_manager.get_num_free_blocks()
-            # No padding if not enough KV cache space
-            if available_blocks < 1:
-                return 0
-
-            cuda_graph_dummy_request_ids = [MAX_UINT64 - 1]
-            self.cuda_graph_dummy_request = kv_cache_manager.add_dummy_requests(
-                cuda_graph_dummy_request_ids,
-                is_gen=True,
-                max_num_draft_tokens=self.max_draft_len,
-                use_mrope=self.use_mrope,
-                max_beam_width=self.max_beam_width)[0]
-            self.cuda_graph_dummy_request.is_cuda_graph_dummy = True
-            if spec_resource_manager is not None:
-                spec_resource_manager.add_dummy_requests(
-                    request_ids=cuda_graph_dummy_request_ids)
-
-        scheduled_requests.generation_requests.extend(
-            [self.cuda_graph_dummy_request] * padding_size)
-
-        return padding_size
-
-    @contextlib.contextmanager
-    def _maybe_pad_batch(
-            self,
-            scheduled_requests: ScheduledRequests,
-            kv_cache_manager,
-            spec_resource_manager: Optional[BaseResourceManager] = None):
-        """
-        CUDA graphs can only be used for specific batch sizes.
-
-        If using CUDA graphs, this method will add dummy requests to the given
-        batch so we can always use a CUDA graph. It is a context manager
-        because the padded requests will be removed from scheduled requests.
-        """
-        padding_size = self._get_padded_batch(scheduled_requests,
-                                              kv_cache_manager,
-                                              spec_resource_manager)
-        try:
-            yield scheduled_requests
-        finally:
-            if padding_size > 0:
-                scheduled_requests.generation_requests = scheduled_requests.generation_requests[:
-                                                                                                -padding_size]
-
-    def _round_up_batch_size(self, batch_size: int) -> int:
-        """
-        Round up the given batch size to the nearest batch size that is
-        associated with a CUDA graph.
-        """
-        idx = bisect.bisect_left(self._cuda_graph_batch_sizes, batch_size)
-        return self._cuda_graph_batch_sizes[idx]
-
-    def _maybe_get_cuda_graph(
-        self,
-        batch: ScheduledRequests,
-        spec_config: Optional["DecodingBaseConfig"] = None
-    ) -> Optional[DecodingCUDAGraphRunner]:
-        """
-        Get a CUDA graph runner or return None (e.g. if CUDA graphs are disabled
-        or if the batch size is too big).
-        """
-        # disable when doing statistic
-        if ExpertStatistic.set_iter(self.iter_counter):
-            return None
-
-        spec_max_draft_tokens = spec_config.max_draft_len if self.is_spec_decode else 0
-        can_run_cuda_graph = batch.can_run_cuda_graph
-        batch_size = len(batch.generation_requests)
-        if self._run_cuda_graphs and self.enable_attention_dp and self.mapping.tp_size > 1:
-            all_can_graph_batch = self.dist.tp_allgather(
-                [can_run_cuda_graph, batch_size])
-            is_all_gen_only = all(all_can_graph[0]
-                                  for all_can_graph in all_can_graph_batch)
-            all_batch_size_equal = all(
-                all_gen_only[1] == all_can_graph_batch[0][1]
-                for all_gen_only in all_can_graph_batch)
-
-            if not is_all_gen_only or not all_batch_size_equal:
-                return None
-
-        if not self._run_cuda_graphs or not can_run_cuda_graph:
-            return None
-
-        if batch_size in self._cuda_graphs:
-            return self._cuda_graphs[batch_size]
-
-        if batch_size not in self._cuda_graph_batch_sizes:
-            return None
-
-        num_sequences_in_batch = batch_size * self.max_beam_width
-        attn_metadata = self.attn_metadata.create_cuda_graph_metadata(
-            num_sequences_in_batch, False, spec_max_draft_tokens)
-        assert attn_metadata.is_cuda_graph
-
-        if self.is_spec_decode:
-            spec_metadata = self.spec_metadata.create_cuda_graph_metadata(
-                num_sequences_in_batch)
-            spec_metadata.draft_tokens = self.draft_tokens_cuda
-        else:
-            spec_metadata = None
-
-        self._cuda_graphs[batch_size] = DecodingCUDAGraphRunner(
-            num_sequences_in_batch, "cuda", attn_metadata, spec_metadata,
-            self.use_mrope)
-        return self._cuda_graphs[batch_size]
-
     def __del__(self) -> None:
         if getattr(self, 'ub_buffers', None):
             for u in self.ub_buffers:
@@ -1102,12 +963,7 @@ def _init_model_capacity(self):
         self._init_max_num_tokens()
 
     def _release_cuda_graphs(self):
-        for _, graph in self._cuda_graphs.items():
-            del graph
-        self._cuda_graphs.clear()
-        torch.cuda.empty_cache()
-        del self._cuda_graph_mem_pool
-        self._cuda_graph_mem_pool = None
+        self.cuda_graph_model_engine.clear()
 
     def get_max_num_sequences(self) -> int:
         """
@@ -2102,51 +1958,28 @@ def forward(
             with MoeLoadBalancerIterContext(moe_load_balancer):
                 return self._forward_step(inputs, gather_ids,
                                           gather_context_logits)
-        with self._maybe_pad_batch(scheduled_requests, kv_cache_manager,
-                                   spec_resource_manager) as scheduled_requests:
-            maybe_graph = self._maybe_get_cuda_graph(
-                scheduled_requests, spec_config=self.spec_config)
-            if maybe_graph is not None:
-                attn_metadata = maybe_graph.attn_metadata
-                if self.is_spec_decode:
-                    spec_metadata = maybe_graph.spec_metadata
-            else:
-                attn_metadata = self.attn_metadata
-                if self.is_spec_decode:
-                    spec_metadata = self.spec_metadata
-
+        with self.cuda_graph_model_engine.pad_batch(
+                scheduled_requests, resource_manager) as padded_requests:
             inputs, gather_ids = self._prepare_inputs(
                 scheduled_requests, kv_cache_manager, attn_metadata,
                 spec_metadata, new_tensors_device, cache_indirection_buffer)
 
             self.iter_counter += 1
 
-            if maybe_graph is None:
+            # 3. Ask the manager to execute the graph
+            graph_output = self.cuda_graph_manager.execute(
+                batch=padded_requests,
+                inputs=inputs,
+                forward_fn=self._forward_step)
+
+            if graph_output is not None:
+                # Graph was successfully run
+                outputs = {"logits": graph_output}
+            else:
+                # 4. Fallback to eager execution if graph was not used
                 with MoeLoadBalancerIterContext(moe_load_balancer):
                     outputs = self._forward_step(inputs, gather_ids,
                                                  gather_context_logits)
-            else:
-                if maybe_graph.needs_capture():
-
-                    def capture_forward_fn(inputs: Dict[str, Any]):
-                        with MoeLoadBalancerIterContext(moe_load_balancer):
-                            return self._forward_step(
-                                inputs,
-                                gather_ids=gather_ids,
-                                gather_context_logits=gather_context_logits)
-
-                    pool = maybe_graph.capture(
-                        capture_forward_fn,
-                        self._cuda_graph_mem_pool,
-                    )
-                    self._cuda_graph_mem_pool = pool
-
-                    # here we don't need to use context since cuda graph capture didn't run kernel.
-                    # maybe we need a cleaner way to do this.
-                    outputs = maybe_graph.run(inputs)
-                else:
-                    with MoeLoadBalancerIterContext(moe_load_balancer):
-                        outputs = maybe_graph.run(inputs)
 
             self._execute_logit_post_processors(scheduled_requests, outputs)
 

From 57b9db1dcbdaa94d66972f879c5c09b796960b24 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 08:54:51 +0800
Subject: [PATCH 02/48] update

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 3rdparty/xgrammar | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3rdparty/xgrammar b/3rdparty/xgrammar
index b14a281566d..774867ce410 160000
--- a/3rdparty/xgrammar
+++ b/3rdparty/xgrammar
@@ -1 +1 @@
-Subproject commit b14a281566d7a53a2bd1b09fc11ac735977f9e36
+Subproject commit 774867ce410ce1c5c7c10011cc0a9e20bd7894e2

From fdfacbc250821de098478a8cc71c07790f38d3b3 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 13:30:10 +0800
Subject: [PATCH 03/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index 986b253705c..d766bbbcef3 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2027,7 +2027,7 @@ def forward(
             self.iter_counter += 1
 
             # 3. Ask the manager to execute the graph
-            graph_output = self.cuda_graph_manager.execute(
+            graph_output = self.cuda_graph_model_engine.execute(
                 batch=padded_requests,
                 inputs=inputs,
                 forward_fn=self._forward_step)

From 2eb30309c314b9048b1a67453b9075807a5e97e9 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 13:36:47 +0800
Subject: [PATCH 04/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index d766bbbcef3..ec1dec29361 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -750,18 +750,6 @@ def disable_optimization(backend: Backend):
                 if bs > self.batch_size:
                     # skip batch size larger than self.batch_size
                     continue
-                with release_batch(get_cuda_graph_warmup_request(bs)) as batch:
-                    if batch is None:
-                        # No KV cache space!
-                        return
-                    logger.info(
-                        f"Run generation only CUDA graph warmup for batch size={bs}"
-                    )
-                    self.cuda_graph_model_engine.execute(
-                        batch,
-                        new_tensors_device=None,
-                        resource_manager=resource_manager)
-                    torch.cuda.synchronize()
 
                 for draft_len in draft_lengths:
                     with release_batch(

From 0640458f1b7276032d24cc9c3d3b098e716a676b Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 13:57:13 +0800
Subject: [PATCH 05/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../pyexecutor/cuda_graph_model_engine.py      | 18 ++++++++++++------
 tensorrt_llm/_torch/pyexecutor/model_engine.py |  2 ++
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
index 96ef0b163bd..0dd0be7c6b3 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
@@ -66,6 +66,7 @@ def __init__(self, engine: "PyTorchModelEngine"):
         self.padding_enabled = config.cuda_graph_padding_enabled
         self.supported_batch_sizes = engine._cuda_graph_batch_sizes
         self.max_supported_batch_size = engine._max_cuda_graph_batch_size
+        self.max_num_tokens = engine.max_num_tokens
 
         # Low-level state, storing resources per batch size
         self.graphs: Dict[int, torch.cuda.CUDAGraph] = {}
@@ -106,8 +107,12 @@ def execute(self, batch: ScheduledRequests, inputs: Dict[str, Any],
 
         return self._run_graph(batch_size, inputs)
 
-    def _capture_graph(self, batch_size: int, forward_fn: Callable,
-                       initial_inputs: Dict[str, Any]):
+    def _capture_graph(self,
+                       batch_size: int,
+                       forward_fn: Callable,
+                       initial_inputs: Dict[str, Any],
+                       gather_ids: torch.Tensor,
+                       gather_context_logits: bool = False):
         """Captures the forward pass for a given batch size."""
         engine = self._get_engine()
 
@@ -117,13 +122,13 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
 
         static_tensors = {
             "input_ids":
-            torch.ones((batch_size * max_tokens_per_req, ),
+            torch.ones((self.max_num_tokens, ),
                        device="cuda",
                        dtype=torch.int32),
             "position_ids":
             torch.zeros((
                 1,
-                batch_size * max_tokens_per_req,
+                self.max_num_tokens,
             ),
                         device="cuda",
                         dtype=torch.int32),
@@ -144,10 +149,11 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
         graph = torch.cuda.CUDAGraph()
         with capturing_cuda_graph_context():
             for _ in range(self.WARMUP_STEPS):
-                forward_fn(capture_inputs)
+                forward_fn(capture_inputs, gather_ids, gather_context_logits)
 
             with torch.cuda.graph(graph, pool=self.memory_pool):
-                output = forward_fn(capture_inputs)
+                output = forward_fn(capture_inputs, gather_ids,
+                                    gather_context_logits)
 
         self.graphs[batch_size] = graph
         self.graph_outputs[batch_size] = make_weak_ref(output)
diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index ec1dec29361..d0c7fed417e 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2018,6 +2018,8 @@ def forward(
             graph_output = self.cuda_graph_model_engine.execute(
                 batch=padded_requests,
                 inputs=inputs,
+                gather_ids=gather_ids,
+                gather_context_logits=gather_context_logits,
                 forward_fn=self._forward_step)
 
             if graph_output is not None:

From 4fb28764e4a0c0da8ec80f37d4ebcd245591d461 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 15:06:28 +0800
Subject: [PATCH 06/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
index 0dd0be7c6b3..a9e72ea82fe 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
@@ -88,6 +88,7 @@ def _get_engine(self) -> "PyTorchModelEngine":
         return engine
 
     def execute(self, batch: ScheduledRequests, inputs: Dict[str, Any],
+                gather_ids: torch.Tensor, gather_context_logits: bool,
                 forward_fn: Callable) -> Optional[torch.Tensor]:
         """
         Runs the model via a CUDA graph or captures it if needed.
@@ -101,7 +102,8 @@ def execute(self, batch: ScheduledRequests, inputs: Dict[str, Any],
 
         if batch_size not in self.graphs:
             if batch_size in self.supported_batch_sizes:
-                self._capture_graph(batch_size, forward_fn, inputs)
+                self._capture_graph(batch_size, forward_fn, inputs, gather_ids,
+                                    gather_context_logits)
             else:
                 return None
 

From a0d4d523b8d235027d88d2506908f558a6feb71d Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 15:35:07 +0800
Subject: [PATCH 07/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index d0c7fed417e..598ea946021 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -439,9 +439,7 @@ def __init__(
         self.kv_cache_manager_key = ResourceManagerType.KV_CACHE_MANAGER
         self.lora_model_config: Optional[LoraModelConfig] = None
         self.cuda_graph_dummy_request = None
-        self.cuda_graph_model_engine = CUDAGraphModelEngine(
-            self
-        ) if self._run_cuda_graphs or self._torch_compile_piecewise_cuda_graph else None
+        self.cuda_graph_model_engine = CUDAGraphModelEngine(self)
 
         # Setup the local cache indirection buffer only once and reuse it.
         # This way it can also be used for CUDA graphs.

From 96793c8c8a694816cff0497243238f781c08b73a Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 20:15:21 +0800
Subject: [PATCH 08/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../pyexecutor/cuda_graph_model_engine.py       | 17 +++++------------
 tensorrt_llm/_torch/pyexecutor/model_engine.py  | 11 ++++++++---
 2 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
index a9e72ea82fe..00abdb80778 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
@@ -88,7 +88,6 @@ def _get_engine(self) -> "PyTorchModelEngine":
         return engine
 
     def execute(self, batch: ScheduledRequests, inputs: Dict[str, Any],
-                gather_ids: torch.Tensor, gather_context_logits: bool,
                 forward_fn: Callable) -> Optional[torch.Tensor]:
         """
         Runs the model via a CUDA graph or captures it if needed.
@@ -102,19 +101,14 @@ def execute(self, batch: ScheduledRequests, inputs: Dict[str, Any],
 
         if batch_size not in self.graphs:
             if batch_size in self.supported_batch_sizes:
-                self._capture_graph(batch_size, forward_fn, inputs, gather_ids,
-                                    gather_context_logits)
+                self._capture_graph(batch_size, forward_fn, inputs)
             else:
                 return None
 
         return self._run_graph(batch_size, inputs)
 
-    def _capture_graph(self,
-                       batch_size: int,
-                       forward_fn: Callable,
-                       initial_inputs: Dict[str, Any],
-                       gather_ids: torch.Tensor,
-                       gather_context_logits: bool = False):
+    def _capture_graph(self, batch_size: int, forward_fn: Callable,
+                       initial_inputs: Dict[str, Any]):
         """Captures the forward pass for a given batch size."""
         engine = self._get_engine()
 
@@ -151,11 +145,10 @@ def _capture_graph(self,
         graph = torch.cuda.CUDAGraph()
         with capturing_cuda_graph_context():
             for _ in range(self.WARMUP_STEPS):
-                forward_fn(capture_inputs, gather_ids, gather_context_logits)
+                forward_fn(capture_inputs)
 
             with torch.cuda.graph(graph, pool=self.memory_pool):
-                output = forward_fn(capture_inputs, gather_ids,
-                                    gather_context_logits)
+                output = forward_fn(capture_inputs)
 
         self.graphs[batch_size] = graph
         self.graph_outputs[batch_size] = make_weak_ref(output)
diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index 598ea946021..7831db5da94 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2012,13 +2012,18 @@ def forward(
 
             self.iter_counter += 1
 
+            def capture_forward_fn(inputs: Dict[str, Any]):
+                with MoeLoadBalancerIterContext(moe_load_balancer):
+                    return self._forward_step(
+                        inputs,
+                        gather_ids=gather_ids,
+                        gather_context_logits=gather_context_logits)
+
             # 3. Ask the manager to execute the graph
             graph_output = self.cuda_graph_model_engine.execute(
                 batch=padded_requests,
                 inputs=inputs,
-                gather_ids=gather_ids,
-                gather_context_logits=gather_context_logits,
-                forward_fn=self._forward_step)
+                forward_fn=capture_forward_fn)
 
             if graph_output is not None:
                 # Graph was successfully run

From df4d782ebab612a20f080b003f3a49a6f804c79e Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 21:53:48 +0800
Subject: [PATCH 09/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../pyexecutor/cuda_graph_model_engine.py     | 20 +++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
index 00abdb80778..524cedfa3fe 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
@@ -66,7 +66,8 @@ def __init__(self, engine: "PyTorchModelEngine"):
         self.padding_enabled = config.cuda_graph_padding_enabled
         self.supported_batch_sizes = engine._cuda_graph_batch_sizes
         self.max_supported_batch_size = engine._max_cuda_graph_batch_size
-        self.max_num_tokens = engine.max_num_tokens
+        self.batch_size = engine.batch_size
+        self.max_beam_width = engine.max_beam_width
 
         # Low-level state, storing resources per batch size
         self.graphs: Dict[int, torch.cuda.CUDAGraph] = {}
@@ -116,15 +117,22 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
         if engine.is_spec_decode:
             max_tokens_per_req += engine.spec_config.max_draft_len
 
+        spec_metadata = initial_inputs.get("spec_metadata", None)
+        # [CUDA graph spec decode padding]
+        # We pad input IDs/position IDs to the maximum draft length (token per request).
+        # We're forced to do this because we cannot reallocate inputs over many graph runs.
+        token_per_request = spec_metadata.max_draft_len + 1 if spec_metadata is not None else 1
+
         static_tensors = {
             "input_ids":
-            torch.ones((self.max_num_tokens, ),
-                       device="cuda",
-                       dtype=torch.int32),
+            torch.ones(
+                (self.batch_size * self.max_beam_width * token_per_request, ),
+                device="cuda",
+                dtype=torch.int32),
             "position_ids":
             torch.zeros((
                 1,
-                self.max_num_tokens,
+                self.batch_size * self.max_beam_width * token_per_request,
             ),
                         device="cuda",
                         dtype=torch.int32),
@@ -139,7 +147,7 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
 
         self.graph_metadata[batch_size] = {
             "attn_metadata": initial_inputs["attn_metadata"],
-            "spec_metadata": initial_inputs.get("spec_metadata"),
+            "spec_metadata": spec_metadata,
         }
 
         graph = torch.cuda.CUDAGraph()

From 677c2187c6eb3a40ab1c761358ba5c8217846cae Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 22:14:41 +0800
Subject: [PATCH 10/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../_torch/pyexecutor/cuda_graph_model_engine.py       | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
index 524cedfa3fe..aa44d700b1f 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
@@ -66,7 +66,6 @@ def __init__(self, engine: "PyTorchModelEngine"):
         self.padding_enabled = config.cuda_graph_padding_enabled
         self.supported_batch_sizes = engine._cuda_graph_batch_sizes
         self.max_supported_batch_size = engine._max_cuda_graph_batch_size
-        self.batch_size = engine.batch_size
         self.max_beam_width = engine.max_beam_width
 
         # Low-level state, storing resources per batch size
@@ -125,14 +124,13 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
 
         static_tensors = {
             "input_ids":
-            torch.ones(
-                (self.batch_size * self.max_beam_width * token_per_request, ),
-                device="cuda",
-                dtype=torch.int32),
+            torch.ones((batch_size * self.max_beam_width * token_per_request, ),
+                       device="cuda",
+                       dtype=torch.int32),
             "position_ids":
             torch.zeros((
                 1,
-                self.batch_size * self.max_beam_width * token_per_request,
+                batch_size * self.max_beam_width * token_per_request,
             ),
                         device="cuda",
                         dtype=torch.int32),

From 5b1ed332ebdfc40b71b2143f660c4f5bf4e2301d Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 22:19:03 +0800
Subject: [PATCH 11/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
index aa44d700b1f..abb0d76dd44 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
@@ -185,7 +185,7 @@ def _run_graph(self, batch_size: int,
         self.graphs[batch_size].replay()
         output_ref = self.graph_outputs[batch_size]
 
-        return output_ref()
+        return output_ref
 
     def _can_run_graph(self, batch: ScheduledRequests) -> bool:
         """Checks if the current batch is eligible for CUDA graph execution."""

From 215d0d59cef07afab7e5ae314dfdaf50f6cdbd7b Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 22:35:48 +0800
Subject: [PATCH 12/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index 7831db5da94..eb272a6dbc3 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2020,16 +2020,13 @@ def capture_forward_fn(inputs: Dict[str, Any]):
                         gather_context_logits=gather_context_logits)
 
             # 3. Ask the manager to execute the graph
-            graph_output = self.cuda_graph_model_engine.execute(
+            outputs = self.cuda_graph_model_engine.execute(
                 batch=padded_requests,
                 inputs=inputs,
                 forward_fn=capture_forward_fn)
 
-            if graph_output is not None:
-                # Graph was successfully run
-                outputs = {"logits": graph_output}
-            else:
-                # 4. Fallback to eager execution if graph was not used
+            # 4. Fallback to eager execution if graph was not used
+            if outputs is None:
                 with MoeLoadBalancerIterContext(moe_load_balancer):
                     outputs = self._forward_step(inputs, gather_ids,
                                                  gather_context_logits)

From cf36b99f14ace4a46d01007bcfb3e6dd18784227 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Mon, 11 Aug 2025 22:39:23 +0800
Subject: [PATCH 13/48] update

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../_torch/pyexecutor/cuda_graph_runner.py    | 142 ------------------
 1 file changed, 142 deletions(-)
 delete mode 100644 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
deleted file mode 100644
index 50306d66a66..00000000000
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ /dev/null
@@ -1,142 +0,0 @@
-import threading
-from typing import Any, Callable, Dict, Optional, Tuple
-
-import torch
-
-from ..attention_backend.interface import AttentionMetadata
-from ..speculative.interface import SpecMetadata
-from ..utils import make_weak_ref, set_piecewise_cuda_graph_flag
-
-
-class graph_capturing_local(threading.local):
-
-    def __init__(self):
-        self.is_graph_capturing = False
-
-
-_local = graph_capturing_local()
-
-
-def set_graph_capturing(enable: bool):
-    _local.is_graph_capturing = enable
-
-
-def is_graph_capturing() -> bool:
-    return _local.is_graph_capturing
-
-
-class DecodingCUDAGraphRunner:
-
-    def __init__(
-        self,
-        batch_size: int,
-        device: str,
-        attn_metadata: AttentionMetadata,
-        spec_metadata: Optional[SpecMetadata] = None,
-        use_mrope: bool = False,
-        max_beam_width: int = 1,
-    ) -> None:
-        """
-        Stores a CUDA graph and its associated input buffers.
-
-        Each CUDA graph runner is associated with an AttentionMetadata object
-        if flashinfer is being used. Make sure to call attn_metadata.prepare()
-        before run()!
-
-        Note that torch.compile w/ mode reduce-overhead supports CUDA graphs
-        with memory pool sharing. However, we have our own manager here because,
-        at the time of writing this, torch.compile takes way too long to warmup
-        graphs compared to doing it manually (not to mention, custom ops from
-        e.g. FlashInfer cause graph breaks).
-        """
-        self.batch_size = batch_size
-        self.max_beam_width = max_beam_width
-        # [CUDA graph spec decode padding]
-        # We pad input IDs/position IDs to the maximum draft length (token per request).
-        # We're forced to do this because we cannot reallocate inputs over many graph runs.
-        token_per_request = spec_metadata.max_draft_len + 1 if spec_metadata is not None else 1
-
-        # Using ones instead of zeros prevents NaNs in e.g. Deepseek
-        self.input_ids = torch.ones(
-            (batch_size * max_beam_width * token_per_request, ),
-            device=device,
-            dtype=torch.int32)
-        self.position_ids = torch.zeros(
-            (1, batch_size * max_beam_width * token_per_request),
-            device=device,
-            dtype=torch.int32)
-        self.mrope_position_deltas = torch.zeros(
-            (batch_size,
-             1), device=device, dtype=torch.int32) if use_mrope else None
-
-        self.attn_metadata = attn_metadata
-        self.spec_metadata = spec_metadata
-        self._output = None
-        self._graph = None
-        self.optional_extra_model_inputs = ["mrope_position_deltas"]
-
-    def __del__(self):
-        self._graph.reset()
-
-    def capture(
-        self,
-        forward_fn: Callable[[Dict[str, Any]], torch.Tensor],
-        pool: Optional[Tuple[int, int]] = None,
-    ) -> Tuple[int, int]:
-        self._graph = torch.cuda.CUDAGraph()
-        inputs = {
-            "attn_metadata": self.attn_metadata,
-            "input_ids": self.input_ids,
-            "position_ids": self.position_ids,
-            "inputs_embeds": None,
-            "spec_metadata": self.spec_metadata,
-            "mrope_position_deltas": self.mrope_position_deltas,
-        }
-
-        # We have to do warm up runs to initialize PyTorch's
-        # internal states according to the docs:
-        # https://pytorch.org/docs/stable/notes/cuda.html#cuda-graph-semantics
-        # This also lets us initialize states in the attn_metadata.
-        set_graph_capturing(True)
-        set_piecewise_cuda_graph_flag(False)
-        for _ in range(2):
-            forward_fn(inputs)
-        with torch.cuda.graph(self._graph, pool=pool):
-            output = forward_fn(inputs)
-        set_graph_capturing(False)
-        set_piecewise_cuda_graph_flag(True)
-        # Mark weak ref here. The output tensor should be freed properly.
-        self._output = make_weak_ref(output)
-        return self._graph.pool()
-
-    def needs_capture(self) -> bool:
-        return self._output is None
-
-    def run(self, inputs: Dict[str, Any]) -> torch.Tensor:
-        assert "input_ids" in inputs
-        assert "position_ids" in inputs
-        assert "attn_metadata" in inputs
-
-        attn_metadata = inputs["attn_metadata"]
-        assert attn_metadata is self.attn_metadata, (
-            "attn_metadata does not match the attn_metadata instance that was used to "
-            "capture this graph.")
-
-        if "spec_metadata" in inputs:
-            spec_metadata = inputs["spec_metadata"]
-            assert spec_metadata is self.spec_metadata, (
-                "spec_metadata does not match the spec_metadata instance that was used to "
-                "capture this graph.")
-
-        input_ids = inputs["input_ids"]
-        position_ids = inputs["position_ids"]
-        seqlen = input_ids.shape[0]
-        self.input_ids[:seqlen].copy_(input_ids)
-        self.position_ids[:, :seqlen].copy_(position_ids)
-        if "mrope_position_deltas" in inputs:
-            self.mrope_position_deltas[:self.batch_size].copy_(
-                inputs["mrope_position_deltas"])
-
-        assert self._output is not None and self._graph is not None
-        self._graph.replay()
-        return self._output

From 492f6c01b4e53ade2545927d1f16771962e1bacb Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 12 Aug 2025 08:56:31 +0800
Subject: [PATCH 14/48] rename

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 ...cuda_graph_model_engine.py => cuda_graph_runner.py} |  2 +-
 tensorrt_llm/_torch/pyexecutor/model_engine.py         | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)
 rename tensorrt_llm/_torch/pyexecutor/{cuda_graph_model_engine.py => cuda_graph_runner.py} (99%)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
similarity index 99%
rename from tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
rename to tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index abb0d76dd44..f4cd3dc09cf 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -47,7 +47,7 @@ def capturing_cuda_graph_context():
         set_piecewise_cuda_graph_flag(True)
 
 
-class CUDAGraphModelEngine:
+class CUDAGraphRunner:
     """
     Manages the lifecycle and execution of CUDA graphs for the model engine.
 
diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index f0672bf9d1b..4a5cd774736 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -54,7 +54,7 @@
                      with_model_extra_attrs)
 from .config import LoadFormat, PyTorchConfig
 from .config_utils import is_mla
-from .cuda_graph_model_engine import CUDAGraphModelEngine
+from .cuda_graph_runner import CUDAGraphRunner
 from .layerwise_nvtx_marker import LayerwiseNvtxMarker
 from .llm_request import get_draft_token_length
 from .resource_manager import (BaseResourceManager, KVCacheManager,
@@ -439,7 +439,7 @@ def __init__(
         self.kv_cache_manager_key = ResourceManagerType.KV_CACHE_MANAGER
         self.lora_model_config: Optional[LoraModelConfig] = None
         self.cuda_graph_dummy_request = None
-        self.cuda_graph_model_engine = CUDAGraphModelEngine(self)
+        self.cuda_graph_runner = CUDAGraphRunner(self)
 
         # Setup the local cache indirection buffer only once and reuse it.
         # This way it can also be used for CUDA graphs.
@@ -1006,7 +1006,7 @@ def _init_model_capacity(self):
         self._init_max_num_tokens()
 
     def _release_cuda_graphs(self):
-        self.cuda_graph_model_engine.clear()
+        self.cuda_graph_runner.clear()
 
     def get_max_num_sequences(self) -> int:
         """
@@ -2008,7 +2008,7 @@ def forward(
             with MoeLoadBalancerIterContext(moe_load_balancer):
                 return self._forward_step(inputs, gather_ids,
                                           gather_context_logits)
-        with self.cuda_graph_model_engine.pad_batch(
+        with self.cuda_graph_runner.pad_batch(
                 scheduled_requests, resource_manager) as padded_requests:
             inputs, gather_ids = self._prepare_inputs(
                 scheduled_requests, kv_cache_manager, attn_metadata,
@@ -2024,7 +2024,7 @@ def capture_forward_fn(inputs: Dict[str, Any]):
                         gather_context_logits=gather_context_logits)
 
             # 3. Ask the manager to execute the graph
-            outputs = self.cuda_graph_model_engine.execute(
+            outputs = self.cuda_graph_runner.execute(
                 batch=padded_requests,
                 inputs=inputs,
                 forward_fn=capture_forward_fn)

From 7b470e9e72ccf1f93cf69aca59952a835dd954de Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 12 Aug 2025 09:07:44 +0800
Subject: [PATCH 15/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index b3326577bb2..421116c9378 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -498,10 +498,12 @@ def wrapper(self, *args, **kwargs):
     def no_cuda_graph(self):
         _run_cuda_graphs = self._run_cuda_graphs
         self._run_cuda_graphs = False
+        self.cuda_graph_runner.enabled = False
         try:
             yield
         finally:
             self._run_cuda_graphs = _run_cuda_graphs
+            self.cuda_graph_runner.enabled = _run_cuda_graphs
 
     @with_warmup_flag
     def warmup(self, resource_manager: ResourceManager) -> None:

From d821fa0e7a74ca013d41df39d060a3363f8e1b39 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 12 Aug 2025 09:55:01 +0800
Subject: [PATCH 16/48] clean

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 5 ++---
 tensorrt_llm/_torch/pyexecutor/model_engine.py      | 3 +--
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index f4cd3dc09cf..56c65f2d756 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -227,7 +227,6 @@ def pad_batch(self, scheduled_requests: ScheduledRequests,
         engine = self._get_engine()
         kv_cache_manager = resource_manager.get_resource_manager(
             engine.kv_cache_manager_key)
-
         padding_size = 0
         if self.padding_enabled and self._can_run_graph(scheduled_requests):
             current_batch_size = len(scheduled_requests.generation_requests)
@@ -248,8 +247,6 @@ def pad_batch(self, scheduled_requests: ScheduledRequests,
                 if padding_size > 0:
                     if self.padding_dummy_request is None:
                         if kv_cache_manager.get_num_free_blocks() > 0:
-                            spec_res_mgr = resource_manager.get_resource_manager(
-                                ResourceManagerType.SPEC_RESOURCE_MANAGER)
                             self.padding_dummy_request = kv_cache_manager.add_dummy_requests(
                                 [CUDA_GRAPH_DUMMY_REQUEST_ID],
                                 is_gen=True,
@@ -257,6 +254,8 @@ def pad_batch(self, scheduled_requests: ScheduledRequests,
                                 use_mrope=engine.use_mrope,
                                 max_beam_width=engine.max_beam_width)[0]
                             self.padding_dummy_request.is_cuda_graph_dummy = True
+                            spec_res_mgr = resource_manager.get_resource_manager(
+                                ResourceManagerType.SPEC_RESOURCE_MANAGER)
                             if spec_res_mgr:
                                 spec_res_mgr.add_dummy_requests(
                                     [CUDA_GRAPH_DUMMY_REQUEST_ID])
diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index 421116c9378..08bdf12a7fc 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -439,7 +439,6 @@ def __init__(
         # with different KV cache managers.
         self.kv_cache_manager_key = ResourceManagerType.KV_CACHE_MANAGER
         self.lora_model_config: Optional[LoraModelConfig] = None
-        self.cuda_graph_dummy_request = None
         self.cuda_graph_runner = CUDAGraphRunner(self)
 
         # Setup the local cache indirection buffer only once and reuse it.
@@ -518,7 +517,7 @@ def warmup(self, resource_manager: ResourceManager) -> None:
 
         # The lifetime of model engine and kv cache manager can be different.
         # Reset the global cuda graph dummy request to None in warmup.
-        self.cuda_graph_dummy_request = None
+        self.cuda_graph_runner.padding_dummy_request = None
 
         def get_cuda_graph_warmup_request(batch_size, draft_len):
             # Divide by max_beam_width to get an approximation of the number of requests that can be run in parallel.

From 22df791a03e02c4ba8ab130d880495393638a4d2 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 12 Aug 2025 10:10:48 +0800
Subject: [PATCH 17/48] polish

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index 08bdf12a7fc..ee8e13ed4ec 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2025,13 +2025,13 @@ def capture_forward_fn(inputs: Dict[str, Any]):
                         gather_ids=gather_ids,
                         gather_context_logits=gather_context_logits)
 
-            # 3. Ask the manager to execute the graph
+            # Ask the runner to execute the graph
             outputs = self.cuda_graph_runner.execute(
                 batch=padded_requests,
                 inputs=inputs,
                 forward_fn=capture_forward_fn)
 
-            # 4. Fallback to eager execution if graph was not used
+            # Fallback to eager execution if graph was not used
             if outputs is None:
                 with MoeLoadBalancerIterContext(moe_load_balancer):
                     outputs = self._forward_step(inputs, gather_ids,

From c10dba45132cd5ec419862770c99e89f2c91cf28 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 12 Aug 2025 18:56:53 +0800
Subject: [PATCH 18/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../_torch/pyexecutor/cuda_graph_runner.py    | 64 +++++++++++++++----
 .../_torch/pyexecutor/model_engine.py         | 17 ++++-
 2 files changed, 68 insertions(+), 13 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 56c65f2d756..c04e8fca7f2 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -2,7 +2,7 @@
 import contextlib
 import threading
 import weakref
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple
 
 import torch
 
@@ -67,15 +67,27 @@ def __init__(self, engine: "PyTorchModelEngine"):
         self.supported_batch_sizes = engine._cuda_graph_batch_sizes
         self.max_supported_batch_size = engine._max_cuda_graph_batch_size
         self.max_beam_width = engine.max_beam_width
-
-        # Low-level state, storing resources per batch size
-        self.graphs: Dict[int, torch.cuda.CUDAGraph] = {}
-        self.static_inputs: Dict[int, Dict[str, torch.Tensor]] = {}
-        self.graph_outputs: Dict[int, Callable[[], Optional[torch.Tensor]]] = {}
-        self.graph_metadata: Dict[int, Dict[str, Any]] = {}
+        self.spec_config = engine.spec_config
+        self.attn_metadata = engine.attn_metadata
+        self.spec_metadata = engine.spec_metadata
+        self.draft_tokens_cuda = engine.draft_tokens_cuda
+
+        self.graphs: Dict[Tuple[int, int], torch.cuda.CUDAGraph] = {}
+        self.static_inputs: Dict[Tuple[int, int], Dict[str, torch.Tensor]] = {}
+        self.graph_outputs: Dict[Tuple[int, int],
+                                 Callable[[], Optional[torch.Tensor]]] = {}
+        self.graph_metadata: Dict[Tuple[int, int], Dict[str, Any]] = {}
         self.memory_pool = engine._cuda_graph_mem_pool
         self.padding_dummy_request: Optional["Request"] = None
 
+    @property
+    def enable_spec_decode(self):
+        return self._get_engine().is_spec_decode
+
+    @property
+    def draft_len(self):
+        return self.spec_config.max_draft_len if self.enable_spec_decode else 0
+
     def __del__(self):
         self.clear()
 
@@ -87,6 +99,34 @@ def _get_engine(self) -> "PyTorchModelEngine":
                 "The parent PyTorchModelEngine has been garbage collected.")
         return engine
 
+    def maybe_get_cuda_graph(self, batch: ScheduledRequests):
+        if not self._can_run_graph(batch):
+            return False, None, None
+
+        batch_size = len(batch.generation_requests)
+
+        key = (batch_size, self.draft_len)
+        if key in self.graphs:
+            return True, self.graph_metadata[key][
+                "attn_metadata"], self.graph_metadata[key]["spec_metadata"]
+
+        if batch_size not in self.supported_batch_sizes:
+            return False, None, None
+
+        num_sequences_in_batch = batch_size * self.max_beam_width
+        attn_metadata = self.attn_metadata.create_cuda_graph_metadata(
+            num_sequences_in_batch, False, self.draft_len)
+        assert attn_metadata.is_cuda_graph
+
+        if self.enable_spec_decode:
+            spec_metadata = self.spec_metadata.create_cuda_graph_metadata(
+                num_sequences_in_batch)
+            spec_metadata.draft_tokens = self.draft_tokens_cuda
+        else:
+            spec_metadata = None
+
+        return True, attn_metadata, spec_metadata
+
     def execute(self, batch: ScheduledRequests, inputs: Dict[str, Any],
                 forward_fn: Callable) -> Optional[torch.Tensor]:
         """
@@ -111,6 +151,7 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
                        initial_inputs: Dict[str, Any]):
         """Captures the forward pass for a given batch size."""
         engine = self._get_engine()
+        key = (batch_size, self.draft_len)
 
         max_tokens_per_req = 1
         if engine.is_spec_decode:
@@ -138,12 +179,12 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
         if engine.use_mrope:
             static_tensors["mrope_position_deltas"] = torch.zeros(
                 (batch_size, 1), device="cuda", dtype=torch.int32)
-        self.static_inputs[batch_size] = static_tensors
+        self.static_inputs[key] = static_tensors
 
         capture_inputs = initial_inputs.copy()
         capture_inputs.update(static_tensors)
 
-        self.graph_metadata[batch_size] = {
+        self.graph_metadata[key] = {
             "attn_metadata": initial_inputs["attn_metadata"],
             "spec_metadata": spec_metadata,
         }
@@ -156,13 +197,14 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
             with torch.cuda.graph(graph, pool=self.memory_pool):
                 output = forward_fn(capture_inputs)
 
-        self.graphs[batch_size] = graph
-        self.graph_outputs[batch_size] = make_weak_ref(output)
+        self.graphs[key] = graph
+        self.graph_outputs[key] = make_weak_ref(output)
         self.memory_pool = graph.pool()
 
     def _run_graph(self, batch_size: int,
                    current_inputs: Dict[str, Any]) -> Optional[torch.Tensor]:
         """Replays a previously captured graph."""
+        (batch_size, self.draft_len)
         stored_meta = self.graph_metadata[batch_size]
         assert current_inputs["attn_metadata"] is stored_meta["attn_metadata"]
         if stored_meta["spec_metadata"] is not None:
diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index ee8e13ed4ec..465ff4cdf1e 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2012,9 +2012,22 @@ def forward(
                                           gather_context_logits)
         with self.cuda_graph_runner.pad_batch(
                 scheduled_requests, resource_manager) as padded_requests:
+
+            maybe_graph, maybe_attn_metadata, maybe_spec_metadata = self.cuda_graph_runner.maybe_get_cuda_graph(
+                padded_requests)
+            if maybe_graph:
+                attn_metadata = maybe_attn_metadata
+                spec_metadata = maybe_spec_metadata
+            else:
+                attn_metadata = self.attn_metadata
+                if self.enable_spec_decode:
+                    spec_metadata = self.spec_metadata
+                else:
+                    spec_metadata = None
+
             inputs, gather_ids = self._prepare_inputs(
-                scheduled_requests, kv_cache_manager, attn_metadata,
-                spec_metadata, new_tensors_device, cache_indirection_buffer)
+                padded_requests, kv_cache_manager, attn_metadata, spec_metadata,
+                new_tensors_device, cache_indirection_buffer)
 
             self.iter_counter += 1
 

From ed19860bc049100cd0a4fa57dca0842474f56c9f Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 12 Aug 2025 19:44:26 +0800
Subject: [PATCH 19/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index c04e8fca7f2..5c3a88db843 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -69,7 +69,6 @@ def __init__(self, engine: "PyTorchModelEngine"):
         self.max_beam_width = engine.max_beam_width
         self.spec_config = engine.spec_config
         self.attn_metadata = engine.attn_metadata
-        self.spec_metadata = engine.spec_metadata
         self.draft_tokens_cuda = engine.draft_tokens_cuda
 
         self.graphs: Dict[Tuple[int, int], torch.cuda.CUDAGraph] = {}
@@ -88,6 +87,10 @@ def enable_spec_decode(self):
     def draft_len(self):
         return self.spec_config.max_draft_len if self.enable_spec_decode else 0
 
+    @property
+    def spec_metadata(self):
+        return self._get_engine().spec_metadata
+
     def __del__(self):
         self.clear()
 

From 1f64f35a3d8649aa9b572891ff7c968ce33381e8 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 12 Aug 2025 19:48:02 +0800
Subject: [PATCH 20/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 5c3a88db843..135752ced56 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -69,7 +69,6 @@ def __init__(self, engine: "PyTorchModelEngine"):
         self.max_beam_width = engine.max_beam_width
         self.spec_config = engine.spec_config
         self.attn_metadata = engine.attn_metadata
-        self.draft_tokens_cuda = engine.draft_tokens_cuda
 
         self.graphs: Dict[Tuple[int, int], torch.cuda.CUDAGraph] = {}
         self.static_inputs: Dict[Tuple[int, int], Dict[str, torch.Tensor]] = {}
@@ -91,6 +90,10 @@ def draft_len(self):
     def spec_metadata(self):
         return self._get_engine().spec_metadata
 
+    @property
+    def draft_tokens_cuda(self):
+        return self._get_engine().draft_tokens_cuda
+
     def __del__(self):
         self.clear()
 

From c13d9fb4ffd8194ad9a0de28077d53b8d8ad32cb Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 12 Aug 2025 19:52:54 +0800
Subject: [PATCH 21/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 135752ced56..62e40617077 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -68,7 +68,6 @@ def __init__(self, engine: "PyTorchModelEngine"):
         self.max_supported_batch_size = engine._max_cuda_graph_batch_size
         self.max_beam_width = engine.max_beam_width
         self.spec_config = engine.spec_config
-        self.attn_metadata = engine.attn_metadata
 
         self.graphs: Dict[Tuple[int, int], torch.cuda.CUDAGraph] = {}
         self.static_inputs: Dict[Tuple[int, int], Dict[str, torch.Tensor]] = {}
@@ -94,6 +93,10 @@ def spec_metadata(self):
     def draft_tokens_cuda(self):
         return self._get_engine().draft_tokens_cuda
 
+    @property
+    def attn_metadata(self):
+        return self._get_engine().attn_metadata
+
     def __del__(self):
         self.clear()
 

From e20fbab0a23145268abcd95ee9b24ab254c6e1bb Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 12 Aug 2025 19:54:50 +0800
Subject: [PATCH 22/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 62e40617077..602cbe4e456 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -213,14 +213,14 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
     def _run_graph(self, batch_size: int,
                    current_inputs: Dict[str, Any]) -> Optional[torch.Tensor]:
         """Replays a previously captured graph."""
-        (batch_size, self.draft_len)
-        stored_meta = self.graph_metadata[batch_size]
+        key = (batch_size, self.draft_len)
+        stored_meta = self.graph_metadata[key]
         assert current_inputs["attn_metadata"] is stored_meta["attn_metadata"]
         if stored_meta["spec_metadata"] is not None:
             assert current_inputs.get(
                 "spec_metadata") is stored_meta["spec_metadata"]
 
-        static_tensors = self.static_inputs[batch_size]
+        static_tensors = self.static_inputs[key]
 
         input_ids = current_inputs["input_ids"]
         seqlen = input_ids.shape[0]
@@ -233,8 +233,8 @@ def _run_graph(self, batch_size: int,
             static_tensors["mrope_position_deltas"].copy_(
                 current_inputs["mrope_position_deltas"])
 
-        self.graphs[batch_size].replay()
-        output_ref = self.graph_outputs[batch_size]
+        self.graphs[key].replay()
+        output_ref = self.graph_outputs[key]
 
         return output_ref
 

From f4166395fcb52fca44ca43ab6ccc91751c21b5c0 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Thu, 14 Aug 2025 13:54:09 +0800
Subject: [PATCH 23/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py   | 2 +-
 tests/unittest/_torch/modeling/test_modeling_llama.py | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 602cbe4e456..69f6a98bfb7 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -53,7 +53,7 @@ class CUDAGraphRunner:
 
     This unified class handles high-level orchestration (padding, eligibility)
     and low-level execution (capturing, resource management, replaying) for
-    multiple graphs, keyed by batch size.
+    multiple graphs, keyed by (batch size, draft_len).
     """
     WARMUP_STEPS = 2
 
diff --git a/tests/unittest/_torch/modeling/test_modeling_llama.py b/tests/unittest/_torch/modeling/test_modeling_llama.py
index e72957997f5..881274a2e2f 100644
--- a/tests/unittest/_torch/modeling/test_modeling_llama.py
+++ b/tests/unittest/_torch/modeling/test_modeling_llama.py
@@ -14,8 +14,6 @@
 from tensorrt_llm._torch.metadata import KVCacheParams
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_llama import LlamaForCausalLM
-from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import \
-    DecodingCUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping

From 821d54a3c55cecdd92f468a96b9f432e4483790f Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Thu, 14 Aug 2025 17:18:02 +0800
Subject: [PATCH 24/48] fix test

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tests/unittest/_torch/helpers.py              | 97 ++++++++++++++++++-
 .../_torch/modeling/test_modeling_exaone4.py  |  3 +-
 .../_torch/modeling/test_modeling_llama.py    |  1 +
 .../test_modeling_llama_min_latency.py        |  3 +-
 .../_torch/modeling/test_modeling_mistral.py  |  5 +-
 .../_torch/modeling/test_modeling_mixtral.py  |  3 +-
 .../_torch/modeling/test_modeling_mllama.py   |  3 +-
 .../_torch/modeling/test_modeling_nemotron.py |  3 +-
 .../_torch/modeling/test_modeling_phi3.py     |  3 +-
 .../_torch/modeling/test_modeling_qwen_moe.py |  3 +-
 10 files changed, 107 insertions(+), 17 deletions(-)

diff --git a/tests/unittest/_torch/helpers.py b/tests/unittest/_torch/helpers.py
index 5e9f2ba1a26..1b8105a20ab 100644
--- a/tests/unittest/_torch/helpers.py
+++ b/tests/unittest/_torch/helpers.py
@@ -1,8 +1,11 @@
-from typing import Dict, Tuple
+import threading
+from typing import Any, Callable, Dict, Optional, Tuple
 
 import torch
 import torch.nn.functional as F
 
+from tensorrt_llm._torch.utils import make_weak_ref
+
 
 def ceil_div(x: int, y: int) -> int:
     return (x + y - 1) // y
@@ -149,3 +152,95 @@ def block_scale_gemm(mat_a: torch.Tensor, mat_scale_a: torch.Tensor,
         results[batch_idx] += final_scales[batch_idx, nth_expert, None] * output
 
     return results.view_as(x)
+
+
+class graph_capturing_local(threading.local):
+
+    def __init__(self):
+        self.is_graph_capturing = False
+
+
+_local = graph_capturing_local()
+
+
+def set_graph_capturing(enable: bool):
+    _local.is_graph_capturing = enable
+
+
+def is_graph_capturing() -> bool:
+    return _local.is_graph_capturing
+
+
+class DecodingCUDAGraphRunner:
+
+    def __init__(
+        self,
+        batch_size: int,
+        device: str,
+        attn_metadata,
+    ) -> None:
+        self.batch_size = batch_size
+        # Using ones instead of zeros prevents NaNs in e.g. Deepseek
+        self.input_ids = torch.ones((batch_size, ),
+                                    device=device,
+                                    dtype=torch.int32)
+        self.position_ids = torch.zeros((1, batch_size),
+                                        device=device,
+                                        dtype=torch.int32)
+
+        self.attn_metadata = attn_metadata
+        self._output = None
+        self._graph = None
+
+    def __del__(self):
+        self._graph.reset()
+
+    def capture(
+        self,
+        forward_fn: Callable[[Dict[str, Any]], torch.Tensor],
+        pool: Optional[Tuple[int, int]] = None,
+    ) -> Tuple[int, int]:
+        self._graph = torch.cuda.CUDAGraph()
+        inputs = {
+            "attn_metadata": self.attn_metadata,
+            "input_ids": self.input_ids,
+            "position_ids": self.position_ids,
+            "inputs_embeds": None,
+        }
+
+        # We have to do warm up runs to initialize PyTorch's
+        # internal states according to the docs:
+        # https://pytorch.org/docs/stable/notes/cuda.html#cuda-graph-semantics
+        # This also lets us initialize states in the attn_metadata.
+        set_graph_capturing(True)
+        for _ in range(2):
+            forward_fn(inputs)
+        with torch.cuda.graph(self._graph, pool=pool):
+            output = forward_fn(inputs)
+        set_graph_capturing(False)
+        # Mark weak ref here. The output tensor should be freed properly.
+        self._output = make_weak_ref(output)
+        return self._graph.pool()
+
+    def needs_capture(self) -> bool:
+        return self._output is None
+
+    def run(self, inputs: Dict[str, Any]) -> torch.Tensor:
+        assert "input_ids" in inputs
+        assert "position_ids" in inputs
+        assert "attn_metadata" in inputs
+
+        attn_metadata = inputs["attn_metadata"]
+        assert attn_metadata is self.attn_metadata, (
+            "attn_metadata does not match the attn_metadata instance that was used to "
+            "capture this graph.")
+
+        input_ids = inputs["input_ids"]
+        position_ids = inputs["position_ids"]
+        seqlen = input_ids.shape[0]
+        self.input_ids[:seqlen].copy_(input_ids)
+        self.position_ids[:, :seqlen].copy_(position_ids)
+
+        assert self._output is not None and self._graph is not None
+        self._graph.replay()
+        return self._output
diff --git a/tests/unittest/_torch/modeling/test_modeling_exaone4.py b/tests/unittest/_torch/modeling/test_modeling_exaone4.py
index 48ad7d8d835..44bc2476f4d 100644
--- a/tests/unittest/_torch/modeling/test_modeling_exaone4.py
+++ b/tests/unittest/_torch/modeling/test_modeling_exaone4.py
@@ -22,6 +22,7 @@ class Exaone4Config(PretrainedConfig):
     # TODO: Remove this once we have a proper config for Exaone4
     SKIP_EXAONE4_HF_ACCURACY_TEST = True
 
+from _torch.helpers import DecodingCUDAGraphRunner
 from transformers.cache_utils import HybridCache
 from utils.util import getSMVersion
 
@@ -30,8 +31,6 @@ class Exaone4Config(PretrainedConfig):
 from tensorrt_llm._torch.metadata import KVCacheParams
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_exaone4 import Exaone4ForCausalLM
-from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import \
-    DecodingCUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
diff --git a/tests/unittest/_torch/modeling/test_modeling_llama.py b/tests/unittest/_torch/modeling/test_modeling_llama.py
index 881274a2e2f..54b43112575 100644
--- a/tests/unittest/_torch/modeling/test_modeling_llama.py
+++ b/tests/unittest/_torch/modeling/test_modeling_llama.py
@@ -4,6 +4,7 @@
 from typing import Any
 
 import torch
+from _torch.helpers import DecodingCUDAGraphRunner
 from parameterized import parameterized
 from transformers import LlamaConfig
 from transformers import LlamaForCausalLM as HFLlamaForCausalLM
diff --git a/tests/unittest/_torch/modeling/test_modeling_llama_min_latency.py b/tests/unittest/_torch/modeling/test_modeling_llama_min_latency.py
index a0d09c18c71..007f03bf3e4 100644
--- a/tests/unittest/_torch/modeling/test_modeling_llama_min_latency.py
+++ b/tests/unittest/_torch/modeling/test_modeling_llama_min_latency.py
@@ -4,6 +4,7 @@
 
 import torch
 import transformers
+from _torch.helpers import DecodingCUDAGraphRunner
 from parameterized import parameterized
 from transformers import Llama4Config
 from transformers import \
@@ -20,8 +21,6 @@
 from tensorrt_llm._torch.models.modeling_llama import \
     Llama4ForConditionalGeneration
 from tensorrt_llm._torch.pyexecutor.config import PyTorchConfig
-from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import \
-    DecodingCUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
diff --git a/tests/unittest/_torch/modeling/test_modeling_mistral.py b/tests/unittest/_torch/modeling/test_modeling_mistral.py
index c330126942e..5b67d37e84c 100644
--- a/tests/unittest/_torch/modeling/test_modeling_mistral.py
+++ b/tests/unittest/_torch/modeling/test_modeling_mistral.py
@@ -7,6 +7,7 @@
 import pytest
 import torch
 import transformers
+from _torch.helpers import DecodingCUDAGraphRunner
 from utils.util import getSMVersion
 
 import tensorrt_llm
@@ -15,7 +16,7 @@
 from tensorrt_llm._torch import model_config as model_config_lib
 from tensorrt_llm._torch.attention_backend import utils as attention_utils
 from tensorrt_llm._torch.models import modeling_mistral
-from tensorrt_llm._torch.pyexecutor import cuda_graph_runner, resource_manager
+from tensorrt_llm._torch.pyexecutor import resource_manager
 from tensorrt_llm.bindings import executor as executor_lib
 from tensorrt_llm.models import modeling_utils
 
@@ -405,7 +406,7 @@ def run_forward(input_ids, position_ids, attn_metadata):
                     input_ids=input_ids, position_ids=position_ids, attn_metadata=attn_metadata
                 )
             else:
-                graph_runner = cuda_graph_runner.DecodingCUDAGraphRunner(
+                graph_runner = DecodingCUDAGraphRunner(
                     attn_metadata.max_num_requests, "cuda", attn_metadata
                 )
                 graph_runner.capture(lambda inputs: mistral.forward(**inputs))
diff --git a/tests/unittest/_torch/modeling/test_modeling_mixtral.py b/tests/unittest/_torch/modeling/test_modeling_mixtral.py
index 3b9e6896e32..20fe49430ba 100644
--- a/tests/unittest/_torch/modeling/test_modeling_mixtral.py
+++ b/tests/unittest/_torch/modeling/test_modeling_mixtral.py
@@ -3,6 +3,7 @@
 from dataclasses import dataclass
 
 import torch
+from _torch.helpers import DecodingCUDAGraphRunner
 from parameterized import parameterized
 from transformers import MixtralConfig
 from transformers import MixtralForCausalLM as HFMixtralForCausalLM
@@ -15,8 +16,6 @@
 from tensorrt_llm._torch.models.checkpoints.hf.mixtral_weight_mapper import \
     MixtralHfWeightMapper
 from tensorrt_llm._torch.models.modeling_mixtral import MixtralForCausalLM
-from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import \
-    DecodingCUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
diff --git a/tests/unittest/_torch/modeling/test_modeling_mllama.py b/tests/unittest/_torch/modeling/test_modeling_mllama.py
index 665e28919b5..1b06eaa61f1 100644
--- a/tests/unittest/_torch/modeling/test_modeling_mllama.py
+++ b/tests/unittest/_torch/modeling/test_modeling_mllama.py
@@ -3,6 +3,7 @@
 from copy import deepcopy
 
 import torch
+from _torch.helpers import DecodingCUDAGraphRunner
 from parameterized import parameterized
 from test_modeling_llama import Scenario, reduce_llama_config
 from transformers import MllamaConfig
@@ -15,8 +16,6 @@
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_mllama import \
     MllamaForConditionalGeneration
-from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import \
-    DecodingCUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
diff --git a/tests/unittest/_torch/modeling/test_modeling_nemotron.py b/tests/unittest/_torch/modeling/test_modeling_nemotron.py
index a17b050ec0f..f10e39aa909 100644
--- a/tests/unittest/_torch/modeling/test_modeling_nemotron.py
+++ b/tests/unittest/_torch/modeling/test_modeling_nemotron.py
@@ -4,6 +4,7 @@
 from typing import Any
 
 import torch
+from _torch.helpers import DecodingCUDAGraphRunner
 from parameterized import parameterized
 from transformers import NemotronConfig
 from transformers import NemotronForCausalLM as HFNemotronForCausalLM
@@ -14,8 +15,6 @@
 from tensorrt_llm._torch.metadata import KVCacheParams
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_nemotron import NemotronForCausalLM
-from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import \
-    DecodingCUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
diff --git a/tests/unittest/_torch/modeling/test_modeling_phi3.py b/tests/unittest/_torch/modeling/test_modeling_phi3.py
index 4a277c01ba1..088a6323c8b 100644
--- a/tests/unittest/_torch/modeling/test_modeling_phi3.py
+++ b/tests/unittest/_torch/modeling/test_modeling_phi3.py
@@ -4,6 +4,7 @@
 from typing import Any
 
 import torch
+from _torch.helpers import DecodingCUDAGraphRunner
 from transformers import Phi3Config
 from transformers import Phi3ForCausalLM as HFPhi3ForCausalLM
 from utils.util import default_dtype
@@ -13,8 +14,6 @@
 from tensorrt_llm._torch.metadata import KVCacheParams
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_phi3 import Phi3ForCausalLM
-from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import \
-    DecodingCUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
diff --git a/tests/unittest/_torch/modeling/test_modeling_qwen_moe.py b/tests/unittest/_torch/modeling/test_modeling_qwen_moe.py
index 608a17fe1b5..39b5f607dac 100644
--- a/tests/unittest/_torch/modeling/test_modeling_qwen_moe.py
+++ b/tests/unittest/_torch/modeling/test_modeling_qwen_moe.py
@@ -3,6 +3,7 @@
 from dataclasses import dataclass
 
 import torch
+from _torch.helpers import DecodingCUDAGraphRunner
 from parameterized import parameterized
 from transformers import Qwen2MoeConfig
 from transformers import Qwen2MoeForCausalLM as HFQwen2MoeForCausalLM
@@ -15,8 +16,6 @@
 from tensorrt_llm._torch.models.checkpoints.hf.qwen2_moe_weight_mapper import \
     Qwen2MoeHfWeightMapper
 from tensorrt_llm._torch.models.modeling_qwen_moe import Qwen2MoeForCausalLM
-from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import \
-    DecodingCUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping

From f2ab53a5b45feed733f58bb8af69e03643881063 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Thu, 14 Aug 2025 17:48:55 +0800
Subject: [PATCH 25/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tests/unittest/_torch/helpers.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/unittest/_torch/helpers.py b/tests/unittest/_torch/helpers.py
index 1b8105a20ab..9dabf7314d3 100644
--- a/tests/unittest/_torch/helpers.py
+++ b/tests/unittest/_torch/helpers.py
@@ -4,8 +4,6 @@
 import torch
 import torch.nn.functional as F
 
-from tensorrt_llm._torch.utils import make_weak_ref
-
 
 def ceil_div(x: int, y: int) -> int:
     return (x + y - 1) // y
@@ -219,6 +217,7 @@ def capture(
             output = forward_fn(inputs)
         set_graph_capturing(False)
         # Mark weak ref here. The output tensor should be freed properly.
+        from tensorrt_llm._torch.utils import make_weak_ref
         self._output = make_weak_ref(output)
         return self._graph.pool()
 

From 2d7a7806a46f81349cf80363e329b09d5bc4848f Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Thu, 14 Aug 2025 20:36:54 +0800
Subject: [PATCH 26/48] fix ci

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tests/unittest/_torch/modeling/test_modeling_qwen.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/unittest/_torch/modeling/test_modeling_qwen.py b/tests/unittest/_torch/modeling/test_modeling_qwen.py
index fe8e0f5a4cd..02ab56bcbcd 100644
--- a/tests/unittest/_torch/modeling/test_modeling_qwen.py
+++ b/tests/unittest/_torch/modeling/test_modeling_qwen.py
@@ -17,8 +17,7 @@
 from tensorrt_llm._torch.models.modeling_qwen import (
     Qwen2ForCausalLM, Qwen2ForProcessRewardModel)
 # yapf: enable
-from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import \
-    DecodingCUDAGraphRunner
+from _torch.helpers import DecodingCUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping

From 5dd8d1776543a0a39be2578cf139326e7ccf1e79 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Fri, 15 Aug 2025 08:11:20 +0800
Subject: [PATCH 27/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 69f6a98bfb7..13fa6c41060 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -230,7 +230,7 @@ def _run_graph(self, batch_size: int,
         static_tensors["position_ids"][:, :seqlen].copy_(position_ids)
 
         if "mrope_position_deltas" in static_tensors:
-            static_tensors["mrope_position_deltas"].copy_(
+            static_tensors["mrope_position_deltas"][:batch_size].copy_(
                 current_inputs["mrope_position_deltas"])
 
         self.graphs[key].replay()

From 58f9482194b95fb6d25bb063d064f8edadeb24dd Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Fri, 15 Aug 2025 08:25:30 +0800
Subject: [PATCH 28/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 13fa6c41060..d8f47225896 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -229,7 +229,8 @@ def _run_graph(self, batch_size: int,
         position_ids = current_inputs["position_ids"]
         static_tensors["position_ids"][:, :seqlen].copy_(position_ids)
 
-        if "mrope_position_deltas" in static_tensors:
+        if "mrope_position_deltas" in current_inputs:
+            assert "mrope_position_deltas" in static_tensors
             static_tensors["mrope_position_deltas"][:batch_size].copy_(
                 current_inputs["mrope_position_deltas"])
 

From 801c3d4e815bfd7c186e3c20000a490c7758b047 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Fri, 15 Aug 2025 08:55:17 +0800
Subject: [PATCH 29/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index 27adcc95940..826ad11d242 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2044,14 +2044,14 @@ def capture_forward_fn(inputs: Dict[str, Any]):
                         gather_ids=gather_ids,
                         gather_context_logits=gather_context_logits)
 
-            # Ask the runner to execute the graph
-            outputs = self.cuda_graph_runner.execute(
-                batch=padded_requests,
-                inputs=inputs,
-                forward_fn=capture_forward_fn)
-
-            # Fallback to eager execution if graph was not used
-            if outputs is None:
+            if maybe_graph:
+                # Ask the runner to execute the graph
+                outputs = self.cuda_graph_runner.execute(
+                    batch=padded_requests,
+                    inputs=inputs,
+                    forward_fn=capture_forward_fn)
+            else:
+                # Fallback to eager execution if graph was not used
                 with MoeLoadBalancerIterContext(moe_load_balancer):
                     outputs = self._forward_step(inputs, gather_ids,
                                                  gather_context_logits)

From 6690c36d7004d7e50fe7ec4366d72eafe30a012a Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Fri, 15 Aug 2025 09:44:15 +0800
Subject: [PATCH 30/48] clean moe

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../_torch/pyexecutor/cuda_graph_runner.py    | 30 ++++-------------
 .../_torch/pyexecutor/model_engine.py         | 32 +++++++++++--------
 2 files changed, 24 insertions(+), 38 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index d8f47225896..43829173897 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -133,31 +133,13 @@ def maybe_get_cuda_graph(self, batch: ScheduledRequests):
             spec_metadata.draft_tokens = self.draft_tokens_cuda
         else:
             spec_metadata = None
-
         return True, attn_metadata, spec_metadata
 
-    def execute(self, batch: ScheduledRequests, inputs: Dict[str, Any],
-                forward_fn: Callable) -> Optional[torch.Tensor]:
-        """
-        Runs the model via a CUDA graph or captures it if needed.
-
-        Returns the model output tensor if a graph was run, otherwise None.
-        """
-        if not self._can_run_graph(batch):
-            return None
-
-        batch_size = len(batch.generation_requests)
-
-        if batch_size not in self.graphs:
-            if batch_size in self.supported_batch_sizes:
-                self._capture_graph(batch_size, forward_fn, inputs)
-            else:
-                return None
-
-        return self._run_graph(batch_size, inputs)
+    def needs_capture(self, batch_size: int):
+        return self.graph_outputs[(batch_size, self.draft_len)] is None
 
-    def _capture_graph(self, batch_size: int, forward_fn: Callable,
-                       initial_inputs: Dict[str, Any]):
+    def capture_graph(self, batch_size: int, forward_fn: Callable,
+                      initial_inputs: Dict[str, Any]):
         """Captures the forward pass for a given batch size."""
         engine = self._get_engine()
         key = (batch_size, self.draft_len)
@@ -210,8 +192,8 @@ def _capture_graph(self, batch_size: int, forward_fn: Callable,
         self.graph_outputs[key] = make_weak_ref(output)
         self.memory_pool = graph.pool()
 
-    def _run_graph(self, batch_size: int,
-                   current_inputs: Dict[str, Any]) -> Optional[torch.Tensor]:
+    def run_graph(self, batch_size: int,
+                  current_inputs: Dict[str, Any]) -> Optional[torch.Tensor]:
         """Replays a previously captured graph."""
         key = (batch_size, self.draft_len)
         stored_meta = self.graph_metadata[key]
diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index 826ad11d242..0a0b6e8fac3 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2037,24 +2037,28 @@ def forward(
 
             self.iter_counter += 1
 
-            def capture_forward_fn(inputs: Dict[str, Any]):
-                with MoeLoadBalancerIterContext(moe_load_balancer):
-                    return self._forward_step(
-                        inputs,
-                        gather_ids=gather_ids,
-                        gather_context_logits=gather_context_logits)
-
-            if maybe_graph:
-                # Ask the runner to execute the graph
-                outputs = self.cuda_graph_runner.execute(
-                    batch=padded_requests,
-                    inputs=inputs,
-                    forward_fn=capture_forward_fn)
-            else:
+            if not maybe_graph:
                 # Fallback to eager execution if graph was not used
                 with MoeLoadBalancerIterContext(moe_load_balancer):
                     outputs = self._forward_step(inputs, gather_ids,
                                                  gather_context_logits)
+            else:
+                batch_size = len(padded_requests.generation_requests)
+                if self.cuda_graph_runner.needs_capture(batch_size):
+
+                    def capture_forward_fn(inputs: Dict[str, Any]):
+                        with MoeLoadBalancerIterContext(moe_load_balancer):
+                            return self._forward_step(
+                                inputs,
+                                gather_ids=gather_ids,
+                                gather_context_logits=gather_context_logits)
+
+                    outputs = self.cuda_graph_runner.capture_graph(
+                        batch_size, capture_forward_fn, inputs)
+                else:
+                    with MoeLoadBalancerIterContext(moe_load_balancer):
+                        outputs = self.cuda_graph_runner.run_graph(
+                            batch_size, inputs)
 
             self._execute_logit_post_processors(scheduled_requests, outputs)
 

From 48eab08f48185b32a735db57fdc1f8f61f16a228 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Fri, 15 Aug 2025 09:48:46 +0800
Subject: [PATCH 31/48] clean

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index 0a0b6e8fac3..ccceba3d94a 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2053,8 +2053,12 @@ def capture_forward_fn(inputs: Dict[str, Any]):
                                 gather_ids=gather_ids,
                                 gather_context_logits=gather_context_logits)
 
-                    outputs = self.cuda_graph_runner.capture_graph(
+                    self.cuda_graph_runner.capture_graph(
                         batch_size, capture_forward_fn, inputs)
+
+                    # here we don't need to use context since cuda graph capture didn't run kernel.
+                    # maybe we need a cleaner way to do this.
+                    self.cuda_graph_runner.run_graph(batch_size, inputs)
                 else:
                     with MoeLoadBalancerIterContext(moe_load_balancer):
                         outputs = self.cuda_graph_runner.run_graph(

From f8c12ec8347225fcc03f6b34be5f88988b354bc6 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Fri, 15 Aug 2025 10:57:56 +0800
Subject: [PATCH 32/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 43829173897..f36985fd96c 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -136,7 +136,7 @@ def maybe_get_cuda_graph(self, batch: ScheduledRequests):
         return True, attn_metadata, spec_metadata
 
     def needs_capture(self, batch_size: int):
-        return self.graph_outputs[(batch_size, self.draft_len)] is None
+        return (batch_size, self.draft_len) not in self.graph_outputs
 
     def capture_graph(self, batch_size: int, forward_fn: Callable,
                       initial_inputs: Dict[str, Any]):

From 16ebd43cb48af86253fcc1097853fe4c9e65fa4d Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Fri, 15 Aug 2025 11:02:19 +0800
Subject: [PATCH 33/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index ccceba3d94a..0ef4ae5b93e 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2058,7 +2058,8 @@ def capture_forward_fn(inputs: Dict[str, Any]):
 
                     # here we don't need to use context since cuda graph capture didn't run kernel.
                     # maybe we need a cleaner way to do this.
-                    self.cuda_graph_runner.run_graph(batch_size, inputs)
+                    outputs = self.cuda_graph_runner.run_graph(
+                        batch_size, inputs)
                 else:
                     with MoeLoadBalancerIterContext(moe_load_balancer):
                         outputs = self.cuda_graph_runner.run_graph(

From 9d8f9f6e6690f92384d31542154c9faf7883aefd Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Fri, 15 Aug 2025 16:37:32 +0800
Subject: [PATCH 34/48] fix test_pad_generation_requests

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tests/unittest/_torch/test_pytorch_model_engine.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/tests/unittest/_torch/test_pytorch_model_engine.py b/tests/unittest/_torch/test_pytorch_model_engine.py
index 4cfec14c750..58876350424 100644
--- a/tests/unittest/_torch/test_pytorch_model_engine.py
+++ b/tests/unittest/_torch/test_pytorch_model_engine.py
@@ -140,6 +140,8 @@ class PyTorchModelEngineTestCase(unittest.TestCase):
 
     def test_pad_generation_requests(self) -> None:
         model_engine, kv_cache_manager = create_model_engine_and_kvcache()
+        resource_manager = ResourceManager(
+            {ResourceManagerType.KV_CACHE_MANAGER: kv_cache_manager})
 
         seqlens_and_batch_sizes = [
             (5, 1),
@@ -155,8 +157,8 @@ def test_pad_generation_requests(self) -> None:
             batch.generation_requests = []
 
             pages_before = kv_cache_manager.get_num_free_blocks()
-            with model_engine._maybe_pad_batch(
-                    batch, kv_cache_manager) as padded_batch:
+            with model_engine.cuda_graph_runner.pad_batch(
+                    batch, resource_manager) as padded_batch:
                 # No padding for prefill
                 self.assertIs(batch, padded_batch)
             self.assertEqual(kv_cache_manager.get_num_free_blocks(),
@@ -166,9 +168,9 @@ def test_pad_generation_requests(self) -> None:
             batch.context_requests = []
             batch.generation_requests = requests
             pages_before = kv_cache_manager.get_num_free_blocks()
-            new_dummy_block = 1 if model_engine.cuda_graph_dummy_request is None else 0
-            with model_engine._maybe_pad_batch(
-                    batch, kv_cache_manager) as padded_batch:
+            new_dummy_block = 1 if model_engine.cuda_graph_runner.padding_dummy_request is None else 0
+            with model_engine.cuda_graph_runner.pad_batch(
+                    batch, resource_manager) as padded_batch:
                 if batch_size < 8 and max_seq_len < 25:
                     self.assertEqual(
                         len(padded_batch.generation_requests) % 8, 0)

From b97069a358a5706a1383c0e9bd997dec176762f4 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 19 Aug 2025 15:27:55 +0800
Subject: [PATCH 35/48] fix attention dp

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../_torch/pyexecutor/cuda_graph_runner.py    | 137 ++++++++++--------
 1 file changed, 73 insertions(+), 64 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index b543af506d5..4a9911a57ba 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -80,10 +80,28 @@ def _get_engine(self) -> "PyTorchModelEngine":
         return engine
 
     def maybe_get_cuda_graph(self, batch: ScheduledRequests):
-        if not self._can_run_graph(batch):
+        engine = self._get_engine()
+
+        # disable when doing statistic
+        if ExpertStatistic.set_iter(self.iter_counter):
             return False, None, None
 
-        batch_size = len(batch.generation_requests)
+        can_run_cuda_graph = batch.can_run_cuda_graph
+        batch_size = batch.batch_size
+        if self.enabled and engine.enable_attention_dp and engine.mapping.tp_size > 1:
+            all_can_graph_batch = engine.dist.tp_allgather(
+                [can_run_cuda_graph, batch_size])
+            is_all_gen_only = all(all_can_graph[0]
+                                  for all_can_graph in all_can_graph_batch)
+            all_batch_size_equal = all(
+                all_gen_only[1] == all_can_graph_batch[0][1]
+                for all_gen_only in all_can_graph_batch)
+
+            if not is_all_gen_only or not all_batch_size_equal:
+                return False, None, None
+
+        if not self.enabled or not can_run_cuda_graph:
+            return False, None, None
 
         key = (batch_size, self.draft_len)
         if key in self.graphs:
@@ -195,29 +213,61 @@ def run_graph(self, batch_size: int,
 
         return output_ref
 
-    def _can_run_graph(self, batch: ScheduledRequests) -> bool:
-        """Checks if the current batch is eligible for CUDA graph execution."""
+    def _get_padded_batch(self, batch: ScheduledRequests,
+                          resource_manager: ResourceManager) -> int:
         engine = self._get_engine()
-        if not self.enabled or not batch.can_run_cuda_graph:
-            return False
-
-        if hasattr(engine, 'iter_counter') and ExpertStatistic.set_iter(
-                engine.iter_counter):
-            return False
-
-        if engine.enable_attention_dp and engine.mapping.tp_size > 1:
-            batch_size = len(batch.generation_requests)
-            all_rank_info = engine.dist.tp_allgather(
-                [batch.can_run_cuda_graph, batch_size])
+        kv_cache_manager = resource_manager.get_resource_manager(
+            engine.kv_cache_manager_key)
+        can_run_cuda_graph = batch.can_run_cuda_graph
+        batch_size = batch.batch_size
+        new_batch_size = batch_size
+
+        if self.enabled and engine.enable_attention_dp and engine.mapping.tp_size > 1:
+            graph_batch_size = engine.dist.tp_allgather(
+                [can_run_cuda_graph, batch_size])
+            all_can_graph = all(graph_batch[0]
+                                for graph_batch in graph_batch_size)
+            if all_can_graph:
+                new_batch_size = max(gen_only_batch[1]
+                                     for gen_only_batch in graph_batch_size)
+
+        if (not self.enabled or not self.padding_enabled
+                or not can_run_cuda_graph
+                or new_batch_size > self.max_supported_batch_size):
+            return 0
 
-            is_all_gen_only = all(info[0] for info in all_rank_info)
-            is_all_bs_equal = all(info[1] == all_rank_info[0][1]
-                                  for info in all_rank_info)
+        padded_batch_size = self._round_up_batch_size(new_batch_size)
+        if batch_size == padded_batch_size:
+            return 0
 
-            if not is_all_gen_only or not is_all_bs_equal:
-                return False
+        padding_size = padded_batch_size - batch_size
+        if padding_size + batch.batch_size > engine.batch_size:
+            return 0
 
-        return True
+        # No padding if it would create too many concurrent requests.
+        # This is not strictly required, but we should probably
+        # respect the requirement just in case that changes in the future.
+        if self.padding_dummy_request is None:
+            available_blocks = kv_cache_manager.get_num_free_blocks()
+            # No padding if not enough KV cache space
+            if available_blocks < 1:
+                return 0
+
+            self.padding_dummy_request = kv_cache_manager.add_dummy_requests(
+                [CUDA_GRAPH_DUMMY_REQUEST_ID],
+                is_gen=True,
+                max_num_draft_tokens=engine.max_draft_len,
+                use_mrope=engine.use_mrope,
+                max_beam_width=engine.max_beam_width)[0]
+            self.padding_dummy_request.is_cuda_graph_dummy = True
+            spec_res_mgr = resource_manager.get_resource_manager(
+                ResourceManagerType.SPEC_RESOURCE_MANAGER)
+            if spec_res_mgr:
+                spec_res_mgr.add_dummy_requests([CUDA_GRAPH_DUMMY_REQUEST_ID])
+
+        batch.generation_requests.extend([self.padding_dummy_request] *
+                                         padding_size)
+        return padding_size
 
     def _round_up_batch_size(self, batch_size: int) -> int:
         """Finds the smallest supported graph batch size >= the given size."""
@@ -232,50 +282,9 @@ def _round_up_batch_size(self, batch_size: int) -> int:
     def pad_batch(self, scheduled_requests: ScheduledRequests,
                   resource_manager: ResourceManager):
         """Context manager to pad a batch to a graph-compatible size."""
-        engine = self._get_engine()
-        kv_cache_manager = resource_manager.get_resource_manager(
-            engine.kv_cache_manager_key)
-        padding_size = 0
-        if self.padding_enabled and self._can_run_graph(scheduled_requests):
-            current_batch_size = len(scheduled_requests.generation_requests)
-
-            if current_batch_size >= self.max_supported_batch_size:
-                # Already at or beyond max size, no padding up
-                padded_batch_size = current_batch_size
-            else:
-                padded_batch_size = self._round_up_batch_size(
-                    current_batch_size)
-
-            if padded_batch_size > 0 and padded_batch_size != current_batch_size:
-                padding_size = padded_batch_size - current_batch_size
-
-                if current_batch_size + padding_size > engine.batch_size:
-                    padding_size = 0
-
-                if padding_size > 0:
-                    if self.padding_dummy_request is None:
-                        if kv_cache_manager.get_num_free_blocks() > 0:
-                            self.padding_dummy_request = kv_cache_manager.add_dummy_requests(
-                                [CUDA_GRAPH_DUMMY_REQUEST_ID],
-                                is_gen=True,
-                                max_num_draft_tokens=engine.max_draft_len,
-                                use_mrope=engine.use_mrope,
-                                max_beam_width=engine.max_beam_width)[0]
-                            self.padding_dummy_request.is_cuda_graph_dummy = True
-                            spec_res_mgr = resource_manager.get_resource_manager(
-                                ResourceManagerType.SPEC_RESOURCE_MANAGER)
-                            if spec_res_mgr:
-                                spec_res_mgr.add_dummy_requests(
-                                    [CUDA_GRAPH_DUMMY_REQUEST_ID])
-                        else:
-                            padding_size = 0
-
-                    if self.padding_dummy_request:
-                        scheduled_requests.generation_requests.extend(
-                            [self.padding_dummy_request] * padding_size)
-                    else:
-                        padding_size = 0
 
+        padding_size = self._get_padded_batch(scheduled_requests,
+                                              resource_manager)
         try:
             yield scheduled_requests
         finally:

From 95f488bdf704098ac135891cec7991af0d9faf11 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 19 Aug 2025 15:34:55 +0800
Subject: [PATCH 36/48] polish

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 .../_torch/pyexecutor/cuda_graph_runner.py       | 16 ++++++++++++----
 tensorrt_llm/_torch/pyexecutor/model_engine.py   |  7 +++----
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 4a9911a57ba..b48f6859e02 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -80,6 +80,14 @@ def _get_engine(self) -> "PyTorchModelEngine":
         return engine
 
     def maybe_get_cuda_graph(self, batch: ScheduledRequests):
+        """
+        Determines if the current batch can be run with a CUDA graph.
+
+        Returns a tuple containing:
+        - A boolean indicating if a graph can be used.
+        - The attn_metadata for the graph, if applicable.
+        - The spec_metadata for the graph, if applicable.
+        """
         engine = self._get_engine()
 
         # disable when doing statistic
@@ -127,8 +135,8 @@ def maybe_get_cuda_graph(self, batch: ScheduledRequests):
     def needs_capture(self, batch_size: int):
         return (batch_size, self.draft_len) not in self.graph_outputs
 
-    def capture_graph(self, batch_size: int, forward_fn: Callable,
-                      initial_inputs: Dict[str, Any]):
+    def capture(self, batch_size: int, forward_fn: Callable,
+                initial_inputs: Dict[str, Any]):
         """Captures the forward pass for a given batch size."""
         engine = self._get_engine()
         key = (batch_size, self.draft_len)
@@ -184,8 +192,8 @@ def capture_graph(self, batch_size: int, forward_fn: Callable,
         self.graph_outputs[key] = make_weak_ref(output)
         self.memory_pool = graph.pool()
 
-    def run_graph(self, batch_size: int,
-                  current_inputs: Dict[str, Any]) -> Optional[torch.Tensor]:
+    def replay(self, batch_size: int,
+               current_inputs: Dict[str, Any]) -> Optional[torch.Tensor]:
         """Replays a previously captured graph."""
         key = (batch_size, self.draft_len)
         stored_meta = self.graph_metadata[key]
diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index c74148211af..a844cded21f 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2071,13 +2071,12 @@ def capture_forward_fn(inputs: Dict[str, Any]):
                                 gather_ids=gather_ids,
                                 gather_context_logits=gather_context_logits)
 
-                    self.cuda_graph_runner.capture_graph(
-                        batch_size, capture_forward_fn, inputs)
+                    self.cuda_graph_runner.capture(batch_size,
+                                                   capture_forward_fn, inputs)
 
                     # here we don't need to use context since cuda graph capture didn't run kernel.
                     # maybe we need a cleaner way to do this.
-                    outputs = self.cuda_graph_runner.run_graph(
-                        batch_size, inputs)
+                    outputs = self.cuda_graph_runner.replay(batch_size, inputs)
                 else:
                     with MoeLoadBalancerIterContext(moe_load_balancer):
                         outputs = self.cuda_graph_runner.run_graph(

From b57ba3b3270c3fd761cb7c339d79ebefaf4f5ddc Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 19 Aug 2025 19:44:53 +0800
Subject: [PATCH 37/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index b48f6859e02..98e260660c5 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -91,7 +91,8 @@ def maybe_get_cuda_graph(self, batch: ScheduledRequests):
         engine = self._get_engine()
 
         # disable when doing statistic
-        if ExpertStatistic.set_iter(self.iter_counter):
+        if hasattr(engine, 'iter_counter') and ExpertStatistic.set_iter(
+                engine.iter_counter):
             return False, None, None
 
         can_run_cuda_graph = batch.can_run_cuda_graph

From 9fae2695cf9441b28fee4dbb983a179bfcfdacd6 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Tue, 19 Aug 2025 19:51:48 +0800
Subject: [PATCH 38/48] fix

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/model_engine.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index a844cded21f..ac36344043f 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -2079,7 +2079,7 @@ def capture_forward_fn(inputs: Dict[str, Any]):
                     outputs = self.cuda_graph_runner.replay(batch_size, inputs)
                 else:
                     with MoeLoadBalancerIterContext(moe_load_balancer):
-                        outputs = self.cuda_graph_runner.run_graph(
+                        outputs = self.cuda_graph_runner.replay(
                             batch_size, inputs)
 
             self._execute_logit_post_processors(scheduled_requests, outputs)

From debca3cebe3dba7ebbd01917eb560133933adaa0 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Wed, 20 Aug 2025 10:49:00 +0800
Subject: [PATCH 39/48] clean

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py | 5 -----
 tensorrt_llm/_torch/pyexecutor/model_engine.py      | 7 ++-----
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
index 98e260660c5..0007b99ebd2 100644
--- a/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
+++ b/tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py
@@ -141,11 +141,6 @@ def capture(self, batch_size: int, forward_fn: Callable,
         """Captures the forward pass for a given batch size."""
         engine = self._get_engine()
         key = (batch_size, self.draft_len)
-
-        max_tokens_per_req = 1
-        if engine.is_spec_decode:
-            max_tokens_per_req += engine.spec_config.max_draft_len
-
         spec_metadata = initial_inputs.get("spec_metadata", None)
         # [CUDA graph spec decode padding]
         # We pad input IDs/position IDs to the maximum draft length (token per request).
diff --git a/tensorrt_llm/_torch/pyexecutor/model_engine.py b/tensorrt_llm/_torch/pyexecutor/model_engine.py
index ac36344043f..28caf2a9b4f 100644
--- a/tensorrt_llm/_torch/pyexecutor/model_engine.py
+++ b/tensorrt_llm/_torch/pyexecutor/model_engine.py
@@ -420,7 +420,6 @@ def __init__(
         self.iter_states = {}
         self._cuda_graphs = {}
         self._cuda_graph_mem_pool = self._torch_compile_backend._graph_pool_handle if self._torch_compile_enabled else None
-        self._run_cuda_graphs = pytorch_backend_config.use_cuda_graph
 
         self._cuda_graph_padding_enabled = pytorch_backend_config.cuda_graph_padding_enabled
 
@@ -536,13 +535,11 @@ def wrapper(self, *args, **kwargs):
 
     @contextlib.contextmanager
     def no_cuda_graph(self):
-        _run_cuda_graphs = self._run_cuda_graphs
-        self._run_cuda_graphs = False
+        _run_cuda_graphs = self.cuda_graph_runner.enabled
         self.cuda_graph_runner.enabled = False
         try:
             yield
         finally:
-            self._run_cuda_graphs = _run_cuda_graphs
             self.cuda_graph_runner.enabled = _run_cuda_graphs
 
     @with_warmup_flag
@@ -753,7 +750,7 @@ def release_batch(result: ScheduledRequests | None):
 
             AutoTuner.get().print_profiling_cache()
 
-        if not (self._run_cuda_graphs
+        if not (self.cuda_graph_runner.enabled
                 or self._torch_compile_piecewise_cuda_graph):
             return
 

From 43b18bdf762a7df3f2c0d2611c7ad87e57802310 Mon Sep 17 00:00:00 2001
From: junq <22017000+QiJune@users.noreply.github.com>
Date: Fri, 22 Aug 2025 19:43:00 +0800
Subject: [PATCH 40/48] clean tests

Signed-off-by: junq <22017000+QiJune@users.noreply.github.com>
---
 tests/unittest/_torch/helpers.py              | 121 ++++--------------
 .../_torch/modeling/test_modeling_exaone4.py  |  28 ++--
 .../_torch/modeling/test_modeling_llama.py    |  28 ++--
 .../test_modeling_llama_min_latency.py        |  23 ++--
 .../_torch/modeling/test_modeling_mistral.py  |  28 ++--
 .../_torch/modeling/test_modeling_mixtral.py  |  28 ++--
 .../_torch/modeling/test_modeling_mllama.py   |  27 ++--
 .../_torch/modeling/test_modeling_nemotron.py |  27 ++--
 .../_torch/modeling/test_modeling_phi3.py     |  27 ++--
 .../_torch/modeling/test_modeling_qwen.py     |  27 ++--
 .../_torch/modeling/test_modeling_qwen_moe.py |  28 ++--
 11 files changed, 199 insertions(+), 193 deletions(-)

diff --git a/tests/unittest/_torch/helpers.py b/tests/unittest/_torch/helpers.py
index 522b2f918cf..86580f9b94a 100644
--- a/tests/unittest/_torch/helpers.py
+++ b/tests/unittest/_torch/helpers.py
@@ -1,5 +1,4 @@
-import threading
-from typing import Any, Callable, Dict, Optional, Tuple
+from typing import Dict, Tuple
 
 import torch
 import torch.nn.functional as F
@@ -165,94 +164,30 @@ def block_scale_gemm(mat_a: torch.Tensor, mat_scale_a: torch.Tensor,
     return results.view_as(x)
 
 
-class graph_capturing_local(threading.local):
-
-    def __init__(self):
-        self.is_graph_capturing = False
-
-
-_local = graph_capturing_local()
-
-
-def set_graph_capturing(enable: bool):
-    _local.is_graph_capturing = enable
-
-
-def is_graph_capturing() -> bool:
-    return _local.is_graph_capturing
-
-
-class DecodingCUDAGraphRunner:
-
-    def __init__(
-        self,
-        batch_size: int,
-        device: str,
-        attn_metadata,
-    ) -> None:
-        self.batch_size = batch_size
-        # Using ones instead of zeros prevents NaNs in e.g. Deepseek
-        self.input_ids = torch.ones((batch_size, ),
-                                    device=device,
-                                    dtype=torch.int32)
-        self.position_ids = torch.zeros((1, batch_size),
-                                        device=device,
-                                        dtype=torch.int32)
-
-        self.attn_metadata = attn_metadata
-        self._output = None
-        self._graph = None
-
-    def __del__(self):
-        self._graph.reset()
-
-    def capture(
-        self,
-        forward_fn: Callable[[Dict[str, Any]], torch.Tensor],
-        pool: Optional[Tuple[int, int]] = None,
-    ) -> Tuple[int, int]:
-        self._graph = torch.cuda.CUDAGraph()
-        inputs = {
-            "attn_metadata": self.attn_metadata,
-            "input_ids": self.input_ids,
-            "position_ids": self.position_ids,
-            "inputs_embeds": None,
-        }
-
-        # We have to do warm up runs to initialize PyTorch's
-        # internal states according to the docs:
-        # https://pytorch.org/docs/stable/notes/cuda.html#cuda-graph-semantics
-        # This also lets us initialize states in the attn_metadata.
-        set_graph_capturing(True)
-        for _ in range(2):
-            forward_fn(inputs)
-        with torch.cuda.graph(self._graph, pool=pool):
-            output = forward_fn(inputs)
-        set_graph_capturing(False)
-        # Mark weak ref here. The output tensor should be freed properly.
-        from tensorrt_llm._torch.utils import make_weak_ref
-        self._output = make_weak_ref(output)
-        return self._graph.pool()
-
-    def needs_capture(self) -> bool:
-        return self._output is None
-
-    def run(self, inputs: Dict[str, Any]) -> torch.Tensor:
-        assert "input_ids" in inputs
-        assert "position_ids" in inputs
-        assert "attn_metadata" in inputs
-
-        attn_metadata = inputs["attn_metadata"]
-        assert attn_metadata is self.attn_metadata, (
-            "attn_metadata does not match the attn_metadata instance that was used to "
-            "capture this graph.")
-
-        input_ids = inputs["input_ids"]
-        position_ids = inputs["position_ids"]
-        seqlen = input_ids.shape[0]
-        self.input_ids[:seqlen].copy_(input_ids)
-        self.position_ids[:, :seqlen].copy_(position_ids)
-
-        assert self._output is not None and self._graph is not None
-        self._graph.replay()
-        return self._output
+class MockPytorchBackendConfig:
+
+    def __init__(self, use_cuda_graph, cuda_graph_padding_enabled):
+        self.use_cuda_graph = use_cuda_graph
+        self.cuda_graph_padding_enabled = cuda_graph_padding_enabled
+
+
+class MockEngine:
+    """A replacement for SimpleNamespace that supports weak references."""
+
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+
+
+def create_mock_engine(batch_size: int):
+
+    return MockEngine(
+        pytorch_backend_config=MockPytorchBackendConfig(
+            use_cuda_graph=True, cuda_graph_padding_enabled=False),
+        _cuda_graph_batch_sizes=[batch_size],
+        _max_cuda_graph_batch_size=batch_size,
+        max_beam_width=1,
+        is_spec_decode=False,
+        spec_config=None,
+        _cuda_graph_mem_pool=None,
+        use_mrope=False,
+    )
diff --git a/tests/unittest/_torch/modeling/test_modeling_exaone4.py b/tests/unittest/_torch/modeling/test_modeling_exaone4.py
index 44bc2476f4d..ebf496b2c14 100644
--- a/tests/unittest/_torch/modeling/test_modeling_exaone4.py
+++ b/tests/unittest/_torch/modeling/test_modeling_exaone4.py
@@ -22,7 +22,7 @@ class Exaone4Config(PretrainedConfig):
     # TODO: Remove this once we have a proper config for Exaone4
     SKIP_EXAONE4_HF_ACCURACY_TEST = True
 
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from transformers.cache_utils import HybridCache
 from utils.util import getSMVersion
 
@@ -31,6 +31,7 @@ class Exaone4Config(PretrainedConfig):
 from tensorrt_llm._torch.metadata import KVCacheParams
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_exaone4 import Exaone4ForCausalLM
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
@@ -337,6 +338,11 @@ def test_exaone4_allclose_to_hf(self, scenario: Scenario) -> None:
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
 
+        graph_runner = None
+        if scenario.use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
+
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
             if not scenario.use_cuda_graph:
@@ -344,19 +350,20 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                        position_ids=position_ids,
                                        attn_metadata=attn_metadata)
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata)
-                graph_runner.capture(lambda inputs: exaone4.forward(**inputs))
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1,
+                                     lambda inputs: exaone4.forward(**inputs),
+                                     inputs)
 
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run({
-                        "input_ids": input_ids,
-                        "position_ids": position_ids,
-                        "attn_metadata": attn_metadata,
-                    })
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if scenario.use_cuda_graph:
@@ -379,5 +386,6 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                    ref.logits[:, -1].float(),
                                    atol=0.4,
                                    rtol=0.4)
-
+        if graph_runner is not None:
+            graph_runner.clear()
         kv_cache_manager.shutdown()
diff --git a/tests/unittest/_torch/modeling/test_modeling_llama.py b/tests/unittest/_torch/modeling/test_modeling_llama.py
index 54b43112575..73cd4bf9bac 100644
--- a/tests/unittest/_torch/modeling/test_modeling_llama.py
+++ b/tests/unittest/_torch/modeling/test_modeling_llama.py
@@ -4,7 +4,7 @@
 from typing import Any
 
 import torch
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from parameterized import parameterized
 from transformers import LlamaConfig
 from transformers import LlamaForCausalLM as HFLlamaForCausalLM
@@ -15,6 +15,7 @@
 from tensorrt_llm._torch.metadata import KVCacheParams
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_llama import LlamaForCausalLM
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
@@ -325,6 +326,11 @@ def test_llama_allclose_to_hf(self, scenario: Scenario) -> None:
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
 
+        graph_runner = None
+        if scenario.use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
+
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
             if not scenario.use_cuda_graph:
@@ -332,19 +338,18 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                      position_ids=position_ids,
                                      attn_metadata=attn_metadata)
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata)
-                graph_runner.capture(lambda inputs: llama.forward(**inputs))
-
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1, lambda inputs: llama.forward(**inputs),
+                                     inputs)
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run({
-                        "input_ids": input_ids,
-                        "position_ids": position_ids,
-                        "attn_metadata": attn_metadata,
-                    })
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if scenario.use_cuda_graph:
@@ -363,5 +368,6 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                    ref.logits[:, -1].float(),
                                    atol=0.4,
                                    rtol=0.4)
-
+        if graph_runner is not None:
+            graph_runner.clear()
         kv_cache_manager.shutdown()
diff --git a/tests/unittest/_torch/modeling/test_modeling_llama_min_latency.py b/tests/unittest/_torch/modeling/test_modeling_llama_min_latency.py
index 007f03bf3e4..2f7618cb39b 100644
--- a/tests/unittest/_torch/modeling/test_modeling_llama_min_latency.py
+++ b/tests/unittest/_torch/modeling/test_modeling_llama_min_latency.py
@@ -4,7 +4,7 @@
 
 import torch
 import transformers
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from parameterized import parameterized
 from transformers import Llama4Config
 from transformers import \
@@ -21,6 +21,7 @@
 from tensorrt_llm._torch.models.modeling_llama import \
     Llama4ForConditionalGeneration
 from tensorrt_llm._torch.pyexecutor.config import PyTorchConfig
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
@@ -402,6 +403,10 @@ def test_llama_allclose_to_hf(self, scenario: AllCloseScenario) -> None:
                          input_ids.size(-1) + gen_input_ids.size(-1))
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
+        graph_runner = None
+        if scenario.use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
 
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
@@ -410,19 +415,19 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                      position_ids=position_ids,
                                      attn_metadata=attn_metadata)
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata)
-                graph_runner.capture(lambda inputs: llama.forward(**inputs))
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1, lambda inputs: llama.forward(**inputs),
+                                     inputs)
 
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run({
-                        "input_ids": input_ids,
-                        "position_ids": position_ids,
-                        "attn_metadata": attn_metadata,
-                    })
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if scenario.use_cuda_graph:
diff --git a/tests/unittest/_torch/modeling/test_modeling_mistral.py b/tests/unittest/_torch/modeling/test_modeling_mistral.py
index 5b67d37e84c..f85837ddb14 100644
--- a/tests/unittest/_torch/modeling/test_modeling_mistral.py
+++ b/tests/unittest/_torch/modeling/test_modeling_mistral.py
@@ -7,7 +7,7 @@
 import pytest
 import torch
 import transformers
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from utils.util import getSMVersion
 
 import tensorrt_llm
@@ -17,6 +17,7 @@
 from tensorrt_llm._torch.attention_backend import utils as attention_utils
 from tensorrt_llm._torch.models import modeling_mistral
 from tensorrt_llm._torch.pyexecutor import resource_manager
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 from tensorrt_llm.bindings import executor as executor_lib
 from tensorrt_llm.models import modeling_utils
 
@@ -399,6 +400,11 @@ def test_mistral_3_vlm_allclose_to_hf(mistral_small_3_1_24b_config, backend, use
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
 
+        graph_runner = None
+        if use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
+
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
             if not use_cuda_graph:
@@ -406,22 +412,18 @@ def run_forward(input_ids, position_ids, attn_metadata):
                     input_ids=input_ids, position_ids=position_ids, attn_metadata=attn_metadata
                 )
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata
-                )
-                graph_runner.capture(lambda inputs: mistral.forward(**inputs))
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1, lambda inputs: mistral.forward(**inputs), inputs)
 
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run(
-                        {
-                            "input_ids": input_ids,
-                            "position_ids": position_ids,
-                            "attn_metadata": attn_metadata,
-                        }
-                    )
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if use_cuda_graph:
@@ -439,3 +441,5 @@ def run_forward(input_ids, position_ids, attn_metadata):
             )
 
         torch.testing.assert_close(logits, ref.logits[:, -1].float(), atol=0.4, rtol=0.4)
+        if graph_runner is not None:
+            graph_runner.clear()
diff --git a/tests/unittest/_torch/modeling/test_modeling_mixtral.py b/tests/unittest/_torch/modeling/test_modeling_mixtral.py
index 20fe49430ba..1637120b304 100644
--- a/tests/unittest/_torch/modeling/test_modeling_mixtral.py
+++ b/tests/unittest/_torch/modeling/test_modeling_mixtral.py
@@ -3,7 +3,7 @@
 from dataclasses import dataclass
 
 import torch
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from parameterized import parameterized
 from transformers import MixtralConfig
 from transformers import MixtralForCausalLM as HFMixtralForCausalLM
@@ -16,6 +16,7 @@
 from tensorrt_llm._torch.models.checkpoints.hf.mixtral_weight_mapper import \
     MixtralHfWeightMapper
 from tensorrt_llm._torch.models.modeling_mixtral import MixtralForCausalLM
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
@@ -309,6 +310,11 @@ def test_mixtral_allclose_to_hf(self, scenario: Scenario):
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
 
+        graph_runner = None
+        if scenario.use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
+
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
             if not scenario.use_cuda_graph:
@@ -316,19 +322,20 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                        position_ids=position_ids,
                                        attn_metadata=attn_metadata)
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata)
-                graph_runner.capture(lambda inputs: mixtral.forward(**inputs))
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1,
+                                     lambda inputs: mixtral.forward(**inputs),
+                                     inputs)
 
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run({
-                        "input_ids": input_ids,
-                        "position_ids": position_ids,
-                        "attn_metadata": attn_metadata,
-                    })
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if scenario.use_cuda_graph:
@@ -347,5 +354,6 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                    ref.logits[:, -1].float(),
                                    atol=0.1,
                                    rtol=0.1)
-
+        if graph_runner is not None:
+            graph_runner.clear()
         kv_cache_manager.shutdown()
diff --git a/tests/unittest/_torch/modeling/test_modeling_mllama.py b/tests/unittest/_torch/modeling/test_modeling_mllama.py
index 1b06eaa61f1..1ecfd396612 100644
--- a/tests/unittest/_torch/modeling/test_modeling_mllama.py
+++ b/tests/unittest/_torch/modeling/test_modeling_mllama.py
@@ -3,7 +3,7 @@
 from copy import deepcopy
 
 import torch
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from parameterized import parameterized
 from test_modeling_llama import Scenario, reduce_llama_config
 from transformers import MllamaConfig
@@ -16,6 +16,7 @@
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_mllama import \
     MllamaForConditionalGeneration
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
@@ -416,6 +417,11 @@ def test_mllama_allclose_to_hf_text_only(self, scenario: Scenario) -> None:
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
 
+        graph_runner = None
+        if scenario.use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
+
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
             if not scenario.use_cuda_graph:
@@ -423,19 +429,19 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                       position_ids=position_ids,
                                       attn_metadata=attn_metadata)
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata)
-                graph_runner.capture(lambda inputs: mllama.forward(**inputs))
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1, lambda inputs: mllama.forward(**inputs),
+                                     inputs)
 
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run({
-                        "input_ids": input_ids,
-                        "position_ids": position_ids,
-                        "attn_metadata": attn_metadata,
-                    })
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if scenario.use_cuda_graph:
@@ -454,3 +460,6 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                    ref.logits[:, -1].float(),
                                    atol=0.3,
                                    rtol=0.3)
+        if graph_runner is not None:
+            graph_runner.clear()
+        kv_cache_manager.shutdown()
diff --git a/tests/unittest/_torch/modeling/test_modeling_nemotron.py b/tests/unittest/_torch/modeling/test_modeling_nemotron.py
index f10e39aa909..11456d0f099 100644
--- a/tests/unittest/_torch/modeling/test_modeling_nemotron.py
+++ b/tests/unittest/_torch/modeling/test_modeling_nemotron.py
@@ -4,7 +4,7 @@
 from typing import Any
 
 import torch
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from parameterized import parameterized
 from transformers import NemotronConfig
 from transformers import NemotronForCausalLM as HFNemotronForCausalLM
@@ -15,6 +15,7 @@
 from tensorrt_llm._torch.metadata import KVCacheParams
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_nemotron import NemotronForCausalLM
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
@@ -317,6 +318,11 @@ def test_nemotron_allclose_to_hf(self, scenario: Scenario) -> None:
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
 
+        graph_runner = None
+        if scenario.use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
+
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
             if not scenario.use_cuda_graph:
@@ -324,19 +330,20 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                         position_ids=position_ids,
                                         attn_metadata=attn_metadata)
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata)
-                graph_runner.capture(lambda inputs: nemotron.forward(**inputs))
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1,
+                                     lambda inputs: nemotron.forward(**inputs),
+                                     inputs)
 
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run({
-                        "input_ids": input_ids,
-                        "position_ids": position_ids,
-                        "attn_metadata": attn_metadata,
-                    })
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if scenario.use_cuda_graph:
@@ -356,4 +363,6 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                    atol=0.4,
                                    rtol=0.4)
 
+        if graph_runner is not None:
+            graph_runner.clear()
         kv_cache_manager.shutdown()
diff --git a/tests/unittest/_torch/modeling/test_modeling_phi3.py b/tests/unittest/_torch/modeling/test_modeling_phi3.py
index 088a6323c8b..7c5ffd94141 100644
--- a/tests/unittest/_torch/modeling/test_modeling_phi3.py
+++ b/tests/unittest/_torch/modeling/test_modeling_phi3.py
@@ -4,7 +4,7 @@
 from typing import Any
 
 import torch
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from transformers import Phi3Config
 from transformers import Phi3ForCausalLM as HFPhi3ForCausalLM
 from utils.util import default_dtype
@@ -14,6 +14,7 @@
 from tensorrt_llm._torch.metadata import KVCacheParams
 from tensorrt_llm._torch.model_config import ModelConfig
 from tensorrt_llm._torch.models.modeling_phi3 import Phi3ForCausalLM
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
@@ -309,6 +310,11 @@ def test_phi3_allclose_to_hf(self) -> None:
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
 
+        graph_runner = None
+        if scenario.use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
+
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
             if not scenario.use_cuda_graph:
@@ -316,19 +322,19 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                     position_ids=position_ids,
                                     attn_metadata=attn_metadata)
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata)
-                graph_runner.capture(lambda inputs: phi3.forward(**inputs))
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1, lambda inputs: phi3.forward(**inputs),
+                                     inputs)
 
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run({
-                        "input_ids": input_ids,
-                        "position_ids": position_ids,
-                        "attn_metadata": attn_metadata,
-                    })
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if scenario.use_cuda_graph:
@@ -347,5 +353,6 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                    ref.logits[:, -1].float(),
                                    atol=0.4,
                                    rtol=0.4)
-
+        if graph_runner is not None:
+            graph_runner.clear()
         kv_cache_manager.shutdown()
diff --git a/tests/unittest/_torch/modeling/test_modeling_qwen.py b/tests/unittest/_torch/modeling/test_modeling_qwen.py
index 02ab56bcbcd..d1d129de083 100644
--- a/tests/unittest/_torch/modeling/test_modeling_qwen.py
+++ b/tests/unittest/_torch/modeling/test_modeling_qwen.py
@@ -17,11 +17,12 @@
 from tensorrt_llm._torch.models.modeling_qwen import (
     Qwen2ForCausalLM, Qwen2ForProcessRewardModel)
 # yapf: enable
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
 from tensorrt_llm.models.modeling_utils import QuantConfig
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 
 from utils.llm_data import llm_models_root
 from utils.util import getSMVersion
@@ -264,6 +265,11 @@ def test_qwen_allclose_to_hf(self, scenario: Scenario) -> None:
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
 
+        graph_runner = None
+        if scenario.use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
+
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
             if not scenario.use_cuda_graph:
@@ -271,19 +277,19 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                     position_ids=position_ids,
                                     attn_metadata=attn_metadata)
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata)
-                graph_runner.capture(lambda inputs: qwen.forward(**inputs))
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1, lambda inputs: qwen.forward(**inputs),
+                                     inputs)
 
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run({
-                        "input_ids": input_ids,
-                        "position_ids": position_ids,
-                        "attn_metadata": attn_metadata,
-                    })
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if scenario.use_cuda_graph:
@@ -302,7 +308,8 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                    ref.logits[:, -1].float(),
                                    atol=0.4,
                                    rtol=0.4)
-
+        if graph_runner is not None:
+            graph_runner.clear()
         kv_cache_manager.shutdown()
 
     @parameterized.expand(
diff --git a/tests/unittest/_torch/modeling/test_modeling_qwen_moe.py b/tests/unittest/_torch/modeling/test_modeling_qwen_moe.py
index 39b5f607dac..8658ae0e242 100644
--- a/tests/unittest/_torch/modeling/test_modeling_qwen_moe.py
+++ b/tests/unittest/_torch/modeling/test_modeling_qwen_moe.py
@@ -3,7 +3,7 @@
 from dataclasses import dataclass
 
 import torch
-from _torch.helpers import DecodingCUDAGraphRunner
+from _torch.helpers import create_mock_engine
 from parameterized import parameterized
 from transformers import Qwen2MoeConfig
 from transformers import Qwen2MoeForCausalLM as HFQwen2MoeForCausalLM
@@ -16,6 +16,7 @@
 from tensorrt_llm._torch.models.checkpoints.hf.qwen2_moe_weight_mapper import \
     Qwen2MoeHfWeightMapper
 from tensorrt_llm._torch.models.modeling_qwen_moe import Qwen2MoeForCausalLM
+from tensorrt_llm._torch.pyexecutor.cuda_graph_runner import CUDAGraphRunner
 from tensorrt_llm._torch.pyexecutor.resource_manager import KVCacheManager
 from tensorrt_llm.bindings.executor import KvCacheConfig
 from tensorrt_llm.mapping import Mapping
@@ -314,6 +315,11 @@ def test_qwen_moe_allclose_to_hf(self, scenario: Scenario):
         ]
         gen_position_ids = torch.cat(gen_position_ids).unsqueeze(0).cuda()
 
+        graph_runner = None
+        if scenario.use_cuda_graph:
+            mock_engine = create_mock_engine(1)
+            graph_runner = CUDAGraphRunner(mock_engine)
+
         def run_forward(input_ids, position_ids, attn_metadata):
             attn_metadata.prepare()
             if not scenario.use_cuda_graph:
@@ -321,19 +327,20 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                         position_ids=position_ids,
                                         attn_metadata=attn_metadata)
             else:
-                graph_runner = DecodingCUDAGraphRunner(
-                    attn_metadata.max_num_requests, "cuda", attn_metadata)
-                graph_runner.capture(lambda inputs: qwen_moe.forward(**inputs))
+                inputs = {
+                    "input_ids": input_ids,
+                    "position_ids": position_ids,
+                    "attn_metadata": attn_metadata,
+                }
+                graph_runner.capture(1,
+                                     lambda inputs: qwen_moe.forward(**inputs),
+                                     inputs)
 
                 for _ in range(2):
                     # Run it twice. This helps us catch problems if buffers are accidentally reallocated
                     # in prepare().
                     attn_metadata.prepare()
-                    logits = graph_runner.run({
-                        "input_ids": input_ids,
-                        "position_ids": position_ids,
-                        "attn_metadata": attn_metadata,
-                    })
+                    logits = graph_runner.replay(1, inputs)
                 return logits
 
         if scenario.use_cuda_graph:
@@ -352,5 +359,6 @@ def run_forward(input_ids, position_ids, attn_metadata):
                                    ref.logits[:, -1].float(),
                                    atol=0.1,
                                    rtol=0.1)
-
+        if graph_runner is not None:
+            graph_runner.clear()
         kv_cache_manager.shutdown()

From 907bc22fcb2f9ca2bc3d3d009c94a8bb3e6e4d1c Mon Sep 17 00:00:00 2001
From: Yiqing Yan <yiqingy@nvidia.com>
Date: Fri, 22 Aug 2025 22:02:28 +0800
Subject: [PATCH 41/48] [None][chore] Bump version to 1.1.0rc2 (#7167)

Signed-off-by: Yiqing Yan <yiqingy@nvidia.com>
---
 README.md                | 2 +-
 examples/constraints.txt | 2 +-
 tensorrt_llm/version.py  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index def2a7cb5f7..745713e5810 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ TensorRT-LLM
 [![python](https://img.shields.io/badge/python-3.10-green)](https://www.python.org/downloads/release/python-31012/)
 [![cuda](https://img.shields.io/badge/cuda-12.9.1-green)](https://developer.nvidia.com/cuda-downloads)
 [![trt](https://img.shields.io/badge/TRT-10.11.0-green)](https://developer.nvidia.com/tensorrt)
-[![version](https://img.shields.io/badge/release-1.1.0rc1-green)](./tensorrt_llm/version.py)
+[![version](https://img.shields.io/badge/release-1.1.0rc2-green)](./tensorrt_llm/version.py)
 [![license](https://img.shields.io/badge/license-Apache%202-blue)](./LICENSE)
 
 [Architecture](./docs/source/torch/arch_overview.md)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[Performance](./docs/source/performance/perf-overview.md)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[Examples](https://nvidia.github.io/TensorRT-LLM/quick-start-guide.html)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[Documentation](./docs/source/)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[Roadmap](https://github.com/NVIDIA/TensorRT-LLM/issues?q=is%3Aissue%20state%3Aopen%20label%3Aroadmap)
diff --git a/examples/constraints.txt b/examples/constraints.txt
index 4ce23b0de7a..8b0d1a00930 100644
--- a/examples/constraints.txt
+++ b/examples/constraints.txt
@@ -1,3 +1,3 @@
-tensorrt_llm==1.1.0rc1
+tensorrt_llm==1.1.0rc2
 evaluate~=0.4.1
 rouge_score~=0.1.2
diff --git a/tensorrt_llm/version.py b/tensorrt_llm/version.py
index 603fd689b75..93b6027df5c 100644
--- a/tensorrt_llm/version.py
+++ b/tensorrt_llm/version.py
@@ -12,4 +12,4 @@
 # 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.
-__version__ = "1.1.0rc1"
+__version__ = "1.1.0rc2"

From e3de5758a3d42d50aa15affd04d2568e0a53eb92 Mon Sep 17 00:00:00 2001
From: Suyog Gupta <41447211+suyoggupta@users.noreply.github.com>
Date: Fri, 22 Aug 2025 08:30:53 -0700
Subject: [PATCH 42/48] [#7136][feat] trtllm-serve + autodeploy integration
 (#7141)

Signed-off-by: Suyog Gupta <41447211+suyoggupta@users.noreply.github.com>
---
 .../advanced/serving_with_trtllm_serve.md     | 77 +++++++++++++++++++
 docs/source/torch/auto_deploy/auto-deploy.md  |  1 +
 .../custom_ops/flashinfer_attention.py        |  1 -
 tensorrt_llm/_torch/auto_deploy/llm_args.py   | 10 +++
 tensorrt_llm/commands/serve.py                | 24 ++++--
 .../defs/accuracy/test_llm_api_autodeploy.py  |  2 +
 6 files changed, 107 insertions(+), 8 deletions(-)
 create mode 100644 docs/source/torch/auto_deploy/advanced/serving_with_trtllm_serve.md

diff --git a/docs/source/torch/auto_deploy/advanced/serving_with_trtllm_serve.md b/docs/source/torch/auto_deploy/advanced/serving_with_trtllm_serve.md
new file mode 100644
index 00000000000..5a73d047ea4
--- /dev/null
+++ b/docs/source/torch/auto_deploy/advanced/serving_with_trtllm_serve.md
@@ -0,0 +1,77 @@
+# Serving with trtllm-serve
+
+AutoDeploy integrates with the OpenAI-compatible `trtllm-serve` CLI so you can expose AutoDeploy-optimized models over HTTP without writing server code. This page shows how to launch the server with the AutoDeploy backend, configure it via YAML, and validate with a simple request.
+
+## Quick start
+
+Launch `trtllm-serve` with the AutoDeploy backend by setting `--backend _autodeploy`:
+
+```bash
+trtllm-serve \
+  meta-llama/Llama-3.1-8B-Instruct \
+  --backend _autodeploy
+```
+
+- `model`: HF name or local path
+- `--backend _autodeploy`: uses AutoDeploy runtime
+
+Once the server is ready, test with an OpenAI-compatible request:
+
+```bash
+curl -s http://localhost:8000/v1/chat/completions \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "model": "meta-llama/Llama-3.1-8B-Instruct",
+    "messages":[{"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "Where is New York? Tell me in a single sentence."}],
+    "max_tokens": 32
+  }'
+```
+
+## Configuration via YAML
+
+Use `--extra_llm_api_options` to supply a YAML file that augments or overrides server/runtime settings.
+
+```bash
+trtllm-serve \
+  meta-llama/Llama-3.1-8B \
+  --backend _autodeploy \
+  --extra_llm_api_options autodeploy_config.yaml
+```
+
+Example `autodeploy_config.yaml`:
+
+```yaml
+# Compilation backend for AutoDeploy
+compile_backend: torch-opt  # options: torch-simple, torch-compile, torch-cudagraph, torch-opt
+
+# Runtime engine
+runtime: trtllm                # options: trtllm, demollm
+
+# Model loading
+skip_loading_weights: false    # set true for architecture-only perf runs
+
+# KV cache memory
+free_mem_ratio: 0.8            # fraction of free GPU mem for KV cache
+
+# CUDA graph optimization
+cuda_graph_batch_sizes: [1, 2, 4, 8, 16, 32, 64]
+
+# Attention backend
+attn_backend: flashinfer       # recommended for best performance
+```
+
+## Limitations and tips
+
+- KV cache block reuse is disabled automatically for AutoDeploy backend
+- AutoDeploy backend doesn't yet support disaggregated serving. WIP
+- For best performance:
+  - Prefer `compile_backend: torch-opt`
+  - Use `attn_backend: flashinfer`
+  - Set realistic `cuda_graph_batch_sizes` that match expected traffic
+  - Tune `free_mem_ratio` to 0.8–0.9
+
+## See also
+
+- [AutoDeploy overview](../auto-deploy.md)
+- [Benchmarking with trtllm-bench](./benchmarking_with_trtllm_bench.md)
diff --git a/docs/source/torch/auto_deploy/auto-deploy.md b/docs/source/torch/auto_deploy/auto-deploy.md
index fc00c0ccc3e..185e1f321ae 100644
--- a/docs/source/torch/auto_deploy/auto-deploy.md
+++ b/docs/source/torch/auto_deploy/auto-deploy.md
@@ -59,6 +59,7 @@ The exported graph then undergoes a series of automated transformations, includi
 - [Incorporating AutoDeploy into Your Own Workflow](./advanced/workflow.md)
 - [Expert Configurations](./advanced/expert_configurations.md)
 - [Performance Benchmarking](./advanced/benchmarking_with_trtllm_bench.md)
+- [Serving with trtllm-serve](./advanced/serving_with_trtllm_serve.md)
 
 ## Roadmap
 
diff --git a/tensorrt_llm/_torch/auto_deploy/custom_ops/flashinfer_attention.py b/tensorrt_llm/_torch/auto_deploy/custom_ops/flashinfer_attention.py
index 414039a5065..01fb0deb576 100644
--- a/tensorrt_llm/_torch/auto_deploy/custom_ops/flashinfer_attention.py
+++ b/tensorrt_llm/_torch/auto_deploy/custom_ops/flashinfer_attention.py
@@ -198,7 +198,6 @@ def prepare_flashinfer_metadata(
         flashinfer.get_seq_lens(paged_kv_indptr, paged_kv_last_page_len, page_size),
         position_ids.numel(),
     )
-
     # return metadata
     return (
         qo_indptr,
diff --git a/tensorrt_llm/_torch/auto_deploy/llm_args.py b/tensorrt_llm/_torch/auto_deploy/llm_args.py
index 812dfea29cd..9811274a8bc 100644
--- a/tensorrt_llm/_torch/auto_deploy/llm_args.py
+++ b/tensorrt_llm/_torch/auto_deploy/llm_args.py
@@ -274,6 +274,16 @@ def quant_config(self, value: QuantConfig):
         self._quant_config = value
 
     ### VALIDATION #################################################################################
+    @field_validator("max_seq_len", mode="before")
+    @classmethod
+    def ensure_max_seq_len(cls, value: Any, info: ValidationInfo) -> Any:
+        if value is None:
+            # Fallback to the AutoDeployConfig default when not provided
+            return AutoDeployConfig.model_fields["max_seq_len"].get_default(
+                call_default_factory=True
+            )
+        return value
+
     @field_validator("build_config", mode="before")
     @classmethod
     def ensure_no_build_config(cls, value: Any, info: ValidationInfo) -> Any:
diff --git a/tensorrt_llm/commands/serve.py b/tensorrt_llm/commands/serve.py
index 07eb13d7968..c1013eb3c5c 100644
--- a/tensorrt_llm/commands/serve.py
+++ b/tensorrt_llm/commands/serve.py
@@ -14,6 +14,7 @@
 from tensorrt_llm import LLM as PyTorchLLM
 from tensorrt_llm import MultimodalEncoder
 from tensorrt_llm._tensorrt_engine import LLM
+from tensorrt_llm._torch.auto_deploy.llm import LLM as AutoDeployLLM
 from tensorrt_llm._utils import mpi_rank
 from tensorrt_llm.executor.utils import LlmLauncherEnvs
 from tensorrt_llm.llmapi import (BuildConfig, CapacitySchedulerPolicy,
@@ -109,7 +110,7 @@ def get_llm_args(model: str,
         capacity_scheduler_policy=CapacitySchedulerPolicy.GUARANTEED_NO_EVICT,
         dynamic_batch_config=dynamic_batch_config,
     )
-
+    backend = backend if backend in ["pytorch", "_autodeploy"] else None
     llm_args = {
         "model":
         model,
@@ -140,7 +141,7 @@ def get_llm_args(model: str,
         "kv_cache_config":
         kv_cache_config,
         "backend":
-        backend if backend == "pytorch" else None,
+        backend,
         "num_postprocess_workers":
         num_postprocess_workers,
         "postprocess_tokenizer_dir":
@@ -162,9 +163,15 @@ def launch_server(host: str,
 
     backend = llm_args["backend"]
     model = llm_args["model"]
-
     if backend == 'pytorch':
         llm = PyTorchLLM(**llm_args)
+    elif backend == '_autodeploy':
+        # AutoDeploy does not support build_config
+        llm_args.pop("build_config", None)
+        # TODO(https://github.com/NVIDIA/TensorRT-LLM/issues/7142):
+        # AutoDeploy does not support cache reuse yet.
+        llm_args["kv_cache_config"].enable_block_reuse = False
+        llm = AutoDeployLLM(**llm_args)
     else:
         llm = LLM(**llm_args)
 
@@ -204,10 +211,13 @@ def launch_mm_encoder_server(
               default="localhost",
               help="Hostname of the server.")
 @click.option("--port", type=int, default=8000, help="Port of the server.")
-@click.option("--backend",
-              type=click.Choice(["pytorch", "trt"]),
-              default="pytorch",
-              help="Set to 'pytorch' for pytorch path. Default is cpp path.")
+@click.option(
+    "--backend",
+    type=click.Choice(["pytorch", "trt", "_autodeploy"]),
+    default="pytorch",
+    help=
+    "Set to 'pytorch' for pytorch path and '_autodeploy' for autodeploy path. Default is pytorch path."
+)
 @click.option('--log_level',
               type=click.Choice(severity_map.keys()),
               default='info',
diff --git a/tests/integration/defs/accuracy/test_llm_api_autodeploy.py b/tests/integration/defs/accuracy/test_llm_api_autodeploy.py
index da64969337e..d761ae6851d 100644
--- a/tests/integration/defs/accuracy/test_llm_api_autodeploy.py
+++ b/tests/integration/defs/accuracy/test_llm_api_autodeploy.py
@@ -30,6 +30,8 @@ def get_default_kwargs(self):
         return {
             'skip_tokenizer_init': False,
             'trust_remote_code': True,
+            # TODO(https://github.com/NVIDIA/TensorRT-LLM/issues/7142):
+            # AutoDeploy does not support cache reuse yet.
             'kv_cache_config': {
                 'enable_block_reuse': False,
             },

From c232ba8157eba3bb739cc65863d6491287ab18ab Mon Sep 17 00:00:00 2001
From: tomeras91 <57313761+tomeras91@users.noreply.github.com>
Date: Fri, 22 Aug 2025 19:15:20 +0300
Subject: [PATCH 43/48] [TRTLLM-4921][feat] Enable chunked prefill for
 Nemotron-H (#6334)

Signed-off-by: Tomer Asida <57313761+tomeras91@users.noreply.github.com>
Signed-off-by: tomeras91 <57313761+tomeras91@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
---
 .../_torch/models/modeling_nemotron_h.py      |   4 +-
 .../_torch/modules/mamba/mamba2_metadata.py   |  94 +++++-
 .../_torch/modules/mamba/mamba2_mixer.py      |  13 +-
 .../_torch/modules/mamba/ssd_chunk_scan.py    |   9 +-
 .../_torch/modules/mamba/ssd_combined.py      |   9 +-
 .../_torch/modules/mamba/ssd_state_passing.py |  83 +++--
 .../modeling/test_modeling_nemotron_h.py      |  65 +++-
 .../_torch/thop/test_causal_conv1d_op.py      |  18 +-
 .../thop/test_mamba2_chunk_ss_update.py       | 286 +++++++++++++++++-
 tests/unittest/utils/torch_ref.py             |  14 +-
 10 files changed, 540 insertions(+), 55 deletions(-)

diff --git a/tensorrt_llm/_torch/models/modeling_nemotron_h.py b/tensorrt_llm/_torch/models/modeling_nemotron_h.py
index 41f870f890d..e548d09a084 100644
--- a/tensorrt_llm/_torch/models/modeling_nemotron_h.py
+++ b/tensorrt_llm/_torch/models/modeling_nemotron_h.py
@@ -221,7 +221,9 @@ def forward(
             )
 
         if self.mamba_metadata is None or self.mamba_metadata.max_batch_size != attn_metadata.max_num_requests:
-            self.mamba_metadata = Mamba2Metadata(attn_metadata.max_num_requests)
+            self.mamba_metadata = Mamba2Metadata(
+                attn_metadata.max_num_requests,
+                chunk_size=self.model_config.pretrained_config.chunk_size)
         self.mamba_metadata.prepare(attn_metadata)
 
         if inputs_embeds is None:
diff --git a/tensorrt_llm/_torch/modules/mamba/mamba2_metadata.py b/tensorrt_llm/_torch/modules/mamba/mamba2_metadata.py
index 445c288e6ff..d421cc9209d 100644
--- a/tensorrt_llm/_torch/modules/mamba/mamba2_metadata.py
+++ b/tensorrt_llm/_torch/modules/mamba/mamba2_metadata.py
@@ -13,15 +13,83 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import math
+from typing import Tuple
+
 import torch
 
 from tensorrt_llm._torch.attention_backend.interface import AttentionMetadata
 
 
+def cu_seqlens_to_chunk_indices_offsets(
+        cu_seqlens: torch.Tensor,
+        chunk_size: int) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Args:
+        cu_seqlens (torch.Tensor): 1D tensor of cumulative sequence lengths, shape (num_seqs + 1,). The first element should be 0. Each entry represents the starting index of a sequence in the flattened token array.
+        chunk_size (int): The size of each physical mamba chunk (number of tokens per chunk).
+
+    Returns:
+        Tuple[torch.Tensor, torch.Tensor]: A tuple containing:
+            - chunk_indices (torch.Tensor): 1D tensor of indices indicating the physical chunk for each logical chunk.
+            - chunk_offsets (torch.Tensor): 1D tensor of offsets indicating the starting index of each logical chunk within its physical chunk.
+
+    This function computes the chunk indices and offsets for the given cu_seqlens and chunk_size.
+    Both are tensors of integers with length N, where N is the number of logical (pseudo) chunks.
+    A logical chunk is a sequence of tokens that are all part of the same sequence and are all in the same physical mamba chunk.
+    In other words, a logical chunk changes every time we cross a sequence boundary or a physical mamba chunk boundary.
+    Logical chunks are needed to handle batched requests with initial states (see _state_passing_fwd and _chunk_scan_fwd).
+    The chunk_indices tensor contains the index of the physical chunk for each logical chunk.
+    The chunk_offsets tensor contains the offset (AKA starting index) of the logical chunk in the physical chunk.
+
+    Example:
+    cu_seqlens = [0, 5, 10]
+    chunk_size = 8
+    -> chunk_indices = [0, 1, 0]
+    -> chunk_offsets = [0, 5, 0]
+
+    In this example, we have 2 sequences, each with 5 tokens. The physical chunk size is 8 tokens.
+    We have three logical chunks:
+    - the first logical chunk starts at token 0 in the first physical chunk and contains all 5 tokens from the first sequence
+    - the second logical chunk starts at token 5 in the first physical chunk and contains first 3 tokens from the second sequence
+    - the third logical chunk starts at token 0 in the second physical chunk and contains the remaining 2 tokens from the second sequence
+    """
+
+    total_seqlens = cu_seqlens[-1]
+    cu_seqlens = cu_seqlens[1:]  # remove prepended 0
+
+    # outputs will have length expansion of chunks that do not divide
+    # chunk_size
+    N = math.ceil(total_seqlens / chunk_size) + (cu_seqlens[:-1] % chunk_size
+                                                 > 0).sum()
+    chunk_indices = torch.arange(N, dtype=torch.int, device=cu_seqlens.device)
+    chunk_offsets = torch.zeros((N, ),
+                                dtype=torch.int,
+                                device=cu_seqlens.device)
+
+    p = 0  # num of insertions
+    for s, e in zip(cu_seqlens[:-1], cu_seqlens[1:]):
+
+        # if does not divide chunk_size, then there is one chunk insertion
+        p += (s % chunk_size > 0)
+
+        # get the dimensions
+        # - the + 1 for _e is to shift the boundary by one chunk
+        # - this shifting is not needed if chunk_size divides e
+        _s, _e = s // chunk_size + p, e // chunk_size + p + (e % chunk_size > 0)
+
+        # adjust inidces and offsets
+        chunk_indices[_s:_e] -= p
+        chunk_offsets[_s] = s % chunk_size
+
+    return chunk_indices, chunk_offsets
+
+
 class Mamba2Metadata:
 
-    def __init__(self, max_batch_size: int):
+    def __init__(self, max_batch_size: int, chunk_size: int):
         self.max_batch_size = max_batch_size
+        self.chunk_size = chunk_size
 
         # cumulative sequence lengths for prefill requests [batch_size+1]
         self.cu_seqlens = torch.zeros(max_batch_size + 1,
@@ -31,9 +99,18 @@ def __init__(self, max_batch_size: int):
         # sequence index for prefill requests [num_prefill_tokens] - specifies which request each token belongs to
         self.seq_idx: torch.Tensor = None
 
+        # helper tensors for chunked prefill
+        self.has_initial_states = torch.zeros(max_batch_size,
+                                              dtype=torch.bool,
+                                              device="cuda")
+        self.use_initial_states = False
+        self.chunk_indices: torch.Tensor = None
+        self.chunk_offsets: torch.Tensor = None
+
     def prepare(self, attn_metadata: AttentionMetadata):
         num_contexts = attn_metadata.num_contexts
         context_lens = attn_metadata.seq_lens_cuda[:num_contexts]
+        num_ctx_tokens = attn_metadata.num_ctx_tokens
         if num_contexts > 0:
             torch.cumsum(context_lens,
                          dim=0,
@@ -44,4 +121,17 @@ def prepare(self, attn_metadata: AttentionMetadata):
                              dtype=torch.int,
                              device=self.cu_seqlens.device),
                 repeats=context_lens,
-                output_size=self.cu_seqlens[num_contexts]).unsqueeze(0)
+                output_size=num_ctx_tokens).unsqueeze(0)
+
+            num_cached_tokens_per_seq = attn_metadata.kv_cache_params.num_cached_tokens_per_seq
+            self.has_initial_states[:num_contexts] = torch.tensor(
+                num_cached_tokens_per_seq[:num_contexts]) > 0
+            # precomputed bool to avoid host<->device syncs during forward pass
+            self.use_initial_states = torch.any(
+                self.has_initial_states[:num_contexts]).item()
+            if self.use_initial_states:
+                self.chunk_indices, self.chunk_offsets = cu_seqlens_to_chunk_indices_offsets(
+                    self.cu_seqlens[:num_contexts + 1], self.chunk_size)
+            else:
+                self.chunk_indices = None
+                self.chunk_offsets = None
diff --git a/tensorrt_llm/_torch/modules/mamba/mamba2_mixer.py b/tensorrt_llm/_torch/modules/mamba/mamba2_mixer.py
index 6ea096bb6a7..d5a3e3996a3 100644
--- a/tensorrt_llm/_torch/modules/mamba/mamba2_mixer.py
+++ b/tensorrt_llm/_torch/modules/mamba/mamba2_mixer.py
@@ -191,12 +191,15 @@ def forward(
 
             cu_seqlens = mamba_metadata.cu_seqlens[:num_prefills + 1]
             seq_idx = mamba_metadata.seq_idx
+            has_initial_states = mamba_metadata.has_initial_states[:
+                                                                   num_prefills]
 
             xbc_p = causal_conv1d_fn(xbc_p.transpose(0, 1),
                                      self.conv1d.weight,
                                      self.conv1d.bias,
                                      activation="silu",
                                      conv_states=conv_states,
+                                     has_initial_state=has_initial_states,
                                      query_start_loc=cu_seqlens,
                                      cache_indices=state_indices_p).transpose(
                                          0, 1)
@@ -216,6 +219,12 @@ def forward(
                             "b l (h p) -> b l h p",
                             h=self.tp_nheads)
 
+            initial_states = None
+            if mamba_metadata.use_initial_states:
+                initial_states = torch.where(
+                    has_initial_states[:, None, None, None],
+                    ssm_states[state_indices_p], 0)
+
             y, current_ssm_states = mamba_chunk_scan_combined(
                 x_p,
                 dt_p,
@@ -226,7 +235,9 @@ def forward(
                 D=self.D,
                 z=z_p,
                 dt_bias=self.dt_bias,
-                initial_states=None,
+                initial_states=initial_states,
+                chunk_indices=mamba_metadata.chunk_indices,
+                chunk_offsets=mamba_metadata.chunk_offsets,
                 dt_softplus=self.delta_softplus,
                 cu_seqlens=cu_seqlens,
                 seq_idx=seq_idx,
diff --git a/tensorrt_llm/_torch/modules/mamba/ssd_chunk_scan.py b/tensorrt_llm/_torch/modules/mamba/ssd_chunk_scan.py
index 58615ab9238..23b55d8811d 100644
--- a/tensorrt_llm/_torch/modules/mamba/ssd_chunk_scan.py
+++ b/tensorrt_llm/_torch/modules/mamba/ssd_chunk_scan.py
@@ -314,11 +314,12 @@ def _chunk_scan_fwd_kernel(
 
             # get the cs at the offset boundary
             # - c_off == 0 is a passthrough
+            # - We need dA_cs at the boundary, defined by c_off - no need
+            #   to increase pointer by pid_m (it is a constant offset,
+            #   i.e. the same for all blocks)
             dA_cs_m_boundary = tl.load(
-                dA_cumsum_ptr +
-                (pid_m * BLOCK_SIZE_M + c_off - 1) * stride_dA_cs_csize,
-                mask=(((pid_m * BLOCK_SIZE_M + c_off - 1) > -1)
-                      and ((pid_m * BLOCK_SIZE_M + c_off) < chunk_size)),
+                dA_cumsum_ptr + (c_off - 1) * stride_dA_cs_csize,
+                mask=(((c_off - 1) > -1) and (c_off < chunk_size)),
                 other=0.0).to(tl.float32)
 
     if HAS_SEQ_IDX:
diff --git a/tensorrt_llm/_torch/modules/mamba/ssd_combined.py b/tensorrt_llm/_torch/modules/mamba/ssd_combined.py
index 0a6f18bb63b..8edbe902bd8 100644
--- a/tensorrt_llm/_torch/modules/mamba/ssd_combined.py
+++ b/tensorrt_llm/_torch/modules/mamba/ssd_combined.py
@@ -110,21 +110,24 @@ def _mamba_chunk_scan_combined_fwd(
     # 3. Compute the inter-chunk SSM recurrence; produces correct SSM states at chunk boundaries
     # (middle term of factorization of off-diag blocks; A terms)
     # - for handling chunked prefill, this requires i) initial_states
-    #   ii) seq_idx and iii) is_cont_batched to be all specified.
+    #   ii) seq_idx iii) is_cont_batched and (iv) chunk_offsets to be all specified.
     # - When a new seq_idx is detected, we will stop passing the prev_state
     #   and switch accordingly to the init_state corresponding to the new seq_idx.
+    # - We will also make sure that the dA_cumsum is taken only from the start of the
+    #   sequence (hence we need the full dA_cumsum tensor and not just the values at chunk boundaries)
     # - this will ensure that states will be updated with the rightmost flushed seq_idx
     #   of the previous chunk. This implies that the first chunk of states is either 0
     #   or equal to init_states of the first example.
     states, final_states = _state_passing_fwd(
         rearrange(states, "... p n -> ... (p n)"),
-        dA_cumsum[:, :, :, -1],
+        dA_cumsum,
         initial_states=(rearrange(initial_states, "... p n -> ... (p n)")
                         if initial_states is not None else None),
         seq_idx=seq_idx,
         chunk_size=chunk_size,
         out_dtype=mamba_ssm_cache_dtype or C.dtype,
-        is_cont_batched=cu_seqlens is not None)
+        is_cont_batched=cu_seqlens is not None,
+        chunk_offsets=chunk_offsets)
     states, final_states = [
         rearrange(t, "... (p n) -> ... p n", n=dstate)
         for t in [states, final_states]
diff --git a/tensorrt_llm/_torch/modules/mamba/ssd_state_passing.py b/tensorrt_llm/_torch/modules/mamba/ssd_state_passing.py
index e1c4b61eaf8..f751d4cd5f5 100644
--- a/tensorrt_llm/_torch/modules/mamba/ssd_state_passing.py
+++ b/tensorrt_llm/_torch/modules/mamba/ssd_state_passing.py
@@ -41,6 +41,8 @@ def _state_passing_fwd_kernel(
     dA_cs_ptr,
     initstates_ptr,
     seq_idx_ptr,
+    chunk_offsets_ptr,
+    chunk_meta_num,
     # Matrix dimensions
     dim,
     nchunks,
@@ -61,6 +63,7 @@ def _state_passing_fwd_kernel(
     stride_dA_cs_batch,
     stride_dA_cs_chunk,
     stride_dA_cs_head,
+    stride_dA_cs_csize,
     stride_initstates_batch,
     stride_initstates_head,
     stride_initstates_dim,
@@ -76,7 +79,8 @@ def _state_passing_fwd_kernel(
     pid_h = tl.program_id(axis=2)
     pid_m = tl.program_id(axis=0)
     states_ptr += pid_b * stride_states_batch + pid_h * stride_states_head
-    dA_cs_ptr += pid_b * stride_dA_cs_batch + pid_h * stride_dA_cs_head
+    dA_cs_ptr += pid_b * stride_dA_cs_batch + pid_h * stride_dA_cs_head + (
+        chunk_size - 1) * stride_dA_cs_csize
     out_ptr += pid_b * stride_out_batch + pid_h * stride_out_head
     final_states_ptr += (pid_b * stride_final_states_batch +
                          pid_h * stride_final_states_head)
@@ -105,35 +109,63 @@ def _state_passing_fwd_kernel(
                          other=0.0).to(tl.float32)
     tl.store(out_ptrs, states, mask=offs_m < dim)
     out_ptrs += stride_out_chunk
-    seq_idx = 0
+    prev_seq_idx_chunk_end = 0
+    logical_chunk_idx = 0
     for c in range(nchunks):
         new_states = tl.load(states_ptrs, mask=offs_m < dim,
                              other=0.0).to(tl.float32)
         dA_cs = tl.load(dA_cs_ptr).to(tl.float32)
-        scale = tl.exp(dA_cs)
+        scale_mask = True
         if HAS_SEQ_IDX:
             # - the seq to pass forward is the one that is flushed to the right
             #   boundary.
-            # - that is given by seq_idx_new below.
-            seq_idx_new = tl.load(seq_idx_ptr +
-                                  (min((c + 1) * chunk_size, seqlen) - 1) *
-                                  stride_seq_idx_seqlen)
+            # - that is given by seq_idx_chunk_end below: the sequence index at the end of the chunk.
+            seq_idx_chunk_end = tl.load(seq_idx_ptr + (min(
+                (c + 1) * chunk_size, seqlen) - 1) * stride_seq_idx_seqlen)
             if HAS_INITSTATES:
-                if IS_CONT_BATCHED and seq_idx != seq_idx_new:
+                if IS_CONT_BATCHED and prev_seq_idx_chunk_end != seq_idx_chunk_end:
                     # this means in the current chunk the rightmost flushed seq
                     # has changed.
                     # - so we do not propagate the state from previous chunk
                     # - but rather we load that sequence's init state
-                    initstates_ptrs = initstates_ptr + seq_idx_new * stride_initstates_batch
+                    initstates_ptrs = initstates_ptr + seq_idx_chunk_end * stride_initstates_batch
 
                     # - update state with seq_idx_new's init state
                     states = tl.load(initstates_ptrs,
                                      mask=offs_m < dim,
                                      other=0.0).to(tl.float32)
+
+                    # - we need to consider the cumsum only of the last sequence in the chunk
+                    # - find its starting position (given by c_off of the logical chunk index)
+                    # - and subtract the cumsum just before that position from the total cumsum
+                    # - first, update the logical chunk index (add the number of sequences in the current physical chunk):
+                    # sequence index at the start of the current chunk
+                    seq_idx_chunk_start = tl.load(seq_idx_ptr +
+                                                  min(c * chunk_size, seqlen) *
+                                                  stride_seq_idx_seqlen)
+                    logical_chunk_idx += (seq_idx_chunk_end -
+                                          seq_idx_chunk_start)
+                    # - load the chunk offset:
+                    c_off = tl.load(chunk_offsets_ptr + logical_chunk_idx,
+                                    mask=logical_chunk_idx < chunk_meta_num,
+                                    other=0)
+                    # - if offset is 0, then the sequence starts at the beginning of the chunk, and we don't need to subtract anything
+                    if c_off > 0:
+                        # - dA_cs_ptr currently points to the cumsum at the end of the chunk - subtract the chunk size and add the offset
+                        dA_cs_boundary = tl.load(
+                            dA_cs_ptr - (chunk_size - 1) * stride_dA_cs_csize +
+                            (c_off - 1) * stride_dA_cs_csize,
+                            mask=(c_off - 1) > -1 and c_off < chunk_size,
+                            other=0.0)
+                        dA_cs -= dA_cs_boundary
+
+                # - increment logical chunk index for every physical chunk
+                logical_chunk_idx += 1
             else:
-                scale = tl.where(seq_idx_new == seq_idx, scale, 0.0)
+                scale_mask = seq_idx_chunk_end == prev_seq_idx_chunk_end
+            prev_seq_idx_chunk_end = seq_idx_chunk_end
 
-            seq_idx = seq_idx_new
+        scale = tl.where(scale_mask, tl.exp(dA_cs), 0.0)
         states = scale * states + new_states
         if c < nchunks - 1:
             tl.store(out_ptrs, states, mask=offs_m < dim)
@@ -146,28 +178,36 @@ def _state_passing_fwd_kernel(
 
 def _state_passing_fwd(
     states,
-    dA_chunk_cumsum,
+    dA_cumsum,
     initial_states=None,
     seq_idx=None,
     chunk_size=None,
     out_dtype=None,
     is_cont_batched=False,
+    chunk_offsets=None,
 ):
     batch, nchunks, nheads, dim = states.shape
-    assert dA_chunk_cumsum.shape == (batch, nheads, nchunks)
+    if chunk_size is None:
+        chunk_size = dA_cumsum.shape[-1]
+    else:
+        assert chunk_size == dA_cumsum.shape[-1]
+    assert dA_cumsum.shape == (batch, nheads, nchunks, chunk_size)
     if initial_states is not None:
         if is_cont_batched:
             # - if cu_seqlens is provided, then the initial states
             #   are used for continuous batching. In which case we
             #   require seq_idx to be provided
-            assert seq_idx is not None, ""
+            assert seq_idx is not None, "seq_idx must be provided for continuous batching"
+            # - we also need chunk_offsets to be provided, to account
+            #   for computation of dA_cumsum from the start of the
+            #   sequence
+            assert chunk_offsets is not None, "chunk_offsets must be provided for continuous batching"
         else:
             # - this is the regular batching case, where initial
             #   states are used are for each example of the batch.
             assert initial_states.shape == (batch, nheads, dim)
 
     if seq_idx is not None:
-        assert chunk_size is not None
         seqlen = seq_idx.shape[-1]
         assert seq_idx.shape == (batch, seqlen)
     out_dtype = states.dtype if out_dtype is None else out_dtype
@@ -183,13 +223,15 @@ def _state_passing_fwd(
             states,
             out,
             final_states,
-            dA_chunk_cumsum,
+            dA_cumsum,
             initial_states,
             seq_idx,
+            chunk_offsets,
+            len(chunk_offsets) if chunk_offsets is not None else 0,
             dim,
             nchunks,
             seqlen if seq_idx is not None else 0,
-            chunk_size if seq_idx is not None else 0,
+            chunk_size,
             states.stride(0),
             states.stride(1),
             states.stride(2),
@@ -201,9 +243,10 @@ def _state_passing_fwd(
             final_states.stride(0),
             final_states.stride(1),
             final_states.stride(2),
-            dA_chunk_cumsum.stride(0),
-            dA_chunk_cumsum.stride(2),
-            dA_chunk_cumsum.stride(1),
+            dA_cumsum.stride(0),
+            dA_cumsum.stride(2),
+            dA_cumsum.stride(1),
+            dA_cumsum.stride(3),
             *((
                 initial_states.stride(0),
                 initial_states.stride(1),
diff --git a/tests/unittest/_torch/modeling/test_modeling_nemotron_h.py b/tests/unittest/_torch/modeling/test_modeling_nemotron_h.py
index 58c854931e9..3e727e654bf 100644
--- a/tests/unittest/_torch/modeling/test_modeling_nemotron_h.py
+++ b/tests/unittest/_torch/modeling/test_modeling_nemotron_h.py
@@ -33,7 +33,9 @@ def extract_decode_logprobs(result: RequestOutput,
 def create_nemotron_h_llm(use_cuda_graph,
                           disable_overlap_scheduler,
                           max_batch_size,
-                          mamba_ssm_cache_dtype=None):
+                          mamba_ssm_cache_dtype=None,
+                          enable_chunked_prefill=False,
+                          max_num_tokens=None):
     """Create LLM with specific overlap scheduler setting"""
     model_dir = f"{llm_models_root(check=True)}/Nemotron-H-8B-Base-8K"
     return LLM(
@@ -47,6 +49,8 @@ def create_nemotron_h_llm(use_cuda_graph,
             mamba_ssm_cache_dtype="auto"
             if mamba_ssm_cache_dtype is None else mamba_ssm_cache_dtype),
         sampler_type="TRTLLMSampler",
+        enable_chunked_prefill=enable_chunked_prefill,
+        max_num_tokens=max_num_tokens,
     )
 
 
@@ -336,3 +340,62 @@ def test_nemotron_h_cuda_graph_overlap_scheduler():
             msg=lambda x:
             f"Prompt {i}: with/without overlap scheduler (with CG) logprobs for all selected tokens {x}"
         )
+
+
+def test_nemotron_h_chunked_prefill():
+    # Long prompts (~100 tokens) to make sure chunked prefill is enabled
+    # (At the time of development, tokens_per_block isn't configurable from the LLM API,
+    # and max_tokens (i.e. chunk size) needs to be a multiple of tokens_per_block)
+    prompts = [
+        "Artificial Intelligence in Healthcare: Artificial intelligence (AI) is transforming healthcare by improving diagnostics, treatment plans, and patient care. AI algorithms can analyze medical images with high accuracy, assist in early disease detection, and personalize treatment plans based on patient data. Additionally, AI-powered chatbots and virtual assistants provide support to patients, enhancing accessibility and efficiency in healthcare services. As AI technology continues to advance, its integration into healthcare systems promises to deliver better outcomes and reduce costs. With continuous research and development, AI in healthcare is poised to",
+        "The Role of Cloud Computing: Cloud computing has revolutionized the way businesses operate by providing scalable, on-demand access to computing resources. This technology allows organizations to store and process data remotely, reducing the need for physical infrastructure and enabling greater flexibility. Cloud services facilitate collaboration, enhance data security, and support the deployment of innovative applications. As businesses increasingly adopt cloud solutions, they benefit from improved efficiency, cost savings, and the ability to rapidly adapt to changing market conditions. Companies leveraging cloud computing are better positioned to",
+        "Advancements in Renewable Energy: Renewable energy technologies, such as solar and wind power, are crucial for addressing climate change and reducing dependence on fossil fuels. Advances in energy storage, grid integration, and efficiency are making renewable energy sources more viable and cost-effective. Innovations in materials science and engineering are also driving the development of next-generation renewable technologies. As global efforts to combat climate change intensify, the continued advancement of renewable energy will play a pivotal role in achieving a sustainable future. Governments and industries are increasingly investing in",
+        "The Importance of Cybersecurity: In today's digital age, cybersecurity has become essential to protect sensitive information and maintain the integrity of systems. With the rise of cyber threats such as hacking, phishing, and ransomware, organizations must implement robust security measures to safeguard their data. Cybersecurity involves a combination of technologies, processes, and practices designed to defend against unauthorized access and attacks. By staying vigilant and updating security protocols, businesses can mitigate risks and ensure the safety of their digital assets. Proactive cybersecurity strategies are crucial in",
+        "The Impact of Artificial Intelligence on Education: Artificial intelligence is reshaping education by providing personalized learning experiences and automating administrative tasks. AI-driven educational tools can adapt to individual student needs, offering tailored feedback and resources to enhance learning outcomes. Additionally, AI can streamline administrative processes, allowing educators to focus more on teaching and student engagement. As AI continues to evolve, its role in education will expand, offering new opportunities for innovation and efficiency. The integration of AI in classrooms promises to revolutionize how students learn and how educators manage their",
+    ]
+    sampling_config = SamplingParams(max_tokens=10,
+                                     temperature=0.0,
+                                     return_context_logits=True,
+                                     return_generation_logits=True)
+
+    with create_nemotron_h_llm(use_cuda_graph=False,
+                               disable_overlap_scheduler=True,
+                               max_batch_size=16) as llm:
+        outputs = llm.generate(prompts,
+                               sampling_params=sampling_config,
+                               use_tqdm=True)
+
+    with create_nemotron_h_llm(use_cuda_graph=False,
+                               disable_overlap_scheduler=True,
+                               max_batch_size=16,
+                               enable_chunked_prefill=True,
+                               max_num_tokens=64) as llm:
+        chunked_prefill_outputs = llm.generate(prompts,
+                                               sampling_params=sampling_config,
+                                               use_tqdm=True)
+
+    for i, (output, chunked_prefill_output) in enumerate(
+            zip(outputs, chunked_prefill_outputs)):
+        assert output.outputs[0].text == chunked_prefill_output.outputs[0].text
+
+        # assert same prefill logprobs. Same atol as diff between mcore and initial impl
+        prefill_logprobs = extract_prefill_logprobs(output)
+        chunked_prefill_logprobs = extract_prefill_logprobs(
+            chunked_prefill_output)
+        torch.testing.assert_close(
+            prefill_logprobs,
+            chunked_prefill_logprobs,
+            atol=0.3,
+            rtol=0.05,
+            msg=lambda x: f"Prompt {i} prefill logprobs {x}")
+
+        # Decode logprobs shouldn't be affected by chunked prefill - tolerance like batching tolerance
+        decode_logprobs = extract_decode_logprobs(output)
+        chunked_decode_logprobs = extract_decode_logprobs(
+            chunked_prefill_output)
+        torch.testing.assert_close(
+            decode_logprobs,
+            chunked_decode_logprobs,
+            atol=0.2,
+            rtol=0.05,
+            msg=lambda x: f"Prompt {i} decode logprobs {x}")
diff --git a/tests/unittest/_torch/thop/test_causal_conv1d_op.py b/tests/unittest/_torch/thop/test_causal_conv1d_op.py
index c5e42e2618c..54793854c9a 100644
--- a/tests/unittest/_torch/thop/test_causal_conv1d_op.py
+++ b/tests/unittest/_torch/thop/test_causal_conv1d_op.py
@@ -26,11 +26,15 @@
 
 
 @pytest.mark.parametrize(
-    "dim, dconv, req_type, dtype, batch_size, max_seq_len, remove_padding, apply_silu, paged_cache",
+    "dim, dconv, req_type, dtype, batch_size, max_seq_len, remove_padding, apply_silu, paged_cache, use_initial_state",
     list(
         product([2048], [4], ['context', 'generation'],
                 ['float16', 'float32', 'bfloat16'], [5], [16], [False, True],
-                [False, True], [False, True])) +
+                [False, True], [False, True], [False])) +
+    # test with initial state
+    list(
+        product([2048], [4], ['context'], ['bfloat16'], [5], [16],
+                [False, True], [False], [False, True], [True])) +
     # long sequence tests to cover the int overflow issue
     list(
         map(
@@ -42,10 +46,11 @@
                        "The long sequence test needs at least 33GB memory, skipping"
                        )),
             product([5376], [4], ['context'], ['float16', 'bfloat16'], [2],
-                    [131072], [False, True], [False, True], [False]))))
+                    [131072], [False, True], [False, True], [False], [False]))))
 @pytest.mark.high_cuda_memory
 def test_causal_conv1d(dim, dconv, req_type, dtype, batch_size, max_seq_len,
-                       remove_padding, apply_silu, paged_cache):
+                       remove_padding, apply_silu, paged_cache,
+                       use_initial_state):
     device = "cuda"
     seq_len = max_seq_len if req_type == "context" else 1
     mean = 0.0
@@ -68,7 +73,7 @@ def test_causal_conv1d(dim, dconv, req_type, dtype, batch_size, max_seq_len,
         host_context_lengths = torch.ones(
             (batch_size, ), dtype=torch.int32) * seq_len
 
-    if req_type == "context":
+    if req_type == "context" and not use_initial_state:
         conv_state = torch.zeros([batch_size, dim, dconv - 1],
                                  dtype=torch_dtype,
                                  device=device)
@@ -111,7 +116,8 @@ def test_causal_conv1d(dim, dconv, req_type, dtype, batch_size, max_seq_len,
     conv_weight_input = conv_weight.squeeze(1).contiguous()
 
     if req_type == "context":
-        has_initial_state = None
+        has_initial_state = None if not use_initial_state else torch.ones(
+            batch_size, device=device, dtype=torch.bool)
 
         torch.ops.trtllm.causal_conv1d_fwd(
             x_in_out,
diff --git a/tests/unittest/_torch/thop/test_mamba2_chunk_ss_update.py b/tests/unittest/_torch/thop/test_mamba2_chunk_ss_update.py
index ea3c2c2c3cd..e26fe007763 100644
--- a/tests/unittest/_torch/thop/test_mamba2_chunk_ss_update.py
+++ b/tests/unittest/_torch/thop/test_mamba2_chunk_ss_update.py
@@ -21,6 +21,8 @@
 from utils.torch_ref import (selective_state_update_ref,
                              ssd_chunk_scan_combined_ref)
 
+from tensorrt_llm._torch.modules.mamba.mamba2_metadata import \
+    cu_seqlens_to_chunk_indices_offsets
 from tensorrt_llm._torch.modules.mamba.selective_state_update import \
     selective_state_update
 from tensorrt_llm._torch.modules.mamba.ssd_combined import \
@@ -30,51 +32,58 @@
 
 
 @pytest.mark.parametrize(
-    "dim, headdim, ngroups, dstate, req_type, dtype, batch_size, max_seq_len, has_z, remove_padding, paged_cache",
+    "dim, headdim, ngroups, dstate, req_type, dtype, batch_size, max_seq_len, has_z, remove_padding, paged_cache, use_initial_states",
     # dim parametrization
     list(
         product([1024, 2048, 5120], [64], [1], [128], ['context', 'generation'],
-                ['bfloat16'], [3], [16], [False], [True], [False])) +
+                ['bfloat16'], [3], [16], [False], [True], [False], [False])) +
     # headdim parametrization
     list(
         product([2048], [32, 64, 128, 256], [1], [128],
                 ['context', 'generation'], ['bfloat16'], [3], [16], [False],
-                [True], [False])) +
+                [True], [False], [False])) +
     # ngroups parametrization
     list(
         product([2048], [64], [1, 4], [128], ['context', 'generation'],
-                ['bfloat16'], [3], [16], [False], [True], [False])) +
+                ['bfloat16'], [3], [16], [False], [True], [False], [False])) +
     # dstate parametrization
     list(
         product([2048], [64], [1], [64, 96, 128, 256],
                 ['context', 'generation'], ['bfloat16'], [3], [16], [False],
-                [True], [False])) +
+                [True], [False], [False])) +
     # dtype parametrization
     list(
         product([2048], [64], [1], [128], ['context', 'generation'],
                 ['float16', 'bfloat16', 'float32'], [3], [16], [False], [True],
-                [False])) +
+                [False], [False])) +
     # batch_size parametrization
     list(
         product([2048], [64], [1], [128], ['context', 'generation'],
-                ['bfloat16'], [1, 2, 8, 16], [16], [False], [True], [False])) +
+                ['bfloat16'], [1, 2, 8, 16], [16], [False], [True], [False],
+                [False])) +
     # max_seq_len parametrization
     list(
         product([2048], [64], [1], [128], ['context', 'generation'],
                 ['bfloat16'], [3], [32, 64, 256, 2048, 16384], [False], [True],
-                [False])) +
+                [False], [False])) +
     # has_z parametrization
     list(
         product([2048], [64], [1], [128], ['context', 'generation'],
-                ['bfloat16'], [3], [32], [True, False], [True], [False])) +
+                ['bfloat16'], [3], [32], [True, False], [True], [False],
+                [False])) +
     # remove_padding parametrization
     list(
         product([2048], [64], [1], [128], ['context', 'generation'],
-                ['bfloat16'], [3], [32], [False], [True, False], [False])) +
+                ['bfloat16'], [3], [32], [False], [True, False], [False],
+                [False])) +
     # paged_cache parametrization (relevant for generation only)
     list(
         product([2048], [64], [1], [128], ['generation'], ['bfloat16'], [3],
-                [32], [False], [False], [True, False])) +
+                [32], [False], [False], [True, False], [False])) +
+    # use_initial_states parametrization (relevant for context only and remove_padding=True)
+    list(
+        product([2048], [64], [1], [128], ['context'], ['bfloat16'], [3], [32],
+                [False], [True], [False], [True, False])) +
     # long sequence test to cover the int overflow issue
     [
         pytest.param(
@@ -89,6 +98,7 @@
             False,
             False,
             False,
+            False,
             marks=pytest.mark.skipif(
                 get_total_gpu_memory(0) < 68 * 1024**3,
                 reason=
@@ -97,7 +107,8 @@
 def test_mamba2_chunk_scan_selective_state_update(dim, headdim, ngroups, dstate,
                                                   req_type, dtype, batch_size,
                                                   max_seq_len, has_z,
-                                                  remove_padding, paged_cache):
+                                                  remove_padding, paged_cache,
+                                                  use_initial_states):
     # configs
     device = "cuda"
     seq_len = max_seq_len if req_type == 'context' else 1
@@ -168,6 +179,8 @@ def test_mamba2_chunk_scan_selective_state_update(dim, headdim, ngroups, dstate,
     D = torch.randn(nheads, device=device)
     if has_z:
         z = torch.randn_like(x)
+    if use_initial_states:
+        initial_states = state.clone()
 
     if req_type == 'generation':
         # remove the seqlen dimension
@@ -193,8 +206,13 @@ def test_mamba2_chunk_scan_selective_state_update(dim, headdim, ngroups, dstate,
     C_ref = C.detach().clone()
     D_ref = D.detach().clone()
     z_ref = z.detach().clone() if has_z else None
+    initial_states_ref = state_ref.clone() if use_initial_states else None
 
     if req_type == "context":
+        if use_initial_states:
+            assert remove_padding
+            chunk_indices, chunk_offsets = cu_seqlens_to_chunk_indices_offsets(
+                cu_seqlens, chunk_size)
         out, ssm_state = mamba_chunk_scan_combined(
             x,
             dt,
@@ -205,6 +223,9 @@ def test_mamba2_chunk_scan_selective_state_update(dim, headdim, ngroups, dstate,
             D=D,
             z=z if has_z else None,
             dt_bias=dt_bias,
+            initial_states=initial_states if use_initial_states else None,
+            chunk_indices=chunk_indices if use_initial_states else None,
+            chunk_offsets=chunk_offsets if use_initial_states else None,
             seq_idx=seq_idx if remove_padding else None,
             cu_seqlens=cu_seqlens if remove_padding else None,
             dt_softplus=delta_softplus,
@@ -273,7 +294,10 @@ def test_mamba2_chunk_scan_selective_state_update(dim, headdim, ngroups, dstate,
                     D=D_ref,
                     z=z_ref[:, start:end, ...] if has_z else None,
                     dt_bias=dt_bias_ref,
-                    dt_softplus=delta_softplus)
+                    dt_softplus=delta_softplus,
+                    initial_states=initial_states_ref[i:i + 1, ...]
+                    if use_initial_states else None,
+                )
                 out_ref[0, start:end, ...] = part_out_ref.squeeze(0)
                 state_ref[i, ...] = part_state_ref.squeeze(0)
         elif long_context:
@@ -295,7 +319,10 @@ def test_mamba2_chunk_scan_selective_state_update(dim, headdim, ngroups, dstate,
                     D=D_ref,
                     z=z_ref[i:i + 1, ...] if has_z else None,
                     dt_bias=dt_bias_ref,
-                    dt_softplus=delta_softplus)
+                    dt_softplus=delta_softplus,
+                    initial_states=initial_states_ref[i:i + 1, ...]
+                    if use_initial_states else None,
+                )
                 out_ref[i, ...] = part_out_ref.squeeze(0)
                 state_ref[i, ...] = part_state_ref.squeeze(0)
         else:
@@ -309,7 +336,10 @@ def test_mamba2_chunk_scan_selective_state_update(dim, headdim, ngroups, dstate,
                 D=D_ref,
                 z=z_ref if has_z else None,
                 dt_bias=dt_bias_ref,
-                dt_softplus=delta_softplus)
+                dt_softplus=delta_softplus,
+                initial_states=initial_states_ref
+                if use_initial_states else None,
+            )
     elif req_type == 'generation':
         out_ref = selective_state_update_ref(state_ref,
                                              x_ref,
@@ -330,3 +360,229 @@ def test_mamba2_chunk_scan_selective_state_update(dim, headdim, ngroups, dstate,
                                state_ref,
                                rtol=1e-2,
                                atol=atol[dtype])
+
+
+@pytest.mark.parametrize("mamba_chunk_size", [8, 256])
+@pytest.mark.parametrize("seqlens", [
+    (16, 2, 8, 13),
+    (270, 88, 212, 203),
+    (16, 20),
+])
+def test_mamba2_chunk_scan_combined_prefill_chunking(mamba_chunk_size, seqlens):
+    dim = 1024
+    headdim = 64
+    ngroups = 1
+    dstate = 128
+
+    # test in high precision to distinguish between numeric instabilities and actual errors
+    dtype = 'float32'
+
+    num_sequences = len(seqlens)
+    has_z = True
+
+    device = "cuda"
+    nheads = dim // headdim
+    delta_softplus = True
+    mean = 0.0
+    std_dev = 0.1
+
+    torch_dtype = str_dtype_to_torch(dtype)
+
+    seqlens = torch.tensor(seqlens, dtype=torch.int32, device=device)
+    cu_seqlens = torch.cat([
+        torch.tensor([0], dtype=torch.int32, device=device),
+        torch.cumsum(seqlens, dim=0, dtype=torch.int32)
+    ],
+                           dim=0)
+    seq_idx = torch.repeat_interleave(torch.arange(len(seqlens),
+                                                   dtype=torch.int32,
+                                                   device=device),
+                                      seqlens,
+                                      output_size=cu_seqlens[-1]).unsqueeze(0)
+    input_batch_size = 1
+    input_seq_len = cu_seqlens[-1]
+
+    # test data
+    torch.random.manual_seed(0)
+    x = torch.empty(input_batch_size,
+                    input_seq_len,
+                    nheads,
+                    headdim,
+                    device=device,
+                    dtype=torch_dtype)
+    x.normal_(mean, std_dev)
+    dt = torch.randn(input_batch_size,
+                     input_seq_len,
+                     nheads,
+                     device=device,
+                     dtype=torch_dtype)
+    dt_bias = torch.rand(nheads, device=device) - 4.0
+    A = -torch.rand(nheads, device=device) - 1.0
+    B = torch.randn(input_batch_size,
+                    input_seq_len,
+                    ngroups,
+                    dstate,
+                    device=device,
+                    dtype=torch_dtype)
+    C = torch.randn_like(B)
+    D = torch.randn(nheads, device=device)
+
+    z = torch.randn_like(x)
+
+    ## full seqlen computation
+    out_ref, state_ref = mamba_chunk_scan_combined(
+        x,
+        dt,
+        A,
+        B,
+        C,
+        chunk_size=mamba_chunk_size,
+        D=D,
+        z=z if has_z else None,
+        dt_bias=dt_bias,
+        seq_idx=seq_idx,
+        cu_seqlens=cu_seqlens,
+        dt_softplus=delta_softplus,
+        return_final_states=False,
+        return_varlen_states=True,
+    )
+
+    ## chunked seqlen computation
+    # first chunk
+    chunked_seqlens = seqlens // 2
+    chunked_cu_seqlens = torch.cat([
+        torch.tensor([0], dtype=torch.int32, device=device),
+        torch.cumsum(chunked_seqlens, dim=0, dtype=torch.int32)
+    ],
+                                   dim=0)
+    chunked_seq_idx = torch.repeat_interleave(
+        torch.arange(len(chunked_seqlens), dtype=torch.int32, device=device),
+        chunked_seqlens,
+        output_size=chunked_cu_seqlens[-1]).unsqueeze(0)
+    chunked_input_seq_len = chunked_cu_seqlens[-1]
+    x_chunked = torch.zeros_like(x)[:, :chunked_input_seq_len, ...]
+    dt_chunked = torch.zeros_like(dt)[:, :chunked_input_seq_len, ...]
+    B_chunked = torch.zeros_like(B)[:, :chunked_input_seq_len, ...]
+    C_chunked = torch.zeros_like(C)[:, :chunked_input_seq_len, ...]
+    z_chunked = torch.zeros_like(z)[:, :chunked_input_seq_len, ...]
+    for i in range(num_sequences):
+        # yapf: disable
+        chunk_f = lambda x, i: x[:, cu_seqlens[i]:cu_seqlens[i] + chunked_seqlens[i], ...]
+
+        x_chunked[:, chunked_cu_seqlens[i]:chunked_cu_seqlens[i+1], ...] = chunk_f(x, i)
+        dt_chunked[:, chunked_cu_seqlens[i]:chunked_cu_seqlens[i+1], ...] = chunk_f(dt, i)
+        B_chunked[:, chunked_cu_seqlens[i]:chunked_cu_seqlens[i+1], ...] = chunk_f(B, i)
+        C_chunked[:, chunked_cu_seqlens[i]:chunked_cu_seqlens[i+1], ...] = chunk_f(C, i)
+        z_chunked[:, chunked_cu_seqlens[i]:chunked_cu_seqlens[i+1], ...] = chunk_f(z, i)
+        # yapf: enable
+
+    partial_out, partial_state = mamba_chunk_scan_combined(
+        x_chunked,
+        dt_chunked,
+        A,
+        B_chunked,
+        C_chunked,
+        chunk_size=mamba_chunk_size,
+        D=D,
+        z=z_chunked,
+        dt_bias=dt_bias,
+        seq_idx=chunked_seq_idx,
+        cu_seqlens=chunked_cu_seqlens,
+        dt_softplus=delta_softplus,
+        return_final_states=False,
+        return_varlen_states=True,
+    )
+
+    # remaining chunk
+    remaining_chunked_seqlens = seqlens - chunked_seqlens
+    remaining_chunked_cu_seqlens = torch.cat([
+        torch.tensor([0], dtype=torch.int32, device=device),
+        torch.cumsum(remaining_chunked_seqlens, dim=0, dtype=torch.int32)
+    ],
+                                             dim=0)
+    remaining_chunked_seq_idx = torch.repeat_interleave(
+        torch.arange(len(remaining_chunked_seqlens),
+                     dtype=torch.int32,
+                     device=device),
+        remaining_chunked_seqlens,
+        output_size=remaining_chunked_cu_seqlens[-1]).unsqueeze(0)
+    remaining_chunked_input_seq_len = remaining_chunked_cu_seqlens[-1]
+    # yapf: disable
+    remaining_x_chunked = torch.zeros_like(x)[:, :remaining_chunked_input_seq_len, ...]
+    remaining_dt_chunked = torch.zeros_like(dt)[:, :remaining_chunked_input_seq_len, ...]
+    remaining_B_chunked = torch.zeros_like(B)[:, :remaining_chunked_input_seq_len, ...]
+    remaining_C_chunked = torch.zeros_like(C)[:, :remaining_chunked_input_seq_len, ...]
+    remaining_z_chunked = torch.zeros_like(z)[:, :remaining_chunked_input_seq_len, ...]
+    for i in range(num_sequences):
+        remaining_chunk_f = lambda x, i: x[:, cu_seqlens[i] + chunked_seqlens[i]:cu_seqlens[i+1], ...]
+
+        remaining_x_chunked[:, remaining_chunked_cu_seqlens[i]:remaining_chunked_cu_seqlens[i+1], ...] = remaining_chunk_f(x, i)
+        remaining_dt_chunked[:, remaining_chunked_cu_seqlens[i]:remaining_chunked_cu_seqlens[i+1], ...] = remaining_chunk_f(dt, i)
+        remaining_B_chunked[:, remaining_chunked_cu_seqlens[i]:remaining_chunked_cu_seqlens[i+1], ...] = remaining_chunk_f(B, i)
+        remaining_C_chunked[:, remaining_chunked_cu_seqlens[i]:remaining_chunked_cu_seqlens[i+1], ...] = remaining_chunk_f(C, i)
+        remaining_z_chunked[:, remaining_chunked_cu_seqlens[i]:remaining_chunked_cu_seqlens[i+1], ...] = remaining_chunk_f(z, i)
+
+    # assert input chunking is correct
+    concat_chunk_f = lambda pt1, pt2, i: torch.cat([
+        pt1[:,chunked_cu_seqlens[i]:chunked_cu_seqlens[i+1],...],
+        pt2[:,remaining_chunked_cu_seqlens[i]:remaining_chunked_cu_seqlens[i+1],...],
+        ],
+        dim=1)
+    concat_batch_f = lambda pt1, pt2: torch.cat([concat_chunk_f(pt1, pt2, i) for i in range(num_sequences)], dim=1)
+
+    assert concat_batch_f(x_chunked, remaining_x_chunked).equal(x)
+    assert concat_batch_f(dt_chunked, remaining_dt_chunked).equal(dt)
+    assert concat_batch_f(B_chunked, remaining_B_chunked).equal(B)
+    assert concat_batch_f(C_chunked, remaining_C_chunked).equal(C)
+    assert concat_batch_f(z_chunked, remaining_z_chunked).equal(z)
+    # yapf: enable
+
+    chunk_indices, chunk_offsets = cu_seqlens_to_chunk_indices_offsets(
+        remaining_chunked_cu_seqlens, mamba_chunk_size)
+
+    out_chunked, state_chunked = mamba_chunk_scan_combined(
+        remaining_x_chunked,
+        remaining_dt_chunked,
+        A,
+        remaining_B_chunked,
+        remaining_C_chunked,
+        chunk_size=mamba_chunk_size,
+        D=D,
+        z=remaining_z_chunked,
+        dt_bias=dt_bias,
+        initial_states=partial_state,
+        chunk_indices=chunk_indices,
+        chunk_offsets=chunk_offsets,
+        seq_idx=remaining_chunked_seq_idx,
+        cu_seqlens=remaining_chunked_cu_seqlens,
+        dt_softplus=delta_softplus,
+        return_final_states=False,
+        return_varlen_states=True,
+    )
+    out = concat_batch_f(partial_out, out_chunked)
+
+    # kernel chunked is same as kernel overall
+    # tight tolerance to find subtle correctness issues
+    rtol = 1e-2
+    atol = 2e-3
+    for i in range(num_sequences):
+        out_seq = out[:, cu_seqlens[i]:cu_seqlens[i + 1], ...]
+        out_seq_ref = out_ref[:, cu_seqlens[i]:cu_seqlens[i + 1], ...]
+        torch.testing.assert_close(out_seq[:, :chunked_seqlens[i], ...],
+                                   out_seq_ref[:, :chunked_seqlens[i], ...],
+                                   rtol=rtol,
+                                   atol=atol,
+                                   msg=lambda x: f"seq{i} output part1 " + x)
+        torch.testing.assert_close(out_seq[:, chunked_seqlens[i]:, ...],
+                                   out_seq_ref[:, chunked_seqlens[i]:, ...],
+                                   rtol=rtol,
+                                   atol=atol,
+                                   msg=lambda x: f"seq{i} output part2 " + x)
+
+        state_seq = state_chunked[i]
+        state_seq_ref = state_ref[i]
+        torch.testing.assert_close(state_seq,
+                                   state_seq_ref,
+                                   rtol=rtol,
+                                   atol=atol,
+                                   msg=lambda x: f"seq{i} state " + x)
diff --git a/tests/unittest/utils/torch_ref.py b/tests/unittest/utils/torch_ref.py
index 6e666bed264..d8a6b258c57 100644
--- a/tests/unittest/utils/torch_ref.py
+++ b/tests/unittest/utils/torch_ref.py
@@ -480,7 +480,8 @@ def ssd_chunk_scan_combined_ref(x,
                                 D=None,
                                 z=None,
                                 dt_bias=None,
-                                dt_softplus=False):
+                                dt_softplus=False,
+                                initial_states=None):
     """
     Argument:
         x: (batch, seqlen, nheads, headdim)
@@ -492,6 +493,7 @@ def ssd_chunk_scan_combined_ref(x,
         D: (nheads, headdim) or (nheads,)
         z: (batch, seqlen, nheads, headdim)
         dt_bias: (nheads,)
+        initial_states: (batch, nheads, dstate, headdim)
     Return:
         out: (batch, seqlen, nheads, headdim)
         final_states: (batch, nheads, dstate, headdim)
@@ -520,8 +522,16 @@ def ssd_chunk_scan_combined_ref(x,
         states = states.to(torch.float32)
     # 2. Pass the state to all the chunks by weighted cumsum.
     # state_passing_ref is much less numerically stable
+    # align initial_states shape with states shape
+    initial_states = rearrange(
+        initial_states,
+        "... n p -> ... p n") if initial_states is not None else None
     states, final_states = state_passing_ref(
-        rearrange(states, "... p n -> ... (p n)"), dA_cumsum[:, :, :, -1])
+        rearrange(states, "... p n -> ... (p n)"),
+        dA_cumsum[:, :, :, -1],
+        rearrange(initial_states, "... p n-> ... (p n)")
+        if initial_states is not None else None,
+    )
     states, final_states = [
         rearrange(t, "... (p n) -> ... p n", n=dstate)
         for t in [states, final_states]

From 37543a9ad72020bda12117e709ac7b59aeaeea41 Mon Sep 17 00:00:00 2001
From: Robin Kobus <19427718+Funatiq@users.noreply.github.com>
Date: Fri, 22 Aug 2025 18:44:17 +0200
Subject: [PATCH 44/48] [None][refactor] Simplify decoder state initialization
 for speculative decoding (#6869)

Signed-off-by: Robin Kobus <19427718+Funatiq@users.noreply.github.com>
---
 .../batch_manager/createNewDecoderRequests.h  |  32 --
 .../tensorrt_llm/batch_manager/llmRequest.h   |   2 +-
 .../tensorrt_llm/runtime/decodingInput.h      |   2 +
 cpp/include/tensorrt_llm/runtime/request.h    |  54 ---
 .../createNewDecoderRequests.cpp              | 397 +++++++++---------
 .../batch_manager/utils/logitsThread.cpp      |  15 +-
 .../batch_manager/utils/logitsThread.h        |   6 +-
 cpp/tensorrt_llm/runtime/decoderState.cpp     |  20 +-
 8 files changed, 223 insertions(+), 305 deletions(-)
 delete mode 100644 cpp/include/tensorrt_llm/runtime/request.h

diff --git a/cpp/include/tensorrt_llm/batch_manager/createNewDecoderRequests.h b/cpp/include/tensorrt_llm/batch_manager/createNewDecoderRequests.h
index 394f7fb7bfa..0978905b5e2 100644
--- a/cpp/include/tensorrt_llm/batch_manager/createNewDecoderRequests.h
+++ b/cpp/include/tensorrt_llm/batch_manager/createNewDecoderRequests.h
@@ -24,7 +24,6 @@
 #include "tensorrt_llm/runtime/common.h"
 #include "tensorrt_llm/runtime/iTensor.h"
 #include "tensorrt_llm/runtime/modelConfig.h"
-#include "tensorrt_llm/runtime/request.h"
 #include "tensorrt_llm/runtime/worldConfig.h"
 
 namespace tensorrt_llm::runtime
@@ -88,37 +87,6 @@ class CreateNewDecoderRequests : Algorithm
         SizeType32 maxSequenceLength, OptionalRef<MedusaBuffers const> medusaBuffers) const;
 
 private:
-    //! @brief Setups decoder internal tensors for new speculative decoding request
-    static void newRequestSpeculativeDecoding(SizeType32 batchIdx, runtime::decoder_batch::Request const& request,
-        SamplingConfig const& samplingConfig, runtime::ModelConfig const& modelConfig,
-        DecodingInput& jointDecodingInput, DecodingOutput& jointDecodingOutput, CudaStream const& runtimeStream,
-        CudaStream const& decoderStream, SpeculativeDecodingMode const& speculativeDecodingMode,
-        SizeType32 maxDecodingEngineTokens);
-
-    //! @brief Setups decoder internal tensors for new request in Draft model Sps mode
-    static void newRequestDraftTokensExternal(SizeType32 batchIdx, runtime::decoder_batch::Request const& request,
-        SamplingConfig const& samplingConfig, DecodingInput& jointDecodingInput, CudaStream const& decoderStream);
-
-    //! @brief Setups decoder internal tensors for new Medusa request
-    static void newRequestMedusa(SizeType32 batchIdx, runtime::decoder_batch::Request const& request,
-        DecodingInput& jointDecodingInput, CudaStream const& decoderStream, SizeType32 maxDecodingEngineTokens);
-
-    //! @brief Setups decoder internal tensors for new Lookahead request
-    static void newRequestLookahead(SizeType32 batchIdx, runtime::decoder_batch::Request const& request,
-        DecodingInput& jointDecodingInput, DecodingOutput& jointDecodingOutput, CudaStream const& runtimeStream);
-
-    //! @brief Setups decoder internal tensors for new Explicit draft tokens request
-    static void newRequestExplicitDraftTokens(SizeType32 batchIdx, runtime::decoder_batch::Request const& request,
-        DecodingOutput& jointDecodingOutput, CudaStream const& runtimeStream);
-
-    //! @brief Setups decoder internal tensors for new Eagle request
-    static void newRequestEagle(SizeType32 batchIdx, runtime::decoder_batch::Request const& request,
-        runtime::ModelConfig const& modelConfig, DecodingOutput& jointDecodingOutput, CudaStream const& runtimeStream);
-
-    [[nodiscard]] std::shared_ptr<runtime::ITensor> retrieveDraftLogits(runtime::ModelConfig const& modelConfig,
-        runtime::WorldConfig const& worldConfig, std::shared_ptr<runtime::ITensor> const& tensor,
-        runtime::BufferManager const& bufferManager) const;
-
     bool mSpeculativeDecodingFastLogits;
     bool mIsLeaderInOrchMode;
     bool mIsNormalizeLogProbs;
diff --git a/cpp/include/tensorrt_llm/batch_manager/llmRequest.h b/cpp/include/tensorrt_llm/batch_manager/llmRequest.h
index e4d13c9e17b..f069e3ac7f5 100644
--- a/cpp/include/tensorrt_llm/batch_manager/llmRequest.h
+++ b/cpp/include/tensorrt_llm/batch_manager/llmRequest.h
@@ -1110,7 +1110,7 @@ class GenericLlmRequest
 
     [[nodiscard]] SizeType32 getNumDraftTokens() const
     {
-        return mDraftTokens->size();
+        return hasDraftTokens() ? mDraftTokens->size() : 0;
     }
 
     void discardDraftTokens(SizeType32 numTokensToDiscard)
diff --git a/cpp/include/tensorrt_llm/runtime/decodingInput.h b/cpp/include/tensorrt_llm/runtime/decodingInput.h
index deeb0fa0af4..4344f423ac1 100644
--- a/cpp/include/tensorrt_llm/runtime/decodingInput.h
+++ b/cpp/include/tensorrt_llm/runtime/decodingInput.h
@@ -102,11 +102,13 @@ class DecodingInput
     {
     public:
         TensorPtr draftLogits;
+        TensorPtr draftLogitsHost;
         TensorPtr draftProbs;
         TensorPtr targetProbs;
         TensorPtr numDraftTokens;
         TensorPtr numDraftTokensHost;
         TensorPtr draftTokenIds;
+        TensorPtr draftTokenIdsHost;
         TensorPtr useDraftLogits;
         TensorPtr useDraftLogitsHost;
 
diff --git a/cpp/include/tensorrt_llm/runtime/request.h b/cpp/include/tensorrt_llm/runtime/request.h
deleted file mode 100644
index e8f851b7d77..00000000000
--- a/cpp/include/tensorrt_llm/runtime/request.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2024, 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.
- */
-
-#pragma once
-
-#include "tensorrt_llm/executor/executor.h"
-#include "tensorrt_llm/runtime/iTensor.h"
-
-#include <optional>
-
-namespace tensorrt_llm::runtime::decoder_batch
-{
-
-class Request
-{
-public:
-    using TensorConstPtr = ITensor::SharedConstPtr;
-    using TensorPtr = ITensor::SharedPtr;
-    using BufferPtr = IBuffer::SharedPtr;
-
-    explicit Request(SizeType32 inputLen)
-        : inputLen(inputLen)
-    {
-    }
-
-    //! Mandatory parameters
-    SizeType32 inputLen; // Input length without draft tokens, increasing with generation steps
-
-    // optional parameters
-    SizeType32 generatedTokensPerEngineStep{1}; //
-
-    //! Optional parameters for speculative decoding
-    BufferPtr draftTokens;                // [generatedTokensPerEngineStep - 1] on gpu
-    std::optional<TensorPtr> draftLogits; // [generatedTokensPerEngineStep - 1, vocabSize] on gpu
-    TensorPtr medusaPaths;                // [maxDecodingTokens, maxPathLen], on gpu
-    TensorPtr medusaTreeIds;              // [maxDecodingTokens], on gpu
-    std::optional<executor::LookaheadDecodingConfig> lookaheadRuntimeConfig;
-    std::optional<executor::EagleConfig> eagleConfig;
-};
-
-} // namespace tensorrt_llm::runtime::decoder_batch
diff --git a/cpp/tensorrt_llm/batch_manager/createNewDecoderRequests.cpp b/cpp/tensorrt_llm/batch_manager/createNewDecoderRequests.cpp
index 16771709bb4..3335d69a015 100644
--- a/cpp/tensorrt_llm/batch_manager/createNewDecoderRequests.cpp
+++ b/cpp/tensorrt_llm/batch_manager/createNewDecoderRequests.cpp
@@ -20,11 +20,14 @@
 #include "tensorrt_llm/batch_manager/llmRequest.h"
 #include "tensorrt_llm/batch_manager/medusaBuffers.h"
 #include "tensorrt_llm/batch_manager/utils/logitsThread.h"
+#include "tensorrt_llm/common/assert.h"
 #include "tensorrt_llm/common/logger.h"
 #include "tensorrt_llm/common/nvtxUtils.h"
+#include "tensorrt_llm/runtime/common.h"
 #include "tensorrt_llm/runtime/decoderState.h"
 #include "tensorrt_llm/runtime/decodingInput.h"
 #include "tensorrt_llm/runtime/decodingOutput.h"
+#include "tensorrt_llm/runtime/iBuffer.h"
 #include "tensorrt_llm/runtime/runtimeKernels.h"
 #include "tensorrt_llm/runtime/speculativeDecodingMode.h"
 #include "tensorrt_llm/runtime/utils/mpiUtils.h"
@@ -45,6 +48,8 @@ namespace tensorrt_llm::batch_manager
 using SizeType32 = CreateNewDecoderRequests::SizeType32;
 using TensorPtr = CreateNewDecoderRequests::TensorPtr;
 using SharedConstPtr = CreateNewDecoderRequests::SharedConstPtr;
+template <typename T>
+using OptionalRef = tensorrt_llm::common::OptionalRef<T>;
 
 namespace
 {
@@ -320,149 +325,165 @@ void initializeOutputs(DecodingOutput& dJointOutput, SizeType32 batchSlot, SizeT
     TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
 }
 
-} // namespace
-
-void CreateNewDecoderRequests::newRequestSpeculativeDecoding(SizeType32 batchIdx,
-    runtime::decoder_batch::Request const& request, SamplingConfig const& samplingConfig,
-    runtime::ModelConfig const& modelConfig, DecodingInput& jointDecodingInput, DecodingOutput& jointDecodingOutput,
-    CudaStream const& runtimeStream, CudaStream const& decoderStream,
-    SpeculativeDecodingMode const& speculativeDecodingMode, SizeType32 maxDecodingEngineTokens)
+void retrieveDraftLogits(TensorPtr& draftLogitsHost, std::shared_ptr<runtime::ITensor> const& reqDraftLogits,
+    ModelConfig const& modelConfig, WorldConfig const& worldConfig, bool speculativeDecodingFastLogits,
+    bool isLeaderInOrchMode, BufferManager const& bufferManager)
 {
     TLLM_LOG_TRACE("%s start", __PRETTY_FUNCTION__);
 
-    if (speculativeDecodingMode.predictsDraftTokens())
+    if (!speculativeDecodingFastLogits)
     {
-        auto const& stream = decoderStream;
-        BufferManager manager{std::make_shared<CudaStream>(stream.get())};
+        TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
+        bufferManager.copy(*reqDraftLogits, *draftLogitsHost);
+        return;
+    }
 
-        auto& dJointOutput = jointDecodingOutput;
+    if (isLeaderInOrchMode)
+    {
+        // reqDraftLogits contains metadata for fast-logits path; validate size.
+        auto constexpr fastLogitsInfoSize = sizeof(te::SpeculativeDecodingFastLogitsInfo);
+        TLLM_CHECK_WITH_INFO(reqDraftLogits->getSizeInBytes() >= fastLogitsInfoSize,
+            "Draft logits metadata buffer is too small to hold SpeculativeDecodingFastLogitsInfo.");
+        te::SpeculativeDecodingFastLogitsInfo fastLogitsInfo{};
+        std::memcpy(&fastLogitsInfo, reqDraftLogits->data(), fastLogitsInfoSize);
+        utils::targetModelReceiveLogits(draftLogitsHost, fastLogitsInfo, modelConfig.getLogitsDtype());
 
-        TensorPtr nextDraftTokens
-            = ITensor::slice(dJointOutput.speculativeDecodingOutputs->nextDraftTokens, batchIdx, 1);
-        // FIXME: can we skip this?
-        manager.setZero(*nextDraftTokens);
-        if (speculativeDecodingMode.variableDraftLength())
+        // Broadcast to other ranks if needed
+        if (worldConfig.isTensorParallel())
         {
-            TensorPtr nextDraftTokensLen
-                = ITensor::slice(dJointOutput.speculativeDecodingOutputs->nextDraftTokensLen, batchIdx, 1);
-            manager.setZero(*nextDraftTokensLen);
+            auto const& commSession = COMM_SESSION;
+            auto shape = draftLogitsHost->getShape();
+            commSession.bcastValue(shape.d[0], 0);
+            commSession.bcastValue(shape.d[1], 0);
+            commSession.bcast(draftLogitsHost->data(), draftLogitsHost->getSizeInBytes(), mpi::MpiType::kUINT8, 0);
         }
     }
-
-    if (speculativeDecodingMode.isDraftTokensExternal())
-    {
-        newRequestDraftTokensExternal(batchIdx, request, samplingConfig, jointDecodingInput, decoderStream);
-    }
-    else if (speculativeDecodingMode.isMedusa())
-    {
-        newRequestMedusa(batchIdx, request, jointDecodingInput, decoderStream, maxDecodingEngineTokens);
-    }
-    else if (speculativeDecodingMode.isLookaheadDecoding())
-    {
-        newRequestLookahead(batchIdx, request, jointDecodingInput, jointDecodingOutput, runtimeStream);
-    }
-    else if (speculativeDecodingMode.isExplicitDraftTokens())
-    {
-        newRequestExplicitDraftTokens(batchIdx, request, jointDecodingOutput, runtimeStream);
-    }
-    else if (speculativeDecodingMode.isEagle())
+    else
     {
-        newRequestEagle(batchIdx, request, modelConfig, jointDecodingOutput, runtimeStream);
+        TLLM_CHECK_WITH_INFO(worldConfig.isTensorParallel(),
+            "Fast logits path requires tensor-parallel broadcast for non-leader ranks.");
+
+        // Get logits from leader rank
+        auto const& commSession = COMM_SESSION;
+        int64_t dims[2];
+        commSession.bcastValue(dims[0], 0);
+        commSession.bcastValue(dims[1], 0);
+        draftLogitsHost->reshape(ITensor::makeShape({dims[0], dims[1]}));
+        commSession.bcast(draftLogitsHost->data(), draftLogitsHost->getSizeInBytes(), mpi::MpiType::kUINT8, 0);
     }
+
     TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
-}
+};
 
-void CreateNewDecoderRequests::newRequestDraftTokensExternal(SizeType32 batchIdx,
-    runtime::decoder_batch::Request const& request, SamplingConfig const& samplingConfig,
-    DecodingInput& jointDecodingInput, CudaStream const& decoderStream)
+//! @brief Setups decoder internal tensors for new request in Draft model Sps mode
+void newRequestDraftTokensExternal(DecodingInput& jointDecodingInput, SizeType32 batchIdx, LlmRequest const& llmReq,
+    SizeType32 numDecodingEngineTokens, runtime::ModelConfig const& modelConfig, WorldConfig const& worldConfig,
+    bool speculativeDecodingFastLogits, bool isLeaderInOrchMode, CudaStream const& decoderStream)
 {
     TLLM_LOG_TRACE("%s start", __PRETTY_FUNCTION__);
 
-    BufferManager manager{std::make_shared<CudaStream>(decoderStream.get())};
+    BufferManager decoderBufferManager{std::make_shared<CudaStream>(decoderStream.get())};
 
-    auto& dJointInput = jointDecodingInput;
+    TLLM_CHECK(jointDecodingInput.externalDraftTokensInputs);
+    auto& externalDraftTokensInputs = jointDecodingInput.externalDraftTokensInputs;
 
-    auto const numDraftTokens = request.generatedTokensPerEngineStep - 1;
+    auto const& draftTokens = llmReq.getDraftTokens();
+    auto const numDraftTokens = numDecodingEngineTokens - 1;
 
-    auto const useDraftLogits = request.draftLogits.has_value();
-    if (useDraftLogits)
+    auto numDraftTokensHostRange = runtime::BufferRange<SizeType32>(*externalDraftTokensInputs->numDraftTokensHost);
+    numDraftTokensHostRange[batchIdx] = numDraftTokens;
+    auto numDraftTokensView = ITensor::slice(externalDraftTokensInputs->numDraftTokens, batchIdx, 1);
+    runtime::kernels::invokeFill(*numDraftTokensView, numDraftTokens, decoderStream);
+
+    if (numDraftTokens > 0)
     {
-        TensorPtr draftLogitsView = ITensor::view(request.draftLogits.value());
+        TensorPtr draftTokenIdsHostSlice
+            = ITensor::slice(externalDraftTokensInputs->draftTokenIdsHost, {batchIdx, 0}, numDraftTokens);
+        // Copy to pinned host memory (don't care about stream of bufferManager)
+        decoderBufferManager.copy(draftTokens->data(), *draftTokenIdsHostSlice);
 
-        TensorPtr draftLogitsReqBatchSlice
-            = ITensor::slice(dJointInput.externalDraftTokensInputs->draftLogits, batchIdx, 1);
-        draftLogitsReqBatchSlice->squeeze(0);
-        TensorPtr draftLogitsReqTokensSlice = ITensor::slice(draftLogitsReqBatchSlice, 0, numDraftTokens);
-        manager.copy(*draftLogitsView, *draftLogitsReqTokensSlice);
+        TensorPtr draftTokenIdsSlice
+            = ITensor::slice(externalDraftTokensInputs->draftTokenIds, {batchIdx, 0}, numDraftTokens);
+        decoderBufferManager.copy(*draftTokenIdsHostSlice, *draftTokenIdsSlice);
     }
-    auto* useDraftLogitsHostPtr = runtime::bufferCast<bool>(*dJointInput.externalDraftTokensInputs->useDraftLogitsHost);
-    useDraftLogitsHostPtr[batchIdx] = useDraftLogits;
-    auto useDraftLogitsView = ITensor::slice(dJointInput.externalDraftTokensInputs->useDraftLogits, batchIdx, 1);
+
+    auto const& draftLogits = llmReq.getDraftLogits();
+    auto const useDraftLogits = draftLogits.has_value();
+
+    auto useDraftLogitsHostRange = runtime::BufferRange<bool>(*externalDraftTokensInputs->useDraftLogitsHost);
+    useDraftLogitsHostRange[batchIdx] = useDraftLogits;
+    auto useDraftLogitsView = ITensor::slice(externalDraftTokensInputs->useDraftLogits, batchIdx, 1);
     runtime::kernels::invokeFill(*useDraftLogitsView, useDraftLogits, decoderStream);
 
-    if (numDraftTokens > 0)
+    if (useDraftLogits)
     {
-        TensorPtr draftTokensReqBatchSlice
-            = ITensor::slice(dJointInput.externalDraftTokensInputs->draftTokenIds, batchIdx, 1);
-        draftTokensReqBatchSlice->squeeze(0);
-        TensorPtr draftTokensReqTokensSlice = ITensor::slice(draftTokensReqBatchSlice, 0, numDraftTokens);
-        TensorPtr draftTokensView = ITensor::view(request.draftTokens, ITensor::makeShape({numDraftTokens}));
-        manager.copy(*draftTokensView, *draftTokensReqTokensSlice);
+        TensorPtr draftLogitsHostSlice
+            = ITensor::slice(externalDraftTokensInputs->draftLogitsHost, {batchIdx, 0}, numDraftTokens);
+        retrieveDraftLogits(draftLogitsHostSlice, draftLogits.value(), modelConfig, worldConfig,
+            speculativeDecodingFastLogits, isLeaderInOrchMode, decoderBufferManager);
+
+        TensorPtr draftLogitsSlice
+            = ITensor::slice(externalDraftTokensInputs->draftLogits, {batchIdx, 0}, numDraftTokens);
+        decoderBufferManager.copy(*draftLogitsHostSlice, *draftLogitsSlice);
     }
 
-    auto* numDraftTokensHostPtr
-        = runtime::bufferCast<SizeType32>(*dJointInput.externalDraftTokensInputs->numDraftTokensHost);
-    numDraftTokensHostPtr[batchIdx] = numDraftTokens;
-    auto numDraftTokensView = ITensor::slice(dJointInput.externalDraftTokensInputs->numDraftTokens, batchIdx, 1);
-    runtime::kernels::invokeFill(*numDraftTokensView, numDraftTokens, decoderStream);
-
+    auto const& samplingConfig = llmReq.mSamplingConfig;
     bool const useRandomAcceptanceThreshold = !samplingConfig.draftAcceptanceThreshold.has_value();
     float const constantThreshold
         = useRandomAcceptanceThreshold ? 0 : samplingConfig.draftAcceptanceThreshold.value()[0];
 
-    dJointInput.externalDraftTokensInputs->useRandomAcceptanceThreshold = useRandomAcceptanceThreshold;
-    dJointInput.externalDraftTokensInputs->constantThreshold = constantThreshold;
+    externalDraftTokensInputs->useRandomAcceptanceThreshold = useRandomAcceptanceThreshold;
+    externalDraftTokensInputs->constantThreshold = constantThreshold;
 
     TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
 }
 
-void CreateNewDecoderRequests::newRequestMedusa(SizeType32 batchIdx, runtime::decoder_batch::Request const& request,
-    DecodingInput& jointDecodingInput, CudaStream const& decoderStream, SizeType32 maxDecodingEngineTokens)
+//! @brief Setups decoder internal tensors for new Medusa request
+void newRequestMedusa(DecodingInput& jointDecodingInput, SizeType32 batchIdx, LlmRequest& llmReq,
+    SizeType32 numDecodingEngineTokens, SizeType32 maxDecodingEngineTokens, MedusaBuffers const& medusaBuffers,
+    CudaStream const& decoderStream)
 {
     TLLM_LOG_TRACE("%s start", __PRETTY_FUNCTION__);
 
+    llmReq.mSamplingConfig.topKMedusaHeads = {medusaBuffers.mTopKs};
+    // FIXME: we must set medusa paths and tree ids not from seq slot, but from llmRequest?
+    // When multiple microbatches buffers are used, runtime buffers can not be addressed with seqSlot.
+    auto medusaPaths = ITensor::slice(medusaBuffers.medusaPathsDevice, 0, 1);
+    auto medusaTreeIds = ITensor::slice(medusaBuffers.medusaTreeIdsDevice, 0, 1);
+
     BufferManager manager{std::make_shared<CudaStream>(decoderStream.get())};
 
-    auto& dJointInput = jointDecodingInput;
+    auto& medusaInputs = jointDecodingInput.medusaInputs;
 
     TensorPtr curTokensPerStepSlice
-        = ITensor::slice(constPointerCast(dJointInput.medusaInputs->medusaCurTokensPerStep), batchIdx, 1);
+        = ITensor::slice(constPointerCast(medusaInputs->medusaCurTokensPerStep), batchIdx, 1);
     // Context phase Medusa processes 1 token only, new value from targetTokensPerStep will be filled at the end
     // of first decoder
     runtime::kernels::invokeFill(*curTokensPerStepSlice, 1, decoderStream);
     TensorPtr targetTokensPerStepSlice
-        = ITensor::slice(constPointerCast(dJointInput.medusaInputs->medusaTargetTokensPerStep), batchIdx, 1);
-    auto const generatedTokensPerEngineStep = request.generatedTokensPerEngineStep;
-    TLLM_CHECK_WITH_INFO(generatedTokensPerEngineStep <= maxDecodingEngineTokens,
-        "Tokens per step for (%d) is larger than maximum tokens per step (%d)", generatedTokensPerEngineStep,
+        = ITensor::slice(constPointerCast(medusaInputs->medusaTargetTokensPerStep), batchIdx, 1);
+    TLLM_CHECK_WITH_INFO(numDecodingEngineTokens <= maxDecodingEngineTokens,
+        "Tokens per step for (%d) is larger than maximum tokens per step (%d)", numDecodingEngineTokens,
         maxDecodingEngineTokens);
-    runtime::kernels::invokeFill(*targetTokensPerStepSlice, generatedTokensPerEngineStep, decoderStream);
+    runtime::kernels::invokeFill(*targetTokensPerStepSlice, numDecodingEngineTokens, decoderStream);
 
-    TensorPtr pathsSlice = ITensor::slice(constPointerCast(dJointInput.medusaInputs->medusaPaths), batchIdx, 1);
-    manager.copy(*request.medusaPaths, *pathsSlice);
+    TensorPtr pathsSlice = ITensor::slice(constPointerCast(medusaInputs->medusaPaths), batchIdx, 1);
+    manager.copy(*medusaPaths, *pathsSlice);
 
-    TensorPtr treeIdsSlice = ITensor::slice(constPointerCast(dJointInput.medusaInputs->medusaTreeIds), batchIdx, 1);
-    manager.copy(*request.medusaTreeIds, *treeIdsSlice);
+    TensorPtr treeIdsSlice = ITensor::slice(constPointerCast(medusaInputs->medusaTreeIds), batchIdx, 1);
+    manager.copy(*medusaTreeIds, *treeIdsSlice);
 
     TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
 }
 
-void CreateNewDecoderRequests::newRequestLookahead(SizeType32 batchIdx, runtime::decoder_batch::Request const& request,
-    DecodingInput& jointDecodingInput, DecodingOutput& jointDecodingOutput, CudaStream const& runtimeStream)
+//! @brief Setups decoder internal tensors for new Lookahead request
+void newRequestLookahead(DecodingInput& jointDecodingInput, DecodingOutput& jointDecodingOutput, SizeType32 batchIdx,
+    CudaStream const& runtimeStream)
 {
     TLLM_LOG_TRACE("%s start", __PRETTY_FUNCTION__);
 
     TLLM_CHECK(jointDecodingOutput.lookaheadOutputs);
+    TLLM_CHECK(jointDecodingInput.lookaheadInputs);
 
     // The first generation step only generate 1 token.
     TensorPtr curTokensPerStepSlice
@@ -472,65 +493,72 @@ void CreateNewDecoderRequests::newRequestLookahead(SizeType32 batchIdx, runtime:
     TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
 }
 
-void CreateNewDecoderRequests::newRequestExplicitDraftTokens(SizeType32 batchIdx,
-    runtime::decoder_batch::Request const& request, DecodingOutput& jointDecodingOutput,
-    CudaStream const& runtimeStream)
+//! @brief Setups decoder internal tensors for new Explicit draft tokens request
+void newRequestExplicitDraftTokens(
+    DecodingOutput& jointDecodingOutput, SizeType32 batchIdx, LlmRequest const& llmReq, CudaStream const& runtimeStream)
 {
     TLLM_LOG_TRACE("%s start", __PRETTY_FUNCTION__);
 
     TLLM_CHECK(jointDecodingOutput.explicitDraftTokensBuffers);
 
+    auto const inputLen = llmReq.getPromptLen();
+
     TensorPtr positionIdsBaseSlice
         = ITensor::slice(jointDecodingOutput.explicitDraftTokensBuffers->positionIdsBase, batchIdx, 1);
-    runtime::kernels::invokeFill(*positionIdsBaseSlice, request.inputLen, runtimeStream);
+    runtime::kernels::invokeFill(*positionIdsBaseSlice, inputLen, runtimeStream);
 
     TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
 }
 
-void CreateNewDecoderRequests::newRequestEagle(SizeType32 batchIdx, runtime::decoder_batch::Request const& request,
-    runtime::ModelConfig const& modelConfig, DecodingOutput& jointDecodingOutput, CudaStream const& runtimeStream)
+//! @brief Setups decoder internal tensors for new Eagle request
+void newRequestEagle(DecodingOutput& jointDecodingOutput, SizeType32 batchIdx, LlmRequest const& llmReq,
+    runtime::ModelConfig const& modelConfig, executor::DecodingConfig const& decodingConfig,
+    CudaStream const& runtimeStream)
 {
     TLLM_LOG_TRACE("%s start", __PRETTY_FUNCTION__);
 
     TLLM_CHECK(jointDecodingOutput.eagleBuffers);
+    auto& eagleBuffers = *jointDecodingOutput.eagleBuffers;
+
+    auto const inputLen = llmReq.getPromptLen();
 
     BufferManager manager{std::make_shared<CudaStream>(runtimeStream.get())};
 
-    TensorPtr eagleNetCtxRequestTypesHostSlice
-        = ITensor::slice(jointDecodingOutput.eagleBuffers->eagleNetCtxRequestTypesHost, batchIdx, 1);
+    TensorPtr eagleNetCtxRequestTypesHostSlice = ITensor::slice(eagleBuffers.eagleNetCtxRequestTypesHost, batchIdx, 1);
     TensorPtr eagleNetCtxContextLengthsHostSlice
-        = ITensor::slice(jointDecodingOutput.eagleBuffers->eagleNetCtxContextLengthsHost, batchIdx, 1);
+        = ITensor::slice(eagleBuffers.eagleNetCtxContextLengthsHost, batchIdx, 1);
     TensorPtr eagleNetCtxPastKeyValueLengthsHostSlice
-        = ITensor::slice(jointDecodingOutput.eagleBuffers->eagleNetCtxPastKeyValueLengthsHost, batchIdx, 1);
+        = ITensor::slice(eagleBuffers.eagleNetCtxPastKeyValueLengthsHost, batchIdx, 1);
 
     runtime::bufferCast<SizeType32>(*eagleNetCtxRequestTypesHostSlice)[0] = 0;
-    runtime::bufferCast<SizeType32>(*eagleNetCtxContextLengthsHostSlice)[0] = request.inputLen;
-    runtime::bufferCast<SizeType32>(*eagleNetCtxPastKeyValueLengthsHostSlice)[0] = request.inputLen;
+    runtime::bufferCast<SizeType32>(*eagleNetCtxContextLengthsHostSlice)[0] = inputLen;
+    runtime::bufferCast<SizeType32>(*eagleNetCtxPastKeyValueLengthsHostSlice)[0] = inputLen;
 
-    TensorPtr eagleNetGenRequestTypesHostSlice
-        = ITensor::slice(jointDecodingOutput.eagleBuffers->eagleNetGenRequestTypesHost, batchIdx, 1);
+    TensorPtr eagleNetGenRequestTypesHostSlice = ITensor::slice(eagleBuffers.eagleNetGenRequestTypesHost, batchIdx, 1);
     TensorPtr eagleNetGenContextLengthsHostSlice
-        = ITensor::slice(jointDecodingOutput.eagleBuffers->eagleNetGenContextLengthsHost, batchIdx, 1);
+        = ITensor::slice(eagleBuffers.eagleNetGenContextLengthsHost, batchIdx, 1);
     TensorPtr eagleNetGenPastKeyValueLengthsHostSlice
-        = ITensor::slice(jointDecodingOutput.eagleBuffers->eagleNetGenPastKeyValueLengthsHost, batchIdx, 1);
+        = ITensor::slice(eagleBuffers.eagleNetGenPastKeyValueLengthsHost, batchIdx, 1);
 
     runtime::bufferCast<SizeType32>(*eagleNetGenRequestTypesHostSlice)[0] = 1;
-    runtime::bufferCast<SizeType32>(*eagleNetGenContextLengthsHostSlice)[0] = request.inputLen;
-    runtime::bufferCast<SizeType32>(*eagleNetGenPastKeyValueLengthsHostSlice)[0] = request.inputLen;
+    runtime::bufferCast<SizeType32>(*eagleNetGenContextLengthsHostSlice)[0] = inputLen;
+    runtime::bufferCast<SizeType32>(*eagleNetGenPastKeyValueLengthsHostSlice)[0] = inputLen;
 
     auto const eagleModule = std::dynamic_pointer_cast<tensorrt_llm::runtime::EagleModule const>(
         modelConfig.getSpeculativeDecodingModulePtr());
     std::optional<executor::EagleChoices> eagleChoicesOpt;
 
-    if (request.eagleConfig)
+    auto const& eagleConfig = llmReq.getEagleConfig() ? llmReq.getEagleConfig() : decodingConfig.getEagleConfig();
+
+    if (eagleConfig)
     {
-        eagleChoicesOpt = request.eagleConfig->getEagleChoices();
+        eagleChoicesOpt = eagleConfig->getEagleChoices();
     }
 
-    if (!request.eagleConfig || !request.eagleConfig->useDynamicTree())
+    if (!eagleConfig || !eagleConfig->useDynamicTree())
     {
-        TensorPtr draftPathsHostSlice = ITensor::slice(jointDecodingOutput.eagleBuffers->draftPathsHost, batchIdx, 1);
-        TensorPtr draftPathsSlice = ITensor::slice(jointDecodingOutput.eagleBuffers->draftPaths, batchIdx, 1);
+        TensorPtr draftPathsHostSlice = ITensor::slice(eagleBuffers.draftPathsHost, batchIdx, 1);
+        TensorPtr draftPathsSlice = ITensor::slice(eagleBuffers.draftPaths, batchIdx, 1);
 
         // eagleConfig is nullptr or Eagle-1
         std::vector<SizeType32> topKs;
@@ -546,6 +574,61 @@ void CreateNewDecoderRequests::newRequestEagle(SizeType32 batchIdx, runtime::dec
     TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
 }
 
+//! @brief Setups decoder internal tensors for new speculative decoding request
+void newRequestSpeculativeDecoding(DecodingInput& jointDecodingInput, DecodingOutput& jointDecodingOutput,
+    SizeType32 batchIdx, LlmRequest& llmReq, SpeculativeDecodingMode const& speculativeDecodingMode,
+    SizeType32 numDecodingEngineTokens, SizeType32 maxDecodingEngineTokens,
+    OptionalRef<MedusaBuffers const> medusaBuffers, runtime::ModelConfig const& modelConfig,
+    WorldConfig const& worldConfig, executor::DecodingConfig const& decodingConfig, bool speculativeDecodingFastLogits,
+    bool isLeaderInOrchMode, CudaStream const& runtimeStream, CudaStream const& decoderStream)
+{
+    TLLM_LOG_TRACE("%s start", __PRETTY_FUNCTION__);
+
+    if (speculativeDecodingMode.predictsDraftTokens())
+    {
+        BufferManager manager{std::make_shared<CudaStream>(decoderStream.get())};
+
+        TLLM_CHECK(jointDecodingOutput.speculativeDecodingOutputs);
+        auto& speculativeDecodingOutputs = *jointDecodingOutput.speculativeDecodingOutputs;
+
+        TensorPtr nextDraftTokens = ITensor::slice(speculativeDecodingOutputs.nextDraftTokens, batchIdx, 1);
+        // FIXME: can we skip this?
+        manager.setZero(*nextDraftTokens);
+        if (speculativeDecodingMode.variableDraftLength())
+        {
+            TensorPtr nextDraftTokensLen = ITensor::slice(speculativeDecodingOutputs.nextDraftTokensLen, batchIdx, 1);
+            manager.setZero(*nextDraftTokensLen);
+        }
+    }
+
+    if (speculativeDecodingMode.isDraftTokensExternal())
+    {
+        newRequestDraftTokensExternal(jointDecodingInput, batchIdx, llmReq, numDecodingEngineTokens, modelConfig,
+            worldConfig, speculativeDecodingFastLogits, isLeaderInOrchMode, decoderStream);
+    }
+    else if (speculativeDecodingMode.isMedusa())
+    {
+        TLLM_CHECK(medusaBuffers);
+        newRequestMedusa(jointDecodingInput, batchIdx, llmReq, numDecodingEngineTokens, maxDecodingEngineTokens,
+            medusaBuffers.value(), decoderStream);
+    }
+    else if (speculativeDecodingMode.isLookaheadDecoding())
+    {
+        newRequestLookahead(jointDecodingInput, jointDecodingOutput, batchIdx, runtimeStream);
+    }
+    else if (speculativeDecodingMode.isExplicitDraftTokens())
+    {
+        newRequestExplicitDraftTokens(jointDecodingOutput, batchIdx, llmReq, runtimeStream);
+    }
+    else if (speculativeDecodingMode.isEagle())
+    {
+        newRequestEagle(jointDecodingOutput, batchIdx, llmReq, modelConfig, decodingConfig, runtimeStream);
+    }
+    TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
+}
+
+} // namespace
+
 std::tuple<std::vector<runtime::ITensor::SharedConstPtr>, std::vector<executor::LookaheadDecodingConfig>>
 CreateNewDecoderRequests::createDecoderRequests(RequestVector const& finishedContextRequests, TensorPtr const& inputIds,
     executor::DecodingConfig const& decodingConfig, runtime::decoder::DecoderState& decoderState,
@@ -563,9 +646,6 @@ CreateNewDecoderRequests::createDecoderRequests(RequestVector const& finishedCon
     }
     inputIds->resize(decoderInputSize);
 
-    std::vector<decoder_batch::Request> decoderRequests;
-    decoderRequests.reserve(finishedContextRequests.size());
-
     std::vector<runtime::ITensor::SharedConstPtr> lookaheadPrompt;
     std::vector<executor::LookaheadDecodingConfig> lookaheadAlgoConfigs;
     if (modelConfig.getSpeculativeDecodingMode().isLookaheadDecoding())
@@ -597,36 +677,18 @@ CreateNewDecoderRequests::createDecoderRequests(RequestVector const& finishedCon
 
         auto const promptLen = llmReq->getPromptLen();
 
-        auto decoderRequest = decoder_batch::Request{promptLen};
-
+        SizeType32 numDecodingEngineTokens{1};
         if (modelConfig.getSpeculativeDecodingMode().isDraftTokensExternal())
         {
-            if (llmReq->hasDraftTokens())
-            {
-                auto const& draftTokens = llmReq->getDraftTokens();
-                // Copy to pinned host memory (don't care about stream of bufferManager)
-                decoderRequest.draftTokens = decoderBufferManager.copyFrom(*draftTokens, MemoryType::kPINNEDPOOL);
-                auto const& draftLogits = llmReq->getDraftLogits();
-                if (draftLogits.has_value())
-                {
-                    decoderRequest.draftLogits
-                        = retrieveDraftLogits(modelConfig, worldConfig, draftLogits.value(), decoderBufferManager);
-                }
-                decoderRequest.generatedTokensPerEngineStep = draftTokens->size() + 1;
-            }
-            else
-            {
-                decoderRequest.generatedTokensPerEngineStep = 1;
-            }
+            numDecodingEngineTokens = llmReq->getNumDraftTokens() + 1;
         }
         else if (!modelConfig.getSpeculativeDecodingMode().isNone())
         {
-            decoderRequest.generatedTokensPerEngineStep = modelConfig.getMaxDecodingTokens();
+            numDecodingEngineTokens = modelConfig.getMaxDecodingTokens();
         }
 
         auto& dJointInput = decoderState.getJointDecodingInput();
 
-        auto const numDecodingEngineTokens = decoderRequest.generatedTokensPerEngineStep;
         initializeInputLengths(dJointInput, batchSlot, promptLen, llmReq->mMaxNewTokens, numDecodingEngineTokens,
             maxSequenceLength, decoderBufferManager);
         decoderState.setNumDecodingEngineTokens(batchSlot, numDecodingEngineTokens);
@@ -667,16 +729,7 @@ CreateNewDecoderRequests::createDecoderRequests(RequestVector const& finishedCon
         {
             TLLM_CHECK(beamWidth == 1);
 
-            if (modelConfig.getSpeculativeDecodingMode().isMedusa())
-            {
-                TLLM_CHECK(medusaBuffers);
-                llmReq->mSamplingConfig.topKMedusaHeads = {medusaBuffers->mTopKs};
-                // FIXME: we must set medusa paths and tree ids not from seq slot, but from llmRequest?
-                // When multiple microbatches buffers are used, runtime buffers can not be addressed with seqSlot.
-                decoderRequest.medusaPaths = ITensor::slice(medusaBuffers->medusaPathsDevice, 0, 1);
-                decoderRequest.medusaTreeIds = ITensor::slice(medusaBuffers->medusaTreeIdsDevice, 0, 1);
-            }
-            else if (modelConfig.getSpeculativeDecodingMode().isLookaheadDecoding())
+            if (modelConfig.getSpeculativeDecodingMode().isLookaheadDecoding())
             {
                 lookaheadPrompt.emplace_back(requestIds);
 
@@ -684,67 +737,17 @@ CreateNewDecoderRequests::createDecoderRequests(RequestVector const& finishedCon
                     = llmReq->getLookaheadConfig().value_or(decodingConfig.getLookaheadDecodingConfig().value());
                 lookaheadAlgoConfigs.emplace_back(lookaheadRuntimeConfig);
             }
-            else if (modelConfig.getSpeculativeDecodingMode().isEagle())
-            {
-                decoderRequest.eagleConfig
-                    = llmReq->getEagleConfig() ? llmReq->getEagleConfig() : decodingConfig.getEagleConfig();
-            }
 
-            newRequestSpeculativeDecoding(batchSlot, decoderRequest, samplingConfig, modelConfig,
-                decoderState.getJointDecodingInput(), decoderState.getJointDecodingOutput(), runtimeStream,
-                decoderStream, decoderState.getSpeculativeDecodingMode(), decoderState.getMaxDecodingEngineTokens());
+            newRequestSpeculativeDecoding(decoderState.getJointDecodingInput(), decoderState.getJointDecodingOutput(),
+                batchSlot, *llmReq, decoderState.getSpeculativeDecodingMode(), numDecodingEngineTokens,
+                decoderState.getMaxDecodingEngineTokens(), medusaBuffers, modelConfig, worldConfig, decodingConfig,
+                mSpeculativeDecodingFastLogits, mIsLeaderInOrchMode, runtimeStream, decoderStream);
         }
 
-        decoderRequests.push_back(decoderRequest);
-
         inputOffset += promptLen;
     }
 
     return {std::move(lookaheadPrompt), std::move(lookaheadAlgoConfigs)};
 }
 
-std::shared_ptr<runtime::ITensor> CreateNewDecoderRequests::retrieveDraftLogits(ModelConfig const& modelConfig,
-    WorldConfig const& worldConfig, std::shared_ptr<runtime::ITensor> const& tensor,
-    BufferManager const& bufferManager) const
-{
-    TLLM_LOG_TRACE("%s start", __PRETTY_FUNCTION__);
-
-    if (!mSpeculativeDecodingFastLogits)
-    {
-        TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
-        return bufferManager.copyFrom(*tensor, MemoryType::kPINNEDPOOL);
-    }
-
-    if (mIsLeaderInOrchMode)
-    {
-        te::SpeculativeDecodingFastLogitsInfo fastLogitsInfo;
-        std::memcpy(&fastLogitsInfo, tensor->data(), sizeof(fastLogitsInfo));
-        auto logits = utils::targetModelReceiveLogits(fastLogitsInfo, modelConfig).value();
-
-        // Broadcast to other ranks if needed
-        if (worldConfig.isTensorParallel())
-        {
-            auto const& commSession = COMM_SESSION;
-            auto shape = logits->getShape();
-            commSession.bcastValue(shape.d[0], 0);
-            commSession.bcastValue(shape.d[1], 0);
-            commSession.bcast(logits->data(), logits->getSizeInBytes(), mpi::MpiType::kUINT8, 0);
-        }
-        TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
-        return logits;
-    }
-
-    // Get logits from leader rank
-    auto const& commSession = COMM_SESSION;
-    int64_t dims[2];
-    commSession.bcastValue(dims[0], 0);
-    commSession.bcastValue(dims[1], 0);
-    auto const logitsDtype = modelConfig.getLogitsDtype();
-    auto logits = tensorrt_llm::runtime::BufferManager::pinnedPool(ITensor::makeShape({dims[0], dims[1]}), logitsDtype);
-    commSession.bcast(logits->data(), logits->getSizeInBytes(), mpi::MpiType::kUINT8, 0);
-
-    TLLM_LOG_TRACE("%s stop", __PRETTY_FUNCTION__);
-    return logits;
-};
-
 } // namespace tensorrt_llm::batch_manager
diff --git a/cpp/tensorrt_llm/batch_manager/utils/logitsThread.cpp b/cpp/tensorrt_llm/batch_manager/utils/logitsThread.cpp
index 484cd7c3c7b..7234ca9ba57 100644
--- a/cpp/tensorrt_llm/batch_manager/utils/logitsThread.cpp
+++ b/cpp/tensorrt_llm/batch_manager/utils/logitsThread.cpp
@@ -121,8 +121,8 @@ void draftModelSendLogitsThread(int device, std::atomic<bool>* draftModelThreadS
 #endif // ENABLE_MULTI_DEVICE
 }
 
-std::optional<runtime::ITensor::SharedPtr> targetModelReceiveLogits(
-    executor::SpeculativeDecodingFastLogitsInfo const& fastLogitsInfo, runtime::ModelConfig const& modelConfig)
+void targetModelReceiveLogits(runtime::ITensor::SharedPtr& draftLogitsHost,
+    executor::SpeculativeDecodingFastLogitsInfo const& fastLogitsInfo, nvinfer1::DataType logitsDtype)
 {
 #if ENABLE_MULTI_DEVICE
     auto const& worldComm = tensorrt_llm::mpi::MpiComm::world();
@@ -151,10 +151,7 @@ std::optional<runtime::ITensor::SharedPtr> targetModelReceiveLogits(
     int64_t dims[2];
     MPICHECK(MPI_Mrecv(&dims, count, MPI_INT64_T, &msg, &status));
 
-    auto const logitsDtype = modelConfig.getLogitsDtype();
-
-    auto tensor = tensorrt_llm::runtime::BufferManager::pinnedPool(
-        runtime::ITensor::makeShape({dims[0], dims[1]}), logitsDtype);
+    draftLogitsHost->reshape(runtime::ITensor::makeShape({dims[0], dims[1]}));
 
     worldComm.mprobe(fastLogitsInfo.draftParticipantId, mpi::MpiTag::kSpecDecLogitsData, &msg, &status);
 
@@ -163,11 +160,7 @@ std::optional<runtime::ITensor::SharedPtr> targetModelReceiveLogits(
     uint64_t const expectedSize = static_cast<uint64_t>(dims[0]) * dims[1] * tc::getDTypeSize(logitsDtype);
     TLLM_CHECK((uint64_t) count == expectedSize);
 
-    MPICHECK(MPI_Mrecv(tensor->data(), count, MPI_UINT8_T, &msg, &status));
-
-    return tensor;
-#else
-    return std::nullopt;
+    MPICHECK(MPI_Mrecv(draftLogitsHost->data(), count, MPI_UINT8_T, &msg, &status));
 #endif // ENABLE_MULTI_DEVICE
 }
 
diff --git a/cpp/tensorrt_llm/batch_manager/utils/logitsThread.h b/cpp/tensorrt_llm/batch_manager/utils/logitsThread.h
index 6d87ebee162..f19d5f5ef30 100644
--- a/cpp/tensorrt_llm/batch_manager/utils/logitsThread.h
+++ b/cpp/tensorrt_llm/batch_manager/utils/logitsThread.h
@@ -21,10 +21,8 @@
 #include "tensorrt_llm/executor/executor.h"
 #include "tensorrt_llm/runtime/common.h"
 #include "tensorrt_llm/runtime/iTensor.h"
-#include "tensorrt_llm/runtime/modelConfig.h"
 
 #include <memory>
-#include <optional>
 
 namespace tensorrt_llm::batch_manager
 {
@@ -52,7 +50,7 @@ void draftModelSendLogitsThread(int device, std::atomic<bool>* draftModelThreadS
     std::shared_ptr<kv_cache_manager::BaseKVCacheManager> const& crossKvCacheManager,
     std::shared_ptr<BasePeftCacheManager> const& peftCacheManager);
 
-std::optional<runtime::ITensor::SharedPtr> targetModelReceiveLogits(
-    executor::SpeculativeDecodingFastLogitsInfo const& fastLogitsInfo, runtime::ModelConfig const& modelConfig);
+void targetModelReceiveLogits(runtime::ITensor::SharedPtr& draftLogitsHost,
+    executor::SpeculativeDecodingFastLogitsInfo const& fastLogitsInfo, nvinfer1::DataType logitsDtype);
 
 } // namespace tensorrt_llm::batch_manager::utils
diff --git a/cpp/tensorrt_llm/runtime/decoderState.cpp b/cpp/tensorrt_llm/runtime/decoderState.cpp
index abccbe60a13..b5851dc1c2d 100644
--- a/cpp/tensorrt_llm/runtime/decoderState.cpp
+++ b/cpp/tensorrt_llm/runtime/decoderState.cpp
@@ -131,6 +131,7 @@ void DecoderState::setupSpeculativeDecodingBuffers(
 
     mSpeculativeDecodingMode = speculativeDecodingMode;
 
+    auto constexpr nvTokenIdType = TRTDataType<TokenIdType>::value;
     auto constexpr nvSizeType = TRTDataType<SizeType32>::value;
 
     auto& dInput = mJointDecodingInput;
@@ -179,6 +180,7 @@ void DecoderState::setupSpeculativeDecodingBuffers(
         DecodingInput::ExternalDraftTokensInputs externalDraftTokensInputs;
 
         externalDraftTokensInputs.draftLogits = bufferManager.emptyTensor(MemoryType::kGPU, dtype);
+        externalDraftTokensInputs.draftLogitsHost = bufferManager.emptyTensor(MemoryType::kPINNEDPOOL, dtype);
         externalDraftTokensInputs.draftProbs = bufferManager.emptyTensor(MemoryType::kGPU, dtype);
         externalDraftTokensInputs.targetProbs = bufferManager.emptyTensor(MemoryType::kGPU, dtype);
         externalDraftTokensInputs.numDraftTokens = bufferManager.emptyTensor(MemoryType::kGPU, nvSizeType);
@@ -187,8 +189,8 @@ void DecoderState::setupSpeculativeDecodingBuffers(
             = bufferManager.emptyTensor(MemoryType::kGPU, TRTDataType<bool>::value);
         externalDraftTokensInputs.useDraftLogitsHost
             = bufferManager.emptyTensor(MemoryType::kPINNEDPOOL, TRTDataType<bool>::value);
-        externalDraftTokensInputs.draftTokenIds
-            = bufferManager.emptyTensor(MemoryType::kGPU, nvinfer1::DataType::kINT32);
+        externalDraftTokensInputs.draftTokenIds = bufferManager.emptyTensor(MemoryType::kGPU, nvTokenIdType);
+        externalDraftTokensInputs.draftTokenIdsHost = bufferManager.emptyTensor(MemoryType::kPINNEDPOOL, nvTokenIdType);
 
         dInput->externalDraftTokensInputs = externalDraftTokensInputs;
     }
@@ -366,10 +368,16 @@ void DecoderState::reshapeSpeculativeDecodingBuffers(SpeculativeDecodingMode con
             {mMaxNumSequences, mMaxDecodingEngineTokens, mMaxBeamWidth, static_cast<SizeType32>(vocabSizePadded)});
         dInput.externalDraftTokensInputs->draftProbs->reshape(probsShape);
         dInput.externalDraftTokensInputs->targetProbs->reshape(probsShape);
-        dInput.externalDraftTokensInputs->draftLogits->reshape(
-            ITensor::makeShape({mMaxNumSequences, mMaxDecodingEngineTokens, static_cast<SizeType32>(vocabSizePadded)}));
-        dInput.externalDraftTokensInputs->draftTokenIds->reshape(
-            ITensor::makeShape({mMaxNumSequences, mMaxDecodingEngineTokens}));
+
+        auto const logitsShape = ITensor::makeShape(
+            {mMaxNumSequences, mMaxDecodingEngineTokens, static_cast<SizeType32>(vocabSizePadded)});
+        dInput.externalDraftTokensInputs->draftLogits->reshape(logitsShape);
+        dInput.externalDraftTokensInputs->draftLogitsHost->reshape(logitsShape);
+
+        auto const tokenIdsShape = ITensor::makeShape({mMaxNumSequences, mMaxDecodingEngineTokens});
+        dInput.externalDraftTokensInputs->draftTokenIds->reshape(tokenIdsShape);
+        dInput.externalDraftTokensInputs->draftTokenIdsHost->reshape(tokenIdsShape);
+
         dInput.externalDraftTokensInputs->numDraftTokens->reshape(maxNumSequencesShape);
         dInput.externalDraftTokensInputs->numDraftTokensHost->reshape(maxNumSequencesShape);
         dInput.externalDraftTokensInputs->useDraftLogits->reshape(maxNumSequencesShape);

From b36460d7b5697c9f01628e8573fb50de15be49f5 Mon Sep 17 00:00:00 2001
From: Izzy Putterman <iputterman@nvidia.com>
Date: Fri, 22 Aug 2025 09:57:17 -0700
Subject: [PATCH 45/48] [None][feat] Deepseek: Start Eagle work (#6210)

Signed-off-by: Izzy Putterman <iputterman@nvidia.com>
Co-authored-by: Mike Iovine <miovine@nvidia.com>
---
 .../_torch/models/modeling_deepseekv3.py      |  34 +++++-
 .../_torch/models/modeling_speculative.py     |  10 +-
 .../_torch/pyexecutor/py_executor_creator.py  |   7 +-
 tensorrt_llm/_torch/speculative/eagle3.py     |  52 +++++----
 tensorrt_llm/_torch/speculative/interface.py  |   7 ++
 tensorrt_llm/_torch/speculative/utils.py      |   2 +
 tensorrt_llm/llmapi/llm_args.py               |  19 +++-
 .../_torch/speculative/test_eagle3.py         | 105 ++++++++++++++++++
 8 files changed, 201 insertions(+), 35 deletions(-)

diff --git a/tensorrt_llm/_torch/models/modeling_deepseekv3.py b/tensorrt_llm/_torch/models/modeling_deepseekv3.py
index 8eb9acfada2..c9b9fa979fe 100644
--- a/tensorrt_llm/_torch/models/modeling_deepseekv3.py
+++ b/tensorrt_llm/_torch/models/modeling_deepseekv3.py
@@ -65,7 +65,7 @@
 from ..modules.multi_stream_utils import maybe_execute_in_parallel
 from ..modules.rms_norm import RMSNorm
 from ..peft.lora.layer import LoraLayer
-from ..speculative import MTPSpecMetadata, SpecMetadata
+from ..speculative import SpecMetadata
 from ..utils import AuxStreamType, EventType, Fp4QuantizedTensor
 from .modeling_speculative import SpecDecOneEngineForCausalLM
 from .modeling_utils import (DecoderModel, EagerFusionConfig, filter_weights,
@@ -230,7 +230,7 @@ def __init__(
         aux_stream: Optional[torch.cuda.Stream] = None,
     ):
         config = model_config.pretrained_config
-        predicted_tokens_per_seq = model_config.spec_config.num_nextn_predict_layers + 1 if model_config.spec_config is not None else 1
+        predicted_tokens_per_seq = model_config.spec_config.max_draft_len + 1 if model_config.spec_config is not None else 1
         super().__init__(hidden_size=config.hidden_size,
                          num_attention_heads=config.num_attention_heads,
                          num_key_value_heads=config.num_key_value_heads,
@@ -750,6 +750,7 @@ def forward(
         hidden_states: torch.Tensor,
         attn_metadata: AttentionMetadata,
         residual: torch.Tensor,
+        spec_metadata: Optional[SpecMetadata] = None,
         **kwargs,
     ) -> Tuple[torch.Tensor, torch.Tensor]:
         if residual is None:
@@ -765,16 +766,24 @@ def forward(
             **kwargs,
         )
         if isinstance(self.mlp, Deepseekv3MoE):
+            if spec_metadata is not None and spec_metadata.is_layer_capture(
+                    self.layer_idx):
+                self.fusion_config.POST_MOE_FUSION = False
             return self.forward_MoE(
                 hidden_states=hidden_states,
                 attn_metadata=attn_metadata,
                 residual=residual,
+                spec_metadata=spec_metadata,
             )
         else:
+            if spec_metadata is not None and spec_metadata.is_layer_capture(
+                    self.layer_idx):
+                self.fusion_config.POST_MLP_FUSION = False
             assert isinstance(self.mlp, GatedMLP)
             return self.forward_mlp(
                 hidden_states=hidden_states,
                 residual=residual,
+                spec_metadata=spec_metadata,
             )
 
     def forward_MoE(
@@ -782,6 +791,7 @@ def forward_MoE(
         hidden_states: torch.Tensor,
         attn_metadata: AttentionMetadata,
         residual: torch.Tensor,
+        spec_metadata: Optional[SpecMetadata] = None,
     ) -> Tuple[torch.Tensor, torch.Tensor]:
 
         def _run_MoE(hidden_states, hidden_states_fp4, do_finalize):
@@ -856,6 +866,10 @@ def _run_MoE(hidden_states, hidden_states_fp4, do_finalize):
                 hidden_states, residual = self.moe_allreduce(
                     fc2_output, all_reduce_params=moe_all_reduce_params)
         else:
+            if spec_metadata is not None and spec_metadata.is_layer_capture(
+                    self.layer_idx):
+                spec_metadata.maybe_capture_hidden_states(
+                    self.layer_idx, hidden_states, residual)
             if self.next_layer_layernorm is not None:
                 hidden_states, residual = self.next_layer_layernorm(
                     hidden_states, residual)
@@ -866,6 +880,7 @@ def forward_mlp(
         self,
         hidden_states: torch.Tensor,
         residual: torch.Tensor,
+        spec_metadata: Optional[SpecMetadata] = None,
     ) -> Tuple[torch.Tensor, torch.Tensor]:
 
         if self.fusion_config.PRE_MLP_FUSION:
@@ -903,6 +918,10 @@ def forward_mlp(
                 ),
             )
         else:
+            if spec_metadata is not None and spec_metadata.is_layer_capture(
+                    self.layer_idx):
+                spec_metadata.maybe_capture_hidden_states(
+                    self.layer_idx, hidden_states, residual)
             if self.next_layer_layernorm is not None:
                 hidden_states, residual = self.next_layer_layernorm(
                     hidden_states, residual)
@@ -1105,6 +1124,7 @@ def forward(
                 hidden_states=hidden_states,
                 attn_metadata=attn_metadata,
                 residual=residual,
+                spec_metadata=spec_metadata,
             )
 
         return hidden_states
@@ -1132,7 +1152,8 @@ def __init__(self, model_config: ModelConfig[PretrainedConfig]):
                          model_config=model_config)
 
         self.model_nextn = 0
-        if model_config.spec_config is not None:
+        if model_config.spec_config is not None and model_config.spec_config.spec_dec_mode.is_mtp(
+        ):
             model_nextn = model_config.spec_config.num_nextn_predict_layers
             ckpt_nextn = self.config.num_nextn_predict_layers
             self.num_hidden_layers = self.config.num_hidden_layers
@@ -1167,11 +1188,10 @@ def forward(
         input_ids: torch.IntTensor = None,
         position_ids: Optional[torch.IntTensor] = None,
         inputs_embeds: Optional[torch.FloatTensor] = None,
-        spec_metadata: Optional[MTPSpecMetadata] = None,
+        spec_metadata: Optional[SpecMetadata] = None,
         return_context_logits: bool = False,
         **kwargs,
     ) -> torch.Tensor:
-        attn_metadata.num_generations_per_batch = self.model_nextn + 1
         return super().forward(attn_metadata=attn_metadata,
                                input_ids=input_ids,
                                position_ids=position_ids,
@@ -1313,7 +1333,9 @@ def split_kv_b_proj(kv_b_proj: torch.Tensor,
 
         for name, module in tqdm(all_named_modules.items(),
                                  desc="Loading weights"):
-            if len(module._parameters) > 0:
+            if len(module._parameters) <= 0 or name.startswith("draft_model"):
+                continue
+            else:
                 names = name.split('.')
                 parent_module_name = '.'.join(names[:-1])
                 if "model.layers" in name and int(
diff --git a/tensorrt_llm/_torch/models/modeling_speculative.py b/tensorrt_llm/_torch/models/modeling_speculative.py
index f82c3b4de06..56a489c9635 100644
--- a/tensorrt_llm/_torch/models/modeling_speculative.py
+++ b/tensorrt_llm/_torch/models/modeling_speculative.py
@@ -155,10 +155,12 @@ def __init__(
         else:
             self.hidden_size_in = config.hidden_size
 
-        self.fc = Linear(self.hidden_size_in * 3,
-                         config.hidden_size,
-                         bias=getattr(config, "bias", False),
-                         dtype=config.torch_dtype)
+        if self.spec_config.num_capture_layers > 1:
+            self.fc = Linear(self.hidden_size_in *
+                             self.spec_config.num_capture_layers,
+                             config.hidden_size,
+                             bias=getattr(config, "bias", False),
+                             dtype=config.torch_dtype)
 
         self.midlayer = Eagle3DecoderLayer(model_config, start_layer_idx)
 
diff --git a/tensorrt_llm/_torch/pyexecutor/py_executor_creator.py b/tensorrt_llm/_torch/pyexecutor/py_executor_creator.py
index 12686728cda..ac3bb7a9f53 100644
--- a/tensorrt_llm/_torch/pyexecutor/py_executor_creator.py
+++ b/tensorrt_llm/_torch/pyexecutor/py_executor_creator.py
@@ -23,7 +23,7 @@
                            get_spec_resource_manager)
 from ._util import (KvCacheCreator, _adjust_torch_mem_fraction,
                     create_py_executor_instance, instantiate_sampler, is_mla)
-from .config import PyTorchConfig
+from .config import LoadFormat, PyTorchConfig
 from .config_utils import is_mla
 from .guided_decoder import GuidedDecoder
 from .model_engine import PyTorchModelEngine
@@ -252,13 +252,16 @@ def create_py_executor(
         with mem_monitor.observe_creation_stage(
                 _ExecutorCreationStage.MODEL_ENGINE_DRAFT):
             draft_spec_config = copy.copy(spec_config)
+            draft_pytorch_backend_config = copy.copy(pytorch_backend_config)
+            if spec_config.load_format == "dummy":
+                draft_pytorch_backend_config.load_format = LoadFormat.DUMMY
             # The draft model won't have any draft tokens attached to
             # generation requests when we invoke it autoregressively
             draft_spec_config.max_draft_len = 0
 
             draft_model_engine = PyTorchModelEngine(
                 model_path=spec_config.speculative_model_dir,
-                pytorch_backend_config=pytorch_backend_config,
+                pytorch_backend_config=draft_pytorch_backend_config,
                 batch_size=executor_config.max_batch_size,
                 max_beam_width=executor_config.max_beam_width,
                 max_num_tokens=executor_config.max_num_tokens,
diff --git a/tensorrt_llm/_torch/speculative/eagle3.py b/tensorrt_llm/_torch/speculative/eagle3.py
index 417becf12f3..2d4225641b5 100644
--- a/tensorrt_llm/_torch/speculative/eagle3.py
+++ b/tensorrt_llm/_torch/speculative/eagle3.py
@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import List, Optional, Tuple
+from typing import List, Optional, Set
 
 import torch
 from torch import nn
@@ -35,9 +35,10 @@ def __init__(self, config: "EagleDecodingConfig", dtype: torch.dtype,
         # empty hidden states tensor
         max_num_tokens = min(max_num_tokens,
                              max_num_requests * self.max_seq_len)
-        self.hidden_states = torch.empty((max_num_tokens, self.hidden_size * 3),
-                                         dtype=self.dtype,
-                                         device='cuda')
+        self.hidden_states = torch.empty(
+            (max_num_tokens, self.hidden_size * config.num_capture_layers),
+            dtype=self.dtype,
+            device='cuda')
         # sequence length, only used for metadata preparation
         self.seq_lens = {i: 0 for i in range(max_num_requests)}
         # start indices of each slot
@@ -79,8 +80,7 @@ def get_needed_resource_to_completion(self, request: LlmRequest):
 @dataclass
 class Eagle3SpecMetadata(SpecMetadata):
     hidden_states: List[torch.Tensor] = field(default_factory=list)
-    num_capture_layers: int = 3
-    layers_to_capture: Tuple[int, ...] = field(init=False)
+    layers_to_capture: Optional[Set[int]] = None
     target_model_embed_tokens: Optional[torch.nn.Module] = None
     hidden_size: int = 0
     max_num_tokens: int = 0
@@ -90,14 +90,19 @@ class Eagle3SpecMetadata(SpecMetadata):
     eagle3_resource_manager: Optional[Eagle3ResourceManager] = None
 
     def __post_init__(self):
-        if self.num_layers == 1:
-            self.layers_to_capture = (0, )
-        else:
-            if self.num_layers <= 5:
-                raise ValueError("Not enough hidden layers for EAGLE")
+        if self.layers_to_capture is None:
+            if self.num_layers == 1:
+                self.layers_to_capture = (self.num_layers - 1, )
+            else:
+                if self.num_layers <= 5:
+                    raise ValueError(
+                        "Not enough hidden layers for default EAGLE3 capture")
 
-            self.layers_to_capture = (1, self.num_layers // 2 - 1,
-                                      self.num_layers - 4)
+                self.layers_to_capture = (1, self.num_layers // 2 - 1,
+                                          self.num_layers - 4)
+        else:
+            self.layers_to_capture = sorted(list(self.layers_to_capture))
+        self.num_capture_layers = len(self.layers_to_capture)
 
         # Initialize to 0 to avoid reading uninitialized memory during warmup
         self.hidden_states_read_indices = torch.zeros([self.max_num_tokens],
@@ -186,7 +191,7 @@ class Eagle3OneModelSpecMetadata(SpecMetadata):
     # The hidden states
     hidden_states: Optional[torch.Tensor] = None
     # The layers to be captured
-    layers_to_capture: Tuple[int, ...] = field(init=False)
+    layers_to_capture: Optional[Set[int]] = None
     # The hidden size of the hidden states
     hidden_size: int = 0
     # The max number of tokens
@@ -197,14 +202,19 @@ class Eagle3OneModelSpecMetadata(SpecMetadata):
     batch_indices_cuda: Optional[torch.Tensor] = None
 
     def __post_init__(self):
-        if self.num_layers == 1:
-            self.layers_to_capture = (1, )
-        else:
-            if self.num_layers <= 5:
-                raise ValueError("Not enough hidden layers for EAGLE")
+        if self.layers_to_capture is None:
+            if self.num_layers == 1:
+                self.layers_to_capture = (self.num_layers - 1, )
+            else:
+                if self.num_layers <= 5:
+                    raise ValueError(
+                        "Not enough hidden layers for default EAGLE3 capture")
 
-            self.layers_to_capture = (1, self.num_layers // 2 - 1,
-                                      self.num_layers - 4)
+                self.layers_to_capture = (1, self.num_layers // 2 - 1,
+                                          self.num_layers - 4)
+        else:
+            self.layers_to_capture = sorted(list(self.layers_to_capture))
+        self.num_capture_layers = len(self.layers_to_capture)
         self.hidden_states = torch.empty(
             (self.max_num_tokens,
              self.hidden_size * len(self.layers_to_capture)),
diff --git a/tensorrt_llm/_torch/speculative/interface.py b/tensorrt_llm/_torch/speculative/interface.py
index f7cdd92a561..1d306b90291 100644
--- a/tensorrt_llm/_torch/speculative/interface.py
+++ b/tensorrt_llm/_torch/speculative/interface.py
@@ -185,6 +185,13 @@ def create_cuda_graph_metadata(self, max_batch_size: int):
         cuda_graph_metadata.__post_init__()
         return cuda_graph_metadata
 
+    def is_layer_capture(self, layer_id: int):
+        """
+        Whether the layer should be captured (eg for Eagle3).
+        By default, does nothing.
+        """
+        return False
+
     def maybe_capture_hidden_states(self, layer_id: int,
                                     hidden_states: torch.Tensor,
                                     residual: torch.Tensor) -> None:
diff --git a/tensorrt_llm/_torch/speculative/utils.py b/tensorrt_llm/_torch/speculative/utils.py
index c4a4ccf7e3c..16fef4862b3 100644
--- a/tensorrt_llm/_torch/speculative/utils.py
+++ b/tensorrt_llm/_torch/speculative/utils.py
@@ -38,6 +38,7 @@ def get_spec_metadata(spec_config,
             dtype=model_config.torch_dtype,
             is_draft_model=is_draft_model,
             eagle3_resource_manager=spec_resource_manager,
+            layers_to_capture=spec_config.eagle3_layers_to_capture,
         )
     if spec_config.spec_dec_mode.is_eagle3_one_model():
         return Eagle3OneModelSpecMetadata(
@@ -47,6 +48,7 @@ def get_spec_metadata(spec_config,
             num_layers=model_config.num_hidden_layers,
             hidden_size=model_config.hidden_size,
             max_num_tokens=max_num_tokens,
+            layers_to_capture=spec_config.eagle3_layers_to_capture,
         )
     if  spec_config.spec_dec_mode.is_draft_target() or \
         spec_config.spec_dec_mode.is_ngram() or \
diff --git a/tensorrt_llm/llmapi/llm_args.py b/tensorrt_llm/llmapi/llm_args.py
index da5071e3b0a..6ed4dea76c7 100644
--- a/tensorrt_llm/llmapi/llm_args.py
+++ b/tensorrt_llm/llmapi/llm_args.py
@@ -9,7 +9,7 @@
 from enum import Enum, EnumMeta
 from pathlib import Path
 from typing import (TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional,
-                    Type, TypeAlias, TypeVar, Union, get_args, get_origin)
+                    Set, Type, TypeAlias, TypeVar, Union, get_args, get_origin)
 
 import torch
 import yaml
@@ -352,6 +352,7 @@ class DecodingBaseConfig(StrictBaseModel):
     # When specified, speculation will be disabled at batch sizes above
     # this value. Otherwise, speculation will always be on.
     max_concurrency: Optional[int] = None
+    load_format: Optional[str] = None
 
     @classmethod
     def from_dict(cls, data: dict):
@@ -424,6 +425,7 @@ class EagleDecodingConfig(DecodingBaseConfig):
     num_eagle_layers: Optional[int] = None
     max_non_leaves_per_layer: Optional[int] = None
     eagle3_one_model: Optional[bool] = True
+    eagle3_layers_to_capture: Optional[Set[int]] = None
 
     @classmethod
     def from_dict(cls, data: dict):
@@ -443,6 +445,17 @@ def spec_dec_mode(self):
             return TorchSpeculativeDecodingMode.EAGLE3_ONE_MODEL
         return TorchSpeculativeDecodingMode.EAGLE3
 
+    @functools.cached_property
+    def num_capture_layers(self):
+        """
+        Returns the number of layers to capture of the target model.
+        If eagle3_layers_to_capture is not None, return the length of the set.
+        Otherwise, assume Eagle3 base set and return 3.
+        """
+        if self.eagle3_layers_to_capture is not None:
+            return len(self.eagle3_layers_to_capture)
+        return 3
+
 
 class UserProvidedDecodingConfig(DecodingBaseConfig):
     # Cannot use real type annotations due to circular imports
@@ -523,7 +536,9 @@ class MTPDecodingConfig(DecodingBaseConfig):
 
     @classmethod
     def from_dict(cls, data: dict):
-        return cls(**data)
+        out = cls(**data)
+        out.max_draft_len = out.num_nextn_predict_layers
+        return out
 
     decoding_type: ClassVar[str] = "MTP"
 
diff --git a/tests/unittest/_torch/speculative/test_eagle3.py b/tests/unittest/_torch/speculative/test_eagle3.py
index ffb8e33766a..f26fa244f1f 100644
--- a/tests/unittest/_torch/speculative/test_eagle3.py
+++ b/tests/unittest/_torch/speculative/test_eagle3.py
@@ -1,6 +1,9 @@
+import json
 import os
 import sys
+import tempfile
 import unittest
+from pathlib import Path
 
 import pytest
 import torch
@@ -120,5 +123,107 @@ def test_llama_eagle3(use_cuda_graph: bool, attn_backend: str,
         assert text_spec == text_ref
 
 
+def test_deepseek_eagle3():
+    use_cuda_graph = True
+    attn_backend = "TRTLLM"
+    disable_overlap_scheduler = False
+    enable_block_reuse = False
+    use_one_model = False
+    enable_chunked_prefill = False
+
+    # Eagle3 one model works with overlap scheduler and block reuse.
+    total_mem_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
+    if total_mem_gb < 150:
+        pytest.skip("Not enough memory to load target + draft model")
+
+    models_path = llm_models_root()
+    eagle_config = {
+        'architectures': ['LlamaForCausalLMEagle3'],
+        'attention_bias': False,
+        'attention_dropout': 0.0,
+        'bos_token_id': 128000,
+        'eos_token_id': [128001, 128008, 128009],
+        'eagle_config': {
+            'use_aux_hidden_state': False,
+            'use_input_layernorm_in_first_layer': True,
+            'use_last_layernorm': True,
+            'use_mtp_layernorm': False
+        },
+        'head_dim': 128,
+        'hidden_act': 'silu',
+        'hidden_size': 2560,
+        'initializer_range': 0.02,
+        'intermediate_size': 16384,
+        'max_position_embeddings': 4096,
+        'mlp_bias': False,
+        'model_type': 'llama',
+        'num_attention_heads': 32,
+        'num_eagle_features': 1,
+        'num_hidden_layers': 1,
+        'num_key_value_heads': 8,
+        'pretraining_tp': 1,
+        'rms_norm_eps': 1e-05,
+        'rope_scaling': {
+            'factor': 8.0,
+            'high_freq_factor': 4.0,
+            'low_freq_factor': 1.0,
+            'original_max_position_embeddings': 8192,
+            'rope_type': 'llama3'
+        },
+        'rope_theta': 500000.0,
+        'tie_word_embeddings': False,
+        'torch_dtype': 'bfloat16',
+        'transformers_version': '4.52.4',
+        'use_cache': True,
+        'vocab_size': 129280,
+        'draft_vocab_size': 129280
+    }
+    with tempfile.TemporaryDirectory() as temp_dir:
+        eagle_model_dir = Path(temp_dir)
+        config_path = eagle_model_dir / "config.json"
+        with config_path.open("w") as f:
+            json.dump(eagle_config, f, indent=2)
+        target_model_dir = f"{models_path}/DeepSeek-V3-Lite/nvfp4_moe_only"
+
+        # bs > 1 gives non-deterministic when doing IFB. There are slight chances
+        # that ref and spec does not match 100%
+        max_batch_size = 16
+        max_draft_len = 3
+        kv_cache_config = KvCacheConfig(enable_block_reuse=enable_block_reuse,
+                                        free_gpu_memory_fraction=0.5)
+        cuda_graph_config = CudaGraphConfig(
+            batch_sizes=[1]) if use_cuda_graph else None
+
+        llm_common_config = dict(
+            model=target_model_dir,
+            attn_backend=attn_backend,
+            disable_overlap_scheduler=disable_overlap_scheduler,
+            cuda_graph_config=cuda_graph_config,
+            max_batch_size=max_batch_size,
+            max_num_tokens=4096,
+            max_seq_len=4096,
+            kv_cache_config=kv_cache_config,
+            enable_chunked_prefill=enable_chunked_prefill,
+        )
+
+        spec_config = EagleDecodingConfig(
+            max_draft_len=max_draft_len,
+            speculative_model_dir=eagle_model_dir,
+            # Llama 3 does not support one model eagle.
+            eagle3_one_model=use_one_model,
+            eagle3_layers_to_capture={29},
+            load_format="dummy")
+
+        llm_spec = LLM(**llm_common_config, speculative_config=spec_config)
+
+        tok_ids = llm_spec.tokenizer.encode("The future of AI is")
+
+        sampling_params = SamplingParams(max_tokens=32, temperature=0)
+        for output in llm_spec.generate_async(tok_ids,
+                                              sampling_params,
+                                              streaming=True):
+            pass
+
+
 if __name__ == "__main__":
     unittest.main()

From 81fd468feccf8f575b51ab489e09823996c04c0d Mon Sep 17 00:00:00 2001
From: Frank <3429989+FrankD412@users.noreply.github.com>
Date: Fri, 22 Aug 2025 10:28:57 -0700
Subject: [PATCH 46/48] [None][fix] Correct KV cache percentage report out.
 (#7102)

Signed-off-by: Frank Di Natale <3429989+FrankD412@users.noreply.github.com>
---
 tensorrt_llm/bench/dataclasses/reporting.py | 30 ++++++++++++---------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/tensorrt_llm/bench/dataclasses/reporting.py b/tensorrt_llm/bench/dataclasses/reporting.py
index acf7f60bcbb..fd76466cd5a 100755
--- a/tensorrt_llm/bench/dataclasses/reporting.py
+++ b/tensorrt_llm/bench/dataclasses/reporting.py
@@ -273,6 +273,22 @@ def get_statistics_dict(self) -> Dict[str, Any]:
             },
         }
 
+        # Retrieve KV cache information.
+        kv_cache_config = self.kwargs.get("kv_cache_config", KvCacheConfig())
+        if isinstance(kv_cache_config, KvCacheConfig):
+            kv_cache_dtype = kv_cache_config.dtype
+            kv_cache_mem_percent = kv_cache_config.free_gpu_memory_fraction
+        elif isinstance(kv_cache_config, dict):
+            kv_cache_dtype = kv_cache_config.get("dtype", "auto")
+            kv_cache_mem_percent = kv_cache_config.get(
+                "free_gpu_memory_fraction")
+        else:
+            raise ValueError(
+                f"Invalid kv_cache_config type: {type(kv_cache_config)}.")
+
+        kv_cache_mem_percent = f"{kv_cache_mem_percent * 100.0:.2f}%" \
+             if kv_cache_mem_percent is not None else "None"
+
         # Engine/Backend details
         if self.rt_cfg.backend not in ('pytorch', '_autodeploy'):
             config_path = self.rt_cfg.engine_dir / "config.json"
@@ -302,15 +318,6 @@ def get_statistics_dict(self) -> Dict[str, Any]:
             model = self.rt_cfg.model_path or self.rt_cfg.model
             model_config = ModelConfig.from_pretrained(model,
                                                        trust_remote_code=True)
-            kv_cache_config = self.kwargs.get("kv_cache_config",
-                                              KvCacheConfig())
-            if isinstance(kv_cache_config, KvCacheConfig):
-                kv_cache_dtype = kv_cache_config.dtype
-            elif isinstance(kv_cache_config, dict):
-                kv_cache_dtype = kv_cache_config.get("dtype", "auto")
-            else:
-                raise ValueError(
-                    f"Invalid kv_cache_config type: {type(kv_cache_config)}.")
 
             validate_and_set_kv_cache_quant(model_config, kv_cache_dtype)
 
@@ -336,8 +343,7 @@ def get_statistics_dict(self) -> Dict[str, Any]:
             "max_batch_size": self.rt_cfg.settings_config.max_batch_size,
             "max_num_tokens": self.rt_cfg.settings_config.max_num_tokens,
             "scheduling_policy": self.rt_cfg.settings_config.scheduler_policy,
-            "kv_cache_percentage":
-            self.rt_cfg.settings_config.kv_cache_percent * 100.0,
+            "kv_cache_percentage": kv_cache_mem_percent,
             "issue_rate": self.convert_rate_to_s(self.statistics.issue_rate_ns)
         }
 
@@ -526,7 +532,7 @@ def report_statistics(self) -> None:
             f"Max Runtime Batch Size: {world_info['max_batch_size']}\n"
             f"Max Runtime Tokens:     {world_info['max_num_tokens']}\n"
             f"Scheduling Policy:      {world_info['scheduling_policy']}\n"
-            f"KV Memory Percentage:   {world_info['kv_cache_percentage']:.2f}%\n"
+            f"KV Memory Percentage:   {world_info['kv_cache_percentage']}\n"
             f"Issue Rate (req/sec):   {world_info['issue_rate']:.4E}\n"
             f"\n")
 

From 3d54a1a52181390ca58a39f948a8753e51f98543 Mon Sep 17 00:00:00 2001
From: Grace Ho <146482179+gracehonv@users.noreply.github.com>
Date: Fri, 22 Aug 2025 21:57:37 -0700
Subject: [PATCH 47/48] [None] [feat] nsys profile output kernel classifier
 (#7020)

Signed-off-by: Grace Ho <grho@nvidia.com>
---
 .../profiler/nsys_profile_tools/README.md     | 174 +++++++++
 .../nsys_profile_tools/gputrc2graph.py        | 349 ++++++++++++++++++
 .../nsys_profile_tools/images/csv.png         | Bin 0 -> 135258 bytes
 .../nsys_profile_tools/images/html.png        | Bin 0 -> 143191 bytes
 .../nsys_profile_tools/images/html_tbl.png    | Bin 0 -> 153212 bytes
 .../trtllm_engine_model.json                  |  62 ++++
 6 files changed, 585 insertions(+)
 create mode 100644 tensorrt_llm/tools/profiler/nsys_profile_tools/README.md
 create mode 100755 tensorrt_llm/tools/profiler/nsys_profile_tools/gputrc2graph.py
 create mode 100644 tensorrt_llm/tools/profiler/nsys_profile_tools/images/csv.png
 create mode 100644 tensorrt_llm/tools/profiler/nsys_profile_tools/images/html.png
 create mode 100644 tensorrt_llm/tools/profiler/nsys_profile_tools/images/html_tbl.png
 create mode 100644 tensorrt_llm/tools/profiler/nsys_profile_tools/trtllm_engine_model.json

diff --git a/tensorrt_llm/tools/profiler/nsys_profile_tools/README.md b/tensorrt_llm/tools/profiler/nsys_profile_tools/README.md
new file mode 100644
index 00000000000..b7b9f084de3
--- /dev/null
+++ b/tensorrt_llm/tools/profiler/nsys_profile_tools/README.md
@@ -0,0 +1,174 @@
+# gputrc2graph.py
+
+This script processes NVIDIA Nsight Systems (`nsys`) GPU trace files
+(`.nsys-rep`) with -t cuda tracing enabled, and generates kernel-level
+summaries and visualizations of GPU and non-GPU time. It is useful for
+profiling and analyzing nsys profile output.
+
+## Usage
+
+### Command-line Arguments
+
+- `--in_file`
+  **(required)**
+  List of input files and their metadata. Each entry should be in the format:
+  `<nsys-rep>,<engine>,<model>,<elapsed_nonprofiled_sec>`
+  - `nsys-rep`: Path to the `.nsys-rep` file.
+  - `engine`: Engine name (e.g., `trtllm`).
+  - `model`: Model name (e.g., `llama`, `gpt-oss`, `ds`).
+  - `elapsed_nonprofiled_sec`: Wall-clock runtime (in seconds) without
+    profiling. Specify `0` to use the elapsed GPU time calculated from the nsys-rep file (this may inflate non-GPU time if actual runtime without profiling is less). Multiple entries can be provided, separated by spaces.
+
+- `--out_dir`
+  Output directory for the generated CSV and HTML files.
+  If not specified, results are saved in the current directory.
+
+- `--title`
+  Title for the HTML chart/visualization.
+
+- `--nsys_cmd`
+  Path to the `nsys` command.
+  Default: `nsys` (assumes it is in your PATH).
+  Use this if `nsys` is not in your system PATH.
+
+## Notes
+
+- Make sure you have pandas and plotly python packages installed.
+- Make sure [nsys](https://developer.nvidia.com/nsight-systems/get-started) is
+installed, and specify the path to the `nsys` command with `--nsys_cmd` if it
+ is not in your PATH.
+- For more details on available engines and models, see the help string in
+  the script or run:
+
+```bash
+python3 gputrc2graph.py --help
+```
+
+## Example 1: analyze a single profile
+
+To analyze the GPU cycles of for example, a llama-3.1-8B model with trtllm:
+
+1. Run the following command to collect nsys profile, for trtllm serve config.
+
+   ```bash
+   nsys profile -t cuda -o nsys_res -f true --trace-fork-before-exec=true \
+   --cuda-graph-trace=node --delay <DELAY> --duration <DURATION> \
+   python3 -m trtllm-serve meta-llama/Llama-4-Scout-17B-16E-Instruct ...
+   ```
+
+   where:
+
+   - DELAY: how many seconds to delay nsys from collecting profiles, needed so
+     that profiles aren't captured till trtllm server has come up and load
+     generation starts.
+   - DURATION: how many seconds for nsys profile to run before generating the
+     profile. This should be > the duration of the run.
+
+2. Run again, this time without collecting the profile, and get the total run
+   time in seconds. This value will be used by the script to calculate the
+   CPU(non-GPU) seconds for the analysis.
+
+3. Say the run elapsed time is .35 seconds, from step #2. Run script to
+   analyze:
+
+   ```bash
+   python3 gputrc2graph.py \
+   --in_file run1.nsys-rep,trtllm,llama,.35
+   ```
+
+The command will produce 2 files for analysis:
+
+- result.html: this categorizes kernel names into different categories in a
+  stacked bar chart.
+- result.csv: shows how the kernel names are mapped to the different
+  categories.
+
+### HTML visualization with result.html
+
+The html file shows the number of elapsed seconds due to different GPU
+Substages or categories, which consist of moe_gemm as the biggest
+category, at .14 seconds, followed by "attn" kernels. This lets the user
+prioritize the kernels to focus on for performance optimizations.
+
+![Example GPU Trace Visualization](images/html.png)
+
+There's also an appended data table underneath the bar chart for copying out to
+ other post-processing tools.
+
+![Example GPU Trace Visualization Table](images/html_tbl.png)
+
+### Kernel to category mapping with result.csv
+
+Suppose the user would like to focus on improving decreasing calls to nccl
+kernels. The next step is to use the result.csv to dive into what the kernels
+are which compose the nccl GPU cycles. The following image shows that
+ar_fusion all reduce kernel to be the biggest contributor to GPU cycles for 
+nccl, followed by AllGather.
+
+![Example GPU Trace csv](images/csv.png)
+
+## Example 2: analyze multiple profiles
+
+Suppose the user has multiple nsys trace files, captured for different models,
+say llama and gpt-oss in this case, and wish to compare their GPU/non-GPU
+time, something like the following command can be used.
+
+```bash
+python3 gputrc2graph.py \
+--in_file run1.nsys-rep,trtllm,llama,100 run2.nsys-rep,trtllm,gpt-oss,102 \
+--out_dir results
+```
+
+The analysis process is similar to example 1 but now there will be multiple
+stack bar charts that can be compared.  The categories for the different
+kernels will remain the same, so that it's easy to compare the GPU cycles for
+the same categories.
+
+Once a category is shown to have more cycles for one configuration than
+another, the next step would be to use the csv file to see what kernels are
+mapped into that category, and which kernels are taking the largest amount of
+time which would cause a difference for the overall category.
+
+## Example 3: add new classification for a new model
+
+To create a new engine DEF with model ABC, just add another json file in the 
+same directory as gputrc2graph.py with the same format as the other json files.
+The script will automatically pick up all the json files in the same directory 
+as engine/model specifications.
+
+Then, for this new model, suppose there are 4 kernels to be classified into
+"gemm" and "attn", where the gemm kernelshave names with "*H*" or "*I*" in
+them, and attn kernels have names with "*J*" or "*K*" in them, just add another
+ .json file in the same directory as gputrc2graph.py with the same format as
+ the other json files, like the following:
+
+```json
+{
+  "DEF": {
+    "ABC": {
+      "H|I": "gemm",
+      "J|K": "attn",
+      "CUDA mem": "non-gpu-H_D_memops",
+      ".*": "misc"
+    }
+  }
+}
+```
+
+Each entry in the dictionary consists of:
+
+- key: a regex used to classify the kernels
+- value: the category to classify the kernels into.
+
+The last 2 entries are common for all engine/models, consisting of CUDA memory
+operations and a 'misc' for anything that's leftover and can't be classified.
+
+When invoking gputrc2graph.py, specify a trace file with this new model/engine
+like the following:
+
+```bash
+--in_file new.nsys-rep,DEF,ABC,<runtime>
+```
+
+If the engine_DEF.json file already exists, just add the model as a new node in
+ the existing engine file, after the other models.
diff --git a/tensorrt_llm/tools/profiler/nsys_profile_tools/gputrc2graph.py b/tensorrt_llm/tools/profiler/nsys_profile_tools/gputrc2graph.py
new file mode 100755
index 00000000000..1ca8a0ff235
--- /dev/null
+++ b/tensorrt_llm/tools/profiler/nsys_profile_tools/gputrc2graph.py
@@ -0,0 +1,349 @@
+# SPDX-FileCopyrightText: Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+"""
+    This generates gpu kernel analysis output from nsys rep. Will call nsys
+    stats  -r cuda_gpu_trace, get non-overlapped gpu cycles, then generate
+    csv and html output for analysis
+"""
+
+import argparse
+import logging
+import os
+
+import regex as re
+
+logger = logging.getLogger(__name__)
+
+
+# helper data class for annotating kernels
+def load_engine_model():
+    """returns engine_model built from all json files in the current dir"""
+    import glob
+    import json
+
+    engine_model = {}
+
+    json_files = glob.glob(
+        os.path.join(os.path.dirname(__file__) or ".", "*.json"))
+    for fname in json_files:
+        with open(fname, encoding="utf-8") as f:
+            engine_model.update(json.load(f))
+    return engine_model
+
+
+class GPUTrace2Graph:
+    """
+    Parses output of nsys report, generates csv and bar chart output
+    """
+
+    def __init__(self):
+        import pandas as pd  # avoid importing till needed
+
+        self.pd = pd
+        self.pd.options.mode.copy_on_write = True
+
+    # helper functions for generating trace->summary csvs
+    def gen_nonoverlapped_sum_from_gputrace(self, in_file, out_file):
+        logger.info("loading %s", in_file)
+        df = self.pd.read_csv(in_file,
+                              usecols=["Start (ns)", "Duration (ns)", "Name"])
+        if df.empty:
+            return
+        df["End (ns)"] = df["Start (ns)"] + df["Duration (ns)"]
+        df = self.sum_non_overlapping_intervals(df)
+        # get ready to print table with elapsed times per kernel
+        df["Instances"] = 1
+        df_sum = df.groupby("Name", as_index=False).agg({
+            "Elapsed Time (ns)": "sum",
+            "Duration (ns)": "sum",
+            "Instances": "size"
+        })
+
+        # generate csv
+        df_sum["Total Time (sec)"] = df_sum["Duration (ns)"] / 1e9
+        df_sum["Elapsed Time (sec)"] = df_sum["Elapsed Time (ns)"] / 1e9
+        df_sum = df_sum.sort_values(by="Elapsed Time (sec)", ascending=False)
+        df_sum[["Elapsed Time (sec)", "Total Time (sec)", "Instances",
+                "Name"]].to_csv(out_file, index=False)
+
+    def sum_non_overlapping_intervals(self, df):
+        """
+        returns new sorted df with Elapsed Time (ns) column using
+        vectorized operations
+        """
+        logger.info("sorting %s trace records by start time", str(df.shape))
+        assert not df.empty, 'empty nsys records'
+        # Sort by start time and reset index
+        df = df.sort_values(by="Start (ns)").reset_index(drop=True)
+
+        # Initialize elapsed time as duration
+        df["Elapsed Time (ns)"] = df["Duration (ns)"]
+
+        # Get numpy arrays for faster operations
+        starts = df["Start (ns)"].values
+        ends = df["End (ns)"].values
+
+        # Keep track of current interval end
+        current_end = ends[0]
+        display_units = max(1, int(len(df) / 100))
+        # Update current_end for overlapping intervals
+        for i in range(1, len(df)):
+            if i % display_units == 0:
+                print(f"processing trace: {int(i/len(df) * 100)} %", end="\r")
+            if starts[i] <= current_end:
+                if ends[i] > current_end:
+                    # Partial overlap
+                    df.iloc[i, df.columns.get_loc("Elapsed Time (ns)")] = (
+                        ends[i] - current_end)
+                    current_end = ends[i]
+                else:
+                    # Complete overlap
+                    df.iloc[i, df.columns.get_loc("Elapsed Time (ns)")] = 0
+            else:
+                # No overlap
+                current_end = ends[i]
+
+        return df
+
+    # functions for generating html files
+    def make_html(self, df, output_dir, title):
+        """make html graph from df"""
+        import plotly.express as px
+
+        if df.empty:
+            return
+        output_name = os.path.join(output_dir, "result")
+        if not title:
+            title = "Model_Engine"
+        x = "Model_Engine"
+        y = "Elapsed Time (sec)"
+        color = "Category"
+        """ generate kernel mapping table  """
+        # Sort Model_Engine categories by last field after underscore
+        df["Model_Engine"] = self.pd.Categorical(
+            df["Model_Engine"],
+            sorted(df["Model_Engine"].unique(), key=lambda x: x.split("_")[-1]),
+        )
+        df[["Model_Engine", color, "Instances", "Name",
+            y]].sort_values(by=color).to_csv(f"{output_name}.csv", index=False)
+        graph = px.histogram(
+            df.round(2),
+            x=x,
+            y=y,
+            title=(f"{y} for {title}"),
+            color=color,
+            text_auto=True,
+        )
+        # wrap x axis labels
+        graph.update_xaxes(automargin=True)
+        graph.write_html(f"{output_name}.html")
+        """
+            Generate data table with columns per Model_Engine into result.html
+        """
+        pivot_df = df.pivot_table(
+            values="Elapsed Time (sec)",
+            index="Category",
+            columns="Model_Engine",
+            aggfunc="sum",
+            observed=False,
+        ).round(2)
+        # Add sum row at bottom
+        pivot_df.loc["total_elapsed_sec"] = pivot_df.sum()
+        pivot_df.fillna("").to_html("temp.html")
+        with (
+                open(f"{output_name}.html", "a", encoding="utf-8") as outfile,
+                open("temp.html", encoding="utf-8") as infile,
+        ):
+            outfile.write(infile.read())
+        os.remove("temp.html")
+
+        print(f"Finished generating: \n"
+              f" {output_name}.html for stack bar chart \n"
+              f" {output_name}.csv for Kernel-Category mapping")
+
+    def anno_gpu_kernname(self, df, mapping):
+        """add "Category" column"""
+
+        def anno_gpu_kernname_helper(name):
+            for kern_name, val in mapping.items():
+                if re.search(kern_name, name):
+                    return val
+
+        df["Category"] = df["Name"].apply(anno_gpu_kernname_helper)
+
+    def make_nongpu_row(self, df, nongpu_sec):
+        """this will append non-gpu time entry at end of df"""
+        nongpu_row = self.pd.DataFrame([df.iloc[-1]])
+        nongpu_row["Category"] = nongpu_row["Name"] = "CPU(non-GPU)"
+        nongpu_row["Instances"] = 1
+        nongpu_row["Elapsed Time (sec)"] = nongpu_sec
+        return nongpu_row
+
+    def is_valid_file(self, base_file):
+        """asserts if base_file is non-existent or is empty"""
+        assert (os.path.isfile(base_file) and os.path.getsize(base_file)
+                > 0), f"{base_file} doesn't exist or is empty"
+
+    def should_gen_file(self, new_file, base_file):
+        """figure out if new file should be generated from base_file"""
+        self.is_valid_file(base_file)
+        if (os.path.exists(new_file)
+                and (os.path.getmtime(new_file) > os.path.getmtime(base_file))
+                and (os.path.getsize(base_file) > 0)):
+            logger.info("reusing %s", new_file)
+            return False
+        else:
+            logger.info("generating %s", new_file)
+            return True
+
+    def gen_sum_file(self, file, nsys_cmd):
+        """
+        generates sum file from nsys trace with times per kernel and
+        returns the name of the sum file
+        """
+        import subprocess  # nosec B404
+
+        file_dir = os.path.dirname(file)
+        file_name = os.path.basename(file)
+
+        if not file_dir:
+            file_dir = "."
+        # Walk through trace and get the total non-overlapped time
+        nsys_stats_file = os.path.join(file_dir,
+                                       f"{file_name}_cuda_gpu_trace.csv")
+        sum_file = os.path.join(file_dir,
+                                f"{file_name}_cuda_gpu_kernel_tracesum.csv")
+        if self.should_gen_file(nsys_stats_file, file):
+            cmd = [
+                nsys_cmd,
+                "stats",
+                "-r",
+                "cuda_gpu_trace",
+                file,
+                "-o",
+                f"{file_dir}/{file_name}",
+            ]
+            cmd_str = " ".join(cmd)
+            logger.info("+ %s", cmd_str)
+            # estimate time based on calibrated 240M/min
+            file_size_mb = os.path.getsize(file) / 1e6
+            logger.info(
+                "nsys stats for %.2f MB file expected to take %.2f min",
+                file_size_mb,
+                file_size_mb / 240,
+            )
+            try:
+                subprocess.run(cmd)
+            except Exception:
+                logger.error("%s failed; Use --nsys_cmd to specify nsys path",
+                             cmd_str)
+                exit(1)
+            logger.info("generating non-overalapped sum %s", sum_file)
+            self.gen_nonoverlapped_sum_from_gputrace(nsys_stats_file, sum_file)
+        self.is_valid_file(sum_file)
+        logger.info("Finished generating %s", sum_file)
+        return sum_file
+
+    def gen_graph(self, in_file, out_dir, title, nsys_cmd, engine_model):
+        """generates graph and csv file from in_file into out_dir"""
+        # Initialize an empty DataFrame to store combined data
+        combined_df = self.pd.DataFrame()
+        for idx, (file, engine, model, total_sec) in enumerate(in_file):
+            file_dir = os.path.dirname(file)
+            file_name = os.path.basename(file)
+            if not file_dir:
+                file_dir = "."
+            sum_file = self.gen_sum_file(file, nsys_cmd)
+            # read kernel summary file
+            df = self.pd.read_csv(sum_file)
+            # annotate kernel to their categories
+            assert engine_model.get(engine), f"engine {engine} unknown"
+            assert engine_model[engine].get(model), f"model {model} unknown"
+            # remove nsys-rep from file_name for shorter x-label
+            file_name = file_name.replace(".nsys-rep", "")
+            df["Model_Engine"] = f"{model}_{engine}_{file_name}_{idx}"
+            self.anno_gpu_kernname(df, engine_model[engine][model])
+            # patch in non-gpu time
+            gpu_sec = round(df["Elapsed Time (sec)"].sum(), 1)
+            total_sec = round(float(total_sec), 1)
+            if total_sec < gpu_sec:
+                logger.warning(
+                    "Elapsed sec %.2f < GPU sec %.2f resetting Elapsed sec ",
+                    total_sec,
+                    gpu_sec,
+                )
+                total_sec = gpu_sec
+            nongpu_row = self.make_nongpu_row(df, total_sec - gpu_sec)
+            df = self.pd.concat([df, nongpu_row], ignore_index=True)
+            combined_df = self.pd.concat([combined_df, df], ignore_index=True)
+        if out_dir is None:
+            out_dir = "."
+        else:
+            os.makedirs(out_dir, exist_ok=True)
+        # generate html file
+        self.make_html(combined_df, out_dir, title)
+
+
+def parse_tuple(s):
+    return tuple(s.split(","))
+
+
+def main():
+    logging.basicConfig(format=("%(asctime)s - %(levelname)s - %(message)s"),
+                        level=logging.INFO)
+    parser = argparse.ArgumentParser(
+        description=(
+            "Process nsys rep and generate kernel non-overlapped cycles. \n"
+            "Example:\n"
+            "gputrc2graph.py --in_file d1.nsys-rep,trtllm,llama,100 \n"
+            "d2.nsys-rep,trtllm,gpt-oss,102 "
+            '--out_dir results/ --title "Model=gpt-oss TRTLLM chart"'),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    # load supported engine_model
+    engine_model_supported = load_engine_model()
+    # Get a string representation of supported engine/model combinations
+    engine_model_supported_str = ", ".join(
+        f"{engine}:[{', '.join(models.keys())}]"
+        for engine, models in engine_model_supported.items())
+    parser.add_argument(
+        "--in_file",
+        type=parse_tuple,
+        nargs="+",
+        help=("list of (nsys-rep, engine, model, elapsed_nonprofiled_sec) "
+              "separated by space. Elapsed_nonprofiled_sec is runtime without "
+              "profiling used to calculate non-gpu time. Specify 0 to use "
+              "elapsed time from nsys-rep but that might inflate non-gpu time. "
+              f"Available engine:[model] are: {engine_model_supported_str} "
+              f"Example: --in_file d1.nsys-rep,sglan,llama,100 "
+              "d2.nsys-rep,trtllm,gpt-oss,102"),
+        required=True,
+    )
+    parser.add_argument("--out_dir", help=("output dir for result.csv/html"))
+    parser.add_argument("--title", help=("title for html chart"))
+    parser.add_argument(
+        "--nsys_cmd",
+        help=("nsys cmd, e.g. /usr/bin/nsys, Default: nsys"),
+        default="nsys",
+    )
+    args = parser.parse_args()
+    gputrace = GPUTrace2Graph()
+    gputrace.gen_graph(args.in_file, args.out_dir, args.title, args.nsys_cmd,
+                       engine_model_supported)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tensorrt_llm/tools/profiler/nsys_profile_tools/images/csv.png b/tensorrt_llm/tools/profiler/nsys_profile_tools/images/csv.png
new file mode 100644
index 0000000000000000000000000000000000000000..3fd412f657772e98aaf6c0b9781faef414a865c2
GIT binary patch
literal 135258
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

literal 0
HcmV?d00001

diff --git a/tensorrt_llm/tools/profiler/nsys_profile_tools/images/html.png b/tensorrt_llm/tools/profiler/nsys_profile_tools/images/html.png
new file mode 100644
index 0000000000000000000000000000000000000000..35992c7f896c8a8e03ff9708d37026ad34d10802
GIT binary patch
literal 143191
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%0A#7+ih0&$YIl8B_(c1a{^1>9yW`MVOBb
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%0DwxPuvt0Lm1Uc)T+%g_%O<$xtz7p
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
btLFYL(hASpkf4|H8~7OLndlasu)F*}x)S1H

literal 0
HcmV?d00001

diff --git a/tensorrt_llm/tools/profiler/nsys_profile_tools/images/html_tbl.png b/tensorrt_llm/tools/profiler/nsys_profile_tools/images/html_tbl.png
new file mode 100644
index 0000000000000000000000000000000000000000..cb134a014cd98f562cee2f074352a78917ef84a2
GIT binary patch
literal 153212
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
K$*0L(yZ>K?-f`dn

literal 0
HcmV?d00001

diff --git a/tensorrt_llm/tools/profiler/nsys_profile_tools/trtllm_engine_model.json b/tensorrt_llm/tools/profiler/nsys_profile_tools/trtllm_engine_model.json
new file mode 100644
index 00000000000..9287a6d9c6d
--- /dev/null
+++ b/tensorrt_llm/tools/profiler/nsys_profile_tools/trtllm_engine_model.json
@@ -0,0 +1,62 @@
+{
+  "trtllm": {
+    "llama": {
+      "Fused_Moe_Kernel|gemm::|fused_moe|bmm_|GemmUniversal": "moe_gemm",
+      "gemm|nvjet_": "gemm",
+      "moe|Expert|Moe": "moe",
+      "CatArrayBatched": "prepare_next",
+      "ncclDevKernel|AllReduce": "nccl_and_custom_ar",
+      "RMSNormKernel": "norm",
+      "topk": "topk",
+      "act_and_mul_|Activation": "activation",
+      "Rotary": "rope",
+      "SoftMax": "softmax",
+      "flash|splitKreduce|kernel_mha|mmha|fmha": "attn",
+      "elementwise": "elementwise",
+      "Quantize|cvt_": "quantize",
+      "reduce_kernel": "reduce",
+      "triton": "triton_kernel",
+      "CUDA mem": "non-gpu-H_D_memops",
+      ".*": "misc"
+    },
+    "ds": {
+      "fp8_blockscale_gemm": "block_fp8_gemm",
+      "gemm::GroupProblemShape|Fused_Moe_Kernel|bmm_": "moe_gemm",
+      "gemm|matmul|nvjet|gemvx": "gemm",
+      "moe|buildExpertMaps|Moe|Expert|Moe": "moe",
+      "CatArrayBatched": "prepare_next",
+      "ncclDevKernel|cross_device_reduce|AllReduce": "nccl_and_custom_ar",
+      "Norm|_norm_": "norm",
+      "topk": "topk",
+      "act_and_mul_|Activation": "activation",
+      "Rope": "rope",
+      "elementwise": "elementwise",
+      "fmha|flash_fwd_kernel": "attn",
+      "Quantize|fp8_quant|quant_fp8|cvt_": "quantize",
+      "reduce": "reduce",
+      "SoftMax": "softmax",
+      "CUDA mem": "non-gpu-H_D_memops",
+      ".*": "misc"
+    },
+    "gpt-oss": {
+      "block_fp8|gemm_fp8_blockwise": "block_fp8_gemm",
+      "fused_moe_kernel|_group_gemm|GroupProblemShape|GemmUniversal|bmm_|matmul_ogs_|_topk_forward|_combined_routing|_sum_bitmatrix_rows|_compute_writeback_idx": "moe_gemm",
+      "gemm|matmul|nvjet": "gemm",
+      "moe|sigmoid|expert|splitKreduce|Moe": "moe",
+      "CatArrayBatched": "prepare_next",
+      "ncclDevKernel|cross_device_reduce|AllReduce": "nccl_and_custom_ar",
+      "Norm|_norm_": "norm",
+      "sbtopk": "topk",
+      "act_and_mul_|Activation": "activation",
+      "Rope": "rope",
+      "elementwise": "elementwise",
+      "fp8_quant|quant_fp8|cvt_": "quantize",
+      "reduce": "reduce",
+      "SoftMax": "softmax",
+      "fmha|mha|flash_fwd_kernel": "attn",
+      "triton": "triton_kernel",
+      "CUDA mem": "non-gpu-H_D_memops",
+      ".*": "misc"
+    }
+  }
+}

From 96ff82e77a834a804b6230e4d3ea81118c24a6c1 Mon Sep 17 00:00:00 2001
From: Iman Tabrizian <10105175+Tabrizian@users.noreply.github.com>
Date: Sat, 23 Aug 2025 19:45:11 -0700
Subject: [PATCH 48/48] [None][fix] Waive test (#7185)

Signed-off-by: Iman Tabrizian <10105175+Tabrizian@users.noreply.github.com>
---
 tests/integration/test_lists/waives.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/integration/test_lists/waives.txt b/tests/integration/test_lists/waives.txt
index cc970b452f1..6f89b7cc433 100644
--- a/tests/integration/test_lists/waives.txt
+++ b/tests/integration/test_lists/waives.txt
@@ -325,3 +325,4 @@ full:L40S/accuracy/test_disaggregated_serving.py::TestDeepSeekV3Lite::test_auto_
 full:L40S/accuracy/test_disaggregated_serving.py::TestLlama3_1_8BInstruct::test_eagle3[eagle3_one_model=False-overlap_scheduler=False] SKIP (https://nvbugs/5471106)
 full:L40S/accuracy/test_disaggregated_serving.py::TestLlama3_1_8BInstruct::test_tp_pp_symmetric[MMLU-tp2pp2] SKIP (https://nvbugs/5471108)
 test_e2e.py::test_multi_nodes_eval[llama4-models/nvidia/Llama-4-Maverick-17B-128E-Instruct-FP8-tp8pp2-mmlu] SKIP (https://nvbugs/5473781)
+accuracy/test_llm_api_pytorch.py::TestDeepSeekV3Lite::test_nvfp4_4gpus[moe_backend=CUTLASS-mtp_nextn=0-tp4-fp8kv=True-attention_dp=True-cuda_graph=True-overlap_scheduler=True-torch_compile=True] SKIP (https://nvbugs/5476580)