先看一组对比。大模型的参数量约每两年增长 410 倍,而单卡显存容量每两年只翻一番(Gholami et al., AI and Memory Wall, IEEE Micro, 2024)。计算瓶颈早已从 ALU 转移到内存带宽和数据搬运延迟上,这就是"内存墙"。算力越来越便宜,数据搬运越来越贵,这是大模型时代一个反复被验证的判断。

 

图片

编译器能为此做什么?答案藏在两门编译技术的组合拳里:MLIR 提供了承载 AI 计算图的多层中间表示基础设施,而算子融合 Pass(Fusion Pass)则是跑在这套基础设施上、直接对抗内存墙的经典优化。本文把这两层技术串成一条完整的故事线:从 LLVM IR 为什么不够用讲起,到 MLIR 的方言系统、TOSA 与 Affine 两个关键方言,再落到算子融合的三大阶段,最后手写一个 Conv+BN 融合 Pass,并讨论融合的适用边界。文中所有 mlir-opt 演示(方言下降、循环分块、循环融合)均在真实环境跑通并附原始输出,复现方式见文末。

 

一、语义鸿沟:为什么 LLVM IR 不够用

LLVM 是过去二十年最成功的编译器基础设施之一,但如果把 TensorFlow/PyTorch 的计算图直接下译到 LLVM IR,会发生什么?

 

图片

