第 8 课:Pattern Rewrite
文章目录
好,开始第 8 课。
这一课我们正式进入 Pattern Rewrite。这是 MLIR 里做局部优化、规范化、Lowering 时最核心的机制之一。
第 8 课:Pattern Rewrite
先看最简单的优化:
x + 0 → x
比如原始 IR:
%zero = arith.constant 0 : i32
%0 = arith.addi %x, %zero : i32
我们希望优化成:
// %0 直接用 %x 替代
也就是:
arith.addi 消失
%0 的所有使用 → %x
这就是一个典型的 Rewrite Pattern。
1. Pattern 是什么?
可以先把 Pattern 理解成:
“如果看到某种 IR 形状,就把它改写成另一种形状。”
比如:
匹配:
x + 0
重写:
x
或者:
匹配:
x * 1
重写:
x
再比如:
匹配:
某个 mydialect.foo
重写:
arith.addi + arith.muli
所以 Pattern 不只是做“优化”。
它也能做:
Canonicalization
Lowering
Dialect Conversion
IR Cleanup
2. 一个 Pattern 的基本结构
MLIR C++ 里常见写法类似:
struct AddZeroPattern
: public OpRewritePattern<arith::AddIOp> {
using OpRewritePattern::OpRewritePattern;
LogicalResult matchAndRewrite(
arith::AddIOp op,
PatternRewriter &rewriter) const override {
...
}
};
先只看三个东西:
OpRewritePattern<arith::AddIOp>
表示:
这个 Pattern 专门匹配
arith.addi
然后:
matchAndRewrite(...)
表示:
尝试匹配,如果匹配成功就重写
最后:
PatternRewriter &rewriter
负责:
安全地修改 IR
3. 为什么是 matchAndRewrite?
因为 Pattern 有两个阶段:
match
↓
看看这个 Operation 是否符合规则
rewrite
↓
如果符合,就执行修改
例如我们的规则:
x + 0 → x
不是所有 arith.addi 都能改。
比如:
%0 = arith.addi %a, %b : i32
如果 %b 不是 0,就不能改。
所以必须:
先检查
再修改
4. LogicalResult
matchAndRewrite 一般返回:
LogicalResult
常见两个值:
success()
failure()
意思分别是:
success()
= 匹配成功,并完成重写
failure()
= 不匹配,不做修改
所以大概会写:
if (不符合条件)
return failure();
执行重写;
return success();
5. 怎么判断右边是不是 0?
假设:
%zero = arith.constant 0 : i32
%0 = arith.addi %x, %zero : i32
我们拿到:
op.getRhs()
它得到的是一个:
Value
即:
%zero
但我们需要知道:
%zero 是谁定义的?
所以要沿 Def 向上找。
概念上:
%zero
↑
def
↑
arith.constant 0
这时就体现出上一课学的:
Def-Use
的重要性。
6. 找到定义它的 Operation
概念上可以这么做:
Value rhs = op.getRhs();
auto constant =
rhs.getDefiningOp<arith::ConstantIntOp>();
意思是:
看看
%rhs是否由arith.constant定义。
如果不是:
if (!constant)
return failure();
如果是,再检查它是不是 0:
if (constant.value() != 0)
return failure();
于是匹配逻辑就完成了。
7. 真正开始 Rewrite
一旦确认:
rhs = 0
我们原来有:
%0 = arith.addi %x, %zero : i32
希望变成:
%0 的所有 use → %x
最方便的方法:
rewriter.replaceOp(op, op.getLhs());
这句话非常关键。
意思是:
用
%x替代arith.addi的结果,然后删除这个 Operation。
也就是:
原来:
arith.addi
|
v
%0
|
├── user A
└── user B
替换后:
%x
|
├── user A
└── user B
这本质上就是我们上一课讲的:
RAUW
8. 一个完整的概念版 Pattern
可以写成:
struct AddZeroPattern
: public OpRewritePattern<arith::AddIOp> {
using OpRewritePattern::OpRewritePattern;
LogicalResult matchAndRewrite(
arith::AddIOp op,
PatternRewriter &rewriter) const override {
auto constant =
op.getRhs()
.getDefiningOp<arith::ConstantIntOp>();
if (!constant)
return failure();
if (constant.value() != 0)
return failure();
rewriter.replaceOp(op, op.getLhs());
return success();
}
};
先别纠结 API 名字,理解流程最重要:
找到 addi
↓
看 rhs
↓
看 rhs 是否由 constant 定义
↓
检查 constant == 0
↓
replaceOp
9. replaceOp() 到底做了什么?
假设:
%0 = arith.addi %x, %zero : i32
%1 = arith.muli %0, %y : i32
运行:
rewriter.replaceOp(op, op.getLhs());
之后:
%1 = arith.muli %x, %y : i32
原来的:
%0 = arith.addi ...
被删掉。
所以你可以把:
replaceOp
理解成:
1. Replace All Uses
2. Erase old Operation
10. eraseOp()
有时候一个 Operation 根本不需要任何替代 Value。
比如:
无副作用
且结果没人使用
那可能直接:
rewriter.eraseOp(op);
也就是:
删除这个 Operation。
例如:
%0 = arith.addi %a, %b : i32
func.return
如果 %0 完全没人用,并且这个 Operation 没副作用,就可以删掉。
11. replaceOpWithNewOp()
还有一个非常常见的 API:
rewriter.replaceOpWithNewOp<NewOp>(...)
意思是:
创建一个新的 Operation,并用它替换旧 Operation。
例如概念上:
old.foo
↓
arith.addi
就可能写:
rewriter.replaceOpWithNewOp<arith::AddIOp>(
op,
op.getLhs(),
op.getRhs());
这在 Dialect Lowering 里非常常见。
12. create()
如果不是直接替换,而是需要先创建一些辅助 Operation,可以:
rewriter.create<SomeOp>(...)
比如把一个复杂 Operation:
foo.op
降低成:
arith.addi
arith.muli
那么大概:
auto a = rewriter.create<arith::AddIOp>(...);
auto b = rewriter.create<arith::MulIOp>(...);
rewriter.replaceOp(op, b.getResult());
也就是:
旧 op
↓
创建多个新 op
↓
用最终结果替换旧 op
13. Rewriter 为什么重要?
你可能会问:
为什么不能直接
erase()、自己改 use?
因为 PatternRewriter 会帮你正确维护:
SSA
Def-Use
Insertion Point
Operation ownership
Listener / Rewrite bookkeeping
特别是在复杂 Rewrite 框架里,不应该绕过 Rewriter 随便改。
所以有个很实用的原则:
在 Pattern 里修改 IR,优先通过
PatternRewriter。
14. Pattern 不一定只匹配一个 Operation
虽然:
OpRewritePattern<arith::AddIOp>
入口是 arith.addi,
但匹配时你完全可以继续沿:
Operand
DefiningOp
Users
Parent
向周围看。
例如:
%0 = arith.addi %a, %b : i32
%1 = arith.muli %0, %c : i32
Pattern 可以匹配:
addi → muli
这样一个局部子图。
所以 Pattern 实际匹配的可以是:
IR graph pattern
而不仅仅是一行文本。
15. 一个稍微复杂一点的 Pattern
比如:
(x + 0) * 1 → x
IR:
%zero = arith.constant 0 : i32
%one = arith.constant 1 : i32
%0 = arith.addi %x, %zero : i32
%1 = arith.muli %0, %one : i32
可以一步步:
%1
↓
muli
↓ lhs
%0
↓ def
addi
↓ rhs
0
Pattern 就是在沿着 Def-Use 图检查结构。
16. Pattern 可以反复应用
假设有两个规则:
x + 0 → x
x * 1 → x
IR:
%0 = x + 0
%1 = %0 * 1
先应用:
x + 0 → x
变成:
%1 = x * 1
然后再应用:
x * 1 → x
最后:
x
所以 Rewrite Driver 经常会:
不断寻找可匹配 Pattern,直到不能再改。
17. Greedy Pattern Rewrite
MLIR 很常见一个机制:
Greedy Rewrite
大意就是:
只要还能匹配
就继续改
流程类似:
IR
↓
Pattern A 匹配?
↓ yes
改
再检查
↓
Pattern B 匹配?
↓ yes
改
继续
...
直到:
没有 Pattern 能继续应用
18. RewritePatternSet
如果我们有很多规则:
AddZeroPattern
MulOnePattern
SubZeroPattern
一般会放进:
RewritePatternSet patterns(context);
patterns.add<AddZeroPattern>(context);
patterns.add<MulOnePattern>(context);
patterns.add<SubZeroPattern>(context);
可以理解成:
patterns
├── x + 0 → x
├── x * 1 → x
└── x - 0 → x
然后交给 Rewrite Driver。
19. Pass + Pattern
现在把第 7 课和第 8 课真正串起来。
一个 Pass 可能这样工作:
Pass
↓
创建 RewritePatternSet
↓
加入 Pattern A/B/C
↓
调用 greedy rewrite
↓
Pattern 不断修改 IR
概念代码:
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
patterns.add<AddZeroPattern>(&getContext());
patterns.add<MulOnePattern>(&getContext());
applyPatternsGreedily(
getOperation(),
std::move(patterns));
}
所以:
Pass = 执行框架
Pattern = 局部规则
Rewriter = 修改工具
20. Canonicalization 本质上就大量依赖 Pattern
比如:
x + 0 → x
x * 1 → x
x - 0 → x
这些都属于:
Canonicalization
也就是把 IR 变成更规范、更简单的形式。
所以你以后看到:
mlir-opt test.mlir --canonicalize
背后很大一部分就是:
运行很多 canonicalization patterns
21. Pattern Rewrite 和 Lowering 的关系
这是最关键的地方。
假设我们自定义:
my.add %a, %b
想 Lower 成:
arith.addi %a, %b
那 Pattern 就可以:
match:
my.add
rewrite:
arith.addi
大概:
rewriter.replaceOpWithNewOp<arith::AddIOp>(
op,
op.getLhs(),
op.getRhs());
所以:
Dialect Lowering
很多时候本质上也是:
Pattern Rewrite
只是规则更系统、更严格。
22. Pattern 的本质:图重写
这是这一课最重要的理解。
不要只把:
x + 0 → x
看成“文本替换”。
真正发生的是:
IR Graph
before:
%x ----\
addi ----> %0 ----> users
0 ----/
after:
%x -----------------------> users
也就是:
对 SSA Def-Use 图进行局部重写。
这就是为什么 Pattern Rewrite 这么强。
23. Pattern 和 AST Rewrite 的区别
如果你以前接触过 AST,可以类比:
AST Rewrite:
a + 0
↓
a
但 MLIR Rewrite 操作的是:
SSA IR
Operation
Value
Region
Block
Def-Use
所以它不仅改“语法树”,还必须维护数据流。
第 8 课总结
今天最重要的是这几个概念:
Pattern
= 局部 IR 改写规则
matchAndRewrite()
= 匹配 + 重写入口
PatternRewriter
= 安全修改 IR 的工具
几个关键 API:
rewriter.replaceOp(...)
rewriter.eraseOp(...)
rewriter.create<...>(...)
rewriter.replaceOpWithNewOp<...>(...)
然后:
RewritePatternSet
用于保存一组 Pattern。
多个 Pattern 可以交给:
Greedy Rewrite Driver
不断应用。
最核心的一句话是:
Pattern Rewrite 本质上是在重写 SSA Def-Use 图,而不是做字符串替换。
到这里,你已经开始接近 MLIR 真正的核心工作方式了。
下一课我们可以继续讲 第 9 课:Dialect Conversion 和 Lowering。这会比普通 Pattern 更进一步,我们会讲:
Legal / Illegal Dialect
ConversionTarget
TypeConverter
ConversionPattern
并真正理解 MLIR 是怎么把:
高层 Dialect
↓
低层 Dialect
一层层 Lower 下去的。

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