1
2
3
4
5

report claim
  → diagnosis finding (diagnosis_findings.json)
  → evidence id (evidence_index.csv)
  → source path + row range (raw_kernel_index.csv)
  → original kernel_details.csv

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 结构 Role (attention_families.yaml)
- family: csa  # Compressed Sparse Attention
  must_have:
    - attention.kv_compressor      # KV 压缩
    - attention.lightning_indexer   # top-k 选择
    - attention.sparse_sharedkv    # 稀疏 KV 共享

# 实现 Evidence (kernel_signatures.yaml)
- profile_name: fusedinferattentionscore
  categories: [attention.flash_score]
  used_by_family: [mla, dsa, hca, gqa_or_mha]

1
2
3
4

# segment.py 开头的设计原则
The segmenter is intentionally deterministic.
It does not use duration percentiles, fuzzy similarity,
expected model layer counts, or "best score" candidate selection.

1
2
3
4

# 从某个阶段重跑，复用上游结果
python3 profile_analyze.py \
  --from-stage classify \
  --remote-output-dir /tmp/previous_run

1
2
3

# 1. tar-over-ssh 只同步分析框架 (~10MB)
# 2. 远端容器内执行分析
# 3. 只拉回轻量产物 (report/, *manifest.json, *.csv)

1
2
3
4
5
6

# 正确做法：分开统计
aic_mte_total = aic_mte1_time + aic_mte2_time  # AIC 侧
aiv_mte_total = aiv_mte2_time + aiv_mte3_time   # AIV 侧

# 错误做法：合并掩盖真相
# merged_mte = aic_mte2 + aiv_mte2  # 混淆两种路径

1
2
3
4

# segment.py
if "argmax" in text or "applytopktopp" in text:
    role = "selection"
    primary_roles.add("selection")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# segment.py
def anchor_kind(event):
    if has_attention_role(event):
        return primary_attention_category(event)  # attention.flash_score, etc.
    if has_moe_role(event):
        return primary_moe_category(event)  # moe.dispatch, etc.
    if has_matmul(event) and not is_collective(event):
        return "compute.matmul"
    if is_block_head(event):
        return "block_head"

1
2
3
4

标准 transformer layer:
  dense layer    → [attention block] + [ffn block]
  MoE layer      → [attention block] + [moe block]
  companion layer → [moe block] (无 attention)

1
2
3
4
5

# block_taxonomy.md
# Both present: split at the midpoint between last attention row
# and first MoE row.
# Why row-midpoint instead of time-midpoint:
# row order matches on-device sequencing and is independent of stream skew

1
2
3
4
5
6
7
8

# pipeline_taxonomy.md
FAMILY_MAPPING = {
    "cube": ["aic_mac_time", "aic_fixpipe_time"],
    "vector": ["aiv_vec_time"],
    "aic_mte": ["aic_mte1_time", "aic_mte2_time"],
    "aiv_mte": ["aiv_mte2_time", "aiv_mte3_time"],
    "scalar": ["aic_scalar_time", "aiv_scalar_time"],
}

1
2
3

# 关键区分
dominant_core = AIC 侧时间 > AIV 侧时间 ? "aic" : "aiv"
# 而 bound_stage 是 9 个 sub-stage 中累计耗时最大的

1
2
3
4
5
6
7
8
9

# bound_classification.md
# 计算每个子 stage 的累计时间，返回最大的
def bound_stage(pipeline_us):
    stages = {
        "mac": pipeline_us.get("aic_mac_time", 0),
        "mte1": pipeline_us.get("aic_mte1_time", 0),
        # ...
    }
    return max(stages, key=stages.get)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# step_class_grouping.md
# 1. 顺序敏感的 tuple
pairs = [(name1, shape1), (name2, shape2)]  # 3×4 ≠ 4×3

# 2. 缺失 shape 不合并
if not pairs:
    return f"{prefix}_unknown_shape_{digest}"

# 3. BLAKE2b 哈希确保确定性
payload = json.dumps([structure, scope_label, pairs])
digest = blake2b(payload.encode(), digest_size=8).hexdigest()

1
2
3
4

# step_class_grouping.md
# wall_ms_mean: 算术平均
# wall_ms_sum: 总贡献 = Σ(member_count × wall_mean)
# bound_family: 在 pipeline 聚合上重新计算

1
2
3
4
5
6
7
8
9

