@kernaut/kernaut-resources 0.1.17-beta.1 → 0.1.18

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/wiki/ascend/techniques/libdevice-usage/README.md

@@ -1,307 +0,0 @@
----
-id: skill-ascend-libdevice-usage
-title: "Libdevice Math Function Usage"
-type: skill
-vendor: ascend
-tags:
-- triton-ascend
-- libdevice-usage
-evidence_level: spec
-applies_to:
-- ascend910b
-source:
-- path: local
-  anchor: AscendOpGenAgent/skills
-architectures:
-- ascend910b
-languages:
-- triton-ascend
-techniques:
-- libdevice-usage
-symptoms:
-- transcendental functions slow
-- exp log tanh erf slow
-- activation function math
-- gelu swish activation
-- hand written math function
-- fp8 e4m3 bit encoding exp log floor
-- 超越函数慢
-- 激活函数
-- 数学函数
-aliases:
-- libdevice math
-- transcendental
-- exp log
----
-# Libdevice 函数使用
-
-## 概述
-
-Triton-Ascend libdevice 提供了一系列已优化的基础函数库，包括数学函数、三角函数、双曲函数、指数对数函数、激活函数、特殊函数等。使用这些已优化的函数可以避免重复造轮子，提升代码性能和可维护性。
-
-## 适用条件
-
-当需要实现以下类型的函数时，应优先检查 libdevice 是否已有实现：
-- 四舍五入、取整等操作（round, trunc, nearbyint）
-- 三角函数（sin, cos, tan, atan, acos, asin）
-- 双曲函数（sinh, cosh, tanh, asinh, acosh, atanh）
-- 指数、对数函数（exp, log, expm1, log1p, log10）
-- 激活函数（relu）
-- 特殊函数（gamma, erf, erfinv, bessel）
-- 浮点判断与操作（isnan, isinf, signbit）
-
-## 确认 libdevice 路径
-
-不同版本的 triton-ascend 可能有不同的目录结构：
-- 有些版本：`tl.extra.cann.libdevice`
-- 有些版本：`tl.extra.ascend.libdevice`
-
-**确认方法：**
-
-```bash
-# 1. 找到 triton-ascend 安装路径
-pip show triton-ascend
-
-# 2. 在该路径下查找 libdevice.py
-find <triton-ascend路径> -name "libdevice.py"
-
-# 3. 根据文件所在目录确定路径
-# 如果在 cann 文件夹下：tl.extra.cann.libdevice
-# 如果在 ascend 文件夹下：tl.extra.ascend.libdevice
-```
-
-**完整函数列表源码位置：**
-- `triton/language/extra/cann/libdevice.py`（cann 版本）
-- `triton/language/extra/ascend/libdevice.py`（ascend 版本）
-
-## 核心原则
-
-**优先使用 libdevice 中已有的基础函数，不要从头实现。**
-
-**Why:** libdevice 中已提供经过优化的基础函数，重新实现既浪费时间又可能性能更差。
-
-**How to apply:**
-1. 需要数学函数时，**先检查** libdevice 是否已有实现
-2. 找到后直接调用，再组合类型转换等操作
-3. **不要从头造轮子**
-
-## 错误 vs 正确示例
-
-### 示例 1: round 函数
-
-```python
-# ❌ 错误：从头实现 round
-@triton.jit
-def round_int8(x):
-    return (x + 0.5).to(tl.int8)  # 重复造轮子，且逻辑不完整
-
-# ✅ 正确：复用 libdevice 中的 round
-@triton.jit
-def round_int8(x):
-    return tl.extra.cann.libdevice.round(x).to(tl.int8)
-```
-
-### 示例 2: relu 激活
-
-```python
-# ❌ 错误：手写 relu
-@triton.jit
-def relu_kernel(x_ptr, out_ptr, ...):
-    x = tl.load(x_ptr + ...)
-    out = tl.maximum(x, 0.0)  # 手写实现
-
-# ✅ 正确：使用 libdevice relu
-@triton.jit
-def relu_kernel(x_ptr, out_ptr, ...):
-    x = tl.load(x_ptr + ...)
-    out = tl.extra.cann.libdevice.relu(x)  # 更高效
-    tl.store(out_ptr + ..., out)
-```
-
-## 函数分类速查表
-
-### 数学运算函数
-
-| 函数 | libdevice 路径 | 用途 | 支持类型 |
-|-----|---------------|------| ---------|
-| `round` | `tl.extra.xxx.libdevice.round` | 四舍五入 | fp32 |
-| `trunc` | `tl.extra.xxx.libdevice.trunc` | 向零截断 | fp32 |
-| `nearbyint` | `tl.extra.xxx.libdevice.nearbyint` | 就近整数（银行家舍入） | fp32 |
-| `pow` | `tl.extra.xxx.libdevice.pow` | 幂运算 x^y | fp32, fp16, bf16, int |
-| `reciprocal` | `tl.extra.xxx.libdevice.reciprocal` | 倒数 1/x | fp32, fp16 |
-
-### 三角函数
-
-| 函数 | libdevice 路径 | 用途 | 支持类型 |
-|-----|---------------|------| ---------|
-| `tan` | `tl.extra.xxx.libdevice.tan` | 正切 | fp32, fp16 |
-| `atan` | `tl.extra.xxx.libdevice.atan` | 反正切 | fp32, fp16 |
-| `atan2` | `tl.extra.xxx.libdevice.atan2` | 双参数反正切 | fp32, fp16 |
-| `acos` | `tl.extra.xxx.libdevice.acos` | 反余弦 | fp32, fp16, bf16 |
-| `asin` | `tl.extra.xxx.libdevice.asin` | 反正弦 | fp32 |
-
-### 双曲函数
-
-| 函数 | libdevice 路径 | 用途 | 支持类型 |
-|-----|---------------|------| ---------|
-| `sinh` | `tl.extra.xxx.libdevice.sinh` | 双曲正弦 | fp32, fp16, bf16 |
-| `cosh` | `tl.extra.xxx.libdevice.cosh` | 双曲余弦 | fp32, fp16, bf16 |
-| `tanh` | `tl.extra.xxx.libdevice.tanh` | 双曲正切 | fp32, fp16 |
-| `asinh` | `tl.extra.xxx.libdevice.asinh` | 反双曲正弦 | fp32, fp16, bf16 |
-| `acosh` | `tl.extra.xxx.libdevice.acosh` | 反双曲余弦 | fp32, fp16, bf16 |
-| `atanh` | `tl.extra.xxx.libdevice.atanh` | 反双曲正切 | fp32, fp16, bf16 |
-
-### 指数与对数函数
-
-| 函数 | libdevice 路径 | 用途 | 支持类型 |
-|-----|---------------|------| ---------|
-| `exp` | `tl.exp` (内置) | 指数函数 e^x | - |
-| `expm1` | `tl.extra.xxx.libdevice.expm1` | e^x - 1 | fp32, fp16, bf16 |
-| `log` | `tl.log` (内置) | 自然对数 | - |
-| `log1p` | `tl.extra.xxx.libdevice.log1p` | ln(1+x) | fp32, fp16 |
-| `log10` | `tl.extra.xxx.libdevice.log10` | 以10为底对数 | fp32 |
-
-### 激活与工具函数
-
-| 函数 | libdevice 路径 | 用途 | 支持类型 |
-|-----|---------------|------| ---------|
-| `relu` | `tl.extra.xxx.libdevice.relu` | ReLU 激活 | fp32, fp16 |
-| `abs` | `tl.abs` (内置) | 绝对值 | - |
-| `sqrt` | `tl.sqrt` (内置) | 平方根 | - |
-| `rsqrt` | `tl.rsqrt` (内置) | 逆平方根 | - |
-| `hypot` | `tl.extra.xxx.libdevice.hypot` | 欧氏距离 √(x²+y²) | fp32, fp16, bf16 |
-| `copysign` | `tl.extra.xxx.libdevice.copysign` | 复制符号 | fp32 |
-
-### 特殊函数
-
-| 函数 | libdevice 路径 | 用途 | 支持类型 |
-|-----|---------------|------| ---------|
-| `erfinv` | `tl.extra.xxx.libdevice.erfinv` | 逆误差函数 | fp32 |
-| `gamma` | `tl.extra.xxx.libdevice.gamma` | 伽马函数 Γ(x) | fp32 |
-| `lgamma` | `tl.extra.xxx.libdevice.lgamma` | 对数伽马函数 ln\|Γ(x)\| | fp32 |
-| `cyl_bessel_i0` | `tl.extra.xxx.libdevice.cyl_bessel_i0` | 修正贝塞尔函数 I₀ | fp16, fp32 |
-
-### 浮点判断与操作
-
-| 函数 | libdevice 路径 | 用途 | 支持类型 |
-|-----|---------------|------| ---------|
-| `isnan` | `tl.extra.xxx.libdevice.isnan` | 判断是否为 NaN | fp32, fp16, bf16 |
-| `isinf` | `tl.extra.xxx.libdevice.isinf` | 判断是否为无穷 | fp32, fp16, bf16 |
-| `signbit` | `tl.extra.xxx.libdevice.signbit` | 获取符号位 | fp16, fp32 |
-| `nextafter` | `tl.extra.xxx.libdevice.nextafter` | 下一可表示浮点数 | fp32, fp16, bf16 |
-| `ldexp` | `tl.extra.xxx.libdevice.ldexp` | ldexp(x, exp) | fp32, fp16 |
-| `ilogb` | `tl.extra.xxx.libdevice.ilogb` | 整数对数 | fp32, fp16 |
-
-> **注意：** 表中 `xxx` 需根据实际版本替换为 `cann` 或 `ascend`
-
-## 常用工具函数封装
-
-### round_int8 - 四舍五入到 int8
-
-**用途：** 将浮点数四舍五入后转换为 int8，常用于量化算子
-
-```python
-@triton.jit
-def round_int8(x):
-    """四舍五入到 int8，使用 libdevice 的 round 函数"""
-    return tl.extra.cann.libdevice.round(x).to(tl.int8)
-```
-
-### clamp_int8 - 截断到 int8 范围
-
-```python
-@triton.jit
-def clamp_int8(x):
-    """将值截断到 int8 范围 [-128, 127]"""
-    return tl.maximum(tl.minimum(x, 127), -128).to(tl.int8)
-```
-
-### safe_div - 安全除法
-
-```python
-@triton.jit
-def safe_div(a, b, eps=1e-10):
-    """安全除法，避免除零"""
-    return a / (b + eps)
-```
-
-### safe_inv - 安全求逆
-
-```python
-@triton.jit
-def safe_inv(x, eps=1e-10):
-    """安全求逆，避免除零"""
-    return 1.0 / (x + eps)
-```
-
-## 完整使用示例
-
-### 量化场景
-
-```python
-@triton.jit
-def quantize_round(x, scale):
-    """量化：round + 类型转换"""
-    x_scaled = x * scale
-    return tl.extra.cann.libdevice.round(x_scaled).to(tl.int8)
-```
-
-### 激活函数场景
-
-```python
-@triton.jit
-def activations_kernel(x_ptr, out_ptr, mode, ...):
-    """多种激活函数"""
-    x = tl.load(x_ptr + ...)
-
-    if mode == "relu":
-        out = tl.extra.cann.libdevice.relu(x)
-    elif mode == "tanh":
-        out = tl.extra.cann.libdevice.tanh(x)
-    elif mode == "sigmoid":
-        out = 1.0 / (1.0 + tl.exp(-x))  # sigmoid 无 libdevice 版本
-    else:
-        out = x
-
-    tl.store(out_ptr + ..., out)
-```
-
-### 数学运算场景
-
-```python
-@triton.jit
-def math_kernel(x_ptr, y_ptr, out_ptr, op, ...):
-    """数学运算"""
-    x = tl.load(x_ptr + ...)
-    y = tl.load(y_ptr + ...)
-
-    if op == "pow":
-        out = tl.extra.cann.libdevice.pow(x, y)
-    elif op == "hypot":
-        out = tl.extra.cann.libdevice.hypot(x, y)
-    elif op == "atan2":
-        out = tl.extra.cann.libdevice.atan2(x, y)
-    else:
-        out = x
-
-    tl.store(out_ptr + ..., out)
-```
-
-## 关键点
-
-1. **先检查 libdevice**：需要数学函数时，先确认 libdevice 是否已有实现
-2. **确认正确路径**：根据 triton-ascend 版本确认使用 `cann` 还是 `ascend` 路径
-3. **注意支持类型**：不同函数支持的类型不同（fp32/fp16/bf16）
-4. **组合类型转换**：可能需要组合 `.to(tl.int8)` 等类型转换操作
-5. **优先内置函数**：对于 `tl.exp`、`tl.log`、`tl.abs` 等内置函数，直接使用内置版本
-
-## 检查清单
-
-在使用数学函数时，检查以下项目：
-
-- [ ] 是否先检查 libdevice 中是否有该函数
-- [ ] 是否确认了正确的函数路径（cann 或 ascend）
-- [ ] 是否使用了正确的函数路径（`tl.extra.xxx.libdevice.xxx`）
-- [ ] 是否注意了支持的类型（fp32/fp16/bf16）
-- [ ] 是否需要组合类型转换（`.to(tl.int8)` 等）
-- [ ] 对于内置函数（`tl.exp`、`tl.log`、`tl.abs` 等），是否直接使用内置版本

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/wiki/ascend/techniques/load-order-optimization/README.md

