@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/kernel-splitting/broadcast-elemwise-split.md

@@ -1,303 +0,0 @@
----
-id: skill-ascend-broadcast-elemwise-split
-title: "Broadcast Elementwise Kernel Splitting Strategy"
-type: skill
-vendor: ascend
-tags:
-- triton-ascend
-- kernel-splitting
-evidence_level: spec
-applies_to:
-- ascend910b
-source:
-- path: local
-  anchor: AscendOpGenAgent/skills
-architectures:
-- ascend910b
-languages:
-- triton-ascend
-techniques:
-- kernel-splitting
----
-# 广播逐元素算子 Kernel 分裂经验
-
-## 1. 分组维度
-
-| 维度 | 判定条件 | 分组 |
-|------|---------|------|
-| **是否广播** | `x.shape == y.shape` | 无广播 / 有广播 |
-| **广播维度位置** | `broadcast_dims` 位置 | dim0 / dim1 / 多维 |
-| **输出维度数** | `out_ndim` | 2D / 3D / 4D |
-
----
-
-## 2. 无广播特化
-
-### 2.1 适用场景
-`x.shape == y.shape`，纯逐元素操作，无广播开销。
-
-### 2.2 Kernel 实现
-
-```python
-@triton.jit
-def add_no_broadcast_kernel(
-    x_ptr, y_ptr, out_ptr, n_elements, alpha,
-    BLOCK_SIZE: tl.constexpr
-):
-    pid = tl.program_id(0)
-    num_blocks = tl.cdiv(n_elements, BLOCK_SIZE)
-    blocks_per_core = tl.cdiv(num_blocks, tl.num_programs(0))
-    start_block = pid * blocks_per_core
-    end_block = min(start_block + blocks_per_core, num_blocks)
-
-    for block_idx in range(start_block, end_block):
-        offsets = block_idx * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
-        mask = offsets < n_elements
-
-        x = tl.load(x_ptr + offsets, mask=mask, other=0.0)
-        y = tl.load(y_ptr + offsets, mask=mask, other=0.0)
-        out = x + alpha * y
-
-        tl.store(out_ptr + offsets, out, mask=mask)
-```
-
-### 2.3 关键优化点
-
-| 优化点 | 做法 | 收益 |
-|-------|------|------|
-| **大 BLOCK** | 推荐范围 `4096~16384`，通过 autotune 选择 | 充分利用带宽 |
-| **Grid 动态** | `grid = (min(tl.cdiv(n_elements, BLOCK_SIZE), VEC_CORE_NUM),)` | 避免过度并行 |
-| **循环分块** | `blocks_per_core` 分配 | 每个 core 处理多个 block |
-
----
-
-## 3. 2D 广播特化
-
-### 3.1 适用场景
-2D 张量，`y` 在某一维度上广播（如 `y=[M,1]` 或 `y=[1,N]`）。
-
-### 3.2 Broadcast Dim1（`y=[M,1]`）
-
-```python
-@triton.jit
-def add_broadcast_2d_dim1_kernel(
-    x_ptr, y_ptr, out_ptr, M, N, alpha,
-    BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr
-):
-    pid = tl.program_id(0)
-    num_blocks_m = tl.cdiv(M, BLOCK_M)
-    num_blocks_n = tl.cdiv(N, BLOCK_N)
-    num_blocks = num_blocks_m * num_blocks_n
-    blocks_per_core = tl.cdiv(num_blocks, tl.num_programs(0))
-    start_block = pid * blocks_per_core
-    end_block = min(start_block + blocks_per_core, num_blocks)
-
-    for block_idx in range(start_block, end_block):
-        bm = block_idx // num_blocks_n
-        bn = block_idx % num_blocks_n
-        row_offs = bm * BLOCK_M + tl.arange(0, BLOCK_M)
-        col_offs = bn * BLOCK_N + tl.arange(0, BLOCK_N)
-        row_mask = row_offs < M
-        col_mask = col_offs < N
-        mask_2d = row_mask[:, None] & col_mask[None, :]
-
-        x = tl.load(x_ptr + row_offs[:, None] * N + col_offs[None, :], mask=mask_2d, other=0.0)
-        y = tl.load(y_ptr + row_offs[:, None], mask=row_mask[:, None], other=0.0)
-        out = x + alpha * y
-
-        tl.store(out_ptr + row_offs[:, None] * N + col_offs[None, :], out, mask=mask_2d)
-```
-
-### 3.3 Broadcast Dim0（`y=[1,N]`）
-
-```python
-# y load 改为 1D 列维度
-y = tl.load(y_ptr + col_offs, mask=col_mask, other=0.0)
-```
-
-### 3.4 关键优化点
-
-| 优化点 | 做法 | 收益 |
-|-------|------|------|
-| **2D tiling** | `BLOCK_M` 推荐 `4~16`，`BLOCK_N` 推荐 `512~2048`，通过 autotune 选择 | 匹配广播模式 |
-| **广播 load** | `y` 仅加载一次，利用 broadcast 语义 | 减少内存访问 |
-| **2D mask** | `row_mask[:, None] & col_mask[None, :]` | 精确边界处理 |
-
----
-
-## 4. 通用高维广播特化
-
-### 4.1 适用场景
-3D/4D 张量，广播模式复杂，不适合在 kernel 内处理。
-
-### 4.2 特化策略
-Host 端 `expand + contiguous + view(-1)`，退化为 1D kernel。
-
-### 4.3 Kernel 实现
-
-```python
-@triton.jit
-def add_broadcast_1d_kernel(
-    x_ptr, y_ptr, out_ptr, n_elements, alpha,
-    BLOCK_SIZE: tl.constexpr
-):
-    pid = tl.program_id(0)
-    num_blocks = tl.cdiv(n_elements, BLOCK_SIZE)
-    blocks_per_core = tl.cdiv(num_blocks, tl.num_programs(0))
-    start_block = pid * blocks_per_core
-    end_block = min(start_block + blocks_per_core, num_blocks)
-
-    for block_idx in range(start_block, end_block):
-        offsets = block_idx * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
-        mask = offsets < n_elements
-
-        x = tl.load(x_ptr + offsets, mask=mask, other=0.0)
-        y = tl.load(y_ptr + offsets, mask=mask, other=0.0)
-        out = x + alpha * y
-
-        tl.store(out_ptr + offsets, out, mask=mask)
-```
-
-### 4.4 Host 端预处理
-
-```python
-out_shape = torch.broadcast_shapes(x.shape, y.shape)
-x_expanded = x.expand(out_shape).contiguous().view(-1)
-y_expanded = y.expand(out_shape).contiguous().view(-1)
-output = torch.empty(out_shape, dtype=x.dtype, device=x.device)
-out_flat = output.view(-1)
-
-n_elements = out_flat.numel()
-# BLOCK_SIZE 和 grid 通过 autotune 或动态计算
-BLOCK_SIZE = 8192  # 推荐初始值，可 autotune
-num_blocks = triton.cdiv(n_elements, BLOCK_SIZE)
-grid_size = min(num_blocks, self.VEC_CORE_NUM)
-add_broadcast_1d_kernel[grid_size](
-    x_expanded, y_expanded, out_flat, n_elements, alpha, BLOCK_SIZE
-)
-```
-
-### 4.5 关键优化点
-
-| 优化点 | 做法 | 收益 |
-|-------|------|------|
-| **Host 端展平** | 利用 PyTorch 的 `expand` 处理广播 | kernel 简化为 1D |
-| **内存连续化** | `contiguous()` 确保线性访存 | 避免跨步访存 |
-| **复用 1D kernel** | 与无广播路径共享 kernel 代码 | 减少代码量 |
-
----
-
-## 5. 广播信息提取
-
-```python
-def _get_broadcast_info(self, x_shape, y_shape):
-    if x_shape == y_shape:
-        return len(x_shape), [], False
-
-    max_ndim = max(len(x_shape), len(y_shape))
-    x_padded = [1] * (max_ndim - len(x_shape)) + list(x_shape)
-    y_padded = [1] * (max_ndim - len(y_shape)) + list(y_shape)
-
-    out_shape = []
-    broadcast_dims = []
-    for i in range(max_ndim):
-        if x_padded[i] == y_padded[i]:
-            out_shape.append(x_padded[i])
-        elif x_padded[i] == 1:
-            out_shape.append(y_padded[i])
-        elif y_padded[i] == 1:
-            out_shape.append(x_padded[i])
-            broadcast_dims.append(i)
-        else:
-            raise ValueError(f"Incompatible shapes: {x_shape}, {y_shape}")
-
-    return len(out_shape), tuple(broadcast_dims), True
-```
-
----
-
-## 6. 分组建议与参数范围
-
-| Case 特征 | 推荐 Kernel | BLOCK 范围 | 推荐 autotune 配置 |
-|----------|------------|-----------|-------------------|
-| `x.shape == y.shape` | no-broadcast | `BLOCK_SIZE: [4096, 8192, 16384]` | `@triton.autotune(configs=[...], key=['n_elements'])` |
-| 2D, `y` 在 dim1 广播 | broadcast-2d-dim1 | `BLOCK_M: [4, 8, 16], BLOCK_N: [512, 1024, 2048]` | `@triton.autotune(configs=[...], key=['M', 'N'])` |
-| 2D, `y` 在 dim0 广播 | broadcast-2d-dim0 | `BLOCK_M: [4, 8, 16], BLOCK_N: [512, 1024, 2048]` | `@triton.autotune(configs=[...], key=['M', 'N'])` |
-| 3D/4D 任意广播 | generic-1d | `BLOCK_SIZE: [4096, 8192, 16384]` | `@triton.autotune(configs=[...], key=['n_elements'])` |
-
----
-
-## 7. 调度器实现
-
-```python
-class ModelNew(nn.Module):
-    def __init__(self):
-        super().__init__()
-        try:
-            self.VEC_CORE_NUM = torch_npu.npu.npu_config.get_device_limit(0).get("vector_core_num", 40)
-        except Exception:
-            self.VEC_CORE_NUM = 40
-
-    def _get_broadcast_info(self, x_shape, y_shape):
-        # ... 同上 ...
-
-    def forward(self, x: torch.Tensor, y: torch.Tensor, alpha: float = 1.0) -> torch.Tensor:
-        return self._route(x, y, alpha)
-
-    def _route(self, x: torch.Tensor, y: torch.Tensor, alpha: float = 1.0) -> torch.Tensor:
-        out_ndim, broadcast_dims, is_broadcast = self._get_broadcast_info(x.shape, y.shape)
-
-        if not is_broadcast:
-            if not x.is_contiguous(): x = x.contiguous()
-            if not y.is_contiguous(): y = y.contiguous()
-            output = torch.empty_like(x)
-            n_elements = x.numel()
-
-            # BLOCK_SIZE 可通过 autotune 选择，此处为推荐初始值
-            BLOCK_SIZE = 8192
-            grid = (min(triton.cdiv(n_elements, BLOCK_SIZE), self.VEC_CORE_NUM),)
-            add_no_broadcast_kernel[grid](x, y, output, n_elements, alpha, BLOCK_SIZE)
-            return output
-
-        # === 广播路由 ===
-        key = (out_ndim, broadcast_dims)
-
-        if key == (2, (1,)):
-            output = torch.empty_like(x)
-            M, N = x.shape
-            BLOCK_M, BLOCK_N = 8, 1024  # 推荐初始值，可 autotune
-            num_blocks_m = triton.cdiv(M, BLOCK_M)
-            num_blocks_n = triton.cdiv(N, BLOCK_N)
-            grid = (min(num_blocks_m * num_blocks_n, self.VEC_CORE_NUM),)
-            add_broadcast_2d_dim1_kernel[grid](x, y, output, M, N, alpha, BLOCK_M, BLOCK_N)
-            return output
-
-        elif key == (2, (0,)):
-            output = torch.empty_like(x)
-            M, N = x.shape
-            BLOCK_M, BLOCK_N = 8, 1024
-            num_blocks_m = triton.cdiv(M, BLOCK_M)
-            num_blocks_n = triton.cdiv(N, BLOCK_N)
-            grid = (min(num_blocks_m * num_blocks_n, self.VEC_CORE_NUM),)
-            add_broadcast_2d_dim0_kernel[grid](x, y, output, M, N, alpha, BLOCK_M, BLOCK_N)
-            return output
-
-        else:
-            out_shape = torch.broadcast_shapes(x.shape, y.shape)
-            x_expanded = x.expand(out_shape).contiguous().view(-1)
-            y_expanded = y.expand(out_shape).contiguous().view(-1)
-            output = torch.empty(out_shape, dtype=x.dtype, device=x.device)
-            out_flat = output.view(-1)
-
-            n_elements = out_flat.numel()
-            BLOCK_SIZE = 8192
-            grid = (min(triton.cdiv(n_elements, BLOCK_SIZE), self.VEC_CORE_NUM),)
-            add_broadcast_1d_kernel[grid](x_expanded, y_expanded, out_flat, n_elements, alpha, BLOCK_SIZE)
-            return output
-```
-
-**关键设计**：
-- **Key 匹配**：`(out_ndim, broadcast_dims)` 元组作为路由 key
-- **内联分支**：每个分支直接写 kernel 调用
-- **Host 预处理**：3D/4D 走 `expand + contiguous + view(-1)` 路径
-- **参数可调**：BLOCK 值为推荐初始值，支持 `@triton.autotune` 自动调优

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/wiki/ascend/techniques/kernel-splitting/reduce-split.md

