[Performance][KDA] Reduce preprocessing copies and redundant output masks

[Dawn952]

What this PR does / why we need it?

Reduce small-operator overhead around Kimi K3 recurrent KDA on main by optimizing preprocessing copies and removing redundant framework padding cleanup after KDA and the output norm gate.

• Before KDA: consume supported non-contiguous Q/K/V views from the fused projection directly, eliminating forced contiguous copies. Independent token/head strides flow through ACLNN, tiling, and the A2/A3 and A5 kernels. Unsupported layouts still materialize.
• After KDA and norm: delete _zero_padded_recurrent_output on spec/non-spec outputs and _zero_padded_output after o_norm, including the now-unused live-token count calculation. These removals eliminate the corresponding arange / comparison / where chains, profiled as Range / Less / Fill / SelectV2. Norm output is copied directly into the existing result buffer.
• Preserve state updates, mixed-token index copies, idle/dummy handling, and buffer initialization. No new kernel interface, switch, or replacement mask is needed.

The deleted masks sanitize padding after recurrent state computation; the norm gate operates independently per token/head row. Padding rows inside the graph-shaped region no longer have a zero-value guarantee. Effective token computation is unchanged.

Does this PR introduce any user-facing change?

Performance optimization of Kimi K3 KDA preprocessing and postprocessing. The Torch operator schema and contiguous-input behavior remain unchanged.

How was this patch tested?

• Accuracy validation (reported by the project owner): GPQA Avg@5: 93.03.

• Added spec/decode/mixed framework regression cases with NaN padding, checking effective output rows, state updates, and output-buffer tail initialization.

• All three cases passed on each branch in an isolated CPU harness executing the actual _forward and _prepare_beta bodies with mocked kernel/context dependencies (six cases total). This is not a full package or NPU test run.

• Ruff check/format, Python AST parsing, git diff --check, and repository forbidden-import, boolean-context-manager, and long-function checks passed.

• The project owner previously bypassed the padding masks and reported successful runtime validation. Full-model/NPU validation and profiling were not rerun for these commits.

• Full format.sh ci was attempted on main and stopped during actionlint environment installation; the full lint suite did not complete.

• The direct recurrent-operator regression covers distinct Q/K/V strides, non-contiguous state pools, guard holes, and numerical reference checks.

• vLLM main: vllm-project/vllm@b2f6858

[github-actions]

👋 Hi! Thank you for contributing to the vLLM Ascend project. The following points will speed up your PR merge:‌‌

• A PR should do only one thing, smaller PRs enable faster reviews.
• Every PR should include unit tests and end-to-end tests ‌to ensure it works and is not broken by other future PRs.
• Write the commit message by fulfilling the PR description to help reviewer and future developers understand.

If CI fails, you can run linting and testing checks locally according Contributing and Testing.

---

Tip

💡 Consider Linking a Related Issue or RFC

Your PR title contains the [Feature] tag, indicating a bug fix or new feature.

Linking a related issue or RFC in the PR description is strongly encouraged — it gives reviewers helpful context and speeds up the review. You can use any of these keywords:

• Fixes #<issue_number>
• Closes #<issue_number>
• Resolves #<issue_number>
• Refs #<rfc_or_issue_number> (for RFCs)

🙏 Thanks for helping us keep the project well-organized!

[gemini-code-assist]

Summary of Changes

Hello, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request introduces support for non-contiguous Q/K/V inputs in the recurrent KDA operator, significantly improving performance by avoiding unnecessary memory copies. The changes involve updating the operator definition to relax contiguous requirements, enhancing the host-side tiling logic to resolve and validate strides, and modifying the underlying kernels to utilize these strides for direct memory access.

Highlights

• Non-contiguous Q/K/V Support: Enabled the recurrent KDA operator to process non-contiguous Q/K/V views directly, eliminating the need for forced memory materialization.
• Kernel and Tiling Updates: Updated operator host logic, tiling processors, and A2/A3/A5 kernels to correctly handle independent token and head strides.
• Regression Testing: Added comprehensive test cases to verify the correctness of non-contiguous input handling and ensure numerical stability.

New Features

🧠 You can now enable Memory (public preview) to help Gemini Code Assist learn from your team's feedback. This makes future code reviews more consistent and personalized to your project's style. Click here to enable Memory in your admin console.

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.

Feature	Command	Description
Code Review	/gemini review	Performs a code review for the current pull request in its current state.
Pull Request Summary	/gemini summary	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in pull request comments and review comments.
Help	/gemini help	Displays a list of available commands.

Customization

To customize the Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counterproductive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for GitHub and other Google products, sign up here.

Footnotes

1. Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩

[gemini-code-assist]

Code Review

Suggested PR Title:

[Attention][Feature] Support non-contiguous QKV views in recurrent KDA

Suggested PR Summary:

### What this PR does / why we need it?
This pull request adds support for non-contiguous Query, Key, and Value (QKV) views in the recurrent KDA operator. It allows the operator to directly consume independent token and head strides for QKV views, avoiding unnecessary contiguous operations. It introduces stride validation, updates tiling logic to pass strides to the kernel, and modifies the Ascend C kernel to handle strided QKV inputs.

Feedback: A high-severity issue was identified in `CheckQkvMaterializationSafety` where the check `tokenStride < minTokenStride` incorrectly rejects valid non-contiguous layouts (like transposed tensors) that could otherwise be safely materialized via `DataContiguous`. Removing this check allows safe fallback to materialization.

### Does this PR introduce _any_ user-facing change?
Yes, the `recurrent_kda` operator now accepts non-contiguous QKV tensors directly without requiring manual `.contiguous()` calls.

### How was this patch tested?
An end-to-end test `test_kimi_k3_tp16_recurrent_kda_non_contiguous_qkv_and_state_pool` was added to verify correctness with non-contiguous QKV views.

[gemini-code-assist]

The safety check tokenStride < minTokenStride in CheckQkvMaterializationSafety incorrectly rejects valid non-contiguous layouts (such as transposed QKV tensors) and fails the operator with ACLNN_ERR_PARAM_INVALID.

While tokenStride < minTokenStride is indeed unsupported for the direct-view kernel (and is correctly caught by IsSupportedQkvView to trigger materialization), it is completely safe to materialize. Materializing a transposed or non-contiguous tensor via DataContiguous resolves the stride/overlap issues and produces a standard contiguous layout that the kernel can safely execute.

By failing the operator here, you prevent these valid layouts from being materialized. Removing this check from CheckQkvMaterializationSafety allows the operator to safely fall back to materialization for these layouts.

    const int64_t maxInt64 = std::numeric_limits<int64_t>::max();
    if (headCount > 1 && headStride > (maxInt64 - featureCount) / (headCount - 1)) {
        OP_LOGE(ACLNN_ERR_PARAM_INVALID, "npu_recurrent_kda: %s head span overflows.", name);
        return false;
    }
    return true;