// ❌ 错误1：已有 MNN 函数时用 Vec4 替代（MNN 函数有汇编优化，Vec4 只是 intrinsic 包装）
using Vec4 = Math::Vec<float, 4>;
for (int i = 0; i + 3 < size; i += 4) {
    Vec4 v = Vec4::load(data + i);
    v = v * Vec4(scale);
    Vec4::save(data + i, v);
}
// ✅ 正确：直接调用已有函数
MNNScaleAndAddBiasScalar(data, data, 0.0f, scale, size);

// ❌ 错误2：不考虑数据规模，总是用重量级函数
// MNNPackedMatMul 需要 Pack/Unpack，对小矩阵开销可能大于计算
// ✅ 正确：根据数据规模选择策略
//   大规模 → 用 MNN 函数（Pack 开销可摊薄）
//   小规模 → 保持朴素循环（编译器自动向量化，零额外开销）
//   MatVec（一个维度为1） → 用 MNNComputeMatMulForE_1（无需 Pack）

// ❌ 错误3：用循环实现 MatVec（S^T @ q）
for (int j = 0; j < dv; ++j) {
    float sum = 0;
    for (int i = 0; i < dk; ++i)
        sum += S[i*dv+j] * q[i];
    out[j] = sum;
}
// ✅ 正确：直接调用
gcore->MNNComputeMatMulForE_1(q, S, out, nullptr, &matParam, 0);

// ❌ 错误4：用循环实现 exp
for (int i = 0; i < size; ++i) dst[i] = expf(src[i]);
// ✅ 正确：
MNNExp(dst, src, offset, size);

// ❌ 错误5：用 std::vector 分配临时缓存
std::vector<float> temp(size);  // 每次调用都 malloc/free
// ✅ 正确：在 onResize 中用 Backend 的内存池
mTemp.reset(Tensor::createDevice<float>({size}));
backend()->onAcquireBuffer(mTemp.get(), Backend::DYNAMIC);
backend()->onReleaseBuffer(mTemp.get(), Backend::DYNAMIC);

// ❌ 错误6：用裸 NEON intrinsic 写循环（仅在没有 MNN 函数且性能敏感时才考虑，且更推荐写 .S 汇编）
#include "core/SimdHeader.h"
float32x4_t vsum = vdupq_n_f32(0.0f);

// ❌ 错误7：不验证 in-place 安全性就用 dst==src 调用
// 部分 MNN 函数不支持 in-place，会静默产生错误结果
// ✅ 正确：查阅上方 in-place 安全性表，不确定时使用 scratch buffer

// ❌ 错误8：不验证函数语义就替换（函数名匹配 ≠ 数学语义匹配）
// ✅ 正确：替换前阅读函数签名/实现，确认参数含义和计算逻辑完全一致

看到一段循环代码 →
  ├─ 是双重循环的乘加？
  │   ├─ 有一个维度为 1（MatVec）？ → 用 MNNComputeMatMulForE_1（无需 Pack）
  │   ├─ 数据规模大（值得 Pack 开销）？ → 用 MNNPackedMatMul
  │   └─ 数据规模小（Pack 开销 > 计算）？ → 保持朴素循环
  ├─ 是单循环乘标量/加标量？ → 用 MNNScaleAndAddBiasScalar
  ├─ 是循环调用 expf/silu/sigmoid？ → 用 MNNExp/MNNSiLu
  ├─ 是循环做卷积？ → 用 MNNConvRunForLineDepthwise
  ├─ 是循环做数据重排？ → 用 MNNPackCUnit/MNNUnpackCUnit
  ├─ 是循环做 softmax？ → 用 MNNSoftmax
  ├─ 是循环做范数/归一化？ → 用 MNNNorm（先验证语义匹配！）
  ├─ 以上都不匹配？
  │   ├─ 能拆解为已有函数的组合？ → 组合调用（如外积 = MatMul 的特例）
  │   ├─ 计算量极小？ → 保持朴素循环（编译器自动向量化）
  │   ├─ 是性能热点且可向量化？ → 用 Vec4 循环作为中间方案
  │   └─ Vec4 也不够且是核心热点？ → 写新的 .S 汇编 kernel
  │
  ⚠️ 替换前：1) 验证函数语义匹配  2) 确认 in-place 安全性

