第 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 下去的。

评论

暂无评论