@cannbot-plugin/cannbot-harness 0.0.0-stage → 0.1.4

package/assets/ops-direct-invoke/skills/ascendc-tiling-design/references/sort/patterns.md

@@ -0,0 +1,249 @@
+# Sort 类算子场景路由
+
+> 本文档用于**场景判定**和**方案选择**。确定场景后，按链接进入对应详细文档。
+
+---
+
+## 1. 归并排序原理
+
+### 1.1 分治思想
+
+归并排序（Merge Sort）的核心是**分治**（Divide and Conquer）：
+
+```
+Divide:   将无序序列递归拆分为子序列，直至子序列长度为 1（自然有序）
+Conquer:  将有序子序列两两归并，逐层合并为更大的有序序列
+```
+
+```
+无序序列: [5, 3, 8, 1, 9, 2, 7, 4]
+        ↓ Divide
+        [5,3,8,1]   [9,2,7,4]
+        ↓ Divide
+      [5,3] [8,1]   [9,2] [7,4]
+        ↓ Divide
+     [5] [3] [8] [1] [9] [2] [7] [4]    ← 长度为 1，自然有序
+        ↓ Conquer (归并)
+      [3,5] [1,8]   [2,9] [4,7]
+        ↓ Conquer
+        [1,3,5,8]   [2,4,7,9]
+        ↓ Conquer
+        [1,2,3,4,5,7,8,9]
+```
+
+> 稳定排序：归并排序是**稳定排序**——相同值的元素，归并后保持原始相对顺序。
+
+### 1.2 M-way 归并
+
+AscendC 的 `MrgSort` API 支持 **M 路归并**（`MRG_SORT_ELEMENT_LEN`，通常 M=4），即一次 API 调用可将 M 路有序数列归并为一个有序数列。
+
+```
+输入：M 路各自有序的数列
+    list0: [a0, a1, a2, ...]  (有序)
+    list1: [b0, b1, b2, ...]  (有序)
+    ...
+    list(M-1): [...]
+
+MrgSort M-way → 输出：归并后的一条有序数列
+```
+
+### 1.3 并行排序归并策略
+
+当数据量超过 UB 容量时，单次 Sort 无法处理全部数据。此时利用归并排序的分治特性，结合多核并行能力：
+
+```
+大数据集 → 按 UB 容量切分为多个 tile → 各核并行排序 tile（Divide）
+         → 多核多轮归并（Conquer）→ 最终有序结果
+```
+
+```
+GM (Global Memory)
+  ↓ DataCopy
+UB (Unified Buffer, 大小 = ubSize)  ← Sort/MrgSort 操作在 UB 内执行
+  ↓ Sort/MrgSort API
+UB → GM (输出)
+```
+
+关键认知：**UB 容量决定了一次能排序多少元素，进而决定了需要多少层级归并**——数据量越大，需要的归并层级越多，方案越复杂。超出 UB 容量的数据必须拆分为多个 **tile**，分别排序后再归并。
+
+---
+
+## 2. 核心约束：UB 内存
+
+### 2.1 UB 容量
+
+```
+ubSize = GetPlatformInfo().GetUbSize()   // 从平台信息获取，不同芯片取值不同
+```
+
+### 2.2 排序操作的 UB 空间占用模型
+
+**每元素 UB 占用**：
+
+```
+concatTmpPerElem = GetConcatTmpSize(platform, t, sizeof(float)) / t
+sortTmpPerElem   = GetSortTmpSize(platform, t, sizeof(float)) / t
+sortBytesPerElem = sizeof(dtype) + sizeof(float) + sizeof(uint32_t) + PROPOSAL_SIZE
+                   + concatTmpPerElem + sortTmpPerElem
+```
+
+以常见 dtype 为例（实践中 `concatTmpPerElem ≈ sortTmpPerElem ≈ sizeof(float) * 2 = 8B`）：
+
+| dtype | sizeof(dtype) | sortBytesPerElem 近似值 |
+|-------|--------------|----------------------|
+| float16/bf16 | 2B | 2 + 4 + 4 + 8 + 8 + 8 = **34B** |
+| float32 | 4B | 4 + 4 + 8 + 8 + 8 = **32B** |
+
+> **注意**：若输入 dtype 为 float32，则无需 Cast，UB 中可省去类型转换 buffer，此时 `sortBytesPerElem = sizeof(float) + sizeof(uint32_t) + PROPOSAL_SIZE + concatTmpPerElem + sortTmpPerElem`（≈ 32B）。设计方案时需根据实际 dtype 组合确定公式。`concatTmpPerElem` 和 `sortTmpPerElem` 应以 API 返回值为准，不以上述近似值为准。
+
+**Sort 排序 UB 总空间分配**：
+
+假设单次 UB 中处理 `elemCount` 个元素，则单次 Sort 操作需要在 UB 中同时容纳以下 buffer：
+
+| Buffer | 大小（元素数 × 单元素字节） | 说明 |
+|--------|--------------------------|------|
+| 输入数据 | `elemCount × sizeof(dtype)` | 原始输入，dtype = float16/bf16/float32 等 |
+| 类型转换（可选） | `elemCount × sizeof(float)` | `Cast(dtype → float)`，Sort API 要求 float 输入 |
+| 索引数组 | `elemCount × sizeof(uint32_t)` | `ArithProgression` 生成的索引 |
+| Concat tmp buffer | `GetConcatTmpSize(platform, elemCount, sizeof(float))` | `Concat` API 将 value+index 合成为 proposal 所需的临时 buffer，大小由 API 接口获取 |
+| Sort tmp buffer | `GetSortTmpSize(platform, elemCount, sizeof(float))` | `Sort` API 排序所需的临时 buffer，大小由 API 接口获取 |
+| Sort 输出 | `elemCount × PROPOSAL_SIZE` | Sort 输出，proposal 格式（value + index = 8B） |
+
+其中 `PROPOSAL_SIZE = 8`（1 个 proposal = 4B value + 4B index），`PROPOSAL_FACTOR = 4`（proposal 大小因子，详见 API 文档）。
+
+> **关键**：Concat tmp buffer 和 Sort tmp buffer 的大小**必须通过 API 接口获取**（`GetConcatTmpSize` / `GetSortTmpSize`），不应手动估算。与 `ubSize` 一样，它们取决于平台实现，不同芯片版本可能有差异。
+
+### 2.3 UB 容量对 tileSize 的约束
+
+单次 Sort 操作的 UB 约束：
+
+```
+elemCount × sortBytesPerElem ≤ ubSize
+```
+
+由此推导 **elemCount 的理论上限**，又称为 **tileSize**：
+
+```
+tileSize = elemCount_max = ubSize / sortBytesPerElem
+```
+
+tileSize 需对齐到 Sort API 要求的粒度（`TOPK_SORT_NUM = 32`）：
+
+```
+tileSize = floor(tileSize / 32) × 32
+```
+
+工程实践中 tileSize 通常取小于理论最大值的固定值（如 4096，这也是实测性能最优值），留出 UB 余量给对齐填充和 API 内部峰值开销。
+
+---
+
+## 3. 场景建模
+
+### 3.1 输入变量
+
+| 变量 | 含义 | 来源 |
+|------|------|------|
+| `N` | 总元素数 | 输入 shape |
+| `dtype` | 数据类型 | 输入参数（float16/float32 等） |
+| `K` | Top-K 值 | 输入参数 |
+| `M` | 归并路数 | `MRG_SORT_ELEMENT_LEN`（通常 = 4） |
+| `coreNum` | 可用核数 | 硬件规格 / tiling 计算 |
+| `ubSize` | UB 大小 | `GetPlatformInfo().GetUbSize()` |
+
+### 3.2 Pattern 划分
+
+根据上述约束，由tileSize 和 coreNum 的关系划分出三种 Pattern：
+
+- 当 N ≤ tileSize 时：只需要单核处理 1 个 tile，可直接使用 `Sort` API 实现排序并输出
+- 当 tileSize < N ≤ tileSize × coreNum 时：每个核至多处理 1 个 tile，排序后直接进入跨核归并——即**一级归并**
+- 当 N > tileSize × coreNum 时：每个核需处理多个 tile，必须先核内归并再跨核归并——即**两级归并**
+
+---
+
+#### 3.2.1 Pattern A：单核排序
+
+**判定条件**：`N ≤ tileSize`
+
+**特征**：数据量不超单次 Sort 的 UB 容量，无需 tile 切分。
+
+**方案**：单核调用 `Sort<T, true>` 完成排序，数据流为 `GM → UB → Sort → GM`。
+
+> **详细设计**：Pattern A 的具体方案见相关设计文档（待补充）。
+
+---
+
+#### 3.2.2 Pattern B：多核一级归并
+
+**判定条件**：`tileSize < N ≤ tileSize × coreNum`
+
+**特征**：数据需要多核分担，但每个核最多处理 1 个 tile（`ceil(N/tileSize) ≤ coreNum`）。核内无需多 tile 归并——各核排序后直接跨核归并。
+
+**方案**：
+```
+各核并行排序自己的 tile → 跨核归并（将 usedCoreNum 路有序数列合并为最终结果）
+```
+
+> **详细设计**：Pattern B 的具体方案见相关设计文档（待补充）。
+
+---
+
+#### 3.2.3 Pattern C：多核两级归并
+
+**判定条件**：`tileSize × coreNum < N`
+
+**特征**：数据量超过多核单 tile 覆盖范围，每个核需处理多个 tile。必须使用**两级归并**：
+- **第一级**：各核内部对自己的多个 tile 进行归并，输出 1 个有序数列
+- **第二级**：将 coreNum 个有序数列跨核归并，最终输出 Top-K 结果
+
+**方案概要**：
+```
+各核并行排序多个 tile → 各核独立多 tile 归并(第一级) → 跨核归并(第二级) → 最终输出 K 个元素到 GM
+```
+
+**与 Pattern B 的关键区别**：新增了各核独立的多 tile 归并环节。
+**关键设计：减少 SyncAll 开销**：为什么不能将各核的所有 tile 直接进行跨核归并？跨核归并每一轮都需要 `SyncAll` 等待所有核完成，而核内归并完全不需要。若跳过第一级直接将 `totalTiles` 个 tile 跨核归并，归并轮次 = `ceil(log_M(totalTiles))`，每轮一次 SyncAll，开销不可接受。先在各核内部归并可将待归并路数从 `totalTiles` 降至 `coreNum`，大幅减少跨核归并轮次和 SyncAll 次数。
+
+**→ 详细方案设计见 [alg-two-level-mrgsort.md](alg-two-level-mrgsort.md)**
+
+---
+
+## 4. 决策树
+
+```
+给定: N(总元素数), dtype(数据类型), coreNum(可用核数), K(Top-K值), ubSize(UB大小)
+
+Step 1: 计算 tileSize
+  tileSize = ubSize / sortBytesPerElem，对齐到 32，工程建议取值 4096
+
+Step 2: 比较 N 与 tileSize
+  ├─ N ≤ tileSize
+  │   → Pattern A: 单核排序
+  │     数据不超 UB 容量，单核 Sort 一次完成
+  │
+  └─ N > tileSize
+      └─ 比较 N 与 tileSize × coreNum
+          ├─ N ≤ tileSize × coreNum
+          │   → Pattern B: 多核一级归并
+          │     每核 ≤1 个 tile，无需核内多 tile 归并
+          │
+          └─ N > tileSize × coreNum
+              → Pattern C: 多核两级归并
+                每核 >1 个 tile，需两级归并
+                → 详见 [alg-two-level-mrgsort.md](alg-two-level-mrgsort.md)
+```
+
+**数值示例**（float16, tileSize=4096, coreNum=20）：
+
+| N | tileSize×coreNum 阈值 | 判定 | 方案 |
+|---|----------------------|------|------|
+| 2,000 | 81,920 | N ≤ 4096 | Pattern A |
+| 50,000 | 81,920 | 4096 < N ≤ 81,920 | Pattern B |
+| 500,000 | 81,920 | N > 81,920 | Pattern C → [alg-two-level-mrgsort.md](alg-two-level-mrgsort.md) |
+
+---
+
+## 子场景参考
+
+| 主题 | 文档 |
+|------|------|
+| Pattern C 详细方案设计 | [alg-two-level-mrgsort.md](alg-two-level-mrgsort.md) |

