Huawei Ascend 950PR Meets DeepSeek’s Kernel and Inference Work
Ascend 950PR pairs 1.6384 TB/s HBM bandwidth with software work on kernels, communication and inference for DeepSeek models.

DeepSeek’s September 30 release of Ascend support across six software repositories makes the Huawei–DeepSeek relationship concrete: Huawei supplies accelerators and their software stack, while DeepSeek brings model workloads and kernel engineering. Neither side has the other’s strengths in full. Huawei needs demanding workloads to demonstrate what Ascend can do; DeepSeek needs compute capacity and is building support for Huawei’s platform into its software.

The releases cover TileLang, DeepGEMM, DeepEP, TileKernels, FlashMLA and DeepSelect. The practical value is broader than faster individual kernels: the work targets compilation, memory movement, synchronization and communication, the parts that determine whether accelerator performance carries through to a complete model workload.
There are caveats. At the time of the report, TileLang was the only one of the six repositories described as usable. Several dependencies and hardware support components were still pending. The benchmarks and implementation details nevertheless give a useful look at the hardware and software problems the teams are working through.
Ascend 950PR: variants and core layout
The Ascend 950PR and 950DT appear in several configurations, with different numbers of cores, HBM stacks and cache sizes. Some reported combinations may be simulated or intended for testing. The proposed explanation is that Huawei bins compute dies and memory stacks together: defects and power or performance shortfalls mean fewer parts meet the top specification, so weaker memory may be paired with weaker compute. The Ascend 910B family also has multiple variants, including 910B1, 910B2, 910B3 and 910B4.



The microbenchmarks used an Ascend 950PR_9579 with 28 Cube cores and 128 GiB of HBM. A point-chase test reading 16 KiB of integer payload per launch measured about 134 ns through 18 blocks, 182 ns at 56 blocks and 391 ns at 64. That sharp increase is consistent with work spilling into a second wave beyond 56 Vector cores.

Further pointer-chase probes compared load timings across Cube and Vector cores along the same 128 MiB address chain. The resulting similarity groups match two decoded dies. Tests that ran memory traffic or register-only work on one core while timing another helped identify shared resources, including groupings such as {0,2,4} and {1,3,5}. Mixed Cube and Vector launches then helped map one Cube and two Vector cores within each group. The physical positions in the resulting diagram are schematic.


On-package CPU work
Each 950PR has a variable number of Linx816 AArch64 ELF AICPUs. Their MIDR values suggest they may be the same cores used as the middle cores in the Kirin 9000S/9010. The measured SKU has seven configured AICPU cores, six visible to the system and five executing. Their instruction set includes SVE, SVEI8MM, BF16, I8MM, AES, SHA and other extensions.
AICPU cores can handle device control and CPU operators, including KV metadata work. Their limited compute throughput makes them most useful for short tasks where transferring work to the host would cost more than doing it locally, or where data begins and ends on the NPU.
One example is DeepSeek Sparse Attention (DSA). A scheduling step reads sequence lengths and assigns indexer work to accelerator cores. Cube and Vector cores calculate INT8 indexer scores and select the top 2,048 indices. In the vLLM-Ascend implementation, AICPUs handle planning, index selection and gathering. The comparison with host CPU execution illustrates where local control work can reduce overhead.

Compute and memory results
The 950PR is aimed at prefill and recommendation workloads, with less core and memory bandwidth than the larger 950DT. In a comparison of 1,055 BF16 GEMM shapes from open models, stock torch.matmul on Ascend resolved to aclnnMatmul_MatMulV3Common_MatMulV3. Huawei’s best kernels reached 99.7% of the stated ceiling. That shows high utilization is possible through Huawei’s own kernels as well as through DeepSeek’s DeepGEMM results, which exceed 99%.

For the tested shapes below the Ascend device’s ridge point, the median achieved-to-attainable fraction was 41.5%, compared with 46.8% for Nvidia H100. The H100 results were power-limited in some runs: median power was around 690–698 W against a 700 W limit, and median sampled SM clocks were 1,335–1,470 MHz against a maximum of 1,830 MHz. Huawei’s measured power was approximately 599–600 W, with clocks at 1,500–1,550 MHz against a 1,650 MHz reference. Despite utilization figures in the same general range, the 950PR’s absolute performance sits between A100 and MI300X in this comparison.
The Ascend matrix unit’s data path may help explain its utilization. Matrix operands are staged in dedicated L0A and L0B buffers, with accumulators held in L0C. The design can overlap data movement, computation and result handling; Huawei associates a larger L0C with more flexible tiling and data reuse.

