Skip to main content
skill CX Codex

huawei-cloud-ascend-op-mfu-calculator — Claude Code skill

The huawei-cloud-ascend-op-mfu-calculator Claude Code skill calculates MFU for operators running on Ascend NPUs. It also examines profiler data to classify performance bottlenecks.

MIT 270 installs ★ 59 updated 2026-11-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add huaweicloud/huaweicloud-skills --skill huawei-cloud-ascend-op-mfu-calculator -a claude-code
Open on GitHub

What huawei-cloud-ascend-op-mfu-calculator does

The skill derives operation FLOPs, achieved TFLOPs/s, and MFU against the peak rate for a specific Ascend model. Its calculation scenarios include matmul, GEMM, and FlashAttention.

A local script, scripts/bottleneck_diagnoser.py, reads Ascend profiler CSV data and produces a ranked report with optimization suggestions. It labels bottlenecks as memory-, compute-, or communication-bound, or as operator fallback. Python 3.8 or later is required. Time units matter: confusing milliseconds with microseconds changes the result by about 1000×, so ambiguous durations need confirmation.

What it helps with

  • calculate GEMM MFU from FLOPs and execution time
  • compare the compute efficiency of two operator implementations
  • classify bottlenecks in an Ascend profiler CSV
  • derive achieved TFLOPs/s and compute utilization for an operator

Example prompts for the agent

  • Calculate MFU for my GEMM: FLOPs are <value>, runtime is <value> ms, and peak performance is <value> TFLOPs/s.
  • Analyze OpBasicInfo.csv and classify the operator bottlenecks.
  • Assess my FlashAttention performance using the profiler data.

How to install huawei-cloud-ascend-op-mfu-calculator

1Skills CLI (Vercel)

npx skills add huaweicloud/huaweicloud-skills --skill huawei-cloud-ascend-op-mfu-calculator -a claude-code

2Manually: put the files in place

~/.claude/skills/huawei-cloud-ascend-op-mfu-calculator/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/huawei-cloud-ascend-op-mfu-calculator/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about huawei-cloud-ascend-op-mfu-calculator

How do I install huawei-cloud-ascend-op-mfu-calculator in Claude Code?

Run npx skills add huaweicloud/huaweicloud-skills --skill huawei-cloud-ascend-op-mfu-calculator -a claude-code. The skill file is placed at ~/.claude/skills/huawei-cloud-ascend-op-mfu-calculator/SKILL.md.

What does huawei-cloud-ascend-op-mfu-calculator do?

It calculates operation FLOPs, achieved TFLOPs/s, and MFU for Ascend NPUs. Its profiler script also categorizes operator bottlenecks and returns a ranked report.

Why does the execution-time unit matter for MFU?

Mixing milliseconds and microseconds changes the result by about 1000×. Pass profiler durations as time_us or convert them to milliseconds before calculating.

Source text

SKILL.md · MIT
---
name: huawei-cloud-ascend-op-mfu-calculator
description: |
  Calculate MFU (Machine FLOP Utilization) for operators like matmul/GEMM/FlashAttention on Ascend NPU, providing clear formulas and derivation process
  Use when the user wants to: (1) calculate MFU for matrix operations, (2) analyze operator performance efficiency, (3) bottleneck diagnosis from Ascend profiling data, (4) optimize operator implementation
  Triggers include: "MFU", "machine flop utilization", "operator FLOPs", "matmul performance", "GEMM efficiency", "Ascend MFU", "算子MFU", "算力利用率", "矩阵乘效率", "GEMM性能", "FlashAttention性能", "瓶颈诊断", "bottleneck"
tags: [Ascend, MFU, operator, performance]
compatibility:
  - Python3 >= 3.8
allowed-tools:
  - python3
---

# Huawei Cloud Ascend Operator MFU Calculator

## Overview

This skill calculates MFU (Machine FLOP Utilization) for operators like matmul/GEMM/FlashAttention on Ascend NPU, providing clear formulas and derivation process.

**Architecture**: Input Validation → FLOPs Calculation → Achieved TFLOPs/s → MFU Calculation → Result Analysis