package/assets/ops-direct-invoke/skills/ascendc-ut-develop/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: ascendc-ut-develop
+description: Ascend C 算子 UT 开发与覆盖率增强技能。通过分析 op_host / op_api / op_kernel 的测试空白、生成或补充 UT 用例并定位未覆盖代码来提升覆盖率并支持生成覆盖率报告。当用户提及 UT、单元测试、覆盖率、补测、未覆盖代码或需要新增/完善 UT 时使用，不适用于 ST 测试。
+---
+
+# AscendC 算子 UT 开发
+
+## 入口参数
+
+| 参数名 | 含义 | 取值约束 | 初值推断 |
+|-------|------|---------|---------|
+| op_name | 算子名 | 采用下划线命名法 | 驼峰命名自动转换，无法推断时询问 |
+| repo_type | 仓库类型 | 枚举值["ops-math", "ops-nn", "ops-transformer", "ops-cv", "custom"] | 根据工作目录推断，无法推断时询问 |
+| soc_type | 芯片架构 | 枚举值列表["ascend310p", "ascend910b", "ascend910_93", "ascend950"] | 用户没有提及则默认全选 |
+| test_model | 测试模块 | 枚举值列表["opapi", "ophost", "opkernel"] | 用户没有提及则默认全选 |
+| interactive_mode | 使用模式 | 枚举值["auto", "interactive"]，auto 为自动模式不向用户问询，interactive 为交互模式允许向用户问询 | 默认 "auto" |
+
+**格式约定**：整个 skill 里的所有文档中，入口参数使用 `${参数名}` 标记，需替换为真实值后再理解。
+
+**调用方式**：必须以 `repo_type=custom` 模式调用本技能（跳过问卷，走 0.1.2 自定义工程快速通道）。
+
+---
+
+## ⚠️ 强制前置步骤（**不可跳过**）
+
+> - **这是强制步骤，必须在执行主流程前完成！**
+> - **在此步骤完成前，禁止阅读任何 references/ 目录下的文档和当前工作目录下的文件！**
+> - **子步骤必须逐一执行，不允许同时执行或跳步！**
+
+### 0.1 发送问卷确认入口参数
+
+根据"初值推断"规则，尝试获取所有入口参数的值（仅根据已有上下文简单推断，**不阅读具体代码和子目录**）。
+
+#### 0.1.0 仓库类型自动检测
+
+**在执行问卷前，必须先确定项目路径，然后检测仓名**：
+
+1. **优先从用户消息中提取项目路径**（如用户明确指定了路径）
+2. **用户未指定时，使用 `pwd` 获取当前工作目录**
+3. 基于最终确定的项目路径进行仓名匹配
+
+检查路径的**目录组件**（以 `/` 分隔的路径段）是否**完全等于**以下标准仓名之一：`ops-math`、`ops-nn`、`ops-transformer`、`ops-cv`
+
+> **⚠️ 必须是精确的目录名匹配，禁止子串匹配。** 例如路径 `/home/user/ops-math-utils` 中的 `ops-math-utils` 不等于 `ops-math`，应判定为 custom。
+
+**判断逻辑：**
+
+| 检测结果 | repo_type | interactive_mode | 后续行为 |
+|---------|-----------|-----------------|---------|
+| 路径中存在完全等于标准仓名的目录段 | 匹配到的仓名 | 按默认值 "auto" | 进入 **0.1.1 标准确认流程** |
+| 路径中不存在完全等于标准仓名的目录段 | `"custom"` | `"auto"` | 进入 **0.1.2 自定义工程快速通道** |
+
+#### 0.1.1 标准确认流程（路径匹配到标准仓名）
+
+**立即**使用 `question` 工具，向用户确认入口参数是否正确，问卷内容使用 `assets/question.json`，在推断出的选项的 `label` 后加上 "【推荐】"，**除此之外不得有任何修改**
+
+收到用户答复后，根据变量的"含义"理解用户真实需求。
+
+#### 0.1.2 自定义工程快速通道（路径未匹配到标准仓名）
+
+**跳过所有问卷**，从用户消息和上下文中推断所有入口参数，**禁止使用 `question` 工具**：
+
+| 参数 | 取值 |
+|------|------|
+| repo_type | `"custom"` |
+| interactive_mode | `"auto"` |
+| soc_type | 从用户消息或上下文推断。**无法推断时**从算子的 `_def.cpp` 文件中提取：在 `${op_path}/op_host/` 下查找 `*_def.cpp`，解析所有 `AddConfig("xxx", ...)` 调用中的芯片名（如 `"ascend910b"`、`"ascend950"`），作为 soc_type 取值；若有多个则全部使用 |
+| test_model | `["opapi", "ophost"]`（custom 工程不支持 opkernel） |
+| op_name | 从用户消息或上下文推断（如用户提及的算子名、目录名等） |
+
+设定完成后，**直接进入 Step 0.2**。
+
+### 0.2 创建 TODO.md
+
+**立即**使用 `todowrite` 工具创建 Todos，内容使用 `assets/todo.json`，**不允许进行任何修改。**
+
+### 0.3 创建 tmp 目录
+
+创建 `/tmp/cannbot_${op_name}/` 目录，用于存放所有中间文件：
+
+```bash
+mkdir -p /tmp/cannbot_${op_name}
+```
+
+**重要规则**：
+- 将入口参数存储在该目录下的 `params.json` 中
+- 所有中间文件都应放在该目录下
+- 子 Agent 的临时文件也要存放在该目录下
+
+---
+
+## 主流程
+
+### 流程执行规则
+
+用户所有可能的需求都已经被抽象到主流程中，主流程的步骤在不同的需求下会重写为不同实现，你必须**严格遵守**以下规则：
+
+1. **严格顺序执行**：必须按照 Step 1 → Step 2 → Step 3 → ... 的顺序执行，不得跳过或乱序
+2. **禁止提前阅读**：**在执行到某个步骤前，绝对禁止阅读该步骤的文档！**
+3. **即时更新进度**：每完成或跳过一个子步骤，**立即**使用 `todowrite` 工具更新 TODO.md，将其标记为 `[x]`
+4. **交互模式强制约束**：当 `${interactive_mode} == "interactive"` 时，**必须**在每个询问点使用 `question` 工具与用户确认，**禁止**绕过用户自行决策。Step 4.4a 的询问步骤是交互模式的核心特征，跳过即违背用户意图。
+
+### 主流程链接
+
+[Step 1](./references/workflow/step1.md)
+[Step 2](./references/workflow/step2.md)
+[Step 3](./references/workflow/step3.md)
+[Step 4](./references/workflow/step4.md)
+[Step 5](./references/workflow/step5.md)

