之前优化推理性能，我觉得有点慢，但不知道哪慢。兄弟说：“哥，用 profiling-suite 跑一下，看看时间都去哪了。”

好问题。今天一次说清楚。

profiling-suite 是啥？

profiling-suite 是昇腾的性能分析套件。帮你找出性能瓶颈在哪，哪个算子慢，哪个占用内存多。

一句话说清楚：profiling-suite 是昇腾的性能分析套件，帮你分析算子耗时、内存占用、资源利用率，找出性能瓶颈。

你说气人不气人，之前觉得慢但不知道原因，现在跑一下全清楚了。

为什么要用 profiling-suite？

三个字：找瓶颈。

不用 profiling-suite（蒙着跑）

# 跑模型，看结果

for batch in dataloader:

output = model(batch)

print(f"Total time: {time.time() - start:.3f}s")

# 输出：

# Total time: 5.234s

# 问题：不知道哪慢，不知道哪个算子占用时间长

用 profiling-suite（明着跑）

import profiling_suite

# 启用分析

profiler = profiling_suite.Profiler()

profiler.start()

# 跑模型

for batch in dataloader:

output = model(batch)

# 停止分析

profiler.stop()

# 打印报告

profiler.report()

# 输出：

# ========================================

# Performance Report

# ========================================

# Total time: 5.234s

#

# Operator breakdown:

# Conv2d_1 1.234s (23.6%) ████████████████████

# Relu_1 0.123s ( 2.4%) ██

# MaxPool_1 0.456s ( 8.7%) ████████

# Matmul_1 2.345s (44.8%) ██████████████████████████████████████

# Softmax_1 0.876s (16.7%) ████████████

# Other 0.200s ( 3.8%) ███

#

# Memory breakdown:

# Input: 12.3 MB

# Weights: 98.5 MB

# Output: 23.4 MB

# Total: 134.2 MB

#

# Bottleneck: Matmul_1 (44.8% of time)

# Recommendation: Use mixed precision (FP16)

你说气人不气人，一目了然知道该优化哪里。

核心概念就三个

1. 算子分析（Operator Profiling）

分析每个算子的耗时：

import profiling_suite

# 按算子统计

profiler = profiling_suite.Profiler(mode="operator")

profiler.start()

model(input)

profiler.stop()

profiler.print_operator_summary()

# 输出：

# Operator Time(ms) Percentage Calls

# -------- -------- ---------- -----

# Conv2d 12.34 23.5% 10

# Matmul 23.45 44.8% 100

# Relu 1.23 2.4% 50

# Softmax 8.76 16.7% 10

# Add 2.34 4.5% 20

2. 时间线分析（Timeline）

timeline 显示时间顺序：

import profiling_suite

# 时间线模式

profiler = profiling_suite.Profiler(mode="timeline")

profiler.start()

model(input)

profiler.stop()

profiler.save_timeline("timeline.json")

# 可以用 Chrome 的 chrome://tracing 打开看

# 看算子执行的顺序和重叠情况

3. 内存分析（Memory Profiling）

分析内存使用：

import profiling_suite

# 内存模式

profiler = profiling_suite.Profiler(mode="memory")

profiler.start()

model(input)

profiler.stop()

profiler.print_memory_summary()

# 输出：

# ========================================

# Memory Summary

# ========================================

# Peak memory: 234.5 MB

#

# Breakdown:

# Conv2d_1 89.2 MB ( 38.0%)

# Matmul_1 123.4 MB ( 52.6%)

# Relu_1 0.0 KB ( 0.0%)

# Input 12.3 MB ( 5.2%)

# Output 9.6 MB ( 4.1%)

#

# Location:

# Device memory: 234.5 MB (100.0%)

# Host memory: 0.0 KB ( 0.0%)

为什么要用 profiling-suite？

三个理由：

1. 精准定位问题

之前凭感觉优化，现在有数据：

# 凭感觉：我觉得是卷积慢

# 数据：Matmul 占 44.8%

# 凭感觉：可能是内存问题

# 数据：内存 234MB，没问题

# 凭感觉：算子融合能快

# 数据：单算子执行，没有重叠，无法融合

2. 量化优化效果

优化前后对比：

# 优化前

print(profiler_before.report())

# Total time: 5.234s

# 优化后

print(profiler_after.report())

# Total time: 3.456s

# 加速比: 1.51x

3. 指导优化方向

告诉你该优化什么：

# 建议

recommendations = profiler.get_recommendations()

for rec in recommendations:

print(rec)

# 输出：

# 1. Use FP16 for Matmul (expected 2x speedup)

# 2. Fuse Conv2d + Bias + Relu (expected 1.3x speedup)

# 3. Enable memory reuse (save 50MB memory)

# 4. Increase batch size to 16 (better throughput)

怎么用？代码示例

示例 1：基础性能分析

import profiling_suite

import time

import numpy as np

# 创建模型

class SimpleModel:

def __init__(self):

self.conv = np.random.randn(64, 3, 7, 7)

def forward(self, x):

# 模拟卷积

y = np.random.randn(1, 64, 112, 112)

time.sleep(0.1) # 模拟计算

# 模拟 ReLU

y = np.maximum(y, 0)

time.sleep(0.01)

return y

model = SimpleModel()

# 创建分析器

profiler = profiling_suite.Profiler()

# 开始分析

profiler.start()

# 运行模型多次

for i in range(10):

x = np.random.randn(1, 3, 224, 224)

y = model.forward(x)

# 停止分析

profiler.stop()

# 打印报告

profiler.report()

# 输出：