问题出在语义级别上。LLVM IR 的语义大致等同于"带有向量操作的 C 语言"。它预设了扁平化、线性的内存模型,主要操作标量、内存指针和一维向量寄存器(Lattner et al., MLIR: A Compiler Infrastructure for the End of Moore's Law, arXiv:2002.11054, 2020)。

而深度学习计算图的本质是高维张量代数 + 深层嵌套循环。两者的语义鸿沟意味着:一旦高级框架直接下译到 LLVM IR。

  • 多维张量被强制展平为一维内存指针,张量语义彻底丢失;

  • 高层的循环树结构被破坏,转为隐式的扁平控制流图(CFG)和条件分支跳转。

丢失的不只是"好看的代码",而是优化机会本身。张量级别能看出来的模式(两个逐元素算子共享同一个访存循环、卷积与归一化可以共享数据块),在一维指针和扁平 CFG 里都已不存在。等编译器降到 LLVM IR 再想融合,等于要从不定长指针运算中"逆向推理"出张量语义,代价极高且不可靠。

MLIR 的解法是承认层级。不要一层 IR 通吃所有抽象,而是让多个层级的中间表示在同一个编译器里共存、逐级下降。MLIR 由 Chris Lattner 团队于 2019 年开源,2020 年起贡献给 LLVM 基金会并在 LLVM 仓库中维护,如今是 AI 编译器事实上的基础设施。

 

图片

 

 

二、MLIR:一个极简内核,一切皆可扩展

MLIR(Multi-Level Intermediate Representation)的架构哲学是"极简内核 + 可扩展一切"。它的核心组件只有五个:

  • Module(模块):封装整个编译单元的顶层容器,隔离外部作用域;

  • Region(区域):突破扁平 CFG 限制的关键设计,循环可以作为"一等公民"以嵌套结构直接保留;

  • Block(基本块):引入 Block Arguments,避免了传统 LLVM 中维护成本很高的 PHI 节点;

  • Operation(操作):高度统一的不透明 API,一切 IR 元素(函数、循环、张量计算)都是 Operation;

  • Attribute(属性):全局唯一化的属性字典,用于表示常量等编译期信息。

真正让这套内核"活"起来的是方言(Dialect)系统。Dialect 就是一个逻辑命名空间,封装了针对特定计算域定制的算子、类型和属性。在一个计算图里,torch(前端框架)、tensor/linalg(张量代数)、affine(循环)、llvm(机器码)等方言可以完美混存,通过方言间的 Conversion Pass 逐级转换。这带来一个关键能力:编译器能在"最合适的抽象层级"做"最适合的图优化"。融合在张量层做,循环变换在 Affine 层做,指令选择在 LLVM 层做,彼此不越俎代庖。

 

图片

TOSA:沙漏模型的颈部

在整个方言生态中,TOSA(Tensor Operator Set Architecture)占据一个特殊位置。它是独立于硬件的张量算子集规范,充当各种前端框架与后端硬件编译器之间的通用桥梁,相当于 AI 编译栈"沙漏模型"中间的颈部。

 

图片

TOSA 的算子长什么样?下面两行 tosa.add(第二行是广播语义)取自我们在 mlir-opt 22 上实测验证过、可以解析通过的形式。注意操作数是裸写的,类型是一个函数类型:

%0 = tosa.add %a, %b : (tensor<12x6xf32>, tensor<12x6xf32>) -> tensor<12x6xf32>
%1 = tosa.add %a, %s : (tensor<12x6xi32>, tensor<1x1xi32>) -> tensor<12x6xi32>

TOSA 的设计目标有三个维度,每一个都指向工程痛点:

  1. 硬件无关性:不做与特定寄存器大小、缓存层次相关的假设,只表达神经网络的数学语义;

  2. 稳定性与标准化:有严格的规范(Specification)支持,作为稳定的契约层向下游编译器保证输入 IR 的合法性,配套基于 profile 的编译期校验流程,确保算子集合落到具体芯片前完全符合其指令集能力子集;

  3. 完备与精简的平衡:用基础算子组合表达复杂算子,避免"算子爆炸",不为每个微小变体造一个新算子,减少硬件后端的实现负担。

对边缘计算尤其重要的是,TOSA 把量化当作一等公民,支持 FP32/FP16/BF16 浮点类型,原生支持 INT8/INT16/INT32/INT48 整数与量化类型(如 tosa.rescale 与卷积类算子的 acc_type 中都可见 int48),量化参数(scale、zero-point)直接嵌入算子语义,确保硬件执行精度与软件模拟严格一致。

在 MLIR 编译生态中的位置上,TOSA 向上对接前端(TF/torch/mhlo 等高阶方言可直接或间接 lower 到 tosa),向下通常降级到 linalg,再到 vector、scf,最终到 llvm dialect 供 CPU/GPU 执行。自研硬件厂商也可以直接从 TOSA 层提取计算图,映射到自定义加速器指令集。

这条下降路径的第一步可以直接复现。下面是我们在 mlir-opt 22(Ubuntu LLVM 22.1.2,WSL2 环境)上真实跑通的一例:输入是一条逐元素链,tosa.add 接 tosa.clamp(ReLU 类激活的 TOSA 形态)——

func.func @add_clamp(%a: tensor<12x6xf32>, %b: tensor<12x6xf32>) -> tensor<12x6xf32> {
%0 = tosa.add %a, %b : (tensor<12x6xf32>, tensor<12x6xf32>) -> tensor<12x6xf32>
%1 = tosa.clamp %0 {min_int = 0 : i64, max_int = 255 : i64, min_val = 0.0 : f32, max_val = 6.0 : f32} : (tensor<12x6xf32>) -> tensor<12x6xf32>
return %1 : tensor<12x6xf32>
}

执行转换(LLVM 22 中该 pass 需嵌套调度在函数上):

mlir-opt --pass-pipeline='builtin.module(func.func(tosa-to-linalg))' add_clamp.tosa.mlir

真实输出的核心部分(节选):两个 TOSA 算子都变成了 linalg.generic,tosa.add 的算术落在 arith.addf 上,tosa.clamp 则被拆成一对 maximumf(minimumf(x, max), min),clamp 的数学语义被完全展开:

map = affine_map<(d0, d1) -> (d0, d1)>
%1 = linalg.generic {indexing_maps = [#map, #map, #map], iterator_types = ["parallel", "parallel"]} ins(%arg0, %arg1 : ...) outs(%0 : ...) {
^bb0(%in: f32, %in_0: f32, %out: f32):
%4 = arith.addf %in, %in_0 : f32
linalg.yield %4 : f32
} -> tensor<12x6xf32>
%3 = linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel"]} ins(%1 : ...) outs(%2 : ...) {
^bb0(%in: f32, %out: f32):
%cst = arith.constant 0.000000e+00 : f32
%cst_0 = arith.constant 6.000000e+00 : f32
%4 = arith.minimumf %in, %cst_0 : f32
%5 = arith.maximumf %4, %cst : f32
linalg.yield %5 : f32
} -> tensor<12x6xf32>

图片

细心的读者会发现 linalg.generic 的 indexing_maps 里出现了 affine_map——下一节的主角已经提前登场了。

ODS:声明式地定义算子

在方言内部,算子通过 ODS(Operation Definition Specification) 定义:基于 LLVM TableGen(.td 文件)的声明式建模框架。它实现"单一事实来源(Single Source of Truth)"。开发者一次性声明算子的名称、操作数、属性与返回值,生成器(mlir-tblgen)在编译期自动展开为标准 C++ 声明与实现,包括强类型的 Getter/Setter(例如直接调用 .stride() 获取步长),并自动汇总所有约束生成 verify() 验证器,在图优化启动前拦截非法的类型或形状。

ODS 里一个对融合优化极其重要的能力是 Traits(特征)声明:比如给算子声明 NoMemoryEffect,等于明确告知编译器该算子无内存副作用、允许激进重排。这正是后续模式识别阶段判断"能不能融合"的语义依据之一。

 

三、Affine:把循环变换建立在可证明的依赖分析上

张量级优化做完后,计算图最终要落到循环嵌套上。此时的问题是,编译器怎么知道一段循环能不能安全地重排?

Affine Dialect 的回答是,把约束写进类型系统,让依赖分析变成可解的数学问题。它基于多面体模型(Polyhedral Model)做了工程简化,专门表达结构化控制流与多维内存访问,核心概念有四个:

  • Dimensions(维度):对应循环归纳变量(i, j, k);

  • Symbols(符号):循环嵌套中保持不变的参数(如动态张量尺寸 N、M);

  • Affine Map(仿射映射):从维度和符号到访存下标的线性变换;

  • Integer Set(整数集):用仿射约束定义的整数空间,表示 if 条件的边界。

之所以叫"仿射",是因为它的核心约束:循环边界和内存访问下标必须严格限制为循环归纳变量和符号的仿射函数。affine.for 要求循环边界已知、步长为常量。affine.load/affine.store 的下标必须是合法的仿射映射。代价是表达力受限,收益是:编译器可以通过解整数线性规划(ILP)问题,在编译期精确得知哪些循环迭代之间存在数据依赖——不是猜,是证明。

在此基础上,一系列激进的循环变换都可以放心执行。循环分块(Tiling,提升 L1/L2 Cache 命中率)、循环展开(Unrolling,增加指令级并行度)、循环融合与裂变(Fusion/Fission,减少内存往返)、循环互换(Permutation,优化访存步长)。

下面是 MLIR 官方文档中用 Affine Dialect 表达 3×3 有效卷积的完整示例。注意两层 affine.parallel 直接把"输出像素并行、卷积窗口归约"的结构表达得清清楚楚,访存下标 %D[%x + %kx, %y + %ky] 都是仿射表达式:

func.func @conv_2d(%D : memref<100x100xf32>, %K : memref<3x3xf32>) -> (memref<98x98xf32>) {
%O = memref.alloc() : memref<98x98xf32>
affine.parallel (%x, %y) = (0, 0) to (98, 98) {
%0 = affine.parallel (%kx, %ky) = (0, 0) to (2, 2) reduce ("addf") -> f32 {
%1 = affine.load %D[%x + %kx, %y + %ky] : memref<100x100xf32>
%2 = affine.load %K[%kx, %ky] : memref<3x3xf32>
%3 = arith.mulf %1, %2 : f32
affine.yield %3 : f32
}
affine.store %0, %O[%x, %y] : memref<98x98xf32>
}
return %O : memref<98x98xf32>
}

典型的下降管线是:高阶张量方言(如 linalg)的算子被 lower 为 Affine 循环嵌套 → 在 Affine 层执行密集的循环变换与并行化分析 → 优化完成后降级为通用的 SCF(Structured Control Flow)→ 最终转换为 LLVM IR 生成机器码。

这些变换同样可以真实复现。第一个实验:循环分块。 输入是一个 64×64 二维拷贝的仿射循环嵌套(两层 affine.for),执行:

mlir-opt --pass-pipeline='builtin.module(func.func(affine-loop-tile{tile-size=32}))' copy.affine.mlir

真实输出(节选)。两层循环被拆成了四层,外层以 step 32 遍历块坐标,内层的边界由 affine_map 圈出 32×32 的块,这正对应 L1/L2 Cache 能装下的数据量:

map = affine_map<(d0) -> (d0)>
map1 = affine_map<(d0) -> (d0 + 32)>
affine.for %arg2 = 0 to 64 step 32 {
affine.for %arg3 = 0 to 64 step 32 {
affine.for %arg4 = #map(%arg2) to #map1(%arg2) {
affine.for %arg5 = #map(%arg3) to #map1(%arg3) {
%0 = affine.load %arg0[%arg4, %arg5] : memref<64x64xf32>
affine.store %0, %arg1[%arg4, %arg5] : memref<64x64xf32>
}
}
}
}

