[Misc]Main2main to 0420

.github/workflows/_e2e_test.yaml

@@ -36,7 +36,7 @@ on:
       continue_on_error:
         required: false
         type: boolean
-        default: false
+        default: true
       # The following inputs are used by comment-triggered E2E tests (/e2e <tests>).
       # They carry space-separated pytest paths, categorized by runner type.
       # Leave empty (default) when running label-triggered full/light suites.

.github/workflows/dockerfiles/Dockerfile.lint

@@ -27,7 +27,7 @@ RUN apt-get update -y && \
 
 ARG VLLM_REPO=https://github.com/vllm-project/vllm.git
 # For lint purpose, actually we need make a main2main matching.
-ARG VLLM_COMMIT=6f786f2c506cb07f4566771fdc62e640e2c4a176
+ARG VLLM_COMMIT=ccaf5ffaa3e1fb2a081b2c9e403ac0e4dfc142c8
 RUN git init /vllm-workspace/vllm && \
     git -C /vllm-workspace/vllm fetch --depth 1 $VLLM_REPO $VLLM_COMMIT && \
     git -C /vllm-workspace/vllm checkout FETCH_HEAD

.github/workflows/pr_test_full.yaml

@@ -80,7 +80,7 @@ jobs:
     name: e2e-full
     strategy:
       matrix:
-        vllm_version: [6f786f2c506cb07f4566771fdc62e640e2c4a176, v0.19.0]
+        vllm_version: [ccaf5ffaa3e1fb2a081b2c9e403ac0e4dfc142c8, v0.19.0]
     needs: [changes]
     if: ${{ needs.changes.outputs.e2e_tracker == 'true' || needs.changes.outputs.e2e_tracker == true }}
     uses: ./.github/workflows/_e2e_test.yaml

.github/workflows/pr_test_light.yaml

@@ -41,7 +41,7 @@ jobs:
   lint:
     uses: ./.github/workflows/_pre_commit.yml
     with:
-      vllm: 6f786f2c506cb07f4566771fdc62e640e2c4a176
+      vllm: ccaf5ffaa3e1fb2a081b2c9e403ac0e4dfc142c8
   changes:
     runs-on: linux-aarch64-a2b3-0
     outputs:
@@ -92,7 +92,7 @@ jobs:
     if: ${{ needs.lint.result == 'success' && (needs.changes.outputs.e2e_tracker == 'true' || needs.changes.outputs.ut_tracker == 'true') }}
     strategy:
       matrix:
-        vllm_version: [6f786f2c506cb07f4566771fdc62e640e2c4a176, v0.19.0]
+        vllm_version: [ccaf5ffaa3e1fb2a081b2c9e403ac0e4dfc142c8, v0.19.0]
     uses: ./.github/workflows/_unit_test.yaml
     with:
       vllm: ${{ matrix.vllm_version }}
@@ -104,7 +104,7 @@ jobs:
     name: e2e-light
     strategy:
       matrix:
-        vllm_version: [6f786f2c506cb07f4566771fdc62e640e2c4a176, v0.19.0]
+        vllm_version: [ccaf5ffaa3e1fb2a081b2c9e403ac0e4dfc142c8, v0.19.0]
     # Note (yikun): If CI resource are limited we can split job into two chain jobs
     needs: [lint, changes]
     # only trigger e2e test after lint passed and the change is e2e related with pull request.

docs/source/conf.py

@@ -80,7 +80,7 @@
     # CANN image tag
     "cann_image_tag": "8.5.1-910b-ubuntu22.04-py3.11",
     # vLLM commit hash for main branch
-    "main_vllm_commit": "6f786f2c506cb07f4566771fdc62e640e2c4a176",
+    "main_vllm_commit": "ccaf5ffaa3e1fb2a081b2c9e403ac0e4dfc142c8",
     # vLLM tag for main branch
     "main_vllm_tag": "v0.19.0",
     # Python version for main branch

requirements.txt

@@ -35,6 +35,6 @@ numba
 torch-npu==2.9.0
 
 arctic-inference==0.1.1
-transformers>=4.57.4
+transformers>=4.57.4, <5.0
 fastapi<0.124.0
 triton-ascend==3.2.0

tests/ut/ops/test_mla.py

@@ -8,6 +8,7 @@
 
 from tests.ut.base import TestBase
 from vllm_ascend.ops.mla import AscendMultiHeadLatentAttention, IndexerWrapper
+from vllm_ascend.utils import vllm_version_is
 
 
 class TestIndexerWrapper(TestBase):
@@ -19,8 +20,11 @@ def test_initialization(self):
         mock_indexer.topk_tokens = 2048
         mock_indexer.q_lora_rank = 1536
         mock_indexer.wq_b = nn.Linear(128, 128)