package/assets/ops-direct-invoke/skills/ascendc-ut-develop/assets/coverage_files_question.json

@@ -0,0 +1,24 @@
+{
+  "questions": [
+    {
+      "header": "target_files",
+      "question": "请选择需要提升覆盖率的文件（可多选），不选择则自动处理未覆盖代码：",
+      "multiselect": true,
+      "options": [
+        {
+          "label": "auto",
+          "description": "自动处理未覆盖代码"
+        },
+        {
+          "label": "{{文件名1}}",
+          "description": "覆盖率: {{覆盖率1}}%"
+        },
+        {
+          "label": "{{文件名2}}",
+          "description": "覆盖率: {{覆盖率2}}%"
+        }
+      ],
+      "default": ["auto"]
+    }
+  ]
+}

package/assets/ops-direct-invoke/skills/ascendc-ut-develop/assets/csv-refactor/template_cmake.txt

@@ -0,0 +1,46 @@
+# -----------------------------------------------------------------------------------------------------------
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+# -----------------------------------------------------------------------------------------------------------
+
+# ========== 说明 ==========
+
+# 本文件用于架构子目录（如 arch32）的测试编译配置
+# 如果测试在架构子目录下，需要创建此 CMakeLists.txt
+
+# ========== 使用方法 ==========
+
+# 1. 将此文件复制到 {算子目录}/tests/ut/op_host/arch32/CMakeLists.txt
+# 2. 如果有多个架构（arch32, arch33），每个架构目录都需要独立的 CMakeLists.txt
+# 3. UT_NAME 使用 OP_TILING_MODULE_NAME（Tiling 测试）或相应的模块名
+# 4. MODE 通常为 PRIVATE
+
+# ========== 模板内容 ==========
+
+if(UT_TEST_ALL OR OP_HOST_UT)
+    add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
+endif()
+
+# ========== 示例（如果需要特定配置）==========
+
+# 示例1：仅编译特定架构的测试
+# if(UT_TEST_ALL OR OP_HOST_UT_ARCH32)
+#     add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
+# endif()
+
+# 示例2：包含多个模块的测试
+# if(UT_TEST_ALL OR OP_HOST_UT)
+#     add_modules_ut_sources(UT_NAME ${OP_TILING_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
+#     add_modules_ut_sources(UT_NAME ${OP_INFERSHAPE_MODULE_NAME} MODE PRIVATE DIR ${CMAKE_CURRENT_SOURCE_DIR})
+# endif()
+
+# ========== 注意事项 ==========
+
+# 1. 确保父目录的 CMakeLists.txt 正确配置了测试目录
+# 2. CSV 文件会被自动复制到编译目录（通过 CMake 的文件复制机制）
+# 3. 如果 CSV 文件不在当前目录，需要在父目录的 CMakeLists.txt 中配置文件复制

