cleanup eagle tests

Signed-off-by: Lucas Wilkinson <lwilkins@redhat.com>

Author: LucasWilkinson

tests/v1/attention/utils.py

@@ -0,0 +1,132 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Utility functions for attention-related v1 tests."""
+
+from dataclasses import dataclass
+
+import pytest
+import torch
+
+from vllm.config import VllmConfig
+from vllm.v1.attention.backends.utils import CommonAttentionMetadata
+from vllm.v1.kv_cache_interface import FullAttentionSpec
+
+
+@dataclass
+class BatchSpec:
+    """Specification for a batch configuration (workload shape only)."""
+    batch_size: int
+    seq_lens: list[int]
+    query_lens: list[int]
+
+    name: str = "unnamed"
+
+    def __post_init__(self):
+        assert len(self.seq_lens) == self.batch_size
+        assert len(self.query_lens) == self.batch_size
+
+    def compute_num_tokens(self):
+        return sum(self.seq_lens)
+
+
+def create_common_attn_metadata(
+        batch_spec: BatchSpec,
+        block_size: int,
+        device: torch.device,
+        max_block_idx: int = 1000) -> CommonAttentionMetadata:
+    """Create CommonAttentionMetadata from a BatchSpec and ModelParams."""
+    # Create query start locations
+    query_start_loc = torch.zeros(batch_spec.batch_size + 1,
+                                  dtype=torch.int32,
+                                  device=device)
+    query_start_loc[1:] = torch.tensor(batch_spec.query_lens,
+                                       dtype=torch.int32,
+                                       device=device).cumsum(0)
+    query_start_loc_cpu = query_start_loc.cpu()
+    num_tokens = batch_spec.compute_num_tokens()
+
+    # Create sequence lengths
+    seq_lens = torch.tensor(batch_spec.seq_lens,
+                            dtype=torch.int32,
+                            device=device)
+    seq_lens_cpu = seq_lens.cpu()
+
+    # Create computed tokens (assume all tokens are computed for simplicity)
+    num_computed_tokens_cpu = seq_lens_cpu.clone()
+
+    # Create block table (random for testing)
+    max_blocks = max(batch_spec.seq_lens) // block_size + 1
+    block_table_tensor = torch.randint(0,
+                                       max_block_idx,
+                                       (batch_spec.batch_size, max_blocks),
+                                       dtype=torch.int32,
+                                       device=device)
+
+    # Create slot mapping
+    slot_mapping = torch.randint(0,
+                                 max_block_idx, (num_tokens, ),
+                                 dtype=torch.int64,
+                                 device=device)
+
+    # Calculate max query length
+    max_query_len = max(batch_spec.query_lens)
+
+    return CommonAttentionMetadata(
+        query_start_loc=query_start_loc,
+        query_start_loc_cpu=query_start_loc_cpu,
+        seq_lens=seq_lens,
+        seq_lens_cpu=seq_lens_cpu,
+        num_computed_tokens_cpu=num_computed_tokens_cpu,
+        num_reqs=batch_spec.batch_size,
+        num_actual_tokens=num_tokens,
+        max_query_len=max_query_len,
+        block_table_tensor=block_table_tensor,
+        slot_mapping=slot_mapping,
+    )
+
+
+def get_attention_backend(backend_name: str):
+    """Set up attention backend classes for testing.
+    
+    Args:
+        backend_name: Name of the backend ("flash_attn", "flashinfer", etc.)
+        vllm_config: VllmConfig instance
+        
+    Returns:
+        Tuple of (backend_builder_class, backend_impl_class)
+    """
+    backend_map = {
+        "flash_attn":
+        ("vllm.v1.attention.backends.flash_attn", "FlashAttentionBackend"),
+        "flashinfer":
+        ("vllm.v1.attention.backends.flashinfer", "FlashInferBackend"),
+        "flex_attention":
+        ("vllm.v1.attention.backends.flex_attention", "FlexAttentionBackend"),
+    }
+
+    if backend_name not in backend_map:
+        raise ValueError(f"Unknown backend: {backend_name}")
+
+    module_name, backend_class_name = backend_map[backend_name]
+
+    try:
+        import importlib
+        module = importlib.import_module(module_name)
+        backend_class = getattr(module, backend_class_name)
+        return backend_class.get_builder_cls(), backend_class.get_impl_cls()
+    except ImportError as e:
+        pytest.skip(f"{backend_name} not available: {e}")
+
+
+def create_standard_kv_cache_spec(
+        vllm_config: VllmConfig) -> FullAttentionSpec:
+    """Create a FullAttentionSpec from ModelParams only."""
+    return FullAttentionSpec(
+        block_size=vllm_config.cache_config.block_size,
+        num_kv_heads=vllm_config.model_config.get_num_attention_heads(
+            vllm_config.parallel_config),
+        head_size=vllm_config.model_config.get_head_size(),
+        dtype=vllm_config.model_config.dtype,
+        use_mla=vllm_config.model_config.use_mla,
+        sliding_window=vllm_config.model_config.get_sliding_window(),
+    )

tests/v1/spec_decode/test_eagle.py

@@ -6,6 +6,9 @@
 import pytest
 import torch
 
+from tests.v1.attention.utils import (BatchSpec, create_common_attn_metadata,
+                                      create_standard_kv_cache_spec,
+                                      get_attention_backend)
 from vllm.config import (CacheConfig, DeviceConfig, LoadConfig, ModelConfig,
                          ParallelConfig, SchedulerConfig, SpeculativeConfig,
                          VllmConfig)
@@ -90,13 +93,20 @@ def test_prepare_inputs():
     """
     device = torch.device(current_platform.device_type)
 
