[Refactor] Remove dead or duplicate tests (#58446)

Signed-off-by: yewentao256 <zhyanwentao@126.com>
This commit is contained in:
Wentao Ye
2026-09-24 10:29:56 -04:00
committed by GitHub
parent d881812500
commit 3c42385d7d
11 changed files with 0 additions and 646 deletions
-36
View File
@@ -171,42 +171,6 @@ def test_connector_metadata_precedes_async_placeholder_advance(monkeypatch):
assert observed_placeholders == [0, 1]
def test_preempt():
scheduler = create_scheduler(async_scheduling=True)
requests = create_requests(num_requests=10, max_tokens=20)
for req in requests:
scheduler.add_request(req)
sched_outputs: deque[SchedulerOutput] = deque()
sched_outputs.append(scheduler.schedule())
sched_outputs.append(scheduler.schedule())
abort_order = [0, 8, 3, 1, 6, 4, 2, 5, 7, 9]
abort_order_copy = abort_order.copy()
def abort_request():
if not abort_order:
return
req = requests[abort_order.pop(0)]
scheduler.finish_requests(req.request_id, RequestStatus.FINISHED_ABORTED)
while sched_outputs:
# Abort a scheduled request.
abort_request()
sched_output = sched_outputs.popleft()
model_runner_output = _make_model_runner_output(sched_output)
scheduler.update_from_output(sched_output, model_runner_output)
sched_output = scheduler.schedule()
if sched_output.num_scheduled_tokens:
sched_outputs.append(sched_output)
for i, req in enumerate(requests):
assert req.status == RequestStatus.FINISHED_ABORTED
assert req.num_output_tokens == abort_order_copy.index(i)
def test_prefix_caching_for_prefill_dedup():
CHUNK_SIZE = 1000
BLOCK_SIZE = 16
-32
View File
@@ -16,38 +16,6 @@ def new_kv_cache_spec():
)
def test_initialize_kv_cache_for_kv_sharing_different_attn_groups():
"""Test initializing KV cache sharing with different attention groups.
Layers in the same KV cache group might be placed in different attn groups
if they have different attention backends.
"""
shared_kv_cache_layers = {
"model.layers.2": "model.layers.0",
"model.layers.3": "model.layers.1",
}
# Layers 0 and 1 both belong in KV cache group 0
# However, if they have different attention backends, they will be
# placed in different attention groups for KV cache group 0
kv_cache_groups = [
KVCacheGroupSpec(["model.layers.0", "model.layers.1"], new_kv_cache_spec()),
]
add_kv_sharing_layers_to_kv_cache_groups(
shared_kv_cache_layers=shared_kv_cache_layers,
kv_cache_groups=kv_cache_groups,
)
# Check that the layers were added to the correct KV cache group
assert len(kv_cache_groups) == 1
assert kv_cache_groups[0].layer_names == [
"model.layers.0",
"model.layers.1",
"model.layers.2",
"model.layers.3",
]
def test_initialize_kv_cache_for_kv_sharing_same_attn_groups():
"""Test case assuming that all layers in the same KV cache group have the same
attention backends. This is true for most models.
@@ -3440,59 +3440,6 @@ class TestEagle:
# whole request.
assert sched._lookup(req_status) == 4
def test_eagle_verified_survives_eagle_tighten(self, request_runner):
"""Eagle group tightening does NOT clear eagle_verified.
Groups: 0=non-eagle full-attn, 1=eagle full-attn.
Group 0 finds 3 hits (max_hit=12). Group 1 finds 3 hits, pops to 2
(max_hit=8). Since group 1 IS eagle, eagle_verified is NOT cleared.
Result: 8 tokens (eagle only pops once).
"""
block_size = 4
groups = [
KVCacheGroupSpec(
["layer0"],
FullAttentionSpec(
block_size=block_size,
num_kv_heads=1,
head_size=1,
dtype=torch.float32,
),
is_eagle_group=False,
),
KVCacheGroupSpec(
["layer1"],
FullAttentionSpec(
block_size=block_size,
num_kv_heads=2,
head_size=1,
dtype=torch.float32,
),
is_eagle_group=True,
),
]
runner = request_runner(
block_size=block_size,
num_gpu_blocks=100,
async_scheduling=False,
kv_cache_groups=groups,
)
runner.manager.lookup.side_effect = lambda key, req_context: (
LookupResult.HIT
if int(get_offload_block_hash(key).decode()) in {1, 2, 3}
else LookupResult.MISS
)
sched = runner.connector_scheduler
req_status = self._make_req_status(
sched,
num_tokens=12,
offload_keys_per_group=[[1, 2, 3], [1, 2, 3]],
)
# Group 0: 3 hits → max_hit=12, num_hit=12
# Group 1 (eagle): 3 hits, pop to 2 → max_hit=8, num_hit=8
# Tightened but IS eagle → no clear. No re-iteration.
assert sched._lookup(req_status) == 8
# -------------------------------------------------------------------
# Integration tests: store and load via request_runner
# -------------------------------------------------------------------
-73
View File
@@ -167,79 +167,6 @@ def test_topk_impl_equivalence():
assert torch.allclose(result1, result2)
@pytest.mark.skip(
reason="FlashInfer top-k/top-p renorm comparison fails; "
"needs investigation of tolerance threshold or "
"interface differences between Python and FlashInfer implementations"
)
def test_flashinfer_sampler():
"""This test verifies that the FlashInfer top-k and top-p sampling
implementation produces the same results as the Python implementation.
NOTE: FlashInfer did not directly expose an interface for fused top-k and
top-p prob renorm (it did provide fused sampling but we cannot compare
sampling results due to randomness), so we will compare the probability
renormed consequently by top-k and then top-p of FlashInfer implementation.
"""
try:
from flashinfer.sampling import top_k_renorm_probs, top_p_renorm_probs
is_flashinfer_available = True
except ImportError:
is_flashinfer_available = False
FLASHINFER_ENABLED = current_platform.is_cuda() and is_flashinfer_available
if not FLASHINFER_ENABLED:
pytest.skip("FlashInfer not installed or not available on this platform.")
torch.set_default_device(DEVICE_TYPE)
generator = Generator(device=DEVICE_TYPE).manual_seed(42)
# Generate random logits
logits = torch.rand((BATCH_SIZE, VOCAB_SIZE), generator=generator)
# Generate various top-k and top-p values
k_values = torch.randint(1, 1000, (BATCH_SIZE,), generator=generator)
p_values = (
torch.rand((BATCH_SIZE,), generator=generator) * 0.5 + 0.5
) # range in [0.5, 1.0]
# Sometimes disable top-k (k=vocab_size)
k_values.masked_fill_(
torch.randint(0, 2, (BATCH_SIZE,), generator=generator, dtype=torch.bool),
VOCAB_SIZE,
)
# Sometimes disable top-p (p=1.0)
p_values.masked_fill_(
torch.randint(0, 2, (BATCH_SIZE,), generator=generator, dtype=torch.bool), 1.0
)
python_logits = apply_top_k_top_p_pytorch(
logits=logits.clone(),
k=k_values,
p=p_values,
)
python_probs = torch.softmax(python_logits, dim=-1)
# FlashInfer only exposed renorm interfaces for probs so convert first
flashinfer_probs = torch.softmax(logits.clone(), dim=-1)
flashinfer_probs = top_k_renorm_probs(
probs=flashinfer_probs,
top_k=k_values,
)
flashinfer_probs = top_p_renorm_probs(
probs=flashinfer_probs,
top_p=p_values,
)
# Compare the results
assert torch.allclose(python_probs, flashinfer_probs, atol=2e-2), (
"FlashInfer and Python sampling implementations do not match!"
)
@pytest.mark.skipif(
not FLASHINFER_TOPK_TOPP_SUPPORTED,
reason="Requires CUDA and flashinfer",
@@ -1,147 +0,0 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
"""Regression tests for the backup token fix in prepare_next_token_ids_padded.
Fixes #38098: with async scheduling, seq_lens_cpu is inflated by unaccepted
draft token placeholders, causing get_token_id() to return -1.
"""
from __future__ import annotations
import numpy as np
import pytest
import torch
class _FakeRequest:
def __init__(self, prompt_tokens: list[int], output_tokens: list[int]):
self.num_prompt_tokens = len(prompt_tokens)
self._prompt = prompt_tokens
self._output = output_tokens
@property
def num_tokens(self) -> int:
return self.num_prompt_tokens + len(self._output)
def get_token_id(self, idx: int) -> int:
if idx < self.num_prompt_tokens:
return self._prompt[idx]
out_idx = idx - self.num_prompt_tokens
if out_idx < len(self._output):
return self._output[out_idx]
return -1 # out of range
class _FakeInputBatch:
def __init__(
self,
req_ids: list[str],
num_tokens_no_spec: list[int],
vocab_size: int = 32000,
):
self.req_ids = req_ids
self.num_reqs = len(req_ids)
self.vocab_size = vocab_size
self.num_tokens_no_spec = np.array(num_tokens_no_spec, dtype=np.int64)
def _make_requests(
req_ids: list[str],
prompt_lens: list[int],
output_lens: list[int],
) -> dict[str, _FakeRequest]:
requests = {}
for rid, plen, olen in zip(req_ids, prompt_lens, output_lens):
requests[rid] = _FakeRequest(list(range(plen)), list(range(1000, 1000 + olen)))
return requests
def _backup_buggy(
seq_lens_cpu: torch.Tensor,
requests: dict[str, _FakeRequest],
batch: _FakeInputBatch,
) -> list[int]:
"""Old logic: uses seq_lens_cpu directly (may be inflated)."""
n = batch.num_reqs
return [
requests[batch.req_ids[i]].get_token_id(int(seq_lens_cpu[i])) for i in range(n)
]
def _backup_fixed(
requests: dict[str, _FakeRequest],
batch: _FakeInputBatch,
) -> list[int]:
"""New logic: uses num_tokens_no_spec - 1 (last committed token)."""
n = batch.num_reqs
idx = (batch.num_tokens_no_spec[:n] - 1).tolist()
return [requests[batch.req_ids[i]].get_token_id(int(idx[i])) for i in range(n)]
class TestBackupTokenAsyncSpec:
def test_no_inflation_fixed_returns_last_token(self):
req_ids = ["r0", "r1"]
requests = _make_requests(req_ids, [3, 3], [2, 2])
batch = _FakeInputBatch(req_ids, [5, 5])
# idx = 5-1 = 4 → output[1] = 1001
assert _backup_fixed(requests, batch) == [1001, 1001]
def test_inflation_buggy_returns_placeholder(self):
req_ids = ["r0", "r1"]
requests = _make_requests(req_ids, [3, 3], [2, 2])
batch = _FakeInputBatch(req_ids, [5, 5])
# inflated by 3 spec tokens → idx 8 is out of range
seq_lens = torch.tensor([8, 8], dtype=torch.int64)
assert _backup_buggy(seq_lens, requests, batch) == [-1, -1]
def test_inflation_fixed_returns_correct_token(self):
req_ids = ["r0", "r1"]
requests = _make_requests(req_ids, [3, 3], [2, 2])
batch = _FakeInputBatch(req_ids, [5, 5])
assert _backup_fixed(requests, batch) == [1001, 1001]
def test_mixed_inflation_per_request(self):
req_ids = ["r0", "r1", "r2"]
requests = {
"r0": _FakeRequest([0, 1], [1000, 1001, 1002]),
"r1": _FakeRequest([0, 1, 2, 3], [2000]),
"r2": _FakeRequest([0], [3000, 3001, 3002, 3003]),
}
batch = _FakeInputBatch(req_ids, [5, 5, 5])
seq_lens = torch.tensor([7, 9, 5], dtype=torch.int64)
assert _backup_buggy(seq_lens, requests, batch) == [-1, -1, -1]
assert _backup_fixed(requests, batch) == [1002, 2000, 3003]
def test_prefill_only_request(self):
"""No output tokens yet — backup should be the last prompt token."""
req_ids = ["r0"]
requests = {"r0": _FakeRequest([10, 20, 30], [])}
batch = _FakeInputBatch(req_ids, [3])
# idx = 3-1 = 2 → prompt[2] = 30
assert _backup_fixed(requests, batch) == [30]
@pytest.mark.parametrize("num_spec_tokens", [1, 2, 3, 4, 5])
def test_various_spec_token_counts(self, num_spec_tokens: int):
req_ids = ["r0"]
requests = {"r0": _FakeRequest([0, 1, 2], list(range(1000, 1005)))}
batch = _FakeInputBatch(req_ids, [8])
# idx = 8-1 = 7 → output[4] = 1004
assert _backup_fixed(requests, batch) == [1004]
def test_buggy_code_was_always_off_by_one(self):
"""The original code used seq_len as index, which is always one past
the end of output_token_ids even without async inflation."""
req_ids = ["r0"]
requests = {"r0": _FakeRequest([0, 1, 2], [1000, 1001])}
batch = _FakeInputBatch(req_ids, [5])
# no inflation: seq_len == num_tokens == 5 → idx 5 is out of range
seq_lens = torch.tensor([5], dtype=torch.int64)
assert _backup_buggy(seq_lens, requests, batch) == [-1]
assert _backup_fixed(requests, batch) == [1001]
# with inflation: still -1, fixed still correct
seq_lens_inf = torch.tensor([8], dtype=torch.int64)
assert _backup_buggy(seq_lens_inf, requests, batch) == [-1]
assert _backup_fixed(requests, batch) == [1001]