[Bugfix][MRV2] Initialize DCP metadata after batch partitioning (#55212)

Signed-off-by: Raphael Rialland <raphael.rialland@mistral.ai>
Signed-off-by: Ziyang Zhang <hafuhafu@qq.com>
Signed-off-by: Sy03 <1370724210@qq.com>
Co-authored-by: Raphael Rialland <raphael.rialland@mistral.ai>
Co-authored-by: Ziyang Zhang <hafuhafu@qq.com>
Co-authored-by: Codex <noreply@openai.com>
Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>
This commit is contained in:
Sy03
2026-09-10 06:50:09 +00:00
committed by GitHub
co-authored by Raphael Rialland Ziyang Zhang Codex mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>
parent 912d2e79fe
commit 83990f5bcc
12 changed files with 460 additions and 77 deletions
+105
View File
@@ -1,11 +1,17 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
from dataclasses import replace
import numpy as np
import pytest
import torch
from vllm.v1.attention.backends.utils import get_dcp_local_seq_lens
from vllm.v1.worker.gpu import cp_utils as gpu_cp_utils
from vllm.v1.worker.gpu import pcp_manager as pcp_manager_module
from vllm.v1.worker.gpu.input_batch import InputBatch, InputBuffers
from vllm.v1.worker.gpu.pcp_manager import PCPManager
from vllm.v1.worker.gpu.states import RequestState
def _copy_to_cpu(value, out=None, device=None):
@@ -107,3 +113,102 @@ def test_graph_padding_cannot_be_smaller_than_largest_pcp_rank(monkeypatch):
query_start_loc_np=np.arange(4, dtype=np.int32),
padded_num_tokens=2,
)
def _make_global_decode_batch(
num_computed_tokens: list[int], buffers: InputBuffers, device: torch.device
) -> InputBatch:
"""A replicate-decode global batch as `prepare_inputs` would build it."""
num_reqs = len(num_computed_tokens)
num_tokens = num_reqs
seq_lens_np = np.asarray(num_computed_tokens, dtype=np.int32) + 1
base = InputBatch.make_dummy(num_reqs, num_tokens, buffers)
buffers.seq_lens[:num_reqs] = torch.from_numpy(seq_lens_np).to(device)
query_start_loc_np = np.arange(num_reqs + 1, dtype=np.int32)
buffers.query_start_loc[: num_reqs + 1] = torch.from_numpy(query_start_loc_np).to(
device
)
return replace(
base,
req_ids=[f"req_{i}" for i in range(num_reqs)],
num_reqs=num_reqs,
num_reqs_after_padding=num_reqs,
idx_mapping=torch.arange(num_reqs, dtype=torch.int32, device=device),
idx_mapping_np=np.arange(num_reqs, dtype=np.int32),
num_scheduled_tokens=np.ones(num_reqs, dtype=np.int32),
num_tokens=num_tokens,
num_tokens_after_padding=num_tokens,
num_draft_tokens=0,
num_draft_tokens_per_req=np.zeros(num_reqs, dtype=np.int32),
query_start_loc=buffers.query_start_loc[: num_reqs + 1],
query_start_loc_np=query_start_loc_np,
seq_lens=buffers.seq_lens[:num_reqs],
seq_lens_cpu_upper_bound=torch.from_numpy(seq_lens_np),
dcp_local_seq_lens=None,
num_computed_tokens_np=np.asarray(num_computed_tokens, dtype=np.int32),
prefill_len_np=np.zeros(num_reqs, dtype=np.int32),
num_computed_prefill_tokens_np=np.zeros(num_reqs, dtype=np.int32),
is_prefilling_np=np.zeros(num_reqs, dtype=np.bool_),
input_ids=buffers.input_ids[:num_tokens],
positions=buffers.positions[:num_tokens],
is_padding=buffers.is_padding[:num_tokens],
prompt_lens=None,
)
@pytest.mark.skipif(not torch.cuda.is_available(), reason="needs GPU kernels")
def test_partition_defers_dcp_metadata_to_post_partition_batch():
"""DCP-local lengths must derive from the partitioned batch, not the
global one: the partition replaces seq_lens, so a pre-partition value is
stale. partition_batch therefore returns None, and the runtime populates
the field afterwards from the PCP-owned buffers.
"""
device = torch.device("cuda:0")
req_states = RequestState(
max_num_reqs=4,
max_model_len=64,
max_num_batched_tokens=8,
num_speculative_steps=1,
vocab_size=8,
device=device,
)
manager = PCPManager(
pcp_world_size=2,
pcp_rank=0,
device=device,
req_states=req_states,
max_num_reqs=4,
max_num_tokens=8,
dcp_world_size=2,
dcp_rank=0,
)
global_buffers = InputBuffers(4, 8, device)
global_batch = _make_global_decode_batch([16, 24], global_buffers, device)
# A leftover from an earlier DCP batch must not survive the partition.
global_batch.dcp_local_seq_lens = global_buffers.dcp_local_seq_lens[:2]
global_batch.dcp_local_seq_lens.fill_(-1)
local_batch = manager.partition_batch(global_batch, padded_num_tokens=2)
assert local_batch.dcp_local_seq_lens is None
assert local_batch.seq_lens.tolist() == [17, 25]
# What execute_model does next: derive DCP metadata from the final batch
# on the PCP-owned buffers.
local_batch.dcp_local_seq_lens = gpu_cp_utils.maybe_prepare_dcp_local_seq_lens(
manager.input_buffers.dcp_local_seq_lens,
local_batch.seq_lens,
local_batch.num_reqs,
dcp_size=2,
dcp_rank=0,
cp_interleave=1,
num_reqs_padded=local_batch.num_reqs_after_padding,
)
expected = get_dcp_local_seq_lens(
torch.tensor([17, 25], dtype=torch.int32), 2, 0, 1
)
assert local_batch.dcp_local_seq_lens is not None
assert torch.equal(local_batch.dcp_local_seq_lens.cpu(), expected)