[Misc] Main2Main: align vLLM main to 3b95523e (Nov 12)

.github/vllm-main-verified.commit

@@ -1 +1 @@
-24420b7a341af37a9bc3186e6fc6062512e0aa58
+feb4cb019f445b2b3cd2bd0ba0f258610100910e

.github/workflows/_build_csrc_cache.yaml

@@ -152,7 +152,10 @@ jobs:
           fi
           git fetch "$BASE_REMOTE" "$BASE_REF"
           git cat-file -e "${BASE_SHA}^{commit}"
-          git rebase "$BASE_SHA"
+          # Preserve resolved merges when this exact base is already included.
+          if ! git merge-base --is-ancestor "$BASE_SHA" HEAD; then
+            git rebase "$BASE_SHA"
+          fi
 
       - name: Update submodules
         run: |

.github/workflows/_ensure_csrc_cache.yaml

@@ -139,7 +139,10 @@ jobs:
           fi
           git fetch "$BASE_REMOTE" "$BASE_REF"
           git cat-file -e "${BASE_SHA}^{commit}"
-          git rebase "$BASE_SHA"
+          # Preserve resolved merges when this exact base is already included.
+          if ! git merge-base --is-ancestor "$BASE_SHA" HEAD; then
+            git rebase "$BASE_SHA"
+          fi
 
       - name: Calculate csrc hash
         id: hash

.github/workflows/_selected_tests.yaml

@@ -161,7 +161,10 @@ jobs:
             BASE_SHA=$(git rev-parse FETCH_HEAD)
           fi
           git cat-file -e "${BASE_SHA}^{commit}"
-          git rebase "$BASE_SHA"
+          # Preserve resolved merges when this exact base is already included.
+          if ! git merge-base --is-ancestor "$BASE_SHA" HEAD; then
+            git rebase "$BASE_SHA"
+          fi
           git submodule sync --recursive
           git submodule update --init --recursive
 

.github/workflows/_selected_tests_upstream.yaml

@@ -146,7 +146,10 @@ jobs:
                 BASE_SHA=$(git rev-parse FETCH_HEAD)
               fi
               git cat-file -e "${BASE_SHA}^{commit}"
-              git rebase "$BASE_SHA"
+              # Preserve resolved merges when this exact base is already included.
+              if ! git merge-base --is-ancestor "$BASE_SHA" HEAD; then
+                git rebase "$BASE_SHA"
+              fi
               git submodule sync --recursive
               git submodule update --init --recursive
 

.github/workflows/pr_test.yaml

@@ -531,7 +531,10 @@ jobs:
             exit 1
           fi
 
-          git rebase "$BASE_SHA"
+          # Preserve resolved merges when this exact base is already included.
+          if ! git merge-base --is-ancestor "$BASE_SHA" HEAD; then
+            git rebase "$BASE_SHA"
+          fi
           echo "base_sha=$BASE_SHA" >> "$GITHUB_OUTPUT"
 
       - name: Validate test coverage config

release_notes/fragments/21005.yaml

@@ -0,0 +1,6 @@
+pr: 21005
+entries:
+  - category: dependency
+    text: Advanced the verified vLLM main baseline to ba15685a with matching graph, speculative decoding, weight-loading, and KV offload compatibility while retaining v0.33.0 release support.
+  - category: bugfix
+    text: Fixed Gemma4 multimodal initialization with the verified main baseline, preserving configured encoder parallelism and input normalization.

release_notes/fragments/21469.yaml

@@ -0,0 +1,4 @@
+pr: 21469
+entries:
+  - category: dependency
+    text: Aligned the verified vLLM main dependency to feb4cb01 (November 10, 2026), with compatibility updates for configuration hashing and Model Runner V2 interfaces. The release dependency remains v0.33.0.

tests/ut/core/test_dyntra_lb_scheduler.py

@@ -922,8 +922,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

@@ -37,6 +37,7 @@
 from vllm_ascend.core.short_request_first_scheduler import (
     ShortRequestFirstRequestQueue,
 )
