[Misc] main2main 1106

.github/vllm-main-verified.commit

@@ -1 +1 @@
-24420b7a341af37a9bc3186e6fc6062512e0aa58
+ba15685ab7f4f5fbed8630bbb7441f8837e76fbe

tests/ut/core/test_dyntra_lb_scheduler.py

@@ -1023,8 +1023,10 @@ def test_dyntra_lb_async_v2_sets_pp_decode_cadence():
     scheduler_output = scheduler.schedule()
 
     assert request.request_id in scheduler_output.num_scheduled_tokens
-    assert scheduler.pp_size == 2
-    assert request.next_decode_eligible_step == scheduler.current_step + scheduler.pp_size
+    assert scheduler.parallel_config.pipeline_parallel_size == 2
+    assert (
+        request.next_decode_eligible_step == scheduler.current_step + scheduler.parallel_config.pipeline_parallel_size
+    )
 
 
 def test_dyntra_lb_sync_skips_until_previous_output_arrives():

tests/ut/core/test_profiling_chunk.py

@@ -982,10 +982,10 @@ def test_v2_pp_sets_next_decode_eligible_step(self):
         first_output = scheduler.schedule()
 
         self.assertIn(request.request_id, first_output.num_scheduled_tokens)
-        self.assertEqual(scheduler.pp_size, scheduler.parallel_config.pipeline_parallel_size)
+        self.assertEqual(scheduler.parallel_config.pipeline_parallel_size, 2)
         self.assertEqual(
             request.next_decode_eligible_step,
-            scheduler.current_step + scheduler.pp_size,
+            scheduler.current_step + scheduler.parallel_config.pipeline_parallel_size,
         )
 
         # The next step is inside the PP cadence window: the request is skipped.

tests/ut/distributed/kv_transfer/kv_p2p/test_remote_prefill_lifecycle.py

@@ -71,7 +71,7 @@ def test_basic_lifecycle():
     assert len(block_pool.cached_block_hash_to_block) == 0
     blocks = scheduler.kv_cache_manager.coordinator.single_type_managers[0].req_to_blocks[request_id]
     for block in blocks:
-        assert block._block_hash is None
+        assert block.block_hash is None
 
     # (1b): forward()
     model_runner_output = EMPTY_MODEL_RUNNER_OUTPUT
@@ -104,7 +104,7 @@ def test_basic_lifecycle():
     blocks = scheduler.kv_cache_manager.coordinator.single_type_managers[0].req_to_blocks[request_id]
     for block in blocks:
         assert block.ref_cnt == 1
-        num_hashed_blocks += 1 if block._block_hash is not None else 0
+        num_hashed_blocks += 1 if block.block_hash is not None else 0
     assert num_hashed_blocks == NUM_EXTERNAL_FULL_BLOCKS
 
     scheduled_req = scheduler_output.scheduled_new_reqs[0]

tests/ut/distributed/weight_transfer/test_hccl_engine.py

@@ -30,7 +30,10 @@
 def _npu_context():
     with (
         patch.object(
-            torch, "npu", SimpleNamespace(device=lambda _: nullcontext(), current_stream=MagicMock()), create=True
+            torch,
+            "npu",
+            SimpleNamespace(device=lambda _: nullcontext(), current_stream=MagicMock(), empty_cache=MagicMock()),
+            create=True,
         ),
         patch("torch.accelerator.current_device_index", return_value=0),
     ):
@@ -43,13 +46,18 @@ def _make_engine():
     engine.model_config = MagicMock()
     engine.device = torch.device("cpu")
     engine._last_hccl_update_info = {}
+    # Match the upstream constructor's disabled load-plan state.
+    engine._plan_metadata = None
+    engine._plan_manifest = None
+    engine._plan = None
     return engine
 
 
 def test_start_weight_update_initializes_layerwise_reload():
     engine = _make_engine()
 
-    with patch("vllm.model_executor.model_loader.reload.initialize_layerwise_reload") as initialize:
+    start = "initialize_layerwise_reload" if vllm_version_is("0.33.0") else "start_reload"
+    with patch(f"vllm.model_executor.model_loader.reload.{start}") as initialize:
         engine.start_weight_update()
 
     initialize.assert_called_once_with(engine.model)