图片

第二个实验:循环融合,本文主题在循环层的直接预演。 输入是一对生产者-消费者循环嵌套。第一个循环算 tmp[i,j] = a[i,j] * b[i,j],把结果写进一块 64×64 的中间缓冲;第二个循环再把 tmp 读出来加 1.0 写进输出。执行:

mlir-opt --affine-loop-fusion fuse.affine.mlir

真实输出(完整)值得逐行看。两个循环嵌套合并成了一个,mulf 和 addf 现在共处同一个循环体。更妙的是中间缓冲从 memref<64x64xf32>(16 KB)被压缩成了 memref<1x1xf32>(4 字节):

%alloc = memref.alloc() : memref<1x1xf32>
affine.for %arg3 = 0 to 64 {
affine.for %arg4 = 0 to 64 {
%0 = affine.load %arg0[%arg3, %arg4] : memref<64x64xf32>
%1 = affine.load %arg1[%arg3, %arg4] : memref<64x64xf32>
%2 = arith.mulf %0, %1 : f32
affine.store %2, %alloc[0, 0] : memref<1x1xf32>
%3 = affine.load %alloc[0, 0] : memref<1x1xf32>
%cst = arith.constant 1.000000e+00 : f32
%4 = arith.addf %3, %cst : f32
affine.store %4, %arg2[%arg3, %arg4] : memref<64x64xf32>
}
}

