[Rebase] Rebase to vLLM 0.30.0 (#7820)

Signed-off-by: tzhouam <tzhouam@connect.ust.hk>
Signed-off-by: Gao Han <hgaoaf@connect.ust.hk>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Co-authored-by: Gao Han <hgaoaf@connect.ust.hk>

tests/diffusion/diffusion_kv/test_block_tables.py

@@ -279,19 +279,19 @@ def _install_native_modules(monkeypatch: pytest.MonkeyPatch, events: list[tuple]
         group = SimpleNamespace(get_metadata_builder=lambda _index: SimpleNamespace(reorder_batch_threshold=None))
         return [[group], [group]], "cg-support", [4, 8]
 
-    # vLLM 0.29 dropped attn_groups and cache_dtype from init_kv_cache: the
-    # layout now rides on the resolved CacheConfig.kv_cache_layout instead.
+    # f2aad6aa70 (#56888): first arg is forward_context; return a cache dict.
     def init_cache(
-        runner_kv_caches,
         forward_context,
         kv_cache_config,
         device,
         kernel_block_sizes,
         vllm_config,
+        kv_cache_allocation_context=None,
+        *,
+        block_tables=None,
     ):
         events.append(("cache", kv_cache_config, kernel_block_sizes))
-        runner_kv_caches.extend(["cache-0", "cache-1"])
-        return {"layer-0": "tensor-0", "layer-1": "tensor-1"}
+        return {"layer-0": "cache-0", "layer-1": "cache-1"}
 
     monkeypatch.setattr(model_runner_backend_module, "init_attn_backend", init_backend)
     monkeypatch.setattr(model_runner_backend_module, "init_kv_cache", init_cache)
@@ -431,8 +431,7 @@ def test_initialize_failure_does_not_publish_partial_cache_state(
         ],
     )
 
-    def fail_init_cache(runner_kv_caches, *_args, **_kwargs):
-        runner_kv_caches.append("partial-cache")
+    def fail_init_cache(forward_context, *_args, **_kwargs):
         backend._kv_cache_layer_adapters["layer-0"].kv_cache = "partial-binding"
         raise RuntimeError("cache binding failed")
 

tests/diffusion/diffusion_kv/test_mooncake_cfg_fanout.py

@@ -24,7 +24,16 @@ def producer(monkeypatch):
     worker.shutdown = Mock()  # No hardware constructor, sockets or listener thread.
     worker.is_kv_consumer = False
     worker.tp_rank, worker.tp_size = 0, 1
-    worker.transfer_topo = SimpleNamespace(handshake_target_ranks=lambda size: list(range(size)))
+    worker.transfer_topo = SimpleNamespace(
+        handshake_target_ranks=lambda size: list(range(size)),
+        total_num_kv_heads=1,
+    )
+    # vLLM 0.30 send_kv_to_decode also reads the PP size (ce08bb5b34,
+    # #56033), the MLA/Mamba flags and the head-resharding validator.
+    worker.pp_size = 1
+    worker.use_mla = False
+    worker.kv_cache_config = SimpleNamespace(has_mamba_layers=False)
+    worker._validate_head_resharding_layout = Mock(return_value=None)
     worker.reqs_need_send, worker.finished_sending_reqs = {}, set()
     for name in (
         "kv_caches_base_addr",
@@ -42,7 +51,9 @@ def producer(monkeypatch):
     worker._send_blocks = Mock(return_value=0)
     worker.xfer_stats = Mock()
     worker._build_transfer_params = AsyncMock(return_value=([1], [2], [16], [], None))
-    monkeypatch.setattr(mc, "_align_transfer_regions", lambda *_: ([], [], None))
+    # vLLM ce08bb5b34 (#56033) calls _align_transfer_regions with the
+    # allow_partial_layers keyword; the stub must accept it.
+    monkeypatch.setattr(mc, "_align_transfer_regions", lambda *_, **__: ([], [], None))
     monkeypatch.setattr(mc, "_validate_asymmetric_region_lengths", lambda **_: None)
     monkeypatch.setattr(mc.envs, "VLLM_MOONCAKE_ABORT_REQUEST_TIMEOUT", 0.05)
     connector = object.__new__(mc.MooncakeConnector)

tests/diffusion/diffusion_kv/test_native_prefetch.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+from collections.abc import Iterator
 from types import SimpleNamespace
 from unittest.mock import Mock
 
@@ -526,23 +527,30 @@ def test_drain_after_terminal_request_state_was_popped(monkeypatch):
 
 
 @pytest.mark.parametrize("prefetch", [False, True])
-def test_real_active_connector_starts_required_load_before_polling(prefetch):
-    from vllm.v1.worker.gpu.kv_connector import ActiveKVConnector
+def test_real_active_connector_starts_required_load_before_polling(prefetch, monkeypatch):
+    from vllm.distributed.kv_transfer.kv_connector.v1.base import KVConnectorBase_V1
+    from vllm.v1.worker.gpu import kv_connector as native_kv_connector
 
     from vllm_omni.diffusion.diffusion_kv.kv_connector import wait_for_kv_load
 
-    active = object.__new__(ActiveKVConnector)
-    active._disabled = False
-    active._pending_load_start = False
-    active.kv_connector = Mock()
-    active.kv_connector.get_block_ids_with_load_errors.return_value = set()
-    active._start_load_kv = Mock()
+    connector = Mock(spec=KVConnectorBase_V1)
+    connector.get_block_ids_with_load_errors.return_value = set()
+    # Exercise upstream's compatibility adapter instead of returning an
+    # unconstrained Mock from the v0.30 get_transfer_results API.
+    connector.get_transfer_results.side_effect = lambda ids: KVConnectorBase_V1.get_transfer_results(connector, ids)
+    monkeypatch.setattr(native_kv_connector, "get_kv_transfer_group", lambda: connector)
+    context = object()
+    monkeypatch.setattr(native_kv_connector, "is_forward_context_available", lambda: True)
+    monkeypatch.setattr(native_kv_connector, "get_forward_context", lambda: context)
+    active = native_kv_connector.ActiveKVConnector(Mock(), {})
+
+    completions: Iterator[tuple[set[str], set[str]]] = iter([(set(), {"A0"}), (set(), set())])
 
     def finished(_):
-        active._start_load_kv.assert_called_once()
-        return set(), {"A0"}
+        connector.start_load_kv.assert_called_once_with(context)
+        return next(completions)
 
-    active.kv_connector.get_finished.side_effect = finished
+    connector.get_finished.side_effect = finished
     output = _output(submit=["A0"], required=["A0"], metadata=object())
     if prefetch:
         result = KVReceiveProgress().prepare(active, output, 1)
@@ -550,3 +558,6 @@ def test_real_active_connector_starts_required_load_before_polling(prefetch):
         output.kv_required_request_ids = None
         result = wait_for_kv_load(active, output, 1)
     assert result.finished_recving == {"A0"}
+    assert result.finished_sending == set()
+    connector.get_transfer_results.assert_called_once_with(set())
+    connector.start_load_kv.assert_called_once_with(context)

tests/diffusion/diffusion_kv/test_paged_attention_adapter_gpu.py

@@ -106,11 +106,9 @@ def _native_adapter(num_rows: int = 1):
             vllm_config,
             device,
         )
-        runner_kv_caches: list[torch.Tensor | list[torch.Tensor]] = []
-        # vLLM 0.29 dropped attn_groups and cache_dtype here: the layout now
-        # comes from the resolved CacheConfig.kv_cache_layout inside the call.
+        # f2aad6aa70 (#56888): init_kv_cache no longer mutates a runner list;
+        # first arg is forward_context and the allocated caches are returned.
         init_kv_cache(
-            runner_kv_caches,
             vllm_config.compilation_config.static_forward_context,
             kv_cache_config,
             device,