cann-workbench 0.0.0-stage → 0.0.2-alpha

package/skills/asc-tools/tool-ops-tune/ops-family/references/conversion/transpose_gather.md

@@ -0,0 +1,191 @@
+# Transpose 性能调优参考:GATHER_TRANSPOSE 策略
+
+> 策略名:GATHER_TRANSPOSE(基于 gather 指令的转置)
+> tilingKey:**10006**
+> 硬件/编译要求:仅 `__NPU_ARCH__ == 3510`(dav-3510)可用,依赖 AscendC `MicroAPI` / `Reg` 寄存器编程模型,且必须打开编译宏 **`TRANSPOSE_ENABLE_GATHER`**。
+> 关键实现文件:
+> - kernel:`op_kernel/arch35/transpose_with_gather.h`(`Transpose::TransposeWithGather<T>`)
+> - 派发入口:`op_kernel/transpose_kernel.cpp`
+> - host 选择:`op_kernel/transpose_tiling.cpp`(`TryGatherTiling`)
+> - gather 专用 tiling:`op_kernel/transpose_tiling_gather.{h,cpp}`(`TransWithGather::TransposeGatherTiling`)
+
+---
+
+## 一、适用场景
+
+### 1.1 为什么用 gather 指令做转置
+
+传统的 Transpose 在 Ascend 上通常依赖 NDDMA(带 stride 的 DMA 搬运)完成维度重排:数据按输出 perm 的顺序,通过多层带步长的 `DataCopy` 从 GM 搬入/搬出。当被转置的轴落在**最后一维**(last axis transpose)时,NDDMA 的搬运粒度会退化——输出最后一维在输入侧不连续,每个连续 burst 长度很短,MTE 通道被大量小 burst 和非连续 stride 拖累,带宽利用率低。
+
+GATHER_TRANSPOSE 的思路是:把转置从"搬运时重排"改为"搬入后在 UB 内用向量 gather 重排":
+
+1. 用一次尽量连续的 `DataCopyPad`(MTE2)把一个 UB 分块的数据整块搬入 UB,搬入布局尽量保证 burst 连续、MTE 效率高;
+2. 在 UB 内用寄存器 gather 指令(`DataCopyGatherImpl` / `vgather`),按预先构造好的 index,一次性把输入布局按输出 perm 重排到输出 buffer;
+3. 再用一次连续的 `DataCopyPad`(MTE3)把结果搬出。
+
+这样把"非连续访问"的代价从昂贵的 DMA 通道转移到 UB 内的向量 gather 上,MTE2/MTE3 两端都走连续大 burst,显著提升带宽利用。
+
+### 1.2 命中条件(什么 shape / perm 下选到)
+
+host 侧选择逻辑见 `transpose_tiling.cpp::Run`,顺序为:VCONV → **gather** → NDDMA 兜底。gather 命中需要同时满足:
+
+- 编译期打开 `TRANSPOSE_ENABLE_GATHER`(否则该分支整体被 `#if` 屏蔽,host 永远不产出 10006,统一由 NDDMA 覆盖);
+- `shapeInfo_.isLastAxisTranspose == true`,即 `SetIsLastAxisTranspose()` 判定 **归约后 perm 的最后一维不等于 dim-1**(`reducedPerm[dim-1] != dim-1`),也就是最后一维参与了转置;
+- `TransWithGather::DoTiling(...)` 返回成功(tiling 能算出合法的 UB / block 切分,详见下文的多处失败返回点)。
+
+任何一步不满足就 fall through 到 NDDMA。注意 shape 在进入前已经过 `RemoveAxisV2`(去掉大小为 1 的轴)和 `MergeAxisV2`(合并连续可归约轴)。
+
+### 1.3 tiling 层面的可行性约束(为什么有些 shape 命中不了)
+
+`DoTiling` 内部有几个硬门槛,不满足即返回 false 交还 NDDMA:
+
+- **MTE 搬入量下限**:`CalcUbAxesInfo` 要求单次搬入 UB 的字节数 `totalSizeInUb >= MTE_GATE`(`0x8000` = 32KB)。太小的分块用 gather 不划算。
+- **Bank Conflict 规避**:`CheckBC(indexStep)` 检查 gather 的 index 步长按 sub-bank(8B)/ bank(128B)对齐后是否落在会产生 bank conflict 的位置,命中冲突则拒绝该切分。`CalcSqrtedTensor` 里也会因此把切分尺寸回退一个 sub-bank。
+- **多核利用率**:`CalcBlockSplitInfo` 要求 `usedCoreCnt >= coreNum/2`,否则返回 false(核用不满不如走别的策略)。
+- **借轴数量上限**:进 UB 参与重排的轴数受 `UB_MAX_BRW_NUM = 3` 限制(gather index 最多按 3 维构造)。
+
+### 1.4 为什么需要硬件 / toolkit 支持
+
+gather kernel 使用 AscendC 的 **MicroAPI(即 `Reg` 寄存器编程)** 模型:`RegTensor`、`MaskReg`、`MicroAPI::Arange/Div/Muls/Select/DataCopy`、以及核心的 `DataCopyGatherImpl`(向量 gather)。别名 `namespace MicroAPI = Reg` 仅在 `kernel_macros.h` 中 `__NPU_ARCH__ == 3510` 时定义,并通过 reg_compute 接口头暴露。因此:
+
+- 只有 dav-3510 架构才有对应的向量 gather 硬件指令与 API;
+- 旧 toolkit 缺 MicroAPI 别名会编译失败,所以整条路径用 `TRANSPOSE_ENABLE_GATHER`(默认 0)保护,构建可在无 MicroAPI 的 toolkit 上正常通过,只是不产出该策略。
+
+---
+
+## 二、kernel 执行流程与关键实现
+
+### 2.1 整体流程
+
+```mermaid
+flowchart TD
+    A[Init: 申请 UB buffer / 绑定 GM] --> B[Process]
+    B --> C[GetCoreLoopRange: 本核 blk 循环区间]
+    C --> D[InitAxes: 载入 UB 轴 / block 切轴信息]
+    D --> E[GenGatherIndex4AllPhase: 预生成各相位 gather index]
+    E --> F{blkLpIdx 循环}
+    F --> G[CalcBlkAddr: 算本次 in/out GM 基址]
+    G --> H[UpdateUbAxes: 处理尾块, 选 gIndexId 相位]
+    H --> I[CopyDataIn: MTE2 连续搬入 UB]
+    I --> J[GetOutLoopAxes: 输出侧循环轴/步长]
+    J --> K[GatherData: UB 内向量 gather 重排]
+    K --> L[CopyDataOut: MTE3 连续搬出]
+    L --> F
+```
+
+### 2.2 Init:buffer 与 double buffer
+
+`Init`(`transpose_with_gather.h:115`)申请三块 UB:
+
+```cpp
+pipe->InitBuffer(xInQue_,  BUFFER_NUM, td_->dataTensorSize);  // VECIN
+pipe->InitBuffer(xOutQue_, BUFFER_NUM, td_->dataTensorSize);  // VECOUT
+pipe->InitBuffer(idxBuf_,  td_->indexTensorSize);             // VECCALC, gather index
+idxLocal_ = idxBuf_.Get<RangeType_>();
+```
+
+- `BUFFER_NUM = 2`(见 `transpose_base.h`),即输入队列 `xInQue_` 与输出队列 `xOutQue_` 都是 **double buffer**,MTE2 搬入 / gather 计算 / MTE3 搬出通过 `TQue` 的 EnQue/DeQue 天然形成流水,搬运与计算 overlap。
+- index buffer 是单块 `TBuf`(不需要 ping-pong,index 在 `Process` 前一次性生成后整个核复用)。
+- `dataTensorSize` / `indexTensorSize` 由 host `CalcTensorSize` 按元素字节数(1B / 8B / 其它)和 ping-pong 份数从 UB 总量反推,保证 data(×2 ping-pong ×2 in/out)+ index 能放进 UB。
+
+### 2.3 类型策略
+
+kernel 用三个派生类型适配不同位宽(`transpose_with_gather.h:89`):
+
+- `RangeType_`:index / arange 计算类型,`<=2B` 用 `int16_t`,否则 `int32_t`;
+- `IdxType_`:传给 gather 的下标类型(对应无符号版本);
+- `CastType_`:1B 元素(`int8/uint8`)在 gather 时按 16-bit 处理(gather 硬件粒度),搬出时再用 `StoreDist::DIST_PACK_B16` 打包回 8-bit。
+
+`vlSize_` / `idxVLSize_` 由 `GetVRegSize()` 除以对应类型宽度得到,是一次向量指令处理的元素数。
+
+### 2.4 gather index 的构造(核心)
+
+index 表示"输出的每个元素来自输入 UB 内的哪个偏移"。构造在 `GenGatherIndex`(`:533`),按需要重排的维度数分派:
+
+- `dimNum = ubAxesCnt - outUbOutCutPos`(即输出侧连续搬出的 cube 之外、需要 gather 的维度数),最多 3;
+- `GenIndex4OneDim` / `GenIndex4TwoDim` / `GenIndex4ThreeDim` 分别对应 1/2/3 维重排。
+
+以二维为例(`GenIndex4TwoDim`,输入 `(a,b,c,d)` → 输出 `(d,c,b,a)`,为 a、b 生成 index):
+
+```
+vec_a = VL % a            // Arange 后对 a 取模
+vec_b = VL / a            // 除法得高维下标
+index = vec_a * a_in_offset + vec_b * b_in_offset
+```
+
+超过一个向量长度(`idxVLSize_`)的部分,用增量 + 进位方式在循环里递推(避免每次重算除法):
+
+```
+vec_a += a_inc;  cmp_a = (vec_a >= a);  vec_a -= cmp_a * a   // Select 生成进位
+vec_b += b_inc + cmp_a
+```
+
+三维版本 `GenIndex4ThreeDim` 同理再多一层进位链(a→b→c)。每维的 `*_in_offset` 由 `CalcUbAxesInOffset` 根据 UB 内轴布局算出(考虑 `DataCopyPad` 的块对齐:跨过 `inUbInCutPos` 时按 `elemPerBlock_` 向上对齐)。
+
+#### 多相位 index(尾块处理)
+
+`GenGatherIndex4AllPhase`(`:547`)在 Process 循环前**一次性生成多份 index**,因为分块循环里会出现"整块 / 输入方向尾块 / 输出方向尾块 / 双向尾块"四种尺寸组合。用 `gIdxOffset_`(按 block 对齐的每相位 index 长度)把不同相位的 index 依次排在 `idxBuf_` 里:
+
+- 相位 0:满块;
+- 相位 1:输入切轴尾块(`inUbTailFactor_ = inUbCutAxisSize % inUbCutAxisFactor`);
+- 相位 2:输出切轴尾块(`outUbTailFactor_`);
+- 相位 3:双向尾块。
+
+具体生成哪几份取决于 host 给出的 `blkInUbCutPos` / `blkOutUbCutPos` 是否为 -1(即该方向是否真的被 block 切分且除不尽)。运行时 `UpdateUbAxes` 按当前 `blkLpIdx` 是否落在尾块上,置 `gIndexId_ ∈ {0,1,2,3}`;`GatherData` 里用 `idxAddr += gIndexId_ * gIdxOffset_` 直接选中对应相位的 index,无需重算。
+
+### 2.5 GatherData:寄存器编程重排
+
+核心循环(`transpose_with_gather.h:265`),运行在 `__VEC_SCOPE__` 内:
+
+```cpp
+idxAddr += gIndexId_ * gIdxOffset_;          // 选相位
+for (lpIdx : burstLpCnt) {                   // 按向量长度分段
+    mask = UpdateMask<T>(maskValue);
+    MicroAPI::DataCopy(idxOriReg, idxAddr + lpIdx*vlSize_);   // 载入基准 index
+    for (axis2Idx) for (axis1Idx) for (axis0Idx) {           // 输出侧外层循环
+        idxUpdate = axis2*..+ axis1*..+ axis0*outUbAxis0InROffset_;
+        MicroAPI::Adds(idxReg, idxOriReg, idxUpdate, maskIdx);  // 基准 index + 外层偏移
+        DataCopyGatherImpl(xReg, xInAddr, idxReg, mask);        // 向量 gather
+        MicroAPI::DataCopy(xOutAddr + outIdx*outLenAlign + lpIdx*vlSize_, xReg, mask);
+    }
+}
+```
+
+要点:
+
+- **基准 index 复用**:一份 index(`idxOriReg`)描述最内层重排;输出侧的 axis0/1/2 外层循环只需给基准 index 加一个标量偏移 `idxUpdate`(`GetOutLoopAxes` 里算出的 `outUbAxisXInROffset_`),避免为每个外层组合都存一份 index,省 UB。
+- **gather 指令** `DataCopyGatherImpl(dst_reg, base_addr, idx_reg, mask)`:以 `xInAddr` 为基址,按 `idxReg` 的每个元素做偏移取数到 `xReg`,mask 控制有效 lane。这是 dav-3510 特有的向量 gather 硬件能力。
+- **1B 特殊路径**:`sizeof(T)==1` 时 gather 按 `CastType_`(16-bit)进行,写出用 `DataCopy<CastType_, StoreDist::DIST_PACK_B16>` 打包回 8-bit;`maskValue` 也相应 `*= sizeof(int16_t)`。
+
+### 2.6 搬入 / 搬出(MTE 连续化)
+
+- `CopyDataIn`(`:626`):`SetCopyInParams` 用 `DataCopyExtParams` + `LoopModeParams`(loop1/loop2 两层 stride 循环)配置带 stride 的 `DataCopyPad<T, PaddingMode::Compact>`,把一个分块整块搬入 UB。`inCube = CalcUbAxesInOffset(inUbInCutPos-1)*sizeof(T)` 是连续 burst 长度,`srcStride = axis0InSrcStride*sizeof(T) - inCube` 描述 GM 侧跳步;搬入 UB 侧按 block 对齐紧凑摆放(`Compact`)。
+- `CopyDataOut`(`:676`):对称地用 `DataCopyPad` + loop mode 把 gather 结果搬出到 `yGM_[blkOutAddr_]`,`dstStride = axis0OutDstStride*sizeof(T) - outCube` 描述输出 GM 跳步。
+- 搬入/搬出前后都成对调用 `SetLoopModePara` / `ResetLoopModePara`,方向分别为 `OUT_TO_UB` / `UB_TO_OUT`。
+
+两端 burst 长度(inCube / outCube)都尽量做大且连续,把不连续代价集中到 UB 内 gather,这正是该策略的性能收益来源。
+
+### 2.7 多核切分与地址计算
+
+- **block 切分**(host `CalcBlockSplitInfo`):在 UB 分块之上,把剩余的 block 轴乘积 `totalElems` 均分到核。`usedCoreCnt = ceil(totalElems / ceil(totalElems/coreNum))`,`blkFactor` 为每核块数,最后一核用 `blkTailFactor`;要求 `usedCoreCnt >= coreNum/2` 否则放弃该策略。
+- **本核区间**:`GetCoreLoopRange` 用 `blockIdx_ * blkFactor` 定起点,末核用尾 factor;`blockIdx_ >= usedCoreCnt` 的核直接 return(不参与)。
+- **地址**:`CalcBlkAddr` 对每个 block 轴用 `idx / blkAxesOffset(i) % blkAxes[i]` 拆出下标,分别乘 `blkAxesInAOffset` / `blkAxesOutAOffset` 累加得到本次搬入/搬出的 GM 基址。
+
+### 2.8 host tiling 关键概念对照
+
+| host 概念 | 含义 |
+| --- | --- |
+| `inUbPerm_` / `outUbPerm_` | 从最内维往外挑选进 UB 参与重排的输入侧 / 输出侧轴(各 ≤ `UB_MAX_BRW_NUM=3`),挑到累计尺寸超过 `sqrtedTensor` 或达上限为止 |
+| `sqrtedTensor` | `sqrt(elemInTensor)` 按 block / cacheLine 对齐,并做 BC 规避;用来平衡 in/out 两个方向的 UB 分块尺寸 |
+| `inUbCutAxisFactor` / `outUbCutAxisFactor` | 输入 / 输出切轴的分块因子;`AdjustUbCutAxisFactor` 按 UB 是否溢出回调 |
+| `ubPerm` / `inUbAxes` / `outUbAxes` | UB 内轴序与各轴大小,喂给 kernel 生成 index 与循环 |
+| `axisXInSrcStride` / `axisXOutDstStride` | `CalcUbSplitInfo4MTE` 算出的 MTE 搬入/搬出多层 stride |
+| `blkInUbCutPos` / `blkOutUbCutPos` | 该方向切轴是否被 block 切分且除不尽(决定尾块相位) |
+
+---
+
+## 调优提示
+
+- 该策略专治"最后一维参与转置"且分块足够大(≥32KB)的场景;若命中不了,先确认 `TRANSPOSE_ENABLE_GATHER` 是否开启、是否在 dav-3510 上。
+- index 步长若频繁触发 `CheckBC` 的 bank conflict,tiling 会缩小分块或直接放弃;shape 的最后一维大小与元素位宽是影响 BC 的主要因素。
+- gather 相位是预生成的,尾块越多(切轴除不尽)index buffer 占用越大,可能挤压 data buffer 分块尺寸;规整的、能整除的分块尺寸更友好。