图片

"算子融合让中间结果留在片上"这个抽象说法,在这里变成了肉眼可见的事实。中间数组被缩到只有一个元素,每个元素的生产和消费发生在同一次迭代里。那趟 64×64 的显存往返,被整体消灭了。这正是依赖分析可信、变换才敢激进的最佳注脚。下一节我们把同样的思想提升到算子图的级别。

至此,基础设施就位。但要真正对抗内存墙,还需要在这套多层 IR 上跑一个具体的优化 Pass——这就是算子融合。

 

四、算子融合 Pass:图匹配 → 模式识别 → 子图重写

回到内存墙的动机。在未经优化的计算图中,每个算子都要经历"读主存 → 计算 → 写主存"的完整生命周期。卷积的输出特征图写回 DRAM,只为了下一拍的 BatchNorm 再把它读进来。BN 的输出写回去,再被 ReLU 读一次。中间结果在 HBM 上来回搬运,而它本可以留在 L1/L2 Cache 甚至寄存器里。

 

图片

算子融合(Operator Fusion) 的定义因此非常具体,就是将计算图中相邻的多个独立算子(如 Conv + BN + ReLU)合并为一个单一的、更高效的执行内核。收益有三条:消除中间特征图读写的 DRAM 带宽消耗、显著降低内核启动(Kernel Launch)开销、降低推理部署阶段的内存峰值占用。把这件事做到极致的范例是 FlashAttention:它用 tiling 把注意力的 HBM 读写压到最少,训练速度比既有基线显著提升(BERT-large 相比 MLPerf 1.1 纪录快 15%,GPT-2 快 3 倍,序列长度 1K。Dao et al., NeurIPS 2022)。它把"QK^T → softmax → PV"这条算子链融成了一个 IO 感知的内核。

 