package/assets/ops-direct-invoke/skills/ascendc-ut-develop/assets/csv-refactor/template_inferdtype.cpp

@@ -0,0 +1,139 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+// ============================================================================
+// 通用模板 - InferDataType 测试实现
+// ============================================================================
+// 文件命名：test_{op_name}_dtype_infershape.cpp
+// 实际使用时需要根据算子定义替换：
+// 1. 替换占位符 {{OpName}}, {{op_name}}
+// 2. 替换 Tensor/属性名称（参考 template_param.h）
+// ============================================================================
+
+#include "base/registry/op_impl_space_registry_v2.h"
+#include "infer_datatype_context_faker.h"
+#include "{{op_name}}_param.h"
+#include <gtest/gtest.h>
+
+namespace {
+{
+  OpName
+}
+} // namespace
+UT {
+
+  class {
+    {
+      OpName
+    }
+  } InferDTypeTest : public testing::TestWithParam < {
+    {
+      OpName
+    }
+  }
+  InferDTypeUtParam>{protected : static void SetUpTestCase(){
+      std::cout << "{{OpName}} InferDTypeTest SetUp" << std::endl;
+}
+
+static void TearDownTestCase() {
+  std::cout << "{{OpName}} InferDTypeTest TearDown" << std::endl;
+}
+}
+;
+
+TEST_P(
+    {
+      {
+        OpName
+      }
+    } InferDTypeTest,
+    param) {
+  auto param = GetParam();
+
+  // ========== 构建输入数据类型列表（根据 inputInstance 筛选）==========
+  std::vector<void *> inputDataTypes;
+  if (param.inputInstance[0] == 1)
+    inputDataTypes.emplace_back(&param.input0);
+  if (param.inputInstance[1] == 1)
+    inputDataTypes.emplace_back(&param.input1);
+  if (param.inputInstance[2] == 1)
+    inputDataTypes.emplace_back(&param.input_optional);
+  // ... 添加所有输入 Tensor 的判断逻辑 ...
+
+  // ========== 构建输出数据类型列表（根据 outputInstance 筛选）==========
+  std::vector<void *> outputDataTypes;
+  if (param.outputInstance[0] == 1)
+    outputDataTypes.emplace_back(&param.output0);
+  if (param.outputInstance[1] == 1)
+    outputDataTypes.emplace_back(&param.output_optional);
+  // ... 添加所有输出 Tensor 的判断逻辑 ...
+
+  // ========== 构建 InferDataTypeContext ==========
+  auto contextHolder =
+      gert::InferDataTypeContextFaker()
+          .SetOpType("{{OpName}}")
+          .IrInstanceNum(param.inputInstance, param.outputInstance)
+          .InputDataTypes(inputDataTypes)
+          .OutputDataTypes(outputDataTypes)
+          .NodeAttrs({
+              {"attr_int",
+               Ops::Transformer::AnyValue::CreateFrom<int64_t>(param.attr_int)},
+              {"attr_float",
+               Ops::Transformer::AnyValue::CreateFrom<float>(param.attr_float)},
+              {"attr_string",
+               Ops::Transformer::AnyValue::CreateFrom<std::string>(
+                   param.attr_string)},
+              {"attr_bool",
+               Ops::Transformer::AnyValue::CreateFrom<bool>(param.attr_bool)},
+              // ... 添加所有属性 ...
+          })
+          .Build();
+
+  // ========== 执行测试 ==========
+  auto spaceRegistry =
+      gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
+  auto inferDtypeFunc = spaceRegistry->GetOpImpl("{{OpName}}")->infer_datatype;
+  ASSERT_EQ(
+      inferDtypeFunc(contextHolder.GetContext<gert::InferDataTypeContext>()),
+      param.expectResult);
+
+  // ========== 验证输出数据类型（仅 SUCCESS 时）==========
+  if (param.expectResult == ge::GRAPH_SUCCESS) {
+    EXPECT_EQ(contextHolder.GetContext<gert::InferDataTypeContext>()
+                  ->GetOutputDataType(0),
+              param.output0);
+    // EXPECT_EQ(
+    //     contextHolder.GetContext<gert::InferDataTypeContext>()->GetOutputDataType(1),
+    //     param.output_optional
+    // );
+    // ... 验证所有输出 Tensor ...
+  }
+}
+
+// ========== 从 CSV 加载测试用例 ==========
+INSTANTIATE_TEST_SUITE_P(
+    {{OpName}},
+    {
+      {
+        OpName
+      }
+    } InferDTypeTest,
+    testing::ValuesIn(GetCasesFromCsv<{
+      {
+        OpName
+      }
+    } InferDTypeUtParam>(ReplaceFileExtension2Csv(__FILE__))),
+    PrintCaseInfoString<{
+      {
+        OpName
+      }
+    } InferDTypeUtParam>);
+
+} // namespace {{OpName}}UT

package/assets/ops-direct-invoke/skills/ascendc-ut-develop/assets/csv-refactor/template_inferdtype.csv

@@ -0,0 +1,5 @@
+case_name,expectResult,input0_dtype,input1_dtype,input_optional_dtype,output0_dtype,output_optional_dtype,attr_int,attr_float,attr_string,attr_bool,case_annotation
+basic_success,SUCCESS,FLOAT16,FLOAT16,FLOAT16,INT8,FLOAT,16,0.04166,ND,0,基础成功场景（完整dtype填写）
+optional_input,SUCCESS,FLOAT16,,,FLOAT16,FLOAT,8,0.08838,ND,1,Optional input1不使用（dtype留空）
+multi_dtype,SUCCESS,BF16,INT8,FLOAT16,BF16,INT32,4,1.0,NCHW,0,混合精度测试（多种dtype组合）
+failed_case,FAILED,FLOAT16,INT8,,INT8,FLOAT,0,0.1,ND,0,dtype不匹配场景