@@ -1,162 +0,0 @@
----
-id: skill-ascend-load-order
-title: "Load Order Optimization"
-type: skill
-vendor: ascend
-tags:
-- triton-ascend
-- load-order-optimization
-evidence_level: spec
-applies_to:
-- ascend910b
-source:
-- path: local
-  anchor: AscendOpGenAgent/skills
-architectures:
-- ascend910b
-languages:
-- triton-ascend
-techniques:
-- load-order-optimization
-symptoms:
-- transpose layout change strided access
-- reorder loads
-- memory access order
-- layout transform
-- 转置
-- layout变换
-- 搬运顺序
-aliases:
-- load order
-- layout transform
-- transpose
----
-# Load 指令重排序
-
-## 优化原理
-
-该文件旨在说明，编译器不会修改用户load指令的顺序，在前面的load指令被其他指令阻塞时，可以将没有数据依赖的load语句放在前面以提前发射，提升并行度。
-
-## 优化思路
-
-在循环中，原本的语句顺序是：
-
-```
-load B
-load A
-calc
-store O
-store B
-```
-
-由于当前的 load B 会等待上一次循环的 store B，load A 不能提前与 load B 执行，所以 load A 与 store B 不能并行。
-
-将语句顺序改为：
-
-```
-load A
-load B
-calc
-store O
-store B
-```
-
-load A 即可与上一次循环的 store B 并行。
-
-## 代码示例
-
-优化前（load B 在前，load A 在后）：
-
-```python
-@triton.jit
-def AB_load_kernel(
-    A,
-    B,
-    B_index,
-    O,
-    B_DIM: tl.constexpr,
-    HEAD_NUM: tl.constexpr,
-    HEAD_DIM: tl.constexpr,
-):
-    i_n = tl.program_id(0)
-    i_range = tl.arange(0, B_DIM)
-
-    for i in range(HEAD_NUM):
-        # calc index
-        p_A = A + i * HEAD_DIM + i_n * B_DIM + i_range
-        p_O = O + i * HEAD_DIM + i_n * B_DIM + i_range
-        p_B_index = B_index + i
-
-        # load B (在前，会阻塞 load A)
-        idx_B = tl.load(p_B_index)
-        p_B = B + idx_B
-        b_B = tl.load(p_B)
-
-        # load A (在后，必须等 load B 完成)
-        b_A = tl.load(p_A)
-
-        # calculation
-        b_B += tl.sum(b_A)
-        b_O = b_A * b_B
-
-        # store O
-        tl.store(p_O, b_O)
-
-        # store B
-        idx_B = tl.load(p_B_index)
-        p_B = B + idx_B
-        tl.store(p_B, b_B)
-```
-
-优化后（load A 在前，load B 在后）：
-
-```python
-@triton.jit
-def AB_load_kernel(
-    A,
-    B,
-    B_index,
-    O,
-    B_DIM: tl.constexpr,
-    HEAD_NUM: tl.constexpr,
-    HEAD_DIM: tl.constexpr,
-):
-    i_n = tl.program_id(0)
-    i_range = tl.arange(0, B_DIM)
-
-    for i in range(HEAD_NUM):
-        # calc index
-        p_A = A + i * HEAD_DIM + i_n * B_DIM + i_range
-        p_O = O + i * HEAD_DIM + i_n * B_DIM + i_range
-        p_B_index = B_index + i
-
-        # load A (在前，可以与上一次循环的 store B 并行)
-        b_A = tl.load(p_A)
-
-        # load B (在后，但不会阻塞 load A)
-        idx_B = tl.load(p_B_index)
-        p_B = B + idx_B
-        b_B = tl.load(p_B)
-
-        # calculation
-        b_B += tl.sum(b_A)
-        b_O = b_A * b_B
-
-        # store O
-        tl.store(p_O, b_O)
-
-        # store B
-        idx_B = tl.load(p_B_index)
-        p_B = B + idx_B
-        tl.store(p_B, b_B)
-```
-
-## 为什么有效
-
-| 优化前 | 优化后 |
-|--------|--------|
-| load B 等待上一次 store B 完成后才能执行 | load A 无需等待，可以提前发射 |
-| load A 必须等 load B 完成后才能执行 | load A 可以与上一次循环的 store B 并行执行 |
-| 串行执行，并行度低 | 并行执行，并行度高 |
-
-核心原理：load A 与 store B 之间没有数据依赖，调整顺序后 load A 可提前发射，充分利用流水线并行能力。

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/wiki/ascend/techniques/loop-invariant-hoisting/README.md

