执行摘要

• 一句话：将 forward 路径中的静态值提取到 init 中缓存
• 推荐动作：该 PR 展示了如何系统地应用一项代码风格规则来消除冗余计算，对有志于代码质量的读者有参考价值。建议阅读以理解“Extract init-static values”规则的实际应用场景。

功能与动机

引入新的“Extract init-static values at construction”规则（#30701），旨在消除热路径中基于冻结输入的重复推导。PR #30708 将该规则应用到 forward 路径的多个对象，包括 attention 后端选择、PDMux 启用、hidden states 返回、RL on-policy target 等标志的缓存。

实现拆解

1. HybridAttnBackend（hybrid_attn_backend.py）：在 __init__ 中缓存 spec_attn_is_decode 和 spec_attn_is_prefill 布尔值，替换 _select_backend、init_cuda_graph_state、update_mamba_state_after_mtp_verify 中3处字符串比较。

2. BaseRunner（base_runner.py）及子类：将 enable_pdmux 和 enable_return_hidden_states 从 model_runner.server_args 读取提升至 BaseRunner.__init__。子类 EagerRunner 和 DecodeCudaGraphRunner 中4处引用改为 self.enable_pdmux；DecodeCudaGraphRunner 和 CPUGraphRunner 中2处引用改为 self.enable_return_hidden_states。

3. CPUGraphRunner（cpu_graph_runner.py）：因不继承 BaseRunner，独立在 __init__ 中缓存 enable_return_hidden_states，并在 __init__ 和 recapture_if_needed 中使用。

4. ForwardBatchInfo（forward_batch_info.py）：在 _compute_mrope_positions 中将 get_server_args().rl_on_policy_target 提升为循环外的局部变量，消除循环内每序列重复调用。

5. LogitsProcessor（logits_processor.py）：在 __init__ 中缓存 rl_on_policy_target 属性，供后续使用。

6. ModelRunner（model_runner.py）：修复 forward 中一处 self.server_args.elastic_ep_backend is not None 的重复读取，改为使用已缓存的 self.enable_elastic_ep。

所有变更均为纯属性读取替换，未涉及逻辑改动。

关键文件：

• python/sglang/srt/model_executor/forward_batch_info.py（模块 前向批次；类别 source；类型 data-contract；符号 _compute_mrope_positions）: 最热路径之一：在 _compute_mrope_positions 中将 get_server_args().rl_on_policy_target 提升为循环前局部变量，消除循环内每序列重复调用。变更虽小但影响面大（decode/extend 每 token 均命中）。
• python/sglang/srt/layers/attention/hybrid_attn_backend.py（模块 注意力后端；类别 source；类型 core-logic；符号 init, _select_backend, init_cuda_graph_state, update_mamba_state_after_mtp_verify）: 每层 forward 均调用 _select_backend（及 init_cuda_graph_state 等），将 speculative_attention_mode 字符串比较缓存为布尔值，减少热路径开销。
• python/sglang/srt/model_executor/runner/eager_runner.py（模块 执行器；类别 source；类型 data-contract；符号 _resolve_decode_pdmux, _execute_decode, _execute_extend, _execute_idle）: EagerRunner 的 4 处引用（_resolve_decode_pdmux、_execute_decode、_execute_extend、_execute_idle）原先都读取 model_runner.server_args.enable_pdmux，现改为读取 base class 缓存的 self.enable_pdmux。
• python/sglang/srt/model_executor/runner/base_runner.py（模块 基类；类别 source；类型 data-contract；符号 init）: 作为基类，新增 enable_pdmux 和 enable_return_hidden_states 两个缓存属性，被子类继承。
• python/sglang/srt/model_executor/runner/decode_cuda_graph_runner.py（模块 CUDA Graph 执行器；类别 source；类型 data-contract；符号 init, recapture_if_needed）: 移除了自身的 enable_pdmux 缓存（原本在子类重复定义），改为继承 BaseRunner 的缓存。同时将 enable_return_hidden_states 引用替换为 self.enable_return_hidden_states。
• python/sglang/srt/model_executor/cpu_graph_runner.py（模块 CPU 图执行器；类别 source；类型 data-contract；符号 init, recapture_if_needed）: CPUGraphRunner 不继承 BaseRunner，独立缓存 enable_return_hidden_states。
• python/sglang/srt/layers/logits_processor.py（模块 Logits 处理；类别 source；类型 core-logic；符号 init）: 缓存 rl_on_policy_target，与 Sampler 一致的模式。
• python/sglang/srt/model_executor/model_runner.py（模块 模型执行器；类别 source；类型 data-contract；符号 forward）: 修复 forward 中一处重复的 elastic_ep_backend 读取，改为使用已缓存的 self.enable_elastic_ep。