package/skills/asc-tools/tool-ops-tune/ops-family/references/conversion/transpose_n_last.md

@@ -0,0 +1,276 @@
+# Transpose 调优参考:N_LAST_TRANSPOSE(非末轴转置)
+
+- 策略名:N_LAST_TRANSPOSE(kernel 类 `TransposeNLast`)
+- tilingKey:10004
+- kernel 实现:`arch35/transpose_n_last.h`
+- 派发入口:`transpose_kernel.cpp`(`tilingKey == N_LAST_TRANSPOSE`)
+- host 选择:`transpose_tiling.cpp::EntryTilingTemplate`
+
+面向性能调优开发者。内容以代码为准,未使用的技术不做罗列。
+
+---
+
+## 一、适用场景
+
+### 1. 什么是"末轴不参与转置"
+
+对一个 `perm` 排列,若排列后的最后一维仍是原始最后一维,即 `reducedPerm[dim-1] == dim-1`,则称末轴不参与转置(non-last-axis transpose)。判定见 `SetIsLastAxisTranspose`:
+
+```cpp
+shapeInfo_.isLastAxisTranspose = shapeInfo_.reducedPerm[dim - 1] != dim - 1;
+```
+
+注意这里的 shape 与 perm 都是经过 `RemoveAxisV2`(去除大小为 1 的轴)和 `MergeAxisV2`(合并连续轴)化简后的结果。例如 `perm=[0,2,1,3]` 交换的是中间两维,末轴 3 保持在末尾,属于本策略场景;而 `perm=[0,2,3,1]` 把末轴挪走了,则不属于。
+
+### 2. 为什么可以特殊优化(末轴连续搬运)
+
+末轴不动意味着:输入中沿末轴连续的一段元素,在输出中依然是连续的一段。转置只发生在前面的高维之间,是"整块搬运 + 块的重新排布",而不需要在最内层做逐元素的跨步重排。
+
+于是本策略把末轴(以及被切进 UB 的相邻高维)当作一个连续的数据块:
+
+- 搬入(`CopyIn`)时以连续 `DataCopyPad` 把块从 GM 读进 UB;
+- 搬出(`CopyOut`)时利用 `DataCopyPad` + `LoopModeParams` 的多层循环步长,把 UB 中的连续块按输出布局的目的地址步长写回 GM。
+
+整个过程没有任何 Vector 计算,纯 DMA 搬运,末轴长度越大,单次搬运的连续 burst 越长,带宽利用率越高。
+
+### 3. MOVEALIGN_LAST_MIN_ELE = 32 阈值的含义
+
+选择条件见 `EntryTilingTemplate`:
+
+```cpp
+if (shapeInfo_.totalVolumeActual * shapeInfo_.eleLenInBytes >= SMALL_SHAPE_BYTES_THRES_HOLD) {
+    if (!shapeInfo_.isLastAxisTranspose &&
+        shapeInfo_.reducedInShape[shapeInfo_.dim - 1] >= MOVEALIGN_LAST_MIN_ELE) {  // 32
+        tilingKey_ = KEY_N_LAST_TRANSPOSE;   // 10004
+        return;
+    }
+    ...
+}
+```
+
+即三个前提同时满足才选中本策略:
+
+1. 总数据量足够大(`>= SMALL_SHAPE_BYTES_THRES_HOLD`),否则走 SMALL_SHAPE;
+2. 末轴不参与转置(`!isLastAxisTranspose`);
+3. 化简后末轴元素数 `reducedInShape[dim-1] >= 32`。
+
+`MOVEALIGN_LAST_MIN_ELE = 32` 是末轴的最小元素数门槛。它的意义是保证连续搬运块足够长——只有末轴足够长,连续 `DataCopyPad` 才能摊薄每次搬运的固定开销、接近对齐搬运(move-align)的效率。若末轴太短(< 32),连续块太碎,move-align 带来的收益被非对齐尾块和搬运指令开销吃掉,此时改由 NDDMA 系列(`KEY_NDDMA_BASE` / `KEY_BIG_DIM`)处理更合适。
+
+### 4. 为什么能提升性能
+
+- 末轴连续,搬运粒度大,DMA burst 长,带宽利用率高;
+- 无 Vector 计算,纯搬运,指令流简单;
+- 目的地址的重排通过 `LoopModeParams` 的硬件多层循环步长一次配置、循环内复用完成,减少了逐块地址计算与指令发射开销。
+
+---
+
+## 二、kernel 执行流程与关键实现
+
+### 1. 数据通路与 buffer
+
+```cpp
+TQueBind<QuePosition::VECIN, QuePosition::VECOUT, 1> vecQue_;
+```
+
+使用 `TQueBind` 把 VECIN 与 VECOUT 绑定为同一块 UB(搬入即搬出,中间无计算),配合 `BUFFER_NUM = 2` 的 double buffer:
+
+```cpp
+pipe->InitBuffer(vecQue_, BUFFER_NUM, tiling_->ubSize / BUFFER_NUM);
+```
+
+host 侧 `CalcUBSplitInfo` 对本策略把可用 UB 折半:
+
+```cpp
+case KEY_N_LAST_TRANSPOSE:
+    splitInfo_.ubElement = ubSize_ / BUFFER_NUM / eleSize;
+```
+
+因此 double buffer 使搬入与搬出在两块 buffer 上流水重叠,掩盖 MTE 时延。
+
+### 2. 多核切分
+
+`Process` 先按 host 计算好的多核参数(`realCoreNum` / `blkFactor` / `blkTailFactor`)划分本核处理的循环区间:
+
+```cpp
+ParseMultiCoreRange(blockIdx_, realCoreNum, blkFactor, blkTailFactor,
+                    blkProcessNum_, blkProcessIdxStart_, blkProcessIdxEnd_);
+```
+
+`blockIdx >= realCoreNum` 的核直接返回不做工。host 侧 `CalcBlockSplitInfoForNLastTranspose` 会在满足 UB 容量约束(`UbOutOfBoundCheckNLast`)与核利用率阈值(`VEC_CORE_USED_THRES_HOLD = 0.9`)之间选择 UB 切分因子 `inUbFactor` 和切分轴 `inCutIndex`,尽量让 `realCoreNum` 接近物理核数。
+
+### 3. Init / Process 总体流程
+
+```mermaid
+flowchart TD
+    A[Init] --> B[ParseTilingData 解析 UB 内 main/tail shape]
+    A --> C[SetGlobalBuffer x/y]
+    A --> D[InitBuffer double buffer]
+    P[Process] --> E[ParseMultiCoreRange 多核区间]
+    E --> F[ProcessPerCore]
+    F --> G[GetLoopParams 每维步长]
+    F --> H[GetBlockLoopNum 目的地址混合基]
+    F --> I{循环 loopStart..loopEnd}
+    I --> J[CopyIn 连续 DataCopyPad 入 UB]
+    I --> K[CopyOut 多层循环 DataCopyPad 出 GM]
+```
+
+### 4. 关键函数说明
+
+**`ParseTilingData`**:根据 `inCutIndex` / `inUbFactor` / `inTailFactor` 展开 UB 内 main 块与 tail 块的输入 shape(`inUbInputShapeMain_/Tail_`),再按 `perm` 映射出对应的输出 shape。切分轴之后(更靠内)的维保留原大小,切分轴之前的维在 UB 内视作 1,切分轴本身取 factor。
+
+**`GetLoopParams(n)`**:为搬出计算每层循环的 `loopSize`、源步长 `loopSrcStride`(基于末轴按 `BLOCK_SIZE_BYTE=32` 对齐后的 `alignedStride`)与目的步长 `loopDstStride`(沿输出 shape 累乘,直到遇到当前轴在 perm 中的位置)。main 与 tail 分别计算,避免热循环中判分支。
+
+**`GetBlockLoopNum`**:用右侧维度累乘 `rightProducts` 构造目的地址的"混合基"`dstAddressOffsetMixedBase_` 和每维贡献 `dstLoopNumArray_`,供 `GetDstAddressOffset` 按 loopIdx 反解出 GM 目的偏移。
+
+**`GetDstAddressOffset`**:把线性 `loopIdx` 按混合基逐位分解并直接累加成目的地址偏移,融合了"进制分解 + 累加",不落中间数组(见注释 P9)。
+
+**`CopyIn`**:计算源地址偏移后,用 `DataCopyPad` 把一个 UB 块连续搬入。若末轴字节数按 32B 非整除,则退化为 `blockCount = blockLen / lastAxisLen` 的多 block 带 pad 搬入:
+
+```cpp
+copyInParams.blockLen = blockLen * sizeof(T);
+copyInParams.blockCount = 1;
+if ((lastAxisLen * sizeof(T)) % BLOCK_SIZE_BYTE != 0) {
+    copyInParams.blockLen = lastAxisLen * sizeof(T);
+    copyInParams.blockCount = blockLen / lastAxisLen;
+}
+```
+
+**`CopyOut`**:核心搬出。先设 `copyOutParams`(以 `loopSize[0]` 为连续 burst,`loopSize[1]` 为 blockCount,`dstStride` 用输出步长表达跨行),再用 `SetLoopModePara(loopParams, DataCopyMVType::UB_TO_OUT)` 配置 loop1/loop2 两层硬件循环步长,然后在 loop4~loop7 四层软件循环里逐块 `DataCopyPad` 写回 GM:
+
+```cpp
+SetLoopModePara(loopParams, DataCopyMVType::UB_TO_OUT);
+for (loop7) for (loop6) for (loop5) for (loop4)
+    DataCopyPad(outputGM_[dst + ...], bindLocalOut[src + ...], copyOutParams);
+ResetLoopModePara(DataCopyMVType::UB_TO_OUT);
+```
+
+即通过 "硬件 2 层循环(LoopMode)+ 软件 4 层循环 + copyParams 内 2 层" 组合覆盖最多 8 维的输出重排,而每个最内单元都是一次连续块的 move-align 搬运。
+
+**`ProcessPerCore`**:预计算各维 `GetLoopParams` 与 `GetBlockLoopNum`,把 tiling 指针字段、成员数组缓存到栈上局部变量(注释 P1/P4/P6,避免结构体动态下标造成的别名污染与重复 Load),并将 main / tail 循环分离以消除热路径分支(注释 P2):
+
+```cpp
+for (loopIdx = loopStart; loopIdx < loopEnd; loopIdx++) {
+    if (inTailFactor != 0 && (loopIdx + 1) % inCutLoopSize == 0) {
+        CopyIn(...); CopyOut(..., loopSizeTail_, ...);   // 尾块
+    } else {
+        CopyIn(...); CopyOut(..., loopSizeMain_, ...);   // 主块
+    }
+}
+```
+
+### 5. 用到的关键技术小结
+
+- Double buffer(`BUFFER_NUM=2`)+ `TQueBind`(VECIN/VECOUT 绑定同一 UB)实现搬入/搬出流水重叠,无中间计算。
+- 连续 `DataCopyPad`:末轴连续,以长 burst 搬运;末轴非 32B 对齐时退化为多 block + pad。
+- `SetLoopModePara` / `LoopModeParams`(`UB_TO_OUT`)硬件多层循环步长表达输出转置布局,循环外一次配置、循环内复用。
+- 多核切分:host 侧按 0.9 核利用率阈值和 UB 容量约束选切分因子,kernel 侧 `ParseMultiCoreRange` 分配区间。
+- 主/尾块循环分离、tiling 字段与成员数组栈缓存等标量优化,减少热路径分支与重复访存。
+
+---
+
+## 三、CopyOut 维度合并优化
+
+> ⚠️ **实战经验**：N_LAST 的 CopyOut 按 **input 轴顺序**逐维循环，但 perm 会把 input 轴打散到 output 的不同位置。如果 output 中有相邻维度在 GM 中连续（C-order），可以将它们合并为更大的连续块，减少软件循环层数和 strided 写次数。实测在 batch_to_space 等高维 transpose 算子中，维度合并可将 CopyOut 从 6 维 6 循环降为 3 维 2 硬件循环，性能等价于连续写出。
+
+### 1. 问题：循环顺序与 output 连续性不匹配
+
+N_LAST 的循环按 input 轴从内到外排列（axis N-1, N-2, ..., 0），对应 `SimtComputeDim*` 的 `loopSize[n]` / `loopDstStride[n]`。但 perm 重排后，相邻的 input 轴在 output 中的位置不一定连续。
+
+以 batch_to_space（perm=[2,3,0,4,1,5]）为例：
+
+```
+input 6D:  [bs0(0), bs1(1), N(2), H(3), W(4), C(5)]
+output 6D: [N(0), H(1), bs0(2), W(3), bs1(4), C(5)]   (perm=[2,3,0,4,1,5])
+```
+
+N_LAST 循环顺序 vs output 位置：
+
+| loop | input axis | output 位置 | 与下一 loop 在 output 中连续？ |
+|------|-----------|------------|---------------------------|
+| loop0 | bs0(0) | 2 | ✗ (下一 loop bs1 在 output 4) |
+| loop1 | bs1(1) | 4 | ✗ (下一 loop N 在 output 0) |
+| loop2 | N(2) | 0 | ✓ (H 在 output 1) |
+| loop3 | H(3) | 1 | ✗ (W 在 output 3) |
+| loop4 | W(4) | 3 | ✗ (C 在 output 5) |
+| loop5 | C(5) | 5 | — |
+
+5 个相邻关系中有 4 个不连续，导致 CopyOut 每层循环的 dstStride 有 gap（strided 写），每次 DataCopyPad 只搬末轴 C 个元素。
+
+### 2. 维度合并算法
+
+**核心思路**：检查 perm 逆映射，找出 output 中位置连续的 input 轴组，将同组维度合并为更大的连续块。
+
+**步骤**：
+
+1. 计算 perm 逆映射：`inv_perm[input_axis] = output_position`
+2. 按 output 位置排序 input 轴
+3. 找出 output 中位置连续的 input 轴组（`output_pos[i+1] == output_pos[i]+1`）
+4. 合并同组维度：
+   - 最内组的乘积作为新的 `blockLen`（连续 burst）
+   - 次内组的乘积作为 `blockCount`（连续行数）
+   - 更外组的乘积作为硬件循环的 `loopSize`（dstStride 连续，无 gap）
+
+### 3. 合并示例（batch_to_space）
+
+perm=[2,3,0,4,1,5] 的 output 全部相邻维度连续，可合并为 3 组：
+
+```
+output 6D: [N(0), H(1), bs0(2), W(3), bs1(4), C(5)]
+
+连续组1: W(3) + bs1(4) + C(5) → 合并为 W*bs1*C 的连续块 (blockLen)
+连续组2: H(1) + bs0(2)       → 合并为 H_cut*bs0 (硬件循环1, dstStride=W*bs1*C 连续)
+连续组3: N(0)                → 硬件循环2, dstStride=H*bs0*W*bs1*C 连续)
+```
+
+**合并前后对比**：
+
+| | 合并前（6 维 6 循环） | 合并后（3 维 2 硬件循环） |
+|---|---|---|
+| blockLen | C | **W*bs1*C**（连续） |
+| blockCount | W, dstStride=bs1*C（strided） | 1 |
+| 硬件循环1 | H_cut, dstStride=bs0*W*bs1*C | **H_cut*bs0**, dstStride=W*bs1*C（连续） |
+| 硬件循环2 | N, dstStride=H*bs0*W*bs1*C | N, dstStride=H*bs0*W*bs1*C（连续） |
+| 软件循环 | bs1 + bs0（2 层 strided） | **0 层** |
+| DataCopyPad 次数 | bs0×bs1 次 strided | **1 次连续** |
+| 所有 dstStride | 4/5 个有 gap | **0 个有 gap** |
+
+合并后 CopyOut 变成 **1 次 DataCopyPad + 2 层硬件循环**，所有 stride 连续（无 gap），等价于直接连续写出整个 UB 块。
+
+### 4. CopyIn 同理
+
+CopyIn 的 `srcAddressOffset` 按 input 线性偏移计算，input 中相邻维度在 GM 中天然连续（C-order）。同样可以合并 input 中连续的维度组，增大单次 DataCopyPad 的 blockLen，减少搬运次数。
+
+### 5. 通用判断条件
+
+维度合并不是 batch_to_space 专用的——任何 N_LAST 适用场景都可以尝试：
+
+1. **perm 不是完全逆序**（即 output 维度顺序与 input 不同），但部分维度在 output 中仍连续
+2. **可合并维度数 ≥ 2**：至少有一对相邻维度在 output 中连续，合并后减少至少 1 层循环
+3. **cut axis 不在最内组**：cut axis 需要单独成组（UB 切分约束），不能与更内维合并
+
+**特殊情况**：
+- 如果 perm 恒等（无转置），所有维度连续，合并后退化为 TENSOR_MOVE（1 次 DataCopyPad）
+- 如果 perm 完全逆序，无连续维度，不能合并
+- 大部分实际 transpose 的 perm 只有部分维度交换，至少有 1-2 组可合并
+
+### 6. 实测数据参考
+
+以 batch_to_space 算子（perm=[2,3,0,4,1,5]，6D）为例，在 ascend950 上：
+
+| 实现 | CopyOut 方式 | case2 aiv(us) | case12 aiv(us) |
+|------|------------|--------------|---------------|
+| 基线 DataCopyPad | 4D 连续写出 | 19.4 | 24.6 |
+| N_LAST（未合并） | 6 维 strided 写 | 58.9 | 124.1 |
+| N_LAST（合并后预期） | 3 维连续写 | ~19 | ~25 |
+| TQueBind 4D | 4D 连续写出 | 13.1 | 15.4 |
+
+> N_LAST 未合并时比基线慢 2-5 倍，根因就是 CopyOut 的 strided 写。合并后预期与基线持平，因为 CopyOut 变为连续写出。TQueBind 更快是因为它在 4D 空间操作，天然利用了输出连续性，且 TilingData 更小（128B vs 972B）。
+
+### 7. 实施建议
+
+在 N_LAST 模板中增加维度合并逻辑的最佳位置：
+
+- **Host 端**（`ComputeNLastTiling` / `ParseTilingData`）：在计算 `loopSize` / `loopDstStride` 之前，先检测可合并维度组，将合并后的维度组数和乘积写入 TilingData
+- **Kernel 端**（`GetLoopParams` / `CopyOut`）：按合并后的维度组数设置循环参数，减少循环层数
+
+**关键**：合并逻辑应作为 N_LAST 模板的通用增强，而非算子专用适配。通过检查 `inv_perm` 的连续性自动判断，无需 hardcode 特定 perm。