Menu
PyPTO Pass 编译性能优化技能。用于分析和优化 Pass 模块的编译性能，当 Pass 编译耗时过长需要优化时使用此技能。
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Baseado na classificação ocupacional SOC
定位测试案例中出现 aicore error 时的问题 CCE 文件和问题代码行。当用户说"aicore error"、"定位 aicore error 的原因"、"帮我定位 aicore error 报错"时使用此技能。也适用于用户直接提供 CCE 文件希望定位问题代码行或映射到源码的场景。
PyPTO 环境安装与环境问题修复，包括 CANN、torch_npu、编译工具链、第三方依赖和 PyPTO 编译运行等。触发词：PyPTO environment setup, CANN install, torch_npu, NPU environment, Ascend toolkit, compile PyPTO, build PyPTO, NPU driver, prepare_env, diagnose environment, fix import error, torch_npu import fail, DT_FP8E8M0, pto-isa, ASCEND_HOME_PATH, npu-smi, softmax verify, pip dependency conflict
分析当前 session 上下文，识别 PyPTO 框架或文档不完善导致的断裂点，产出可转化为 Issue 的结构化报告。当用户在 pypto 相关 skill 运行结束后提到"断裂点"、"识别断裂点"、"检测断裂点"、"fracture point"时触发此 skill。也适用于用户对 session 中遇到的问题进行复盘、想要生成问题报告、或希望改进 pypto 框架/文档质量的场景。
分析 host 侧捕获异常后的堆栈信息，通过地址到源码行映射和符号解析，定位问题代码位置。支持 Python traceback、C++ stack trace 和混合堆栈的自动识别与分析。支持编译Debug版本PyPTO包并定位具体代码行。Triggers："堆栈分析"、"堆栈反汇编"、"分析堆栈信息"、"地址到源码行"、"stack trace"、"backtrace"
PyPTO MACHINE 内存重叠检测与修复技能。通过系统化流程检测和修复 workspace 内存重叠、内存管理策略问题导致的精度异常。当怀疑精度问题由内存重叠、workspace 不足、内存管理异常引起时使用此技能。触发词：内存重叠、内存重叠检测、workspace问题、内存管理异常、内存复用错误。
PyPTO Pass 模块错误诊断技能。包含错误定位、原因分析和提供问题修复建议，提供从问题定位到修复建议的完整工作流程。当遇到 PyPTO Pass 模块抛出错误时使用此技能。触发词：定位 pass 错误、pass 模块异常、pass 报错、pass 失败、pass 异常。
| name | pypto-pass-perf-optimizer |
| description | PyPTO Pass 编译性能优化技能。用于分析和优化 Pass 模块的编译性能，当 Pass 编译耗时过长需要优化时使用此技能。 |
本技能用于分析和优化 PyPTO Pass 模块的编译性能，帮助识别性能瓶颈并提供优化建议。
🛑 严禁跳过任何关键步骤！以下步骤必须严格执行：
步骤1-5（环境准备+性能测量）
↓
步骤6（编译Debug版本） ⚠️ 强制，不可跳过
↓
步骤7（perf分析） ⚠️ 强制，不可跳过
↓
步骤8（内存分析，可选）
↓
步骤9（理解Pass功能）
↓
步骤10-13（性能分析） ⚠️ 强制，必须基于perf数据
↓
步骤14-18（优化实施）
↓
步骤19（UT验证） ⚠️ 强制，不可跳过
↓
步骤20-22（验证与迭代）
↓
步骤23（优化总结报告） ⚠️ 强制，不可跳过
❌ 严禁跳过步骤6-7：Debug编译和perf分析是优化的数据依据 ❌ 严禁跳过步骤10-13：必须基于perf数据进行优化决策，禁止凭猜测优化 ❌ 严禁在未完成perf分析前修改代码：这是盲目优化，可能导致错误的方向 ❌ 严禁在UT未通过前进行性能验证：功能正确性优先于性能优化
优化前的准备工作：
只有完成以上准备工作后，才能进入步骤14进行代码优化。
优化后的验证工作：
错误 1：跳过perf分析直接优化
步骤1-5 → ❌跳过步骤6-7 → 步骤14修改代码
后果：缺乏数据支撑，优化方向可能错误
错误 2：仅凭代码审查进行优化
步骤1-5 → ❌跳过步骤6-13 → 步骤14修改代码
后果：无法识别真正的性能瓶颈，浪费时间
错误 3：UT未通过就进行性能验证
步骤14修改代码 → ❌跳过步骤19 → 步骤20性能验证
后果：可能引入功能bug，性能优化无效
为什么要使用perf分析？
为什么要编译Debug版本？
为什么必须运行UT？
基准目标：
关键术语定义：
目标时间计算公式：
目标平均耗时 = (实际Op数量 / 200,000) × 20s
示例：
性能判断标准：
当用户提到以下关键词时触发:
本 skill 自带工具脚本在 pypto-pass-perf-optimizer/scripts/，即本 SKILL.md 同级目录下，不在 PyPTO 仓库根目录的 scripts/。
执行前先设置 PASS_PERF_SCRIPTS_DIR=<本 SKILL.md 所在目录>/scripts，后续 helper script 都用 $PASS_PERF_SCRIPTS_DIR/... 调用，业务命令仍在 PyPTO 仓库根目录执行。
用户需要指定要执行的算子脚本（用于触发 Pass 编译流程）：
# 开启 info 级别日志
export ASCEND_GLOBAL_LOG_LEVEL=1
# 设置日志落盘路径（默认为算子脚本同目录下的 logs 文件夹）
export ASCEND_PROCESS_LOG_PATH=$(dirname {user_specified_script})/logs
# 创建日志目录
mkdir -p $ASCEND_PROCESS_LOG_PATH
# 日志文件将落盘到：$ASCEND_PROCESS_LOG_PATH/debug/plog/pypto-log-{pid}-{timestamp}.log
# 注意：单个日志文件超过 20M 会自动拆分为多个文件
# 拆分文件命名：每个文件都有独立的时间戳（pypto-log-{pid}-{timestamp}.log）
# 同一次执行的所有拆分文件具有相同的 pid，可通过 pid 识别
⚠️ 重要：确保使用最新编译的 Release 版本进行性能测试
# 编译 Python 包（Release 版本，用于性能测试）
python3 build_ci.py -f=python3 --build_type Release --disable_auto_execute
# 安装到 Python 环境
pip install ./build_out/pypto-*.whl --force-reinstall
# 执行用户指定的算子脚本（日志自动落盘）
# 使用超时控制，默认 5 分钟，超时后自动中断并继续后续步骤
bash "$PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh" 300 python3 {user_specified_script}.py
# 自定义超时时间（例如 10 分钟）
# bash "$PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh" 600 python3 {user_specified_script}.py
# 不使用超时控制直接执行（不推荐，可能长时间等待）
# python3 {user_specified_script}.py
# 日志文件位置：$ASCEND_PROCESS_LOG_PATH/debug/plog/pypto-log-*.log
# 注意：单个日志文件超过 20M 会自动拆分为多个文件
# 同一次执行的所有文件具有相同的 pid
# 解析日志文件，生成 Pass 耗时排序报告
# 日志文件位于：$ASCEND_PROCESS_LOG_PATH/debug/plog/pypto-log-*.log
# 注意：脚本会自动处理拆分的日志文件（同 pid 的所有文件）
# 查找最新的日志文件
latest_log=$(find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*.log" -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -d' ' -f2-)
echo "使用日志文件: $latest_log"
python3 "$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py" -l $latest_log
⚠️ 重要：perf 采样需要 Debug 版本才能正确显示函数名和调用栈
# 编译 Python 包（Debug 版本带完整调试符号，用于 perf 采样）
python3 build_ci.py -f=python3 --build_type Debug
# 安装到 Python 环境
pip install ./build_out/pypto-*.whl --force-reinstall
⚠️ 重要：perf 能够正确分析当前代码的性能优化点
火焰图提供了直观的可视化视图，更容易识别性能热点。
生成火焰图：
# 生成火焰图（默认 5 分钟超时）
# 参数：超时时间(秒) 输出目录 命令...
bash "$PASS_PERF_SCRIPTS_DIR/generate_flamegraph.sh" \
300 ./flamegraphs python3 {user_specified_script}.py
# 火焰图将保存到 ./flamegraphs/flamegraph_{timestamp}.svg
# 同时生成折叠数据文件 folded_{timestamp}.txt（用于后续对比）
# 使用浏览器打开查看
firefox ./flamegraphs/flamegraph_*.svg
# 或
google-chrome ./flamegraphs/flamegraph_*.svg
🔥 火焰图解读指南：
1. 结构说明
2. 识别热点函数
| 图形特征 | 含义 | 行动建议 |
|---|---|---|
| 宽平台 | 顶部宽大的函数块 | 这是性能热点，优先优化 |
| 高塔尖 | 调用栈很深 | 检查是否存在过度封装或递归 |
| 反复出现 | 同一函数多处出现 | 函数被频繁调用，考虑缓存或批处理 |
| 细长条 | 调用栈很窄但很深 | 可能是单线程瓶颈 |
3. 交互操作（浏览器中）
Ctrl+F 搜索特定函数名4. 常见热点模式及优化方向
| 热点函数 | 问题类型 | 优化方向 |
|---|---|---|
_malloc / _free | 频繁内存分配 | 预分配内存、使用对象池 |
std::unordered_map::find | 哈希表查找 | 优化哈希函数、预分配bucket |
std::vector 扩容 | 动态扩容 | 使用 reserve() 预分配 |
memcpy / memmove | 大量数据拷贝 | 减少拷贝、使用引用 |
| 字符串操作 | 字符串拼接/转换 | 使用 std::string_view、预分配 |
| 循环内函数调用 | 过度循环 | 循环展开、提前计算 |
5. 火焰图示例解读
┌─────────────────────┐
│ hot_function() 15% │ ← 宽平台：性能热点
└─────────────────────┘
┌────────────────────────────────┐
│ process_data() 35% │ ← 宽块：主要耗时函数
└────────────────────────────────┘
┌──────────────────────────────────────────┐
│ main_loop() 50% │ ← 入口函数
└──────────────────────────────────────────┘
hot_function() 占 15% CPU，宽度较宽，是优化重点process_data() 占 35%，是主要耗时函数hot_function() 可以查看其内部调用栈如果火焰图工具不可用，可以使用传统方式：
# 使用 perf 采样
bash "$PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh" 300 \
perf record -g -e cycles,instructions,cache-misses -- python3 {user_specified_script}.py
# 查看报告
perf report
perf report 快捷键：
+：展开调用栈-：折叠调用栈Enter：进入函数详情/：搜索函数名完成火焰图分析后，记录以下信息：
## 性能分析记录
### 热点函数 Top 5（从火焰图识别）
| 排名 | 函数名 | CPU占比 | 所属模块 | 可能原因 |
|-----|--------|---------|---------|---------|
| 1 | | | | |
| 2 | | | | |
| 3 | | | | |
| 4 | | | | |
| 5 | | | | |
### 性能瓶颈类型
- [ ] 计算密集型
- [ ] 内存密集型
- [ ] IO密集型
### 优化方向
1. ...
2. ...
# 使用超时控制执行内存分析，默认 5 分钟
bash "$PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh" 300 \
valgrind --tool=massif -- python3 {user_specified_script}.py
massif-visualizer massif.out.*
⚠️ 重要：优化前必须充分理解 Pass 的功能和业务逻辑
调用 pypto-pass-module-analyzer skill 来深入理解目标 Pass：
分析 Pass 模块 {PassName} 的功能和业务逻辑
需要了解的内容：
理解 Pass 功能的好处：
从 perf report 中识别：
检查以下问题：
| 瓶颈类型 | 症状描述 | 典型原因 |
|---|---|---|
| 计算密集型 | CPU 利用率高，cycles 占比高 | 算法复杂度过高、重复计算 |
| 内存密集型 | cache miss 多，内存访问频繁 | 数据结构不合理、缓存不友好 |
| IO 密集型 | 文件读写、日志输出多 | 过多的日志、文件操作 |
根据性能分析结果修改 Pass 代码，实施优化。
在优化过程中，为 Pass 内部关键步骤添加耗时统计：
#include <chrono>
// 在 Pass 的 RunOnFunction 或关键函数中添加
auto stepStart = std::chrono::high_resolution_clock::now();
// ... 关键步骤代码 ...
auto stepEnd = std::chrono::high_resolution_clock::now();
auto stepDuration = std::chrono::duration_cast<std::chrono::microseconds>(stepEnd - stepStart);
PASS_LOGI("[{PassName}] Step {step_name} cost %ld us", stepDuration.count());
建议添加耗时统计的场景：
常见优化方法：
优化示例：
// 优化前：O(n²) 查找
for (auto& op1 : operations) {
for (auto& op2 : operations) {
if (op1.id == op2.parentId) { ... }
}
}
// 优化后：O(n) 使用哈希表
std::unordered_map<int, Operation*> idToOp;
for (auto& op : operations) {
idToOp[op.id] = &op;
}
for (auto& op : operations) {
auto it = idToOp.find(op.parentId);
if (it != idToOp.end()) { ... }
}
容器选择指南：
| 场景 | 推荐容器 | 原因 |
|---|---|---|
| 顺序访问 | std::vector | 连续内存，缓存友好 |
| 频繁查找 | std::unordered_map | O(1) 查找 |
| 需要排序 | std::set / std::map | 自动排序 |
| 频繁插入删除 | std::list | O(1) 插入删除 |
内存优化：
// 预分配内存
std::vector<Operation*> ops;
ops.reserve(expected_size); // 避免多次重新分配
// 使用引用避免拷贝
for (const auto& op : operations) { ... } // 而不是 for (auto op : ...)
// 使用 emplace_back 避免临时对象
ops.emplace_back(newOp); // 而不是 ops.push_back(newOp)
// 使用 std::move 转移所有权
auto result = std::move(tempVector);
// 改善数据局部性
struct OpInfo {
int id;
int parentId;
Operation* op;
};
std::vector<OpInfo> opInfos; // 连续内存，缓存友好
// 避免"指针追逐"
// 优化前：多层指针
for (auto& op : ops) {
for (auto& consumer : op->consumers) {
for (auto& child : consumer->children) { ... }
}
}
// 优化后：预计算索引
std::vector<std::vector<int>> opToChildren; // 直接索引访问
⚠️ 重要：优化后必须验证目标 Pass 的 UT 通过
# 查找 Pass 相关 UT 测试文件
# 路径：framework/tests/ut/passes/src/test_{pass_name}.cpp
# 运行指定 Pass 的所有 UT
python3 build_ci.py -f=cpp -u="{PassName}Test.*" -j=24
# 示例：运行 AssignMemoryType 的 UT
python3 build_ci.py -f=cpp -u="AssignMemoryTypeTest.*" -j=24
# 运行单个测试用例
python3 build_ci.py -f=cpp -u="AssignMemoryTypeTest.AddReshape" -j=24
# 如果 UT 失败：
# 1. 检查优化代码是否引入 bug
# 2. 必要时回退修改
# 3. 重新优化
注意：UT 测试是 C++ 测试，必须使用 -f=cpp 参数
⚠️ 重要：最终性能验证必须使用 Release 版本，确保性能数据准确
# 编译 Python 包（Release 版本，用于最终性能验证）
python3 build_ci.py -f=python3 --build_type Release
# 安装到 Python 环境
pip install ./build_out/pypto-*.whl --force-reinstall
⚠️ 重要：优化后需要对比验证优化效果
# 重新采集性能数据（日志自动落盘）
# 使用超时控制，默认 5 分钟
bash "$PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh" 300 python3 {user_specified_script}.py
# 日志文件位置：$ASCEND_PROCESS_LOG_PATH/debug/plog/pypto-log-*.log
# 注意：每次运行会生成新的日志文件，可通过时间戳区分
# 查找最新的日志文件
latest_log=$(find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*.log" -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -d' ' -f2-)
echo "最新日志文件: $latest_log"
# 运行 Python 脚本对比
python3 "$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py" \
-l $latest_log
# 生成优化后的火焰图和折叠数据
bash "$PASS_PERF_SCRIPTS_DIR/generate_flamegraph.sh" \
300 ./flamegraphs python3 {user_specified_script}.py
# 这会生成新的文件，例如：
# - folded_20260313_143022.txt (优化前，步骤7生成)
# - folded_20260313_150335.txt (优化后，刚刚生成)
# 对比优化前后的火焰图
bash "$PASS_PERF_SCRIPTS_DIR/compare_flamegraphs.sh" \
./flamegraphs/folded_20260313_143022.txt \
./flamegraphs/folded_20260313_150335.txt
# 差异火焰图将保存到 ./flamegraphs/diff_flamegraph_{timestamp}.svg
差异火焰图颜色说明：
| 颜色 | 含义 | 解读 |
|---|---|---|
| 🔴 红色/橙色 | 优化后增加的热点 | ⚠️ 需要关注，可能是新引入的性能问题 |
| 🔵 蓝色/青色 | 优化后减少的热点 | ✅ 优化有效，这些函数耗时减少 |
| ⚪ 灰色 | 基本不变 | 优化对该函数影响不大 |
对比分析要点：
如果性能未达标：
⚠️ 重要：重新生成火焰图进行性能瓶颈分析，不要盲目优化 重复步骤 6-21 直到达标
⚠️ 重要：性能达标后必须生成优化总结报告，记录所有优化措施及其性能影响
在生成报告前，收集以下数据：
# 1. 查看所有代码变更
git diff --stat HEAD~{n} # n 为优化过程中的 commit 数量
git log --oneline HEAD~{n}..HEAD
# 2. 查找优化前后的日志文件
# 优化前日志（步骤5采集）
ls -lh $ASCEND_PROCESS_LOG_PATH/debug/plog/pypto-log-*.log | head -5
# 优化后日志（步骤21采集）
ls -lh $ASCEND_PROCESS_LOG_PATH/debug/plog/pypto-log-*.log | tail -5
# 3. 查找火焰图文件
ls -lh ./flamegraphs/*.svg ./flamegraphs/*.txt
基于模板文件生成优化总结报告，并保存到 $ASCEND_PROCESS_LOG_PATH/perf_optimization_report.md：
template_path="$PASS_PERF_SCRIPTS_DIR/../templates/perf_optimization_report.md"
report_path="$ASCEND_PROCESS_LOG_PATH/perf_optimization_report.md"
cp "$template_path" "$report_path"
模板文件：templates/perf_optimization_report.md
生成报告时需要替换模板中的占位符，并保留以下必填章节：
## 基本信息## 优化概览## 优化详情## 性能数据汇总## 经验总结## 附录# 报告保存路径
report_path="$ASCEND_PROCESS_LOG_PATH/perf_optimization_report.md"
# 验证报告完整性（检查必填章节）
grep -q "## 基本信息" "$report_path" && \
grep -q "## 优化概览" "$report_path" && \
grep -q "## 优化详情" "$report_path" && \
grep -q "## 性能数据汇总" "$report_path" && \
grep -q "## 经验总结" "$report_path" && \
echo "✅ 报告结构完整" || echo "❌ 报告缺少必填章节"
# 查看报告
cat "$report_path"
生成报告后，逐项确认：
$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py
# 基本用法：分析单个日志文件
# 日志文件位置：$ASCEND_PROCESS_LOG_PATH/debug/plog/pypto-log-*.log
# 查找最新日志文件
latest_log=$(find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*.log" -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -d' ' -f2-)
python3 "$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py" -l $latest_log
# 或者直接指定日志文件路径
python3 "$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py" -l /path/to/pypto-log-*.log
# 对比两个日志文件
python3 "$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py" -l pypto-log-after.log --compare pypto-log-before.log
# 指定 Op 数量阈值（默认 200000）
python3 "$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py" -l pypto-log-*.log --ops-threshold 200000
# 指定时间阈值（默认 20s）
python3 "$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py" -l pypto-log-*.log --time-threshold 20
某些算子在运行阶段可能执行很长时间（超过 1 小时），但对于 Pass 编译性能分析而言：
# 设置超时时间为 10 分钟（600 秒）
bash "$PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh" 600 python3 test.py
# 设置超时时间为 15 分钟（900 秒）
bash "$PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh" 900 python3 test.py
# 设置超时时间为 2 分钟（120 秒）
bash "$PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh" 120 python3 test.py
超时控制适用于所有需要执行算子的步骤：
当算子执行超时被中断后，脚本会返回退出码 0，允许继续执行后续步骤：
如果算子执行因其他原因失败（非超时中断），脚本会返回非零退出码，停止后续执行。
脚本位置: $PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh
参数说明:
bash "$PASS_PERF_SCRIPTS_DIR/run_with_timeout.sh" <超时秒数> <命令> [命令参数...]
退出码:
0 - 成功完成或超时中断（允许继续后续步骤）非 0 - 执行失败（停止后续步骤）技术细节:
⚠️ 重要：优化后必须验证目标 Pass 的 UT 通过
# 运行目标 Pass 的 UT
python3 build_ci.py -f=cpp -u=Test{PassName}.* -j=24
# 如果 UT 失败：
# - 检查优化代码是否引入 bug
# - 使用 git diff 查看修改
# - 必要时回退修改
# - 重新优化
# 只有 UT 全部通过才能接受优化
| 类别 | 文件路径 |
|---|---|
| Pass 日志机制 | framework/src/passes/pass_mgr/pass_manager.cpp |
| 耗时统计函数 | LogPassRuntime() |
| Op 数量日志 | expand_function.cpp 中的 Operations().size() |
| 日志配置 | ASCEND_MODULE_LOG_LEVEL=PASS=1 |
| perf 使用 | perf record -g, perf report |
| valgrind 使用 | valgrind --tool=massif |
# 方法 1：使用 find 命令查找最新日志文件
latest_log=$(find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*.log" -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -d' ' -f2-)
echo "最新日志文件: $latest_log"
# 方法 2：使用 ls 按时间排序查找
latest_log=$(find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*.log" -type f | xargs ls -t | head -1)
echo "最新日志文件: $latest_log"
# 直接使用最新日志文件进行分析
python3 "$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py" -l $latest_log
# 日志文件拆分规则：单个文件超过 20M 自动拆分
# 拆分文件命名：
# - pypto-log-{pid}-{timestamp1}.log
# - pypto-log-{pid}-{timestamp2}.log
# - pypto-log-{pid}-{timestamp3}.log
# - ...
# 同一次执行的所有文件具有相同的 pid
# 查看同一次执行产生的所有拆分日志文件
# 方法 1：手动提取 pid 查找
log_file="pypto-log-1051473-20260312202107387.log"
pid=$(echo $log_file | sed 's/pypto-log-\([0-9]*\)-.*/\1/')
ls -lh pypto-log-${pid}-*.log
# 方法 2：自动分析（推荐）
# parse_pass_perf.py 会自动检测并处理所有拆分文件
python3 "$PASS_PERF_SCRIPTS_DIR/parse_pass_perf.py" -l pypto-log-1051473-20260312202107387.log
# 查看所有日志文件（按时间排序）
find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*.log" -type f | xargs ls -lht
# 查看所有日志文件（按大小排序）
find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*.log" -type f -exec ls -lh {} \; | sort -k5 -h
# 列出所有拆分的日志文件组（按 pid 分组）
find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*.log" -type f | xargs ls -t | head -20
# 查找特定进程ID的所有日志文件
pid="1051473"
find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-${pid}-*.log" -type f
# 查找特定时间段的所有日志文件（2026年3月12日 20:21）
find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*-202603122021*.log" -type f
# 查找特定日期的日志文件（2026年3月12日）
find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*-20260312*.log" -type f
# 统计每次执行产生的日志文件数量
find $ASCEND_PROCESS_LOG_PATH/debug/plog -name "pypto-log-*.log" -type f | \
sed 's/pypto-log-\([0-9]*\)-.*/\1/' | sort | uniq -c
以下是已完成的 Pass 编译性能优化案例，可作为优化参考。
Commit: 6002c12d
优化方法:
auto& 替代 autobreak 终止遍历Commit: 1303180c
优化方法:
tensorToOrderIndex 索引映射，将 O(n²) 降为 O(1) 查找Commit: 0f653952
优化方法:
map<pair<K1,K2>, V>Commit: 22f7d2aa
优化方法:
Commit: 18046c2b
优化方法:
shared_ptr 实现数据共享，仅在修改时触发深拷贝，降低内存与时间开销通用优化模式总结:
| 模式 | 适用场景 | 示例案例 |
|---|---|---|
| 提前终止 | 条件检查类遍历 | 案例1 |
| 避免拷贝 | 遍历容器时 | 案例1 |
| 预计算索引 | 重复遍历同一数据 | 案例2 |
| 添加缓存 | 重复计算相同结果 | 案例3 |
| 数据结构简化 | 多层嵌套容器 | 案例3 |
| 避免临时对象 | 频繁创建销毁对象 | 案例4 |
| Copy-on-Write | 大数据频繁复制 | 案例5 |