第 7 课(下):真正理解 runOnOperation() 和 walk()
文章目录
好,我们继续把第 7 课:Pass 往下讲深一点。这一部分重点放在“一个 Pass 到底怎么在代码里工作”。
第 7 课(下):真正理解 runOnOperation() 和 walk()
先看一个完整一点的 MLIR:
module {
func.func @foo(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
%1 = arith.muli %0, %b : i32
func.return %1 : i32
}
func.func @bar(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
%1 = arith.addi %0, %b : i32
func.return %1 : i32
}
}
假设我们写一个 Pass:
统计每个函数里有多少个
arith.addi
那么逻辑应该是:
module
├── foo
│ └── 1 个 addi
│
└── bar
└── 2 个 addi
1. Pass 到底挂在哪个 Operation 上?
MLIR Pass 经常会写成类似:
OperationPass<func::FuncOp>
这句话非常重要。
它表示:
这个 Pass 会以
func.func为处理单位。
所以:
func.func @foo(...) {
}
会运行一次。
然后:
func.func @bar(...) {
}
又运行一次。
也就是说概念上是:
runOnOperation(foo)
runOnOperation(bar)
所以你写:
void runOnOperation() override {
...
}
第一次执行时:
getOperation()
得到:
foo
第二次:
bar
2. 一个概念版 Pass
先看代码,不要求现在完全会写:
struct CountAddPass
: public PassWrapper<
CountAddPass,
OperationPass<func::FuncOp>> {
void runOnOperation() override {
func::FuncOp func = getOperation();
int count = 0;
func.walk([&](arith::AddIOp op) {
count++;
});
llvm::outs()
<< func.getName()
<< ": "
<< count
<< "\n";
}
};
如果运行在前面的 IR 上,大概输出:
foo: 1
bar: 2
3. getOperation() 是什么意思?
这是写 MLIR Pass 时非常核心的一个 API。
func::FuncOp func = getOperation();
意思就是:
获取当前 Pass 正在处理的 Operation。
因为我们的 Pass 是:
OperationPass<func::FuncOp>
所以返回:
func::FuncOp
如果我们写的是:
OperationPass<ModuleOp>
那么:
getOperation()
拿到的就是:
module
所以可以理解为:
OperationPass<T>
│
▼
getOperation()
│
▼
T
4. walk() 在干什么?
假设:
func.func @foo(...) {
%0 = arith.addi ...
scf.if %cond {
%1 = arith.addi ...
}
}
结构不是平的,而是:
func.func
│
└── Region
│
└── Block
│
├── arith.addi
│
└── scf.if
│
└── Region
│
└── Block
│
└── arith.addi
如果我们只遍历函数最外面的 Block:
看到第一个 addi
看到 scf.if
但是里面那个:
arith.addi
可能看不到。
而:
func.walk(...)
会递归进去。
所以:
func
↓
block
↓
scf.if
↓
region
↓
block
↓
arith.addi
全都可以遍历。
5. walk() 还能按类型过滤
比如:
func.walk([&](arith::AddIOp op) {
...
});
意思其实是:
只在遇到
arith.addi的时候调用这个 lambda。
如果 IR:
%0 = arith.addi ...
%1 = arith.muli ...
%2 = arith.subi ...
%3 = arith.addi ...
那么回调只执行两次:
第一个 arith.addi
第二个 arith.addi
这个 API 很舒服。
不需要自己写:
if (op->getName() == ...)
6. Typed Operation
这里顺便引出一个 MLIR 非常重要的 C++ 概念:
Typed Operation
比如文本里:
arith.addi
在 C++ 中对应:
arith::AddIOp
文本:
func.func
对应:
func::FuncOp
文本:
scf.for
对应:
scf::ForOp
所以关系是:
MLIR Text C++
arith.addi → arith::AddIOp
arith.muli → arith::MulIOp
func.func → func::FuncOp
scf.if → scf::IfOp
scf.for → scf::ForOp
以后你写 Pass,基本一直和这些 C++ 类型打交道。
7. Operation * 和 arith::AddIOp 有什么区别?
MLIR 底层有一个通用:
Operation *
它可以代表:
任何 Operation
例如:
arith.addi
func.func
scf.for
memref.load
都可以用:
Operation *
表示。
但是如果你知道它一定是:
arith.addi
那么用:
arith::AddIOp
就更方便。
比如你可以直接:
op.getLhs()
op.getRhs()
而不用自己从:
op->getOperand(0)
op->getOperand(1)
里取。
所以可以理解:
Operation *
=
通用底层表示
arith::AddIOp
=
强类型封装
这和 C++ 里:
void *
与具体类型有一点点类似,不过只是帮助理解。
8. Pass 可以查看 Operand
例如:
%0 = arith.addi %a, %b : i32
在 C++ 中:
func.walk([&](arith::AddIOp op) {
Value lhs = op.getLhs();
Value rhs = op.getRhs();
});
这里:
lhs = %a
rhs = %b
因此:
Operation
│
├── Operand 0
└── Operand 1
就可以在 C++ 里访问。
9. Pass 也可以查看 Result
例如:
%0 = arith.addi %a, %b : i32
可以拿:
Value result = op.getResult();
那么:
result
↓
%0
所以你前面学的:
Operand
Result
Value
现在开始和 C++ API 对上了。
这也是为什么我们前面没有直接上代码。
如果不理解 IR:
getOperand()
getResult()
getOperation()
这些 API 就会显得很乱。
10. Pass 可以访问 User
假设:
%0 = arith.addi %a, %b : i32
%1 = arith.muli %0, %c : i32
%2 = arith.subi %0, %d : i32
这里:
%0
有两个 Use:
arith.muli
arith.subi
C++ 中可以沿着:
Value → Users
去找。
概念上类似:
for (Operation *user : result.getUsers()) {
...
}
得到:
arith.muli
arith.subi
这就是:
Def-Use Chain
真正被 Pass 使用的地方。
11. 从 Operation 往上走
MLIR 不只是可以:
父 → 子
也可以:
子 → 父
假设:
func.func @foo() {
scf.for ... {
%0 = arith.addi ...
}
}
arith.addi 的结构:
func.func
↓
scf.for
↓
arith.addi
从 addi 可以逐渐找到它的父 Operation。
概念上:
addi
↓ parent
scf.for
↓ parent
func.func
所以 Pass 可以问:
这个 Operation 是不是在某个循环里面?
或者:
它属于哪个函数?
这是做优化时特别重要的能力。
12. 分析 Pass 的一个例子
假设想检查:
哪些
arith.addi位于scf.for里面?
IR:
func.func @foo(...) {
%0 = arith.addi %a, %b : i32
scf.for %i = %c0 to %c10 step %c1 {
%1 = arith.addi %a, %b : i32
}
}
结构:
func
│
├── addi ← 不在 loop
│
└── scf.for
│
└── addi ← 在 loop
Pass 就可以:
walk 所有 addi
↓
检查 parent
↓
有没有 scf.for
这样就可以分析循环内部的计算。
13. Pass 为什么经常配合 Pattern?
假设我们现在想优化:
%x = arith.addi %a, %zero : i32
你当然可以在 Pass 中:
walk 所有 addi
↓
检查 rhs 是否为 0
↓
替换 %x 为 %a
↓
删除 addi
但如果有很多优化:
x + 0 → x
x * 1 → x
x * 0 → 0
x - 0 → x
Pass 里面很快会变成:
巨大的一坨 if/else
所以 MLIR 把:
“遍历 IR”
和:
“局部改写规则”
分离了。
也就是:
Pass
↓
运行一组 Patterns
14. Pass 更像“管理者”
你可以逐渐形成一个新的认识:
Pass
不一定自己亲自做所有修改。
很多 Pass 更像:
准备环境 + 收集 Rewrite Pattern + 启动 Pattern Rewriter。
比如:
Canonicalization Pass
│
├── pattern A
├── pattern B
├── pattern C
└── pattern D
然后框架不断寻找:
能匹配的 Operation
并重写。
这就是下一课的核心。
15. 再区分三个概念
现在这三个词千万别混:
Operation
是:
IR 中的节点
例如:
arith.addi
Pattern
是:
如何改写某种 IR
例如:
x + 0 → x
Pass
是:
什么时候、在哪里运行分析或 Rewrite
关系:
Pass
│
├── 遍历 Operation
│
└── 应用 Pattern
16. mlir-opt 又在哪里?
整个关系现在可以画完整了:
mlir-opt
│
▼
PassManager
│
┌────────┼────────┐
▼ ▼ ▼
Pass1 Pass2 Pass3
│
▼
Operation
│
▼
walk()
│
▼
Rewrite / Analysis
所以你执行:
mlir-opt test.mlir --cse --canonicalize
背后的逻辑大概就是:
mlir-opt
↓
构造 PassManager
↓
加入 CSE Pass
↓
加入 Canonicalize Pass
↓
pm.run(module)
17. 这一点和 LLVM 很像
你之前学过 LLVM 的话,可以对应起来:
LLVM MLIR
LLVM IR MLIR IR
opt mlir-opt
Pass Pass
PassManager PassManager
但 MLIR 最大的不同之一是:
LLVM Pass
通常面对 LLVM 固定的一套 IR。
而:
MLIR Pass
可以面对:
自定义 Dialect
arith
scf
linalg
gpu
llvm
...
所以可扩展性强很多。
第 7 课完整总结
到这里,第 7 课的 Pass 可以形成一个完整模型了:
Pass
│
getOperation()
│
▼
当前 Operation
│
walk()
│
┌─────────┴─────────┐
▼ ▼
Analysis Transform
│
▼
Pattern/Rewriter
最需要掌握的是:
OperationPass<T>
决定 Pass 的运行单位。
getOperation()
获取当前处理的 Operation。
walk()
递归遍历内部 Operation。
Value / getUsers()
可以沿 Def-Use 分析数据流。
Pattern / Rewriter
负责更规范地修改 IR。
还有一个非常重要的思维转变:
Pass 不等于 Rewrite。
Pass 是一个更大的“执行单位”,而 Pattern 是具体的“局部改写规则”。
下一课就可以正式进入 第 8 课:Pattern Rewrite。
我们会从最简单的:
x + 0 → x
开始,真正解释:
matchAndRewrite(...)
PatternRewriter
replaceOp(...)
eraseOp(...)
然后你会第一次看到一个接近真实 MLIR 源码的 Rewrite Pattern。

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论