Peak 950PR memory bandwidth is 1.6384 TB/s, calculated as 8 HiBL stacks × 256 bits × 6.4 Gbps per pin. In the reported HBM tests, the 950PR exceeded H100 in effective bandwidth and bandwidth utilization for smaller per-buffer transfers, and came close to H100’s utilization at larger transfer sizes.

A dip in the bandwidth curve appears when Ascend switches copy methods to a Vector-core TensorMove kernel, which has more startup cost. A slightly larger copy can therefore take longer; as transfers grow further, that fixed cost matters less and measured bandwidth rises again. High compute and memory utilization in microbenchmarks also don’t guarantee high model FLOPs or bandwidth utilization. Training workloads, particularly those using FSDP, add collectives, checkpointing and data movement that may be difficult to overlap.
Comparisons between accelerator “chips” also depend on how dies are grouped into a product. For practical system choices, performance per watt and total cost of ownership matter alongside single-chip throughput. The reported measurements do not establish those system-level comparisons.
TileLang and reusable kernel work
DeepSeek’s Ascend backend has been merged into the main TileLang repository. It adds native compilation, scheduling, synchronization and runtime integration for Ascend. Developers still specify calculations, tile sizes and data placement, while the compiler manages much of the coordination among Cube cores, Vector cores and data transfers.

In a warm-cache, simple benchmark, TileLang matched or beat CANN in some cases, with the preferred implementation depending on problem size. Its AutoSchedule feature uses dependencies and estimated execution times to choose which operations can overlap. It also sets the number of buffer slots in on-chip memory, so one tile can be processed while the next is loaded. Developers can adjust the schedule when its defaults don’t fit the workload.

On 950PR, AutoSchedule cut execution time by as much as 40% for a single operation, with the strongest gains on smaller sizes. The compiler also inserts synchronization where dependencies require it and removes waits made redundant by other dependencies. It accounts for conditional branches, avoiding assumptions that work has completed when its branch may not run. That shifts routine coordination away from kernel authors.

There is also a hardware-specific change in FlashMLA’s KV-cache layout. Earlier layouts kept quantized values and scaling factors in separate regions, requiring separate transfers to fetch a token on Ascend. The updated layout places values and scales together, reducing requests handled by the memory transfer engine.

DeepEP and communication across accelerators
Huawei’s Ascend supernodes extend accelerator interconnects across multiple racks, from the 910 CloudMatrix384 to the 950 SuperPod. The September 30 release included EP16 dispatch and combine benchmarks over URMA on the 950DT SuperPod.

The Huawei dispatch path comprises three sequential operators—pre, URMA and post—while GB300 uses one fused call in the comparison. The Huawei post phase includes receive completion, which the measurement counts, and expert expansion, which the GB300 results don’t include. Those differences matter when interpreting the chart.
DeepEP-Ascend ports DeepEP V2.5 with the same Python API, calling URMA and HCCL underneath. Huawei’s Ascend team proposed adding the port under the deepseek-ai organization in July 2025, but a DeepEP maintainer declined; the Ascend port is now distributed in DeepSeek’s own organization.
Ascend’s separate Cube and Vector execution paths offer opportunities to overlap computation with communication, but the overlap consumes shared resources. Expert work can need Vector processing and memory traffic, while communication also uses HBM bandwidth. Teams have to balance how much communication to hide against the slowdown imposed on concurrent computation.

Huawei’s Kimi K3 inference recipe addresses the same trade-off by limiting Vector use to leave room for concurrent work, and choosing between dedicated CCU and Vector-based communication according to the workload. DeepEP-Ascend documentation also identifies HBM contention between combine processing and URMA communication, with firmware improvements planned to reduce it. The remaining issue is a platform question: how well communication and model computation can coexist on the same hardware.
DeepSeek-V4.1-Flash on Ascend
DeepSeek’s model weights give Huawei a way to prepare optimized support for a specific model from its initial deployment. The DeepSeek-V4.1-Flash attention implementation also adapts to Ascend’s accumulator design. The Cube’s L0C buffer can’t rescale accumulated outputs in place, and sending a rescaled result back would require an expensive identity-matrix multiplication. Instead, DeepSeek keeps the running output accumulator in Vector UB and transfers partial sums from L0C when rescaling and accumulation are needed.