**Related Skills**:
- Profiling data analysis skills may provide operator performance data (execution time and memory traffic) used by this skill's MFU calculation and bottleneck diagnosis.

**Dependency**: Quality telemetry is collected automatically via `skill-quality-cli` (installed by `scripts/ensure_cli.sh` if absent).

## Prerequisites

1. Python 3.8+ installed
2. Basic understanding of FLOPs calculation concepts
- **`skill-quality-cli`** — ensured by `bash scripts/ensure_cli.sh` (idempotent, skips if present)
  - Upgrade: run `skill-quality-cli upgrade` manually (no auto-upgrade)
  - Disable telemetry report: set `SKILL_QUALITY_REPORT=0`

> All `hcloud` commands in this skill are wrapped with `skill-quality-cli run` for telemetry. No manual action required.

## Usage Scenarios

**Typical Problem Scenarios**:
- Evaluating how well an operator utilizes Ascend NPU compute power
- Comparing performance of different operator implementations
- Identifying optimization opportunities for matrix operations

**Typical User Utterances**:
- "Calculate MFU for my GEMM operator"
- "What's the machine FLOP utilization for FlashAttention?"
- "Analyze my matmul operator performance efficiency"

## Workflow

1. **Input Collection**: Gather operator parameters (matrix dimensions, data types, execution time)
2. **FLOPs Calculation**: Compute theoretical FLOPs for the operation
3. **Achieved Performance**: Calculate achieved TFLOPs/s from execution time
4. **MFU Calculation**: Apply formula MFU = Achieved FLOPs / Peak FLOPs
5. **Result Analysis**: Provide interpretation and optimization suggestions

## MFU Calculation Formula

MFU = (Achieved FLOPs / Peak FLOPs) × 100%

**Where**:
- Achieved FLOPs = Operation FLOPs / Execution Time
- Peak FLOPs = Hardware-specific peak performance. Use the **per-model** FP16/BF16 peak values below — do NOT use a single generic value like 256 TFLOPs.

| Ascend Model | FP16/BF16 Peak (TFLOPs/s) |
|--------------|---------------------------|
| 910B1 | ≈ 378.88 |
| 910B2 | ≈ 353.89 |
| 910B3 | ≈ 294.91 |
| 910B4 | ≈ 270 |

## Reference Documents