@@ -1,227 +0,0 @@
----
-id: skill-ascend-loop-invariant-hoisting
-title: "Loop Invariant Hoisting"
-type: skill
-vendor: ascend
-tags:
-- triton-ascend
-- loop-invariant-hoisting
-evidence_level: spec
-applies_to:
-- ascend910b
-source:
-- path: local
-  anchor: AscendOpGenAgent/skills
-architectures:
-- ascend910b
-languages:
-- triton-ascend
-techniques:
-- loop-invariant-hoisting
----
-# 循环不变量外提优化
-
-## 快速识别（看到这些模式立即加载本文档）
-
-| 抽象模式 | 检查方法 |
-|---------|---------|
-| 循环内 `tl.load` 的索引不含当前循环变量 | 检查 load 的索引表达式，看是否缺少 `for` 循环的迭代变量 |
-| 索引通过 `//` 整除映射到更粗粒度 | 检查是否有 `index = something // const` 形式，且该 index 用于 load |
-| 循环内有参数指针的 load | 检查 load 的指针是否为参数指针（非主数据输入指针） |
-
-## 核心模式
-
-**模式**：在循环内重复加载相同的值，且该值只与外层索引相关。
-
-**检测条件**（同时满足）：
-
-1. 存在嵌套循环结构
-2. 内层循环中有 `tl.load(param_ptr + index_expr)`
-3. `index_expr` 只依赖外层循环变量，不依赖内层循环变量
-
-**收益**：当内层循环次数 >> 外层循环次数时，减少重复加载次数。
-
----
-
-## 模式匹配
-
-### 模式 1：参数索引只依赖外层变量
-
-```python
-# 问题代码
-for outer_idx in range(outer_size):
-    for inner_idx in range(inner_size):
-        param_idx = outer_idx  # 只依赖外层变量
-        val = tl.load(param_ptr + param_idx)  # 重复加载相同值
-        ...
-
-# 优化后
-for outer_idx in range(outer_size):
-    param_idx = outer_idx
-    val = tl.load(param_ptr + param_idx)  # 提到外层
-    for inner_idx in range(inner_size):
-        ...
-```
-
-### 模式 2：参数索引通过整除映射到外层
-
-```python
-# 问题代码
-for block in range(num_blocks):
-    offsets = block * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
-    param_idx = offsets // SPATIAL_SIZE  # 映射到更粗粒度的索引
-    val = tl.load(param_ptr + base + param_idx)  # 同一 param_idx 的多个元素重复加载
-    ...
-
-# 优化后
-for coarse_idx in range(num_coarse):
-    val = tl.load(param_ptr + base + coarse_idx)  # 每个粗粒度索引只加载一次
-    for fine_idx in range(num_fine):
-        offsets = coarse_idx * fine_size + fine_idx * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
-        ...
-```
-
----
-
-## 检测方法
-
-```
-Step 1: 找到循环内的 tl.load 语句
-        ↓
-Step 2: 分析 load 的索引表达式
-        ↓
-Step 3: 判断索引是否依赖内层循环变量
-        ↓ 不依赖内层变量，只依赖外层变量或常量
-        ↓
-Step 4: 计算内外层循环次数
-        ↓ 内层次数 >> 外层次数
-        ↓
-Step 5: 可外提到外层循环
-```
-
----
-
-## 收益分析
-
-| 场景 | 内层次数 | 外层次数 | 加载次数变化 | 收益 |
-|------|---------|---------|-------------|------|
-| 归一化算子 per-channel 参数 | N/C | C | N → C | N/C 倍 |
-| 通用情况 | inner | outer | inner×outer → outer | inner 倍 |
-
-实际收益取决于：
-- 内外层循环次数比例
-- load 操作在总计算中的占比
-- 内存访问延迟
-
----
-
-## 示例
-
-### 归一化算子场景
-
-```python
-# 问题：每个元素都加载 weight/bias
-for block in range(num_blocks):
-    offsets = block * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
-    channel = offsets // spatial_size
-    w = tl.load(weight_ptr + channel)  # 相同 channel 重复加载
-    ...
-
-# 优化：按 channel 分组，每个 channel 只加载一次
-for c in range(num_channels):
-    w = tl.load(weight_ptr + c)  # 提到 channel 循环外
-    for block in range(blocks_per_channel):
-        offsets = c * spatial_size + block * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
-        ...
-```
-
-### 通用场景：查找表访问
-
-```python
-# 问题：循环内重复访问查找表同一位置
-for batch in range(N):
-    for elem in range(E):
-        table_idx = batch % TABLE_SIZE  # 只依赖外层 batch
-        val = tl.load(table_ptr + table_idx)
-        ...
-
-# 优化
-for batch in range(N):
-    table_idx = batch % TABLE_SIZE
-    val = tl.load(table_ptr + table_idx)  # 提到外层
-    for elem in range(E):
-        ...
-```
-
-### 场景 3：小查找表在循环内被随机索引访问（结合离散访存优化）
-
-**问题代码**：
-
-```python
-# expert_map 是一个小查找表（如 128 个元素），在循环内通过随机索引访问
-for x in range(tl.cdiv(topk_numel, BLOCK_SIZE)):
-    expert_ids = tl.load(topk_ids_ptrs, ...)  # 运行时随机值
-    # 虽然 expert_map 指针是常量，但索引 expert_ids 是随机的
-    # 传统外提无法解决，因为每个循环迭代的 expert_ids 都不同
-    expert_map_ptrs = expert_map + expert_ids
-    mapped_ids = tl.load(expert_map_ptrs, ...)  # 循环内离散全局内存访问
-```
-
-**分析误区**：
-- 表面上看 `expert_map` 是参数指针，索引表达式 `expert_ids` 在循环内变化，似乎不符合传统"循环不变量外提"条件
-- 但实际上 `expert_map` 的内容（查找表本身）在循环内完全不变，只是**访问方式**是随机的
-
-**正确优化**：将查找表整体预加载到 UB，循环内用 `tl.gather` 局部查找
-
-```python
-# 循环外：将整个 expert_map 加载到 UB（真正的不变量）
-expert_map_data = tl.load(expert_map + tl.arange(0, num_experts)).to(tl.float32)
-
-for x in range(cntx):
-    e_ids = tl.load(topk_ids_ptr + x * BLOCK_SIZE + offsets, mask=mask, other=0)
-    # 循环内：从 UB 局部 buffer gather，而非全局离散加载
-    expert_ids = tl.gather(expert_map_data, e_ids, 0)
-    ...
-```
-
-**关键洞察**：当循环内出现 `tl.load(small_table + random_index)` 模式时，应将"外提"理解为**将整个查找表预加载到局部 buffer**，而非简单地将 `tl.load` 语句移到循环外。
-
----
-
-## 注意事项
-
-1. **不是所有 load 都能外提**：只有索引不依赖内层变量时才能外提
-
-2. **权衡代码复杂度**：外提可能增加代码复杂度，需权衡收益
-
-3. **结合其他优化**：常与循环重排、分块优化结合使用
-
----
-
-## 常见错误
-
-```python
-# ❌ 错误：索引依赖内层变量，不能外提
-for outer in range(N):
-    for inner in range(M):
-        val = tl.load(ptr + outer + inner)  # inner 在索引中
-        ...
-
-# ✅ 正确：这种情况下不能外提
-```
-
-```python
-# ❌ 错误：外提后逻辑变了
-for c in range(C):
-    w = tl.load(weight_ptr + c)
-    for s in range(S):
-        x = tl.load(input_ptr + c * S + s)
-        # 如果原来有 mask 条件，外提后可能访问越界
-
-# ✅ 正确：确保外提后不会越界
-for c in range(C):
-    if c < valid_channels:  # 添加条件判断
-        w = tl.load(weight_ptr + c)
-    for s in range(S):
-        ...
-```