图片

实现一个 Fusion Pass,通常要经过三大阶段。

阶段一:图匹配(Graph Matching)

神经网络在编译器里的基础数据结构是有向无环图(DAG):节点是算子,边是张量数据流。融合规则被定义为模式图(Pattern Graph),匹配的任务是在宿主计算图(Host Graph)中找到精确匹配,这是经典的子图同构(Subgraph Isomorphism)问题,全图匹配是 NP 完全的。

 

图片

但深度学习计算图有强领域特性,可以大幅剪枝:

  • 强类型标签过滤:基于算子类型(Conv2D、BatchNorm 等)的哈希筛选,快速排除不可能兼容的节点;

  • 拓扑排序与 Use-Def 链:顺着或逆着张量的"使用-定义"链做局部深度遍历,把搜索空间限制在数据流的邻域内;

  • 近似与退化匹配:一些前沿工作用图神经网络或结构退化特性,把匹配复杂度降到线性级(Liu et al., D2Match, ICML 2023)。

阶段二:模式识别(Pattern Recognition)

匹配到拓扑结构只是必要条件,还要验证语义合法性:

  • 数据流约束与独占性分析:DAG 中一个算子的输出可能被多个下游算子消费。做垂直融合前必须做严格的存活期(Liveness)与多用户(Multi-use)检查;

  • 操作属性与形状约束:输入张量的形状、维度、对齐要求是否满足融合条件;内存布局(Layout)是否符合硬件加速库的要求,cuDNN 等库对 NCHW/NHWC 排布有严格限制;

  • 基于代价模型的收益评估:这是最容易被忽视的一条——融合并非总是最优。过度融合会让单个内核的活跃变量暴增,导致寄存器溢出(Register Spilling)。硬件感知的代价模型会评估计算、数据搬运与启动开销之间的平衡,若预测融合收益为负,识别引擎应主动放弃这次合并。

阶段三:子图重写(Subgraph Rewriting)

验证通过后执行等价变换。理论框架是图重写的 L → R:L 为模式图(被替换的子图结构),R 为替换图(融合后的高效结构)。经典的形式化是双推拉(Double-Pushout, DPO)语义框架:宿主图被划分为匹配部分(Match)、上下文(Context)和连接两者的补丁边(Patch/Interface)。核心底线只有一条:语义一致性,给定相同输入,重写前后的计算输出必须保持一致。

 

图片

 

五、实战:手写一个 Conv+BN 融合 Pass

接下来做一个完整的代码实验:在 MLIR 中手写一个 Conv+BN 融合 Pass。这个案例选得极好,因为推理态的 BN 不需要真的"算",它可以被代数折叠进卷积权重里。

先把数学想清楚

推理态的 BatchNorm(对每个输出通道 c):

y_c = γc · (x_c − μc) / √(σc² + ε) + βc

其中卷积输出 x_c = W_c ∗ in + b_c。代入整理:

y_c = [γc / √(σc² + ε)] · (W_c ∗ in) + [γc·(b_c − μc) / √(σc² + ε) + βc]

于是 Conv+BN 等价于一个新卷积:

W′c = [γc / √(σc² + ε)] · W_c

b′c = γc·(b_c − μc) / √(σc² + ε) + βc