关键符号：HybridAttnBackend.init, HybridAttnBackend._select_backend, BaseRunner.init, EagerRunner._execute_decode, EagerRunner._execute_extend, ForwardBatchInfo._compute_mrope_positions, CPUGraphRunner.init

关键源码片段

python/sglang/srt/model_executor/forward_batch_info.py

最热路径之一：在 _compute_mrope_positions 中将 get_server_args().rl_on_policy_target 提升为循环前局部变量，消除循环内每序列重复调用。变更虽小但影响面大（decode/extend 每 token 均命中）。

def _compute_mrope_positions(self, model_runner, batch):
    batch_size = self.seq_lens_cpu.shape[0]
    mrope_positions_list = [[]] * batch_size
    # 提升为局部变量，避免循环内重复调用 get_server_args()
    rl_on_policy_target = get_server_args().rl_on_policy_target
    for batch_idx in range(batch_size):
        mm_input = batch.multimodal_inputs[batch_idx]
        if self.forward_mode.is_decode():
            if mm_input is None or rl_on_policy_target is not None:
                mrope_positions_list[batch_idx] = torch.full(
                    (3, 1),
                    self.seq_lens_cpu[batch_idx] - 1,
                    dtype=torch.int64,
                )
            else:
                mrope_positions = self._expand_mrope_from_input(
                    mm_input, self.seq_lens_cpu[batch_idx]
                )
                mrope_positions_list[batch_idx] = mrope_positions
        elif self.forward_mode.is_extend(include_draft_extend_v2=True):
            extend_seq_len, extend_prefix_len = (
                batch.extend_lens[batch_idx],
                batch.prefix_lens[batch_idx],
            )
            if mm_input is None or rl_on_policy_target is not None:
                # text only
                mrope_positions = torch.tensor(
                    [[pos for pos in range(extend_prefix_len, extend_prefix_len + extend_seq_len)]] * 3
                )
            else:
                mrope_positions = mm_input.mrope_positions[
                    :, extend_prefix_len : extend_prefix_len + extend_seq_len
                ]
                if mrope_positions.numel() == 0:
                    mrope_positions = self._expand_mrope_from_input(
                        mm_input, self.seq_lens_cpu[batch_idx]
                    )
            mrope_positions_list[batch_idx] = mrope_positions
​
    self.mrope_positions = torch.cat(
        [pos for pos in mrope_positions_list], dim=1
    ).to(dtype=torch.int64, device=model_runner.device, non_blocking=True)

python/sglang/srt/layers/attention/hybrid_attn_backend.py

每层 forward 均调用 _select_backend（及 init_cuda_graph_state 等），将 speculative_attention_mode 字符串比较缓存为布尔值，减少热路径开销。

def __init__(self, model_runner, prefill_backend, decode_backend):
    # ... 略去其他初始化
    # 缓存布尔值，避免后续每次比较字符串
    self.spec_attn_is_decode = (
        model_runner.server_args.speculative_attention_mode == 'decode'
    )
    self.spec_attn_is_prefill = (
        model_runner.server_args.speculative_attention_mode == 'prefill'
    )
​
def _select_backend(self, forward_mode: ForwardMode) -> AttentionBackend:
    if forward_mode.is_decode_or_idle():
        return self.decode_backend
    elif forward_mode.is_target_verify():
        return (
            self.decode_backend
            if self.spec_attn_is_decode # 替换字符串比较
            else self.prefill_backend
        )
    else:
        return self.prefill_backend