# attention_families.yaml 决策顺序
decision_order:
  1. CSA: kv_compressor + lightning_indexer + sparse_sharedkv
  2. HCA: kv_compressor + flash_score (无 indexer/sparse)
  3. DSA: lightning_indexer + sparse_sharedkv (无 compressor)
  4. MLA: mlaprolog / kvrmsnormropecache 等
  5. linear: causalconv / mamba 等
  6. gqa_or_mha: flash_score (无架构特定伴随)
  7. attn: 未知

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# common.py categories_and_roles
# FusedInferAttentionScore 支持 MHA/GQA/MLA
if "fusedinferattentionscore" in text:
    categories.add("attention.flash_score")
    # 不加 mha/gqa/mla——同一 kernel 可以服务多个架构

# Family 由 block 内的 category 组合决定
def resolve_attention_family(categories):
    if "kv_compressor" in cats and "lightning_indexer" in cats:
        return "csa"
    # ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# common.py (约 350 行)
def categories_and_roles(name, task_type, accelerator_core):
    """Classify one kernel into op_categories + op_roles.

    Rule order and signatures mirror kernel_signatures.yaml.
    """
    text = fold_text(f"{name} {task_type} {accelerator_core}")
    categories = set()
    roles = set()

    # --- Communication ---
    if any(token in text for token in ("hccl", "hcom", "allreduce", ...)):
        categories.add("communication.collective")
        roles.add("communication")

    # --- Attention: sparse-attention building blocks ---
    # CSA 和 DSA 共用这些 kernel
    if "sparseattnsharedkv" in text:
        if "metadata" in text:
            categories.add("attention.sparse_sharedkv.metadata")
        else:
            categories.add("attention.sparse_sharedkv")

    # --- Attention: MLA (DeepSeek V2/V3) ---
    if "mlapreprocess" in text or "mlaprolog" in text:
        categories.add("attention.mla.preprocess")
        categories.add("attention.mla")

    # --- MoE ---
    if "dispatchffncombine" in text:
        categories.add("moe.dispatch_expert_compute")

    # ...
    return (tuple(sorted(categories)), tuple(sorted(roles)))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# common.py
def resolve_attention_family(categories):
    cats = set(categories)

    has_compressor = "attention.kv_compressor" in cats
    has_indexer = "attention.lightning_indexer" in cats
    has_sparse_sharedkv = "attention.sparse_sharedkv" in cats
    has_flash_score = "attention.flash_score" in cats
    has_mla_marker = bool(_MLA_CATEGORIES & cats)

    if has_compressor and has_indexer and has_sparse_sharedkv:
        return "csa"  # Compressed Sparse Attention
    elif has_compressor and has_flash_score and not has_indexer:
        return "hca"  # Heavily Compressed Attention
    elif has_indexer and has_sparse_sharedkv and not has_compressor:
        return "dsa"  # DeepSeek Sparse Attention
    elif has_mla_marker and not (has_compressor or has_indexer):
        return "mla"  # Multi-head Latent Attention
    elif "attention.linear_or_mamba" in cats:
        return "linear"
    elif has_flash_score:
        return "gqa_or_mha"  # 伞形，需要 shape 细化
    else:
        return "attn"

1
2
3

# 如果存在 Hamming-distance KV 剪枝，叠加 +kvc 后缀
if "attention.kvcomp.topk" in categories:
    base = f"{base}+kvc"  # mla+kvc, dsa+kvc, etc.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 1. kernel_signatures.yaml 添加映射
- profile_name: newkernel
  categories: [attention.new_category]
  roles: [attention]
  evidence:
    - "vllm-ascend/path/to/kernel:123"

# 2. attention_families.yaml 更新 must_have 组合

# 3. semantic_conventions.yaml 添加新 enum 值

# 4. Python 测试确保不破坏现有逻辑

1
2
3
4
5
6
7

hccl_op_kind_map = {
    "HCOM_ALLREDUCE_*": "allreduce",
    "HCOM_ALLGATHER_*": "allgather",
    "HCOM_REDUCESCATTER_*": "reducescatter",
    "HCOM_ALLTOALLV_*": "alltoallv",
    "DispatchFFNCombine": "comm_aiv_fused",  # 特殊：混合 AIV
}

1
2
3
4

# communication_taxonomy.md
# Task-level 的 Notify Wait 是暴露 peer 等待的关键
- 症状: one rank's Notify Wait > 50% of collective wall
- 含义: 该 rank 在等待更慢的 peer

1
2
3
4
5
6

finding_type:
  - communication_collective_slow      # rank 间 duration skew > 30%
  - ep_load_imbalance_suspected        # EP 路由不均
  - slow_rank_suspected                # 某个 rank 掉队
  - dp_workload_imbalance              # DP 负载不均
  - reduced_work_or_dummy_rank         # 陪跑/dummy rank