That approach differs from Hopper, which holds its accumulator in registers, and Blackwell, which can load and store between tensor memory and registers. The different data paths make the same attention calculation a distinct kernel-design problem on each platform.
Huawei profiled one rank of DeepSeek-V4.1-Flash on a 32-chip Ascend 950DT deployment, including host threads. The profile shows familiar design choices such as AICPU use and placing some layers on separate streams. The execution sequence is 40 target-model layers, the target language-model head, three DSpark drafter blocks, the draft head and five sampling rounds. Main-model computation runs on Stream 19; the drafter runs on Stream 173.

The trace shows V3 MC² kernels fusing computation and communication, following the V2 approach seen in the DeepSeek-V4 Pro trace. It also records four AICPU-launched HCCL operations per step, compared with 43 expert dispatches. The four operations cover the target and draft vocabulary heads’ hcom_allGather and hcom_alltoallv: hidden-state gathering, language-model-head GEMM and logit exchange.
The drafter blocks run once to produce base logits for the draft positions. A Markov head then models token dependencies through sampling and embedding feedback, without rerunning the transformer blocks for each proposal. The end of a step therefore shifts from attention and expert computation to a serial sequence of smaller projections and sampling operations. Speculative decoding drafts tokens and verifies them in a single pass, amortizing weight loading; the profile shows DSpark drafting faster than the verification step.



DeepSeek-V4.1-Flash is also DeepSeek’s first model to use Engram, after Qwen and Meituan Longcat. Engram takes token IDs as input, allowing a fetch to begin asynchronously and overlap with layer 0 computation. The reported behavior allows offloading to DRAM without a performance loss compared with HBM, while offloading to a PCIe 4.0 SSD reduces performance.

In the steady-state window, Stream 19 is occupied for 88.8% of the time and accounts for 72.6% of summed device time because other streams overlap it. The substantial MIX_AIV and AI_VECTOR_CORE bands include dispatch and combine as well as quantization. Ascend reports task types such as MIX_AIC, MIX_AIV, AI_CORE and AI_VECTOR_CORE; these classify work, but mixed task durations don’t directly measure exclusive use of one physical unit.

A first-order scenario that doubles Cube throughput while keeping other device work unchanged yields a 1.32× step improvement. It assumes measured stream overlap stays constant and leaves idle time unchanged. It’s a composition exercise, not a prediction for future hardware: bandwidth limits, dependencies and scheduling could all change the result. Fusing quantization is another possible target because of repeated producer-to-consumer boundaries and the large share of Vector work, which also includes fused communication.
Where the software still falls short
DeepSeek may get a highly tuned stack for its own workloads without making Ascend equally straightforward for other users. Compiler, kernel and debugging work takes time away from model and product development. Other teams may also use hardware configurations that differ from DeepSeek’s, since many optimizations target supernodes.
At vLLM-Ascend_0.26.0rc1, the reported x86-host issues included no DeepGEMM support on x86, a memfabric_hybrid dependency with hardcoded ARM headers that could prevent startup, and skipped CPU binding on non-ARM CPUs. There was also no NPU-plus-x86 CI coverage, and some recipes required patches.
Availability was another limitation at the time of writing: CANN 9.2.0 was required by DeepGEMM but had not yet been released, while CANN 9.2.0-beta.2 did not provide the required C++20 compiler. The DeepEP-Ascend documentation listed October 15 as the expected HDK release date. These dependencies show why repository support alone doesn’t establish that a stack is ready to deploy.
The engineering exchange is already visible in kernel layouts, scheduling and model traces. Ascend 950PR has measured strengths in bandwidth utilization and high GEMM efficiency, while its absolute compute performance and software compatibility still shape where it fits. The next test is whether the work built around DeepSeek’s models becomes easy to reuse across more Ascend configurations and host systems.
AMD Venice Uses 2.5D Packaging to Feed More Bandwidth Into EPYC Zen 6
CNC Controller Board Design: Interfaces, PCB Specs and Assembly Testing
Stratasys and Nano Dimension End $42.5 Million Markforged Sale Agreement