BN 彻底消失,融合发生在编译期权重域。这是最理想的一类融合,运行期开销干脆变成了零。(一个工程细节:折算应在 FP32 下进行,把量化/舍入推迟到最末端,精度损失可控。)

C++ 实现:三步走

MLIR 把模式定义与模式应用(如 Greedy Pattern Rewrite Driver)严格解耦,最基础的写法是继承 OpRewritePattern,实现 matchAndRewrite。下面这段是教学示意代码(未编译运行):mydl 是假设的教学方言,getFoldedScale/foldWeights/foldBias 是折算辅助函数的占位。但其中用到的每一个 MLIR 接口——OpRewritePattern、getDefiningOp、hasOneUse、notifyMatchFailure、rewriter.create/replaceOp/eraseOp——均与官方 PatternRewriter 文档逐一核对过,流程按三步组织:

struct FoldConvBatchNorm : public OpRewritePattern
mydl::BatchNormOp
{
using OpRewritePattern
mydl::BatchNormOp
::OpRewritePattern;
LogicalResult matchAndRewrite(mydl::BatchNormOp bnOp,
PatternRewriter &rewriter) const override {
// 第一步:逆向追溯——锚定根节点在下游 BN,向上游找定义者
// 从消费者向上游追溯生产者是确定且唯一的,避免多路径搜索
auto convOp = bnOp.getInput().getDefiningOp
mydl::Conv2DOp
();
if (!convOp)
return rewriter.notifyMatchFailure(bnOp, "input not defined by conv2d");
// 第二步:多用户阻断——最核心的安全防线
// 若卷积输出还被别的节点使用(典型如残差连接),折叠会污染其它分支
if (!convOp.getResult().hasOneUse())
return rewriter.notifyMatchFailure(bnOp, "conv result has multiple uses");
// 第三步:重写——编译期折算新权重,切换数据流,清理旧节点
// 权重与 BN 统计量此时都是编译期常量(DenseElementsAttr),可放心做密集张量计算
// W' = W * gamma / sqrt(var + eps);  b' = (b - mean) * gamma / sqrt(var + eps) + beta
auto scale = getFoldedScale(bnOp);                      // 每通道 gamma/sqrt(var+eps)
auto wFold = foldWeights(convOp.getWeights(), scale);
auto bFold = foldBias(convOp.getBias(), bnOp, scale);
// 结果类型与原卷积相同;ODS 生成的 builder 可自动推导
auto fusedConv = rewriter.create
mydl::Conv2DOp
(
bnOp.getLoc(), convOp.getInput(), wFold, bFold);
rewriter.replaceOp(bnOp, fusedConv.getResult());  // 下游连线全部切到新节点
rewriter.eraseOp(convOp);                         // 此刻 convOp 已无任何使用者
return success();
}
};

几个细节值得思考:

根节点为什么锚定在 BN? 模式匹配的触发点设置在下游算子上,从消费者逆向追溯生产者,这条路径是确定且唯一的。反过来从 Conv 出发找消费者则可能有多条分支,搜索逻辑复杂度立刻上升。这也是图匹配加速策略中"use-def 链局部遍历"的具体应用。

hasOneUse() 在防什么? 设想 ResNet 的残差结构:卷积输出同时喂给 BN 和一条 shortcut 支路。如果无视多用户强行折叠——权重被改写、BN 被删除——shortcut 拿到的还是旧卷积的输出,而主路已经是新卷积,数值直接错掉。一行 hasOneUse() 检查,就是"多用户阻断机制"的全部实现。

为什么所有改动必须走 rewriter? MLIR 的硬性约束:模式内一切 IR 修改(创建、替换、删除)都必须通过 PatternRewriter 完成,因为底层驱动可能缓存了 IR 状态,绕过 rewriter 直接改图会使其失效。replaceOp 会把下游所有连线切到新值并删除 BN。此时卷积已无任何使用者,eraseOp 才是合法的(eraseOp 要求操作数无使用者)。先 replace 后 erase 的顺序不是风格问题,是正确性问题。