| Document | Description |
| -------- | ----------- |
| [Ascend 910B Series Technical Specifications](https://e.huawei.com/cn/products/computing/ascend-910) | Official Ascend 910B series product specifications |
| [MFU Calculation Methodology](references/mfu-calculation-methodology.md) | Detailed MFU calculation formulas and examples |
| [FlashAttention Technical Paper](https://arxiv.org/abs/2205.14135) | Original FlashAttention research paper |

## Enhanced Features

### Intelligent Bottleneck Diagnoser

A rule-based bottleneck diagnoser (`scripts/bottleneck_diagnoser.py`) that analyzes Ascend profiling CSV data (e.g. `OpBasicInfo.csv` from msprof) and automatically classifies each operator's bottleneck:

- **memory-bound** — achieved memory bandwidth utilization is close to the hardware peak
- **compute-bound** — AI Core (compute) utils are the limiting resource
- **communication-bound** — collective communication operators (HCCL AllReduce/AllGather, etc.) dominate
- **operator-fallback** — the operator ran on AI CPU / CPU instead of an AI Core kernel

It computes per-operator achieved TFLOPS, memory bandwidth and compute utilization, then returns a ranked report (priority P0/P1/P2) with concrete optimization recommendations.

```bash
skill-quality-cli run --skill-name huawei-cloud-ascend-op-mfu-calculator -- python3 scripts/bottleneck_diagnoser.py --csv OpBasicInfo.csv --peak-tflops 294.91 --peak-memory-bw 1200
```

> Column matching is tolerant of the exact msprof header names (e.g. `Task Duration(us)`, `AI Core Time(us)`, `Memory Read Bytes`, `Memory Write Bytes`). If a column is absent, the related signal is skipped and classification falls back to the remaining signals.

## Core Commands

The skill is a pure calculation/diagnosis skill (no Huawei Cloud CLI mutation): everything is computed locally with Python 3.8+.

| Command | Purpose |
|---------|---------|
| MFU calculation | Compute FLOPs, achieved TFLOPs/s and MFU with the formulas in [MFU Calculation Methodology](references/mfu-calculation-methodology.md); use per-model peak TFLOPs from the table above and confirm the execution-time unit (ms vs us) |
| `python3 scripts/bottleneck_diagnoser.py --csv <profiling.csv> [--peak-tflops <TFLOPs>] [--peak-memory-bw <GB/s>]` | Auto-classify operator bottlenecks from Ascend profiling CSV |

## Parameter Confirmation

| Parameter | Description | Required |
|-----------|-------------|----------|
| operator | Operator type (matmul/flash_attention/gemm, etc.) | Yes |
| flops | Theoretical FLOPs of the operator | Yes |
| time_ms | Operator execution time (milliseconds) | Yes |
| time_us | Operator execution time (microseconds) — alternative to `time_ms` | No |
| peak_tflops | Hardware peak computing power (TFLOPS); use the per-model table above | Yes |
| device | NPU device type (910B1/910B2/910B3/910B4/910, etc.) | No |

### Time Unit Handling (ms / us)

MFU is sensitive to the execution-time unit — mixing ms and us changes the result by ~1000×. Follow these rules:

- **`time_ms` is the canonical input (milliseconds).**
- If the user provides the duration from an Ascend profiler (e.g. profiling CSV columns `Task Duration(us)`), that value is in **microseconds (us)** — convert it before calculating:
  - `time_ms = time_us / 1000`
  - Achieved TFLOPs/s = `flops / (time_us × 1e-6) / 1e12`  (equivalently `flops / (time_ms × 1e-3) / 1e12`)
- Alternatively pass `time_us` as the input parameter and let the calculation convert internally.
- Always ask the user to confirm the unit when it is ambiguous, and state the unit in the final MFU result.

© huaweicloud · MIT · huaweicloud/huaweicloud-skills

Similar skills

All skills for AI and ML →

From the same set80

The whole set →
huawei-cloud-ascend-remote-connect huawei-cloud-ascend-remote-connect — a skill for Claude Code, Codex, and Cursor that opens temporary SSH sessions to Huawei Cloud Ascend hosts to run npu-smi, manage storage, and inspect containers. CX Codex +1 328installs huawei-cloud-flexus-l-server-openclaw-deployment huawei-cloud-flexus-l-server-openclaw-deployment deploys OpenClaw on Huawei Cloud Flexus L: creates an instance, installs the platform, configures models and channels (WeChat Work, Feishu, DingTalk, QQ). CX Codex +1 303installs huawei-cloud-ascend-small-model-migrate huawei-cloud-ascend-small-model-migrate migrates vision models like YOLO, ResNet, and UNet from GPUs to Ascend NPUs with inference verification and operator profiling. CX Codex +1 299installs huawei-cloud-cce-cluster-management huawei-cloud-cce-cluster-management is a Claude Code skill for managing Huawei Cloud CCE clusters, nodes, node pools, and addons during routine Kubernetes operations. CX Codex +1 293installs huawei-cloud-flexus-l-deploy-jiuwenswarm huawei-cloud-flexus-l-deploy-jiuwenswarm is a skill that deploys JiuwenSwarm or JiuwenClaw on Huawei Cloud Flexus L and configures a model API and supported messaging channel. CX Codex +1 260installs huawei-cloud-ascend-profiler-db-explorer huawei-cloud-ascend-profiler-db-explorer translates natural language questions into safe SQL queries for Ascend PyTorch Profiler and msprof SQLite databases. CX Codex +1 245installs huawei-cloud-cli-guidance huawei-cloud-cli-guidance — a skill for Claude Code and Codex guides developers through Huawei Cloud KooCLI operations. It provides command syntax, IAM credential setup, and troubleshooting steps directly in the chat. CX Codex +1 239installs huawei-cloud-ces-ecs-monitoring huawei-cloud-ces-ecs-monitoring is a skill for Claude Code and Codex that queries ECS metrics through Cloud Eye Service to inspect resource usage and performance trends. CX Codex +1 239installs

Project sponsors

Companies that keep this analytics open