[TRTLLM-12669][refactor] rename uses_advanced_sampling to is_all_greedy_sample

Flip the boolean polarity and rename the field for readability: True
now means the batch can take the argmax fast-path. Follows existing
SpecMetadata naming convention (is_cuda_graph, is_spec_dec_tree,
is_first_draft). Default flips to True so non-one-engine paths
naturally select the greedy graph variant.

Signed-off-by: ZhaoyangWang <zhaoyangw@nvidia.com>

Author: zhaoyangwang-nvidia

tensorrt_llm/_torch/pyexecutor/cuda_graph_runner.py

@@ -211,16 +211,18 @@ def get_graph_key(
         # Spec one-engine sampler has two code paths (argmax fast-path vs
         # advanced sampling kernel). Include this in the key so we capture
         # both variants and dispatch at replay based on actual batch state.
-        uses_advanced_sampling = bool(
-            getattr(spec_metadata, "uses_advanced_sampling", False))
+        # Default to True (greedy fast-path) when the metadata doesn't carry
+        # this field (non-one-engine paths or non-spec batches).
+        is_all_greedy_sample = bool(
+            getattr(spec_metadata, "is_all_greedy_sample", True))
 
         if self.config.is_draft_model and spec_resource_manager is not None and isinstance(
                 spec_resource_manager, Eagle3ResourceManager):
             # If 'is_first_draft' is True, even with tree decoding, the length of draft_len will only be 'max_draft_len', not 'max_total_draft_token'.
             # Because we will pad the input to 'max_draft_len' length for the first draft layer.
             draft_len = self.config.original_max_draft_len if spec_resource_manager.is_first_draft else 0
             key = (batch_size, draft_len, spec_resource_manager.is_first_draft,
-                   short_seq_len_mode, uses_advanced_sampling)
+                   short_seq_len_mode, is_all_greedy_sample)
         else:
             # With dynamic spec decode, the draft length may be zero even when enable_spec_decode is True,
             # so we need to get the draft length from the batch instead of using enable_spec_decode.
@@ -231,7 +233,7 @@ def get_graph_key(
             assert len(
                 set(draft_len_list)) == 1, "All draft lengths must be the same"
             key = (batch_size, draft_len, False, short_seq_len_mode,
-                   uses_advanced_sampling)
+                   is_all_greedy_sample)
         return key
 
     def __del__(self):

tensorrt_llm/_torch/speculative/interface.py

@@ -436,12 +436,14 @@ class SpecMetadata:
     # Always set by model_engine.forward() before any downstream code reads it.
     runtime_draft_len: int = 0
 
-    # For non-greedy sampling on 1-model.
     # Auto-detected per step from populated sampling params:
-    # True if any request needs temp/top_k/top_p, False if all greedy.
+    # True if every request is greedy (no temp/top_k/top_p) and we can take
+    # the argmax fast-path. False if any request needs sampling.
     # Used as part of the CUDA graph key so we capture two variants
     # (greedy fast-path vs advanced sampling) and dispatch at replay.
-    uses_advanced_sampling: bool = False
+    # Defaults to True so non-one-engine paths (where populate is a no-op)
+    # never accidentally select the advanced graph variant.
+    is_all_greedy_sample: bool = True
     # Whether to use rejection sampling for one-model speculative decoding.
     use_rejection_sampling: bool = False
     # Sampling parameters for non-greedy sampling (per-request)
@@ -524,7 +526,7 @@ def populate_sampling_params_for_one_model(
           Phase 1: scan request sampling configs to compute skip_*/has_greedy
                    flags and decide whether the batch is all-greedy. No per-token
                    list construction.
-          Phase 2 (only when uses_advanced_sampling=True): build per-token /
+          Phase 2 (only when is_all_greedy_sample=False): build per-token /
                    per-request lists and issue 6 H->D copies into the sampling
                    parameter buffers.
 
@@ -631,11 +633,11 @@ def _normalize_request_sampling_params(
         self.skip_top_k = not top_k_enabled
         self.skip_top_p = not top_p_enabled
         self.has_greedy_requests = has_greedy_requests
-        # Advanced sampling is needed iff any sampling param is active.
-        # When all skip_* flags are True, the entire batch can run argmax fast-path.
+        # All-greedy iff no sampling param is active across the whole batch.
+        # When True, the sampler takes the argmax fast-path.
         # This boolean is part of the CUDA graph key so we capture both variants.
-        self.uses_advanced_sampling = not (self.skip_temperature and
-                                           self.skip_top_k and self.skip_top_p)
+        self.is_all_greedy_sample = (self.skip_temperature and self.skip_top_k
+                                     and self.skip_top_p)
 
         tokens_per_request = (self.max_total_draft_tokens + 1 if
                               self.is_spec_dec_tree else self.max_draft_len + 1)
@@ -668,7 +670,7 @@ def _normalize_request_sampling_params(
         # ===== Fast-path: all-greedy batch skips list build + H->D copies =====
         # The sampler will take the argmax branch and never read these buffers,
         # so leaving their values stale is safe.
-        if not self.uses_advanced_sampling:
+        if self.is_all_greedy_sample:
             return
 
         # ===== Phase 2: build per-token / per-request lists and copy to GPU =====
@@ -1321,7 +1323,7 @@ def _sample_tokens_for_batch(
         Returns:
             sampled_tokens: [num_tokens] - Sampled token ids
         """
-        if spec_metadata.uses_advanced_sampling:
+        if not spec_metadata.is_all_greedy_sample:
             num_gens = batch_size - num_contexts
             num_tokens = num_contexts + num_gens * (
                 spec_metadata.runtime_draft_len + 1)