算子优化概述：从概念到实战

大家好，我是你们的老朋友。今天咱们聊聊算子优化。

说实话，我刚开始接触这个领域时，也觉得“算子”这词挺唬人的。后来做多了才发现，它没那么神秘。

什么是算子？

算子，说白了就是计算的基本单元。

你想想看，在深度学习框架里，卷积、矩阵乘法、激活函数、池化……这些操作，每一个都叫算子。它们就像乐高积木，拼在一起就成了一个完整的神经网络。

我个人习惯把算子分成三类：

• 计算密集型算子：比如矩阵乘法、卷积。这类算子主要“吃”算力。
• 访存密集型算子：比如元素级操作（ReLU、加法）。这类算子主要“吃”带宽。
• 混合型算子：比如某些归一化操作，两者都占。

嗯，这里要注意：同一个算子在不同硬件上，分类可能不一样。我在项目中遇到过，一个在GPU上是计算密集型的算子，放到CPU上就变成了访存密集型。原因很简单——硬件特性不同。

为什么需要优化？

这个问题，我当年也问过自己。

你写一个矩阵乘法，用三层for循环，也能跑。但跑一次要10秒，而优化后只要0.1秒。这100倍的差距，就是优化的价值。

具体来说，有这几个原因：

• 硬件利用率低：默认实现往往不能充分利用硬件的并行能力。GPU有几千个核心，你只用了几个，那多浪费。
• 内存访问模式差：不合理的访存顺序会导致缓存命中率低。我曾经调试过一个算子，性能死活上不去，最后发现是数据在内存里“跳来跳去”地访问，缓存根本帮不上忙。
• 算子融合机会丢失：多个小算子分开执行，中间结果要写回内存再读出来。如果能融合成一个算子，这些开销就省了。

优化的核心目标

做优化，你得知道往哪个方向使劲。我个人总结，就三个目标：

1. 计算效率

计算效率，就是让计算单元别闲着。

举个例子，GPU的Tensor Core专门做矩阵乘法。如果你能让它一直满负荷运转，那计算效率就高。反之，如果它经常在等数据，那效率就低。

我常用的手段包括：

• 循环展开（Loop Unrolling）
• 向量化（Vectorization）
• 指令级并行（ILP）

说白了，就是让CPU或GPU的“流水线”别断。

2. 内存带宽

内存带宽，往往是瓶颈中的瓶颈。

你想想看，计算单元算一次只要1纳秒，但从内存拿数据要100纳秒。这100倍的差距，就是带宽优化的空间。

我曾经优化过一个算子，计算效率已经到95%了，但整体性能还是上不去。后来一分析，发现是内存带宽被吃满了。数据从内存到缓存的速度，跟不上计算的速度。

怎么优化？

• 数据复用：尽量让数据在缓存里多待一会儿
• 合并访存：把多个小请求合并成一个大请求
• 预取：提前把数据搬到缓存里

3. 延迟

延迟，就是响应时间。

在推理场景里，延迟特别重要。用户点一下“识别”，你总不能让他等3秒吧？

降低延迟的手段包括：

• 算子融合：减少内核启动开销
• 异步执行：让计算和访存重叠
• 模型剪枝：减少不必要的计算

嗯，这里要提醒一下：延迟和吞吐量往往是矛盾的。追求低延迟，可能会牺牲一些吞吐量。具体怎么取舍，得看业务场景。

知识体系总览

下面这张图，是我自己整理的算子优化知识体系。你可以把它当作一张“地图”，后面每讲一个技术点，都能在这张图上找到位置。

一个简单的例子

光说不练假把式。咱们看一个最简单的例子：向量加法。

假设有两个长度为N的向量A和B，要计算C = A + B。

最直接的写法：

for (int i = 0; i < N; i++) {
    C[i] = A[i] + B[i];
}

这段代码有什么问题？

问题大了。每次循环都要从内存读A[i]和B[i]，写C[i]。如果N很大，内存带宽就是瓶颈。

怎么优化？

我常用的方法是分块（Tiling）：

int block_size = 64;  // 假设缓存能放下64个元素
for (int i = 0; i < N; i += block_size) {
    int end = min(i + block_size, N);
    for (int j = i; j < end; j++) {
        C[j] = A[j] + B[j];
    }
}

这样，A和B的每个块都能在缓存里待一会儿，减少了内存访问次数。

总结

算子优化，说白了就是三件事：提高计算效率、用好内存带宽、降低延迟。

这三件事不是孤立的。你优化计算效率时，可能会影响内存带宽。你降低延迟时，可能会牺牲吞吐量。所以，做优化要“全局视角”，不能只看局部。

我个人习惯，拿到一个算子，先做性能分析，找到瓶颈，再针对性地优化。而不是一上来就“调参”、“改代码”。

好了，这一章就到这里。下一章，咱们聊聊性能分析工具，看看怎么找到算子的瓶颈。