-        mock_indexer.wk = nn.Linear(128, 128)
-        mock_indexer.weights_proj = nn.Linear(128, 128)
+        if vllm_version_is("0.19.0"):
+            mock_indexer.wk = nn.Linear(128, 128)
+            mock_indexer.weights_proj = nn.Linear(128, 128)
+        else:
+            mock_indexer.wk_weights_proj = nn.Linear(128, 128)
         mock_indexer.k_norm = nn.LayerNorm(128)
         mock_indexer.softmax_scale = 0.123
         mock_indexer.topk_indices_buffer = torch.randn(10)
@@ -33,8 +37,11 @@ def test_initialization(self):
         self.assertEqual(wrapper.topk_tokens, 2048)
         self.assertEqual(wrapper.q_lora_rank, 1536)
         self.assertIs(wrapper.wq_b, mock_indexer.wq_b)
-        self.assertIs(wrapper.wk, mock_indexer.wk)
-        self.assertIs(wrapper.weights_proj, mock_indexer.weights_proj)
+        if vllm_version_is("0.19.0"):
+            self.assertIs(wrapper.wk, mock_indexer.wk)
+            self.assertIs(wrapper.weights_proj, mock_indexer.weights_proj)
+        else:
+            self.assertIs(wrapper.wk_weights_proj, mock_indexer.wk_weights_proj)
         self.assertIs(wrapper.k_norm, mock_indexer.k_norm)
         self.assertEqual(wrapper.softmax_scale, 0.123)
 

vllm_ascend/_310p/fused_moe/fused_moe.py

@@ -20,7 +20,6 @@
 from vllm.distributed import get_dp_group, get_ep_group, get_tp_group
 from vllm.model_executor.layers.fused_moe.config import FusedMoEConfig
 from vllm.model_executor.layers.fused_moe.layer import FusedMoE, UnquantizedFusedMoEMethod
-from vllm.model_executor.layers.fused_moe.shared_fused_moe import SharedFusedMoE
 
 from vllm_ascend.ascend_forward_context import _EXTRA_CTX, MoECommType
 from vllm_ascend.ops.fused_moe.experts_selector import zero_experts_compute
@@ -29,6 +28,9 @@
 from vllm_ascend.quantization.quant_type import QuantType
 from vllm_ascend.utils import vllm_version_is
 
+if vllm_version_is("0.19.0"):
+    from vllm.model_executor.layers.fused_moe.shared_fused_moe import SharedFusedMoE  # type: ignore[no-redef]
+
 from .experts_selector import select_experts
 from .moe_comm_method import AllGatherCommImpl310
 