调试这类 Pass 时,mlir-opt 提供的 greedy-rewriter 日志非常有用,能看到每个算子上哪些模式尝试匹配、为何失败(需使用启用了调试日志的 MLIR 构建;Ubuntu 发行版的 mlir-opt-22 包未包含该支持,实测报 Unknown command line argument):

mlir-opt --debug-only=greedy-rewriter conv_bn.mlir

声明式写法:DRR 与 PDLL

C++ 命令式写法自由度最高(可以直接操作底层 IR、写复杂数学逻辑),但样板代码多、图拓扑不直观。MLIR 因此提供了声明式重写规则 DRR(Table-driven Declarative Rewrite Rule):用 DAG 语法 (Source DAG) -> (Result DAG) 声明规则,编译期展开为 C++ 代码。Conv+BN 折叠的骨架大致是:

// 示意骨架:BN(input = Conv2D(input, W, b), gamma, beta, mean, var)
//          => Conv2D(input, foldW(W, gamma, var), foldB(b, gamma, beta, mean, var))
// 折算逻辑放在 C++ 辅助函数里,$_builder 会被替换为当前的 PatternRewriter
def foldW : NativeCodeCall<"foldWeights(
0, $1, $2)">;
def foldB : NativeCodeCall<"foldBias(
0, $1, $2, $3, $4)">;
def : Pat<(BatchNormOp (Conv2DOp:
input, 
bias),
beta, 
var),
(Conv2DOp 
weight, 
var),
(foldB 
gamma, 
mean, $var))>;

实际工程中把折算逻辑放进 NativeCodeCall 引用的 C++ 辅助函数($_builder 会被替换为当前 PatternRewriter)。DRR 的规则收益值默认等于源模式中的算子个数("大模式优先匹配"的启发式)。需要注意的是 DRR 擅长算子到算子的转换,不擅长"把一个算子展开成循环嵌套"这类重写。更新的 PDLL 是专为 MLIR 设计的模式描述语言,原生支持多结果操作、区域和可变参数,支持 AOT 编译与运行时 JIT 字节码解释,是更现代的选择。融合规则积累到几十上百条,声明式规则在可读性和维护成本上的优势会非常明显。

 

六、融合的边界:什么时候不该融合

还有一条原则在实践中被反复验证:融合并非总是最优。这一点值得展开成工程判断,因为它正是融合 Pass 的设计难点所在。

融合的收益来自消除访存,代价来自资源占用。 逐元素算子链(Add、Mul、激活函数)融合几乎总是安全的,每个元素只被碰一次,寄存器压力可控。但把两个大 GEMM 融在一起,通常需要为中间结果预留巨大的寄存器/共享内存空间,要么溢出要么挤占 occupancy,得不偿失。这就是代价模型存在的意义。FlashAttention 的成功不是"融合万能"的证明,恰恰是"融合要挑对结构"的证明,注意力链路中 QK^T、softmax、PV 的中间结果是分块可消化的,tiling 让每块数据在 SRAM 里走完全程,这个前提太特殊了。

检查逻辑决定正确性边界。 hasOneUse 防残差,liveness 检查防中间结果还有后用,布局检查防 NCHW/NHWC 错配。每一条检查都对应一类真实网络的翻车案例。漏掉一条,融合 Pass 就会在某个模型上悄悄产出错误结果,而且往往精度只是略微下降,很难被发现。工程上建议给 Pass 加等价性校验开关:融合前后对随机输入跑逐层对比。

训练与推理是两个世界。 本文的 BN 折叠只对推理成立,训练态下 μ、σ 是随批次更新的运行统计量,BN 必须显式存在。把推理优化误用到训练图上,是融合 Pass 的经典 bug 来源。

编译时间也是成本。 融合规则库会随支持的网络结构持续膨胀,模式匹配在超大计算图上的开销、规则间的冲突消解,都会拖慢编译。这也是 DRR/PDLL 这类声明式方案被推动的深层原因。规则更紧凑、可分析性更好,驱动器才有机会做全局优化。

 