+from vllm_ascend.utils import vllm_version_is
 
 MODEL = "Qwen/Qwen3-0.6B"
 BLOCK_SIZE = 16
@@ -67,7 +68,7 @@ def make_output(scheduler):
     sampled_token_ids = [[1000]] * len(scheduler.running)
     return ModelRunnerOutput(
         req_ids=req_ids,
-        req_id_to_index=req_id_to_index,
+        **({"req_id_to_index": req_id_to_index} if vllm_version_is("0.33.0") else {}),
         sampled_token_ids=sampled_token_ids,
         logprobs=None,
         prompt_logprobs_dict={},
@@ -982,10 +983,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/core/test_score_encoder_cache_scheduler.py

@@ -14,6 +14,7 @@
 
 from tests.ut.kv_offload.utils import create_model_runner_output, create_scheduler, create_vllm_config
 from vllm_ascend.ec_manager.score_ec_manager import ScoreEncoderCacheManager
+from vllm_ascend.utils import vllm_version_is
 
 
 def _make_scheduler(npu_slots: int = 8) -> Scheduler:
@@ -27,6 +28,18 @@ def _make_scheduler(npu_slots: int = 8) -> Scheduler:
     config.ec_manager_config.manager_config = {"cpu_cache_slots": 8}
     scheduler.encoder_cache_manager = ScoreEncoderCacheManager(npu_slots, config)
     scheduler.max_num_encoder_input_tokens = 32
+    if not vllm_version_is("0.33.0"):
+        # Main removed MRv1's metadata transport. These CPU tests exercise the
+        # manager's scheduling decisions, so collect its real payload at the
+        # same boundary without claiming native MRv2 worker transport coverage.
+        native_schedule = scheduler.schedule
+
+        def schedule_with_manager_metadata():
+            output = native_schedule()
+            output.ec_manager_metadata = scheduler.encoder_cache_manager.get_manager_metadata()
+            return output
+
+        scheduler.schedule = schedule_with_manager_metadata
     return scheduler
 
 
@@ -87,7 +100,10 @@ def _capacity(manager: ScoreEncoderCacheManager) -> tuple[int, int, int, int]:
 def _assert_error_and_finish(scheduler: Scheduler, request: Request, scheduler_output) -> None:
     assert scheduler_output.total_num_scheduled_tokens == 0
     assert not scheduler_output.scheduled_encoder_inputs
-    outputs = scheduler.update_from_output(scheduler_output, ModelRunnerOutput(req_ids=[], req_id_to_index={}))
+    outputs = scheduler.update_from_output(
+        scheduler_output,
+        ModelRunnerOutput(req_ids=[], **({"req_id_to_index": {}} if vllm_version_is("0.33.0") else {})),
+    )
     assert request.status == RequestStatus.FINISHED_ERROR
     assert request.request_id not in scheduler.requests
     assert request.request_id not in scheduler.encoder_cache_manager.request_cached_ids

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

@@ -50,6 +50,7 @@
     NPUIPCTrainerWeightTransferEngine,
     NPUIPCWeightTransferEngine,
 )
+from vllm_ascend.utils import vllm_version_is
 
 _MODULE = "vllm_ascend.distributed.weight_transfer.npu_ipc_engine"
 
@@ -76,6 +77,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},
@@ -196,13 +199,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

@@ -29,6 +29,8 @@
 from vllm.v1.request import Request
 from vllm.v1.structured_output import StructuredOutputManager
 
+from vllm_ascend.utils import vllm_version_is
+
 EOS_TOKEN_ID = 50256
 
 
@@ -59,6 +61,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",
@@ -257,7 +260,7 @@ def create_model_runner_output(
 
     model_runner_output = ModelRunnerOutput(
         req_ids=req_ids,
-        req_id_to_index=req_id_to_index,
+        **({"req_id_to_index": req_id_to_index} if vllm_version_is("0.33.0") else {}),
         sampled_token_ids=sampled_token_ids,
         logprobs=None,
         prompt_logprobs_dict={},

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