@@ -118,7 +120,12 @@ def apply(
 
 class AscendFusedMoE310(FusedMoE):
     def __init__(self, *args, **kwargs):
+        is_legacy = vllm_version_is("0.19.0")
+        if not is_legacy:
+            _routed_input_transform = kwargs.get("routed_input_transform")
         super().__init__(*args, **kwargs)
+        if not is_legacy:
+            self.reduce_results = False
 
         self.global_num_experts = kwargs["num_experts"]
 
@@ -164,18 +171,29 @@ def __init__(self, *args, **kwargs):
 
         from vllm_ascend.ops.fused_moe.fused_moe import AscendMoERunner
 
-        is_legacy = vllm_version_is("0.19.0")
-        self.runner = AscendMoERunner(
-            self if is_legacy else self.layer_name,
-            self.moe_config,
-            self.router,
-            self._routed_input_transform,
-            self.gate if is_legacy else kwargs.pop("gate", None),
-            self.shared_experts if is_legacy else kwargs.pop("shared_experts", None),
-            self.quant_method,
-            self.reduce_results,
-            self.vllm_config.parallel_config.enable_dbo,
-        )
+        if is_legacy:
+            self.runner = AscendMoERunner(
+                self,
+                self.moe_config,
+                self.router,
+                self._routed_input_transform,
+                self.gate,
+                self.shared_experts,
+                self.quant_method,
+                self.reduce_results,
+                self.vllm_config.parallel_config.enable_dbo,
+            )
+        else:
+            self.runner = AscendMoERunner(
+                self.layer_name,
+                self.moe_config,
+                self.router,
+                _routed_input_transform,
+                kwargs.get("gate"),
+                kwargs.get("shared_experts"),
+                self.quant_method,
+                self.vllm_config.parallel_config.enable_dbo,
+            )
 
     def init_experts_map(self, moe_config):
         """
@@ -221,6 +239,9 @@ def get_quant_type(self) -> QuantType:
             raise RuntimeError("Only Unquant and W8A8 is supported.")
         return quant_type
 
+    def maybe_init_modular_kernel(self) -> None:
+        return None
+
     def forward_impl(  # type: ignore[override]
         self, hidden_states: torch.Tensor, router_logits: torch.Tensor
     ) -> torch.Tensor:
@@ -263,7 +284,10 @@ def forward_impl(  # type: ignore[override]
         return routed_out
 
 
-class AscendSharedFusedMoE310(SharedFusedMoE, AscendFusedMoE310):
+_SharedFusedMoEBase310 = (SharedFusedMoE, AscendFusedMoE310) if vllm_version_is("0.19.0") else (AscendFusedMoE310,)
+
+
+class AscendSharedFusedMoE310(*_SharedFusedMoEBase310):  # type: ignore[misc]
     def __init__(
         self,
         shared_experts: torch.nn.Module,
@@ -286,17 +310,29 @@ def __init__(
         from vllm_ascend.ops.fused_moe.fused_moe import AscendMoERunner
 
         is_legacy = vllm_version_is("0.19.0")
-        self.runner = AscendMoERunner(
-            self if is_legacy else self.layer_name,
-            self.moe_config,
-            self.router,
-            self._routed_input_transform,
-            self._gate,
-            self._shared_experts,
-            self.quant_method,
-            self.reduce_results,
-            self.vllm_config.parallel_config.enable_dbo,
-        )
+        if is_legacy:
+            self.runner = AscendMoERunner(
+                self,
+                self.moe_config,
+                self.router,
+                self._routed_input_transform,
+                self._gate,
+                self._shared_experts,
+                self.quant_method,
+                self.reduce_results,
+                self.vllm_config.parallel_config.enable_dbo,
+            )
+        else:
+            self.runner = AscendMoERunner(
+                self.layer_name,
+                self.moe_config,
+                self.router,
+                self._routed_input_transform,
+                self._gate,
+                self._shared_experts,
+                self.quant_method,
+                self.vllm_config.parallel_config.enable_dbo,
+            )
 
     @property
     def is_internal_router(self) -> bool:

vllm_ascend/ascend_forward_context.py

@@ -20,6 +20,7 @@
     is_drafter_moe_model,
     is_moe_model,
     speculative_enable_dispatch_gmm_combine_decode,
+    vllm_version_is,
 )
 
 
@@ -153,7 +154,11 @@ def set_ascend_forward_context(
 
         dp_world_size = get_dp_group().world_size
         if dp_world_size > 1 and forward_context.dp_metadata is not None:
-            max_tokens_across_dp = forward_context.dp_metadata.max_tokens_across_dp_cpu.item()
+            dp_meta = forward_context.dp_metadata
+            if vllm_version_is("0.19.0"):
+                max_tokens_across_dp = dp_meta.max_tokens_across_dp_cpu.item()
+            else:
+                max_tokens_across_dp = dp_meta.num_tokens_across_dp_cpu.max().item()
             if forward_context.flash_comm_v1_enabled or forward_context.flashcomm_v2_enabled:
                 padded_length = (max_tokens_across_dp + tp_world_size - 1) // tp_world_size * tp_world_size
                 pad_size = padded_length - num_tokens

vllm_ascend/attention/context_parallel/sfa_cp.py

@@ -12,6 +12,7 @@
 from vllm_ascend.attention.sfa_v1 import AscendSFAImpl, AscendSFAMetadata, AscendSFAMetadataBuilder
 from vllm_ascend.attention.utils import AscendCommonAttentionMetadata, enabling_mlapo, split_decodes_and_prefills
 from vllm_ascend.ops.triton.rope import rope_forward_triton_siso
+from vllm_ascend.utils import vllm_version_is
 
 M = TypeVar("M", bound=AscendSFAMetadata)
 
@@ -385,7 +386,11 @@ def indexer_select_post_process(
         actual_seq_lengths_query: torch.Tensor,
         actual_seq_lengths_key: torch.Tensor,
     ):
-        weights, _ = self.weights_proj(x)
+        if vllm_version_is("0.19.0"):
+            weights, _ = self.weights_proj(x)
+        else:
+            kw, _ = self.wk_weights_proj(x)
+            weights = kw[:, self.head_dim :]
 
         q_li, _ = self.wq_b(q_c)  # [b,s,1536] @ [1536,64*128] = [b,s,64*128]
         q_li = q_li.view(-1, self.n_head, self.head_dim)  # [n_toks,64,128]

vllm_ascend/attention/sfa_v1.py

@@ -55,6 +55,7 @@
     enable_dsa_cp_with_o_proj_tp,
     get_weight_prefetch_method,
     maybe_trans_nz,
+    vllm_version_is,
 )
 from vllm_ascend.worker.npu_input_batch import NPUInputBatch
 
@@ -438,8 +439,12 @@ def __init__(
         self.n_head: int = self.indexer.n_head  # 64
         self.head_dim: int = self.indexer.head_dim  # 128
         self.wq_b = self.indexer.wq_b
-        self.wk = self.indexer.wk
-        self.weights_proj = self.indexer.weights_proj
+        # upstream ac3dac545 fused wk+weights_proj into wk_weights_proj
+        if vllm_version_is("0.19.0"):
+            self.wk = self.indexer.wk
+            self.weights_proj = self.indexer.weights_proj
+        else:
+            self.wk_weights_proj = self.indexer.wk_weights_proj
         self.k_norm = self.indexer.k_norm
         self.cp_size = 1
         self.is_rope_neox_style = True
@@ -908,7 +913,11 @@ def indexer_select_pre_process(
         cos: torch.Tensor,
         sin: torch.Tensor,
     ):
-        k_li, _ = self.wk(x)  # [b,s,7168] @ [7168,128] = [b,s,128]
+        if vllm_version_is("0.19.0"):
+            k_li, _ = self.wk(x)  # [b,s,7168] @ [7168,128] = [b,s,128]
+        else:
+            kw, _ = self.wk_weights_proj(x)
+            k_li = kw[:, : self.head_dim]
         k_li = self.k_norm(k_li).unsqueeze(1)
         k_li = k_li.view(-1, 1, self.head_dim)
 
@@ -953,7 +962,11 @@ def indexer_select_post_process(
         actual_seq_lengths_query: torch.Tensor,
         actual_seq_lengths_key: torch.Tensor,
     ):
-        weights, _ = self.weights_proj(x)
+        if vllm_version_is("0.19.0"):
+            weights, _ = self.weights_proj(x)
+        else:
+            kw, _ = self.wk_weights_proj(x)
+            weights = kw[:, self.head_dim :]
 
         q_li, _ = self.wq_b(q_c)  # [b,s,1536] @ [1536,64*128] = [b,s,64*128]
         q_li = q_li.view(-1, self.n_head, self.head_dim)  # [n_toks,64,128]

vllm_ascend/lora/utils.py

@@ -26,6 +26,7 @@
     AscendRowParallelLinear,
 )
 from vllm_ascend.ops.vocab_parallel_embedding import AscendVocabParallelEmbedding
+from vllm_ascend.utils import vllm_version_is
 
 
 class AscendColumnParallelLinearWithLoRA(ColumnParallelLinearWithLoRA):
@@ -184,16 +185,27 @@ def can_replace_layer(
         return type(source_layer) is AscendRowParallelLinear
 
 
+_ASCEND_LORA_CLASSES = (
+    AscendColumnParallelLinearWithLoRA,
+    AscendMergedColumnParallelLinearWithLoRA,
+    AscendRowParallelLinearWithLoRA,
+    AscendVocabParallelEmbeddingWithLoRA,
+    AscendQKVParallelLinearWithLoRA,
+    AscendMergedQKVParallelLinearWithLoRA,
+    AscendColumnParallelLinearWithShardedLoRA,
+    AscendMergedColumnParallelLinearWithShardedLoRA,
+    AscendMergedQKVParallelLinearWithShardedLoRA,
+    AscendQKVParallelLinearWithShardedLoRA,
+    AscendRowParallelLinearWithShardedLoRA,
+    AscendReplicatedLinearWithLoRA,
+)
+
+
 def refresh_all_lora_classes():
-    vllm.lora.utils._all_lora_classes.add(AscendColumnParallelLinearWithLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendMergedColumnParallelLinearWithLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendRowParallelLinearWithLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendVocabParallelEmbeddingWithLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendQKVParallelLinearWithLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendMergedQKVParallelLinearWithLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendColumnParallelLinearWithShardedLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendMergedColumnParallelLinearWithShardedLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendMergedQKVParallelLinearWithShardedLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendQKVParallelLinearWithShardedLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendRowParallelLinearWithShardedLoRA)
-    vllm.lora.utils._all_lora_classes.add(AscendReplicatedLinearWithLoRA)
+    if vllm_version_is("0.19.0"):
+        vllm.lora.utils._all_lora_classes.update(_ASCEND_LORA_CLASSES)
+        return
+
+    vllm.lora.utils._all_lora_classes = tuple(
+        dict.fromkeys((*_ASCEND_LORA_CLASSES, *vllm.lora.utils._all_lora_classes))
+    )