-    # a = 4, b = 7, c = 5
+    # q1 = 4, q2 = 7, q3 = 5
     # n1 = 1, n2 = 3, n3 = 2
 
-    # Cumulative lengths: [0, 4, 11, 16]
-    cu_target_query_lens = torch.tensor([0, 4, 11, 16],
-                                        dtype=torch.int32,
-                                        device=device)
+    batch_spec = BatchSpec(
+        batch_size=4,
+        seq_lens=[4, 7, 5],
+        query_lens=[4, 7, 5],
+    )
+
+    common_attn_metadata = create_common_attn_metadata(
+        batch_spec,
+        block_size=16,
+        device=device,
+    )
 
     # Rejected tokens per request: [1, 3, 2]
     num_rejected_tokens = torch.tensor([1, 3, 2],
@@ -130,18 +140,10 @@ def test_prepare_inputs():
         ],
         dtype=torch.int32,
         device=device)
-
-    # n1 + n2 + n3 - a - b -c
-    num_tokens = int(cu_target_query_lens[-1].item() -
-                     num_rejected_tokens.sum().item())
-
-    # Create CommonAttentionMetadata for new API
-    common_attn_metadata = _create_common_attn_metadata(
-        cu_target_query_lens, device)
     proposer = _create_proposer("eagle", 1)
 
     updated_metadata, token_indices = proposer.prepare_inputs(
-        common_attn_metadata, num_rejected_tokens.cpu(), num_tokens)
+        common_attn_metadata, num_rejected_tokens.cpu())
 
     assert torch.equal(updated_metadata.query_start_loc,
                        expected_cu_num_tokens)
@@ -324,25 +326,24 @@ def create_deterministic_logits(token_ids):
 
     # Create CommonAttentionMetadata for new API
     common_attn_metadata = _create_common_attn_metadata(cu_num_tokens, device)
+    attn_metadata_builder_cls, _ = get_attention_backend("flash_attn")
+    attn_metadata_builder = attn_metadata_builder_cls(
+        kv_cache_spec=create_standard_kv_cache_spec(proposer.vllm_config),
+        vllm_config=proposer.vllm_config,
+        device=device,
+    )
 
     # Mock runner for attention metadata building
     proposer.runner = mock.MagicMock()
     proposer.runner.attn_metadata_builders = [mock.MagicMock()]
-
-    # Create mock with required attributes for multi-token tests
-    attn_metadata_mock = mock.MagicMock()
-    attn_metadata_mock.max_seq_len = 10
-    attn_metadata_mock.seq_lens = torch.tensor([5, 3], device=device)
-    proposer.runner.attn_metadata_builders[
-        0].build.return_value = attn_metadata_mock
-
-    with mock.patch('vllm.v1.spec_decode.eagle.isinstance', return_value=True):
-        result = proposer.propose(target_token_ids=target_token_ids,
-                                  target_positions=target_positions,
-                                  target_hidden_states=target_hidden_states,
-                                  next_token_ids=next_token_ids,
-                                  common_attn_metadata=common_attn_metadata,
-                                  sampling_metadata=sampling_metadata)
+    proposer.runner.attn_metadata_builders[0] = attn_metadata_builder
+
+    result = proposer.propose(target_token_ids=target_token_ids,
+                              target_positions=target_positions,
+                              target_hidden_states=target_hidden_states,
+                              next_token_ids=next_token_ids,
+                              common_attn_metadata=common_attn_metadata,
+                              sampling_metadata=sampling_metadata)
 
     assert result.shape == (batch_size, num_speculative_tokens)