# Total time: 1.100s

#

# Breakdown:

# forward 1.100s (100.0%)

# Conv2d 1.000s (90.9%)

# ReLU 0.100s (9.1%)

示例 2：Timeline 分析

import profiling_suite

import numpy as np

import time

# 设置 timeline 模式

profiler = profiling_suite.Profiler(mode="timeline", trace=True)

# 启动

profiler.start()

# 模型推理

input_data = np.random.randn(1, 3, 224, 224)

# Layer 1

conv1_out = np.random.randn(1, 64, 112, 112)

profiler.add_marker("Conv1 done")

# Activation

relu1_out = np.maximum(conv1_out, 0)

profiler.add_marker("Relu1 done")

# Layer 2

conv2_out = np.random.randn(1, 128, 56, 56)

profiler.add_marker("Conv2 done")

# 停止

profiler.stop()

# 保存 timeline

profiler.save_timeline("model_trace.json")

print("Timeline saved to model_trace.json")

print("Open in Chrome at chrome://tracing")

示例 3：内存分析

import profiling_suite

import numpy as np

# 内存分析模式

profiler = profiling_suite.Profiler(mode="memory")

profiler.start()

# 模拟大模型推理

# Input: 1*3*224*224 * 4 bytes = 0.6 MB

input = np.random.randn(1, 3, 224, 224).astype(np.float32)

profiler.mark("Input allocated")

# Convs: 64 layers

for i in range(64):

# 每个卷积权重: out_ch * in_ch * kH * kW * 4 bytes

pass

profiler.mark("Weights loaded")

# Output: 1*1000 * 4 bytes = 4 KB

output = np.random.randn(1, 1000)

profiler.mark("Inference done")

# Forward 中间激活值：约 100 MB

profiler.mark("Forward intermediate")

# Backward 梯度

profiler.mark("Backward done")

profiler.stop()

# 打印内存报告

profiler.print_memory()

# 输���：

# Memory: 234.5 MB peak

#

# By lifecycle:

# Input: 0.6 MB ( 0.3%)

# Weights: 98.5 MB (42.0%)

# Output: 0.0 MB ( 0.0%)

# Activations: 135.4 MB (57.7%)

示例 4：对比分析

import profiling_suite

import numpy as np

import time

# 对比两种实现

def version_fp32():

"""FP32 版本"""

data = np.random.randn(1024, 1024).astype(np.float32)

weights = np.random.randn(1024, 1024).astype(np.float32)

time.sleep(0.1) # matmul simulation

return np.dot(data, weights)

def version_fp16():

"""FP16 版本"""

data = np.random.randn(1024, 1024).astype(np.float16)

weights = np.random.randn(1024, 1024).astype(np.float16)

time.sleep(0.05) # faster simulation

return np.dot(data, weights)

# 分析 FP32

profiler_fp32 = profiling_suite.Profiler(name="FP32")

profiler_fp32.start()

for _ in range(100):

version_fp32()

profiler_fp32.stop()

# 分析 FP16

profiler_fp16 = profiling_suite.Profiler(name="FP16")

profiler_fp16.start()

for _ in range(100):

version_fp16()

profiler_fp16.stop()

# 对比报告

print("\n=== Comparison ===")

print(f"FP32: {profiler_fp32.get_total_time():.3f}s")

print(f"FP16: {profiler_fp16.get_total_time():.3f}s")

print(f"Speedup: {profiler_fp32.get_total_time() / profiler_fp16.get_total_time():.2f}x")

# 输出：

# === Comparison ===

# FP32: 10.00s

# FP16: 5.00s

# Speedup: 2.00x

性能数据

使用 profiling-suite 的优化效果：

优化前

优化后

加速比

FP32 matmul

FP16 matmul

2.0x

未融合算子

融合算子

1.3x

静态 batch

动态 batch

1.5x

无优化

内存复用

节省 50MB

你说气人不气人，有数据才能精准优化。

跟其他仓库的关系

profiling-suite 在 CANN 架构里属于第 3 层（昇腾计算编译层），是性能分析工具。

依赖关系：

profiling-suite（性能分析）

↓ 分析

ge（图引擎）

↓ 执行

算子库（ops-xxx）

↓ 实现

硬件（昇腾 NPU）

解释一下：

ge：图引擎，调度算子

profiling-suite：分析 ge 的执行

算子库：实际执行

硬件：昇腾 NPU

简单说：profiling-suite 是性能"CT 机"。给模型做体检，哪有问题都能看出来。

profiling-suite 的核心能力

1. Operator Profiling

profiler = profiling_suite.Profiler(mode="operator")

profiler.start()

model()

profiler.stop()

profiler.print_operator_summary()

2. Timeline Profiling

profiler = profiling_suite.Profiler(mode="timeline", trace=True)

profiler.start()

model()

profiler.stop()

profiler.save_timeline("trace.json")

3. Memory Profiling

profiler = profiling_suite.Profiler(mode="memory")

profiler.start()

model()

profiler.stop()

profiler.print_memory_summary()

4. Comparison

baseline = profiler.version1()

optimized = profiler.version2()

comparison = baseline.compare_with(optimized)

print(comparison)

适用场景

什么情况下用 profiling-suite：

性能优化：不知道哪慢

内存优化：内存不够

对比实验：优化前后对比

验���：性能达标

什么情况下不用：

生产环境：会影响性能

简单场景：Run 就完事了

总结

profiling-suite 就是昇腾的"性能 CT 机"：

算子分析：精确到每个算子

时间线：看执行顺序

内存：看内存分配

对比：优化前后对比