@@ -58,10 +66,14 @@ def test_start_weight_update_initializes_layerwise_reload():
 def test_finish_weight_update_finalizes_layerwise_reload():
     engine = _make_engine()
 
-    with patch("vllm.model_executor.model_loader.reload.finalize_layerwise_reload") as finalize:
+    finish = "finalize_layerwise_reload" if vllm_version_is("0.33.0") else "finish_reload"
+    with patch(f"vllm.model_executor.model_loader.reload.{finish}") as finalize:
         engine.finish_weight_update()
 
-    finalize.assert_called_once_with(engine.model, engine.model_config)
+    args: tuple[Any, ...] = (engine.model, engine.model_config)
+    if not vllm_version_is("0.33.0"):
+        args += (engine.device,)
+    finalize.assert_called_once_with(*args)
 
 
 def test_shutdown_closes_session_once():
@@ -109,7 +121,10 @@ def test_init_info_preserves_upstream_payload_contract():
 
     assert isinstance(init_info, NCCLWeightTransferInitInfo)
     assert HCCLWeightTransferEngine.init_info_cls is HCCLWeightTransferInitInfo
-    assert worker_init_payload(init_info) == dict(master_address="host", master_port=1234, rank_offset=1, world_size=2)
+    expected = dict(master_address="host", master_port=1234, rank_offset=1, world_size=2)
+    if not vllm_version_is("0.33.0"):
+        expected["use_load_plan"] = False
+    assert worker_init_payload(init_info) == expected
     restored = HCCLWeightTransferInitInfo(**worker_init_payload(init_info))
     assert restored == init_info
     assert restored.packed is None

tests/ut/distributed/weight_transfer/test_npu_ipc_engine.py

@@ -52,6 +52,7 @@
     NPUIPCTrainerWeightTransferEngine,
     NPUIPCWeightTransferEngine,
 )
+from vllm_ascend.utils import vllm_version_is
 
 _MODULE = "vllm_ascend.distributed.weight_transfer.npu_ipc_engine"
 
@@ -78,6 +79,8 @@ def _patch_reload_module(*, initialize=None, finalize=None):
     fake_mod = types.ModuleType("vllm.model_executor.model_loader.reload")
     fake_mod.initialize_layerwise_reload = initialize or MagicMock()  # type: ignore[attr-defined]
     fake_mod.finalize_layerwise_reload = finalize or MagicMock()  # type: ignore[attr-defined]