struct CoreFunctions {
    // CPU 特性检测
    bool supportFp16arith;
    bool supportSDot;
    bool supportI8mm;
    bool supportSME2;

    // Pack 参数
    int pack;     // FP32=4, FP16=8
    int bytes;    // FP32=4, FP16=2

    // 关键函数指针
    void(*MNNPackedMatMul)(...);         // 矩阵乘主核心
    void(*MNNPackedMatMulRemain)(...);   // 矩阵乘余数处理
    void(*MNNPackC4ForMatMul_A)(...);    // 输入数据 Pack
    void(*MNNPackForMatMul_B)(...);      // 权重数据 Pack
    void(*MNNGetMatMulPackMode)(&eP, &lP, &hP); // 获取 Pack 参数
    // ...
};

source/backend/cpu/
├── CPUXxx.cpp/.hpp              ← 算子主逻辑（调度、多线程）
├── compute/
│   ├── CommonOptFunction.h      ← CoreFunctions 定义
│   ├── CommonOptFunction.cpp    ← 默认 C++ 实现
│   ├── ConvOpt.h                ← 卷积相关函数声明
│   └── ...
├── arm/
│   ├── arm64/
│   │   ├── MNNPackedMatMul.S            ← FP32 NEON 矩阵乘
│   │   ├── MNNPackedMatMulFP16.S        ← FP16 矩阵乘
│   │   ├── MNNGemmInt8AddBiasScale_*.S  ← INT8 GEMM
│   │   ├── MNNPackedMatMul_int8.S       ← SDOT 矩阵乘
│   │   ├── MNNPackedMatMulRemain_int8.S ← SDOT 余数
│   │   └── ...
│   └── arm32/
│       ├── MNNGemmInt8*.S               ← 32 位 INT8 GEMM
│       └── ...
└── x86_64/
    └── ...                              ← x86 SSE/AVX 实现

┌──────────────────────────────────────────────────────────┐
│  步骤 0: 计算拆解 (step0-decompose.md) ★ 最关键的步骤     │
│  输入: 算子源码                                           │
│  输出: 每个计算逻辑对应的 MNN 已有函数映射表               │
│  测试: 所有可复用的函数已识别，不存在遗漏                   │
├──────────────────────────────────────────────────────────┤
│  步骤 1: 建立性能基准 (step1-benchmark.md)               │
│  输入: 待优化的算子名和参数                                │
│  输出: test/speed/ 下的基准测试 + 基线数据                 │
│  测试: 基准测试能稳定运行，数据可复现                       │
├──────────────────────────────────────────────────────────┤
│  步骤 2: 分析瓶颈与制定方案 (step2-analyze.md)            │
│  输入: 步骤 0 的映射表 + 步骤 1 的基线数据                 │
│  输出: 优化方案（哪些换函数、哪些改排布、哪些需要新汇编）    │
│  测试: 方案可行性论证                                     │
├──────────────────────────────────────────────────────────┤
│  步骤 3: C++ 优化（函数替换 + 多线程 + 排布）              │
│  输入: 步骤 2 的优化方案                                  │
│  输出: 用 MNN 函数替换循环 + 多线程 + 内存池               │
│  测试: 正确性验证 + 性能对比                               │
├──────────────────────────────────────────────────────────┤
│  步骤 4: ARM 汇编优化 (step4-asm.md)（仅在必要时）        │
│  输入: 步骤 3 中无法用已有函数覆盖的热点                    │
│  输出: ARM NEON/FP16/SDOT/I8MM/SME2 汇编实现             │
│  测试: 正确性验证 + 性能对比 + 多指令集覆盖               │
├──────────────────────────────────────────────────────────┤
│  步骤 5: 集成与回归测试 (step5-integrate.md)              │
│  输入: 步骤 3 或 4 通过                                   │
│  输出: 全量回归测试                                       │
│  测试: 所有相关算子测试通过 + 性能报告                     │
└──────────────────────────────────────────────────────────┘