@@ -1,255 +0,0 @@
----
-id: skill-ascend-reduce-split
-title: "Reduce Operator Kernel Splitting Strategy"
-type: skill
-vendor: ascend
-tags:
-- triton-ascend
-- kernel-splitting
-evidence_level: spec
-applies_to:
-- ascend910b
-source:
-- path: local
-  anchor: AscendOpGenAgent/skills
-architectures:
-- ascend910b
-languages:
-- triton-ascend
-techniques:
-- kernel-splitting
----
-# Reduce 类算子 Kernel 分裂经验
-
-## 1. 分组维度
-
-| 维度 | 判定条件 | 分组 |
-|------|---------|------|
-| **Reduce 轴位置** | `inner_size == 1` vs `inner_size > 1` | reduce-last / reduce-non-last |
-| **Reduce 规模** | `reduce_size < 256` / `256~4096` / `>4096` | 小/中/大 |
-| **数据类型** | fp16/bf16/fp32 | 不同精度需不同向量化策略 |
-
----
-
-## 2. Reduce-Last 特化（`inner_size == 1`）
-
-### 2.1 适用场景
-Reduce 轴在最后维度，数据在内存中连续，可直接线性访存。
-
-### 2.2 Kernel 实现
-
-```python
-@triton.jit
-def sum_kernel_reduce_last(
-    input_ptr, output_ptr,
-    outer_size, reduce_size,
-    BLOCK_RED: tl.constexpr,
-):
-    pid = tl.program_id(0)
-    num_pids = tl.num_programs(0)
-
-    # Grid 动态分配：按 VEC_CORE_NUM 限制
-    tiles_per_pid = (outer_size + num_pids - 1) // num_pids
-    tile_start = pid * tiles_per_pid
-    tile_end = tl.minimum(tile_start + tiles_per_pid, outer_size)
-
-    for outer_idx in range(tile_start, tile_end):
-        acc = tl.full((), 0.0, tl.float32)
-        base_offset = outer_idx * reduce_size
-
-        # 沿 reduce 轴分块累加
-        for r_start in range(0, reduce_size, BLOCK_RED):
-            r_end = tl.minimum(r_start + BLOCK_RED, reduce_size)
-            r_offsets = r_start + tl.arange(0, BLOCK_RED)
-            r_mask = r_offsets < r_end
-
-            vals = tl.load(input_ptr + base_offset + r_offsets, mask=r_mask, other=0.0)
-            vals = vals.to(tl.float32)
-            acc += tl.sum(vals, axis=0)
-
-        tl.store(output_ptr + outer_idx, acc.to(output_ptr.dtype.element_ty))
-```
-
-### 2.3 关键优化点
-
-| 优化点 | 做法 | 收益 |
-|-------|------|------|
-| **连续访存** | `base_offset + r_offsets` 线性偏移，无 stride | 最大化内存带宽利用率 |
-| **固定 constexpr** | `BLOCK_RED` 声明为 constexpr | 编译期优化，消除运行时分支 |
-| **Grid 限制** | `grid = (min(outer_size, VEC_CORE_NUM),)` | 避免过度并行导致调度开销 |
-| **标量累加器** | `acc = tl.full((), 0.0, tl.float32)` | 单值累加，减少寄存器压力 |
-
-### 2.4 Grid 配置
-
-```python
-grid = (min(outer_size, self.VEC_CORE_NUM),)
-sum_kernel_reduce_last[grid](
-    x, output,
-    outer_size, reduce_size,
-    BLOCK_RED=1024,
-)
-```
-
----
-
-## 3. Reduce-Non-Last 特化（`inner_size > 1`）
-
-### 3.1 适用场景
-Reduce 轴不在最后维度，需要 2D tile 策略同时处理 reduce 轴和 inner 轴。
-
-### 3.2 Kernel 实现
-
-```python
-@triton.jit
-def sum_kernel_reduce_non_last(
-    input_ptr, output_ptr,
-    outer_size, reduce_size, inner_size,
-    BLOCK_RED: tl.constexpr,
-    BLOCK_INNER: tl.constexpr,
-):
-    pid = tl.program_id(0)
-    num_pids = tl.num_programs(0)
-
-    # 2D tile 映射：outer × inner 展平为 1D grid
-    inner_tiles = (inner_size + BLOCK_INNER - 1) // BLOCK_INNER
-    total_tiles = outer_size * inner_tiles
-
-    tiles_per_pid = (total_tiles + num_pids - 1) // num_pids
-    tile_start = pid * tiles_per_pid
-    tile_end = tl.minimum(tile_start + tiles_per_pid, total_tiles)
-
-    for tile_idx in range(tile_start, tile_end):
-        outer_idx = tile_idx // inner_tiles
-        inner_tile = tile_idx % inner_tiles
-        inner_start = inner_tile * BLOCK_INNER
-        inner_end = tl.minimum(inner_start + BLOCK_INNER, inner_size)
-        inner_len = inner_end - inner_start
-
-        # 向量累加器：shape = (BLOCK_INNER,)
-        acc = tl.zeros((BLOCK_INNER,), dtype=tl.float32)
-        base_offset = outer_idx * reduce_size * inner_size + inner_start
-
-        for r_start in range(0, reduce_size, BLOCK_RED):
-            r_end = tl.minimum(r_start + BLOCK_RED, reduce_size)
-
-            # 2D offset 计算
-            r_offs = r_start + tl.arange(0, BLOCK_RED)[:, None]
-            i_offs = tl.arange(0, BLOCK_INNER)[None, :]
-            in_offsets = base_offset + r_offs * inner_size + i_offs
-
-            mask_r = r_offs < r_end
-            mask_i = i_offs < inner_len
-            mask = mask_r & mask_i
-
-            vals = tl.load(input_ptr + in_offsets, mask=mask, other=0.0)
-            vals = vals.to(tl.float32)
-            acc += tl.sum(vals, axis=0)
-
-        # 2D store
-        out_base = outer_idx * inner_size + inner_start
-        out_offsets = out_base + tl.arange(0, BLOCK_INNER)
-        out_mask = tl.arange(0, BLOCK_INNER) < inner_len
-        tl.store(output_ptr + out_offsets, acc.to(output_ptr.dtype.element_ty), mask=out_mask)
-```
-
-### 3.3 关键优化点
-
-| 优化点 | 做法 | 收益 |
-|-------|------|------|
-| **2D tiling** | 同时 tile reduce 轴和 inner 轴 | 充分利用并行度 |
-| **向量累加器** | `acc = tl.zeros((BLOCK_INNER,), dtype=tl.float32)` | 批量累加，减少循环次数 |
-| **Offset 计算** | `r_offs * inner_size + i_offs` 二维广播 | 精确映射 2D 内存布局 |
-| **Grid 计算** | `total_tiles = outer_size * inner_tiles` | 按 `VEC_CORE_NUM` 限制 |
-
-### 3.4 Grid 配置
-
-```python
-inner_tiles = (inner_size + 63) // 64
-total_tiles = outer_size * inner_tiles
-grid = (min(total_tiles, self.VEC_CORE_NUM),)
-sum_kernel_reduce_non_last[grid](
-    x, output,
-    outer_size, reduce_size, inner_size,
-    BLOCK_RED=64,
-    BLOCK_INNER=64,
-)
-```
-
----
-
-## 4. 分组建议
-
-| Case 特征 | 推荐 Kernel | BLOCK 配置 |
-|----------|------------|-----------|
-| `inner_size == 1`, reduce_size 任意 | reduce-last | `BLOCK_RED=1024` |
-| `inner_size > 1`, reduce_size ≤ 256 | reduce-non-last | `BLOCK_RED=64, BLOCK_INNER=64` |
-| `inner_size > 1`, reduce_size > 256 | reduce-non-last | `BLOCK_RED=128, BLOCK_INNER=32` |
-
----
-
-## 5. 调度器实现
-
-```python
-class ModelNew(nn.Module):
-    def __init__(self):
-        super(ModelNew, self).__init__()
-        try:
-            self.VEC_CORE_NUM = torch_npu.npu.npu_config.get_device_limit(0).get("vector_core_num", 40)
-        except Exception:
-            self.VEC_CORE_NUM = 40
-
-    def forward(self, x: torch.Tensor, dim=None, keepdim: bool = False) -> torch.Tensor:
-        return self._route(x, dim, keepdim)
-
-    def _route(self, x: torch.Tensor, dim=None, keepdim: bool = False) -> torch.Tensor:
-        original_dim = dim
-        if dim is None:
-            x = x.reshape(1, -1)
-            dim = 1
-        if dim < 0:
-            dim = x.ndim + dim
-
-        shape = x.shape
-        outer_size = math.prod(shape[:dim]) if dim > 0 else 1
-        reduce_size = shape[dim]
-        inner_size = math.prod(shape[dim + 1:]) if dim + 1 < x.ndim else 1
-
-        if keepdim:
-            out_shape = list(shape)
-            out_shape[dim] = 1
-        else:
-            out_shape = list(shape[:dim]) + list(shape[dim + 1:])
-
-        output = torch.empty(out_shape, dtype=x.dtype, device=x.device)
-
-        # === 路由决策 ===
-        if inner_size == 1:
-            # reduce-last: 直接沿 reduce 轴连续访存
-            grid = (min(outer_size, self.VEC_CORE_NUM),)
-            sum_kernel_reduce_last[grid](
-                x, output,
-                outer_size, reduce_size,
-                BLOCK_RED=1024,
-            )
-        else:
-            # reduce-non-last: 2D tile 策略
-            inner_tiles = (inner_size + 63) // 64
-            total_tiles = outer_size * inner_tiles
-            grid = (min(total_tiles, self.VEC_CORE_NUM),)
-            sum_kernel_reduce_non_last[grid](
-                x, output,
-                outer_size, reduce_size, inner_size,
-                BLOCK_RED=64,
-                BLOCK_INNER=64,
-            )
-
-        if original_dim is None and not keepdim:
-            output = output.squeeze()
-
-        return output
-```
-
-**关键设计**：
-- **无字典映射**：直接用 `if-else` 分支，零开销
-- **内联 grid 计算**：每个分支独立计算 grid
-- **constexpr 固定**：BLOCK 值硬编码