​
def init_cuda_graph_state(self, max_bs, max_num_tokens):
    self.decode_backend.init_cuda_graph_state(max_bs, max_num_tokens)
    if (
        self.model_runner.server_args.speculative_algorithm is not None
        and self.spec_attn_is_prefill # 替换字符串比较
    ):
        self.prefill_backend.init_cuda_graph_state(max_bs, max_num_tokens)
​
def update_mamba_state_after_mtp_verify(self, *args, **kwargs):
    if self.spec_attn_is_decode: # 替换字符串比较
        backend = self.decode_backend
    else:
        backend = self.prefill_backend
    # ... 后续逻辑

python/sglang/srt/model_executor/runner/eager_runner.py

EagerRunner 的 4 处引用（_resolve_decode_pdmux、_execute_decode、_execute_extend、_execute_idle）原先都读取 model_runner.server_args.enable_pdmux，现改为读取 base class 缓存的 self.enable_pdmux。

def _resolve_decode_pdmux(self):
    model_runner = self.model_runner
    if self.enable_pdmux: # 改为使用缓存的属性
        return model_runner.decode_attn_backend, forward_context(
            ForwardContext(attn_backend=model_runner.decode_attn_backend)
        )
    return model_runner.attn_backend, contextlib.nullcontext()
​
def _execute_decode(self, forward_batch, pp_proxy_tensors=None):
    model_runner = self.model_runner
    enable_pdmux = self.enable_pdmux # 改为使用缓存的属性
    attn_backend, pdmux_ctx = self._resolve_decode_pdmux()
    if not enable_pdmux:
        forward_batch = self.load_batch(forward_batch, pp_proxy_tensors)
    # ... 其余逻辑不变
​
def _execute_extend(self, forward_batch, pp_proxy_tensors=None):
    model_runner = self.model_runner
    kwargs = model_runner._extend_forward_kwargs(forward_batch, pp_proxy_tensors)
    if not self.enable_pdmux: # 改为使用缓存的属性
        forward_batch = self.load_batch(forward_batch, pp_proxy_tensors)
    # ... 其余逻辑不变
​
def _execute_idle(self, forward_batch, pp_proxy_tensors=None):
    model_runner = self.model_runner
    if forward_batch.batch_size > 0:
        if not self.enable_pdmux: # 改为使用缓存的属性
            forward_batch = self.load_batch(forward_batch, pp_proxy_tensors)
        model_runner.attn_backend.init_forward_metadata(forward_batch)
    else:
        # ... 其余逻辑不变

评论区精华

作者通过自定义 AST 静态等价验证脚本对比了 origin/main 与 PR 版本的所有方法体，确认每个替换均保持行为等价，并公开了验证报告与可复现脚本。未产生 review 争议。

• AST 静态等价验证 (testing): 所有替换经AST验证等价，无逻辑变更。

风险与影响

• 风险：变更是纯等价的属性读取替换，通过AST静态等价验证，行为风险极低。潜在注意事项：
  • 若 server_args 字段在对象构造后动态变更（当前架构不允许），缓存的属性会过期。
  • CPUGraphRunner 不继承 BaseRunner，需独立维护 enable_return_hidden_states 缓存，后续修改时需同步。
  • 无新增测试覆盖验证重构后行为不变，但 AST 验证提供了强保障。
  • 影响：影响8个源文件，无用户可见变化。对系统影响：降低前向路径中的重复函数调用和字符串比较，带来微小性能提升。对团队影响：明确了静态值应缓存到 __init__ 的编码规范，后续开发者需遵循该模式。
  • 风险标记：核心路径变更, 通过AST等价验证, 无逻辑变更, 无测试覆盖

关联脉络

• PR #30701 Extract init-static values at construction: 定义本 PR 所遵循的编码规则的原始 PR，PR body 中提及。
• PR #30709 [style] Extract init-static values in tokenizer + multimodal path: 同一编码规则在 Tokenizer 和多模态路径的应用，与本 PR 属于同一系列。
• PR #30710 [style] Extract init-static values in memory-cache path: 同一编码规则在内存缓存路径的应用，与本 PR 属于同一系列。