图片

七、回到 FlagOS:机制如何长在统一软件栈里

把视线拉高一层:这些编译机制在真实的统一系统软件栈中处于什么位置?

FlagOS 是智源联合多家机构共同推出的统一 AI 系统软件栈:向下支持英伟达架构及各类国产 AI 加速芯片与边缘算力模组,中间核心层包含通用大模型算子库(FlagGems)、统一编译底座(FlagTree 系列)、并行训推框架与统一通信库,向上对接主流深度学习框架与大模型、多模态、具身智能模型,目标是"一次开发、跨芯迁移"。

本文讲的机制就嵌在下面这张图里:FlagTree 的 CPU 后端把 Triton 算子经 MLIR、LLVM 编译执行,正是 Part.1~Part.3 描述的多层下降管线的一次工程落地。

 

图片

而算子融合作为跨芯迁移中的关键优化,其代价模型必须感知目标芯片的资源参数(寄存器文件、共享内存、缓存层次),同一份融合决策规则在不同芯片上可能给出不同答案。这正是 TOSA"硬件无关描述 + 后端各自决策"分层设计的价值所在。编译器基础设施的意义,就在于让这些针对每种芯片的适配工作不必从零开始。

 

八、结语

从内存墙出发,我们走完了一条完整的链路:LLVM IR 的语义鸿沟催生了 MLIR 的多层中间表示;Dialect 系统让张量级(TOSA/linalg)与循环级(Affine)优化各得其所;算子融合 Pass 在这套基础设施上通过图匹配、模式识别、子图重写三阶段,把 Conv+BN 这样的算子链在编译期折叠成一个内核;而代价模型与独占性检查,划定了融合的适用边界。

一句话总结全文的核心,编译器优化的本质,是在正确的抽象层级上,用可证明的安全检查换取更激进的变换。MLIR 提供了层级,融合 Pass 示范了变换,hasOneUse() 那一行代码示范了证明。

参考与复现

关键数据与引文来自 Lattner et al.(MLIR,arXiv:2002.11054,2020)、Gholami et al.(AI and Memory Wall,IEEE Micro 44(3),2024)、Dao et al.(FlashAttention,NeurIPS 35,2022)、Liu et al.(D2Match,ICML 2023)及 MLIR 官方文档(Pattern Rewriting / DRR / Affine / TOSA / Passes)。

实操环境为 WSL2 Ubuntu 26.04 + mlir-22-tools(Ubuntu LLVM 22.1.2),输入文件逻辑如正文代码块所示,所有 IR 输出为 mlir-opt-22 真实运行结果,命令随文给出、可复现。

 

关于众智FlagOS社区

为解决不同 AI 芯片大规模落地应用,北京智源研究院联合众多科研机构、芯片企业、系统厂商、算法和软件相关单位等国内外机构共同发起并创立了众智 FlagOS 社区,目前已经有 100多家成员单位。

FlagOS 是一款专为异构 AI 芯片打造的开源、跨芯系统软件栈,支持 AI 模型一次开发即可无缝移植至各类硬件平台,大幅降低迁移与适配成本。它包括大型算子库、跨芯AI 编译器、并行训推框架、跨芯通信库等核心开源项目,致力于构建「模型-系统-芯片」三层贯通的开放技术生态,通过"一次开发跨芯迁移"释放硬件计算潜力,打破不同芯片软件栈之间生态隔离。

 

官网:https://flagos.io

GitHub 项目地址:https://github.com/flagos-ai

GitCode 项目地址:https://gitcode.com/flagos-ai

SkillHub: https://skillhub.flagos.io

Logo

欢迎来到FlagOS开发社区,这里是一个汇聚了AI开发者、数据科学家、机器学习爱好者以及业界专家的活力平台。我们致力于成为业内领先的Triton技术交流与应用分享的殿堂,为推动人工智能技术的普及与深化应用贡献力量。

更多推荐