+    fake_mod.start_reload = fake_mod.initialize_layerwise_reload  # type: ignore[attr-defined]
+    fake_mod.finish_reload = fake_mod.finalize_layerwise_reload  # type: ignore[attr-defined]
     return patch.dict(
         sys.modules,
         {"vllm.model_executor.model_loader.reload": fake_mod},
@@ -198,13 +201,17 @@ def test_finish_weight_update():
     engine = object.__new__(NPUIPCWeightTransferEngine)
     engine.model = MagicMock()
     engine.model_config = MagicMock()
+    engine.device = torch.device("cpu")
     engine._packed_importer = MagicMock()
     mock_finalize = MagicMock()
 
     with _patch_reload_module(finalize=mock_finalize):
         engine.finish_weight_update()
 
-    mock_finalize.assert_called_once_with(engine.model, engine.model_config)
+    if vllm_version_is("0.33.0"):
+        mock_finalize.assert_called_once_with(engine.model, engine.model_config)
+    else:
+        mock_finalize.assert_called_once_with(engine.model, engine.model_config, engine.device)
     engine._packed_importer.close.assert_called_once_with()
 
 

tests/ut/kv_offload/test_dspark_transfer_cancellation.py

@@ -147,12 +147,16 @@ def _fixture(names=("cancel",), *, admit=True):
     upstream.waiting = Mock()
     upstream.skipped_waiting = Mock()
     upstream.kv_holding_waiting = Mock()
+    upstream.async_kv_waiting = Mock()
+    upstream._aborted_kv_loads = set()
     upstream.deferred_waiting = set()
     upstream.finished_recving_kv_req_ids = set()
     upstream.failed_recving_kv_req_ids = set()
     upstream.finished_req_ids = set()
     upstream.finished_req_ids_dict = None
     upstream._inflight_prefills = set()
+    upstream._parked_reservations = {}
+    upstream._parked_reserved_blocks = 0
     upstream._kv_fetch_stages = None
     upstream.aux_output_connector = None
     upstream.ec_connector = None

tests/ut/kv_offload/utils.py

@@ -59,6 +59,7 @@ def _fake_opt_model_info() -> SimpleNamespace:
     """Static ModelInfo for OPT fake weights; avoids registry subprocess inspect."""
     return SimpleNamespace(
         architecture="OPTForCausalLM",
+        speculator_config_class=None,
         is_text_generation_model=True,
         is_pooling_model=False,
         attn_type="decoder",

tests/ut/models/test_kimi_k3_gate_loading.py

@@ -21,6 +21,8 @@ def make_linear(cls, output_sizes, tp_size=1, tp_rank=0):
     layer.tp_rank = tp_rank
     layer.tp_size = tp_size
     layer.output_sizes = output_sizes
+    layer.shard_ids = tuple(range(len(output_sizes)))
+    layer.loaded_shard_ids = {}
     return layer
 
 

tests/ut/ops/test_linear.py

@@ -1,6 +1,7 @@
 import unittest
 from contextlib import contextmanager
 from types import SimpleNamespace
+from typing import Any
 from unittest import mock
 from unittest.mock import MagicMock, patch
 
@@ -14,13 +15,15 @@
 from vllm_ascend.ops.linear import (
     AscendDCPGroupColumnParallelLinear,
     AscendMergedColumnParallelLinear,
+    AscendQKVParallelLinear,
     AscendReplicatedLinear,
     AscendRowParallelLinear,
     AscendUnquantizedLinearMethod,
 )
 from vllm_ascend.ops.linear_op import DCPGroupColumnParallelOp
 from vllm_ascend.quantization.method_adapters import AscendLinearMethod
 from vllm_ascend.quantization.methods.w8a8.w8a8_dynamic import AscendW8A8DynamicLinearMethod
+from vllm_ascend.utils import vllm_version_is
 
 
 class BaseLinearTest(unittest.TestCase):
@@ -227,6 +230,28 @@ def test_oproj_tp(self, mock_get_current_vllm_config):
 
 
 class TestAscendMergedColumnParallelLinear(BaseLinearTest):
+    @unittest.skipIf(vllm_version_is("0.33.0"), "Stacked shard tracking was added after v0.33")
+    def test_custom_allocations_preserve_missing_shard_validation(self):
+        layers: tuple[Any, ...] = (
+            AscendMergedColumnParallelLinear(input_size=8, output_sizes=[4, 4], bias=False, disable_tp=True),
+            AscendQKVParallelLinear(hidden_size=8, head_size=2, total_num_heads=2, bias=False, disable_tp=True),
+        )
+        for layer in layers:
+            with self.subTest(layer=type(layer).__name__):
+                shards = layer.shard_ids
+                first = shards[0]
+                size = layer._get_shard_size_mapping(first)
+                layer.weight_loader(layer.weight, torch.ones(size, 8), first)
+                self.assertEqual(layer.pop_missing_shards(), [f"weight.{shard}" for shard in shards[1:]])
+                # A new complete load must start fresh and cover every shard.
+                for shard in shards:
+                    size = layer._get_shard_size_mapping(shard)
+                    layer.weight_loader(layer.weight, torch.ones(size, 8), shard)
+                self.assertEqual(layer.pop_missing_shards(), [])
+                torch.testing.assert_close(layer.weight, torch.ones_like(layer.weight))
+                with self.assertRaises(ValueError):
+                    layer.validate_shard_id("invalid", layer.weight)
+
     def test_merged_mlp_tp_init(self):
         ascend_config._ASCEND_CONFIG = MagicMock()
         ascend_config._ASCEND_CONFIG.scheduler_config.recompute_scheduler_enable = False

tests/ut/ops/test_mla.py

@@ -393,30 +393,34 @@ def test_initialization(self, mock_tp_size, mock_get_vllm_config, mock_indexer_c
         mock_mla_attn.impl = MagicMock()
         mock_mla_attn.impl.process_weights_after_loading = MagicMock()
 
-        with patch("vllm_ascend.ops.mla.AscendMLAAttention", return_value=mock_mla_attn):
+        with patch("vllm_ascend.ops.mla.AscendMLAAttention", return_value=mock_mla_attn) as backend:
             mock_tp_size.return_value = 2
             mock_vllm_config = MagicMock(spec=VllmConfig)
             mock_vllm_config.model_config.hf_text_config = MagicMock(num_hidden_layers=32, first_k_dense_replace=True)
             mock_get_vllm_config.return_value = mock_vllm_config
-            mock_vllm_config.compilation_config = CompilationConfig()
-
-            attn = AscendMultiHeadLatentAttention(
-                hidden_size=self.hidden_size,
-                num_heads=self.num_heads,
-                scale=self.scale,
-                qk_nope_head_dim=self.qk_nope_head_dim,
-                qk_rope_head_dim=self.qk_rope_head_dim,
-                v_head_dim=self.v_head_dim,
-                q_lora_rank=self.q_lora_rank,
-                kv_lora_rank=self.kv_lora_rank,
-                mla_modules=self.mock_mla_modules,
-                cache_config=self.mock_cache_config,
-                quant_config=self.mock_quant_config,
-                prefix=self.prefix,
-            )
-
-            self.assertEqual(attn.tp_size, 2)
-            self.assertIsNotNone(attn.mla_attn)
+            # CUDA eligibility must not alter Ascend cache/indexer layout.
+            for shardq_eligible in (False, True):
+                mock_vllm_config.compilation_config = CompilationConfig()
+
+                attn = AscendMultiHeadLatentAttention(
+                    hidden_size=self.hidden_size,
+                    num_heads=self.num_heads,
+                    scale=self.scale,
+                    qk_nope_head_dim=self.qk_nope_head_dim,
+                    qk_rope_head_dim=self.qk_rope_head_dim,
+                    v_head_dim=self.v_head_dim,
+                    q_lora_rank=self.q_lora_rank,
+                    kv_lora_rank=self.kv_lora_rank,
+                    mla_modules=self.mock_mla_modules,
+                    cache_config=self.mock_cache_config,
+                    quant_config=self.mock_quant_config,
+                    prefix=self.prefix,
+                    shardq_eligible=shardq_eligible,
+                )
+
+                self.assertEqual(attn.tp_size, 2)
+                self.assertIsNotNone(attn.mla_attn)
+                self.assertNotIn("shardq_eligible", backend.call_args.kwargs)
 
     @patch("vllm_ascend.ops.mla.IndexerWrapper")
     @patch("vllm_ascend.ops.mla.get_current_vllm_config")

tests/ut/ops/test_mla_weight_processing.py

@@ -14,6 +14,7 @@
 from vllm_ascend.attention.mla_v1 import AscendMLAImpl
 from vllm_ascend.attention.sfa_v1 import AscendSFAImpl
 from vllm_ascend.ops.mla import AscendMultiHeadLatentAttention
+from vllm_ascend.utils import vllm_version_is
 
 
 def make_attention(impl):
@@ -22,6 +23,7 @@ def make_attention(impl):
     nn.Module.__init__(inner)
     set_default_quant_scales(inner, register_buffer=True)
     inner.impl = impl
+    inner.act_dtype = torch.bfloat16
     inner.num_heads = 2
     inner.kv_lora_rank = 4
     inner.qk_nope_head_dim = 2
@@ -70,14 +72,18 @@ def test_impl_post_load_called_once(is_sfa, act_dtype):
         # SFA disposes this projection; upstream dense packing must be bypassed.
         impl.process_weights_after_loading.side_effect = lambda _: setattr(inner.kv_b_proj, "weight", None)
 
-    inner.process_weights_after_loading(act_dtype)
+    inner.act_dtype = act_dtype
+    if vllm_version_is("0.33.0"):
+        inner.process_weights_after_loading(act_dtype)
+    else:
+        inner.process_weights_after_loading()
 
     impl.process_weights_after_loading.assert_called_once_with(act_dtype)
     if is_sfa:
         upstream.assert_not_called()
         assert inner.kv_b_proj.weight is None
     else:
-        upstream.assert_called_once_with(act_dtype)
+        upstream.assert_called_once_with(*([act_dtype] if vllm_version_is("0.33.0") else []))
         assert inner.W_UV.shape == (2, 4, 4)
         assert inner.W_UK_T.shape == (2, 2, 4)
 
@@ -113,7 +119,7 @@ def test_mlapo_post_load_does_not_reprocess_released_weights(is_kv_consumer):
     ):
         inner.process_weights_after_loading(torch.bfloat16)
 
-    upstream.assert_called_once_with(torch.bfloat16)
+    upstream.assert_called_once_with(*([torch.bfloat16] if vllm_version_is("0.33.0") else []))
     impl.process_weights_after_loading.assert_called_once_with(torch.bfloat16)
     assert (impl.fused_qkv_a_proj.weight is None) == is_kv_consumer
     assert (impl.q_proj.weight is None) == is_kv_consumer

tests/ut/patch/platform/test_patch_mamba_config.py

@@ -85,6 +85,7 @@ def _config(
     speculative_method=None,
 ):
     return SimpleNamespace(
+        use_flashinfer_replayssm=False,
         scheduler_config=SimpleNamespace(
             disable_hybrid_kv_cache_manager=disable_hybrid,
         ),

tests/ut/patch/platform/test_patch_pp_mtp.py

@@ -328,6 +328,7 @@ def validate_grammar(_tokens):
         is_finished=lambda: False,
         use_structured_output=True,
         all_token_ids=[200],
+        _all_token_ids=[200],
         structured_output_request=SimpleNamespace(
             grammar=SimpleNamespace(validate_tokens=validate_grammar),
             reasoning_ended=False,

tests/ut/patch/platform/test_patch_speculative_config_dspark.py

@@ -5,6 +5,7 @@
 
 import pytest
 from transformers import PretrainedConfig, Qwen3Config
+from vllm import config as vllm_config
 from vllm.config import ParallelConfig
 from vllm.config.model import ModelConfig
 from vllm.config.model_arch import ModelArchitectureConfig
@@ -16,6 +17,7 @@
     _ascend_verify_with_parallel_config,
     _normalize_deepseek_dspark_draft,
 )
+from vllm_ascend.utils import vllm_version_is
 
 
 def test_legacy_qwen3_dspark_config_uses_qwen3_loader():
@@ -87,6 +89,10 @@ def architectures(self):
 
 
 class _DraftModelConfig(SimpleNamespace):
+    # These fixtures model self-contained DSpark drafts, as declared by the
+    # Kimi/Qwen model classes; None would select the DeepSeek target-config path.
+    speculator_config_class = "vllm.v1.worker.gpu.spec_decode.dspark.config.DSparkSpeculatorConfig"
+
     @property
     def architectures(self):
         return self.model_arch_config.architectures
@@ -158,7 +164,10 @@ def verify(draft_pc):
         draft.verify_with_parallel_config = verify
         # Mock only checkpoint loading; run the real post-init, architecture
         # normalization, draft parallel-config creation, and after-validator.
-        monkeypatch.setattr(patch_speculative_config.speculative_config, "ModelConfig", lambda **_: draft)
+        # vLLM #63205 moves draft construction to a method that imports
+        # ModelConfig from vllm.config rather than vllm.config.speculative.
+        model_config_module = patch_speculative_config.speculative_config if vllm_version_is("0.33.0") else vllm_config
+        monkeypatch.setattr(model_config_module, "ModelConfig", lambda **_: draft)
         create_draft_pc = SpeculativeConfig.create_draft_parallel_config
         created = []
 

tests/ut/patch/platform/test_patch_use_v2_model_runner.py

@@ -20,7 +20,11 @@ def test_use_v2_model_runner_is_driven_by_ascend_default():
 def test_native_v2_spec_pp_validation(method, enable_sp):
     config = SimpleNamespace(
         model_config=None,
-        speculative_config=SimpleNamespace(method=method, parallel_drafting=False),
+        speculative_config=SimpleNamespace(
+            method=method,
+            parallel_drafting=False,
+            speculator_config=SimpleNamespace(speculator_class="test.Speculator"),
+        ),
         compilation_config=SimpleNamespace(mode=CompilationMode.NONE, pass_config=SimpleNamespace(enable_sp=enable_sp)),
         parallel_config=SimpleNamespace(
             pipeline_parallel_size=2,