第 7 课:Pass 是什么?

好,继续第 7 课。

这节我们专门学习 Pass。这是 MLIR 真正开始“动起来”的地方。

第 7 课:Pass 是什么?

先记一句最核心的话:

Pass = 对 IR 做一次分析或变换。

比如:

原始 IR
  ↓
CSE Pass
  ↓
去掉重复表达式后的 IR

或者:

scf Dialect
  ↓
Lowering Pass
  ↓
cf Dialect

1. Pass 能做什么?

大体分两类:

Analysis Pass
Transformation Pass

也就是:

分析型
变换型

分析型 Pass 可能只是检查:

某个 Value 被谁使用
循环有几个
哪些 Operation 有副作用

不修改 IR。

变换型 Pass 会真的改 IR,例如:

常量折叠
删除死代码
CSE
循环展开
Dialect Lowering

2. Pass 操作的是 Operation

MLIR 里所有东西最终都围绕:

Operation

展开。

例如:

module {
  func.func @foo(%a: i32, %b: i32) -> i32 {
    %0 = arith.addi %a, %b : i32
    func.return %0 : i32
  }
}

结构是:

builtin.module
    ↓
func.func
    ↓
arith.addi
func.return

Pass 可以选择运行在某一类 Operation 上。

比如:

针对 module

或者:

针对 func.func

3. Pass 的“运行层级”

假设有:

module {
  func.func @foo() {
    ...
  }

  func.func @bar() {
    ...
  }
}

一个 Module-level Pass 可能看到的是:

module
├── foo
└── bar

它适合做:

跨函数分析
全局符号处理
模块级转换

而 Function-level Pass 会分别跑:

foo
bar

大概像:

runOnOperation(foo)
runOnOperation(bar)

4. runOnOperation()

以后你写 C++ Pass 时,会经常见:

void runOnOperation() override {
    ...
}

这里的:

getOperation()

会拿到当前 Pass 正在处理的 Operation。

如果这是一个:

OperationPass<func::FuncOp>

那么:

getOperation()

拿到的就是当前函数。


5. 一个非常简单的 Pass 思路

假设我们想统计:

一个函数里有多少个 arith.addi

IR:

func.func @foo(%a: i32, %b: i32) -> i32 {
  %0 = arith.addi %a, %b : i32
  %1 = arith.addi %0, %b : i32
  %2 = arith.muli %1, %a : i32
  func.return %2 : i32
}

我们希望得到:

arith.addi count = 2

6. 怎么遍历 Operation?

MLIR 常见方式是:

op->walk(...)

概念上像这样:

func.walk([&](Operation *op) {
    ...
});

遍历结构:

func.func
   │
   ├── arith.addi
   ├── arith.addi
   ├── arith.muli
   └── func.return

然后检查:

是不是 arith.addi

7. walk() 为什么很重要?

因为 MLIR 是嵌套结构。

比如:

func.func @foo(...) {
  scf.if %cond {
    scf.for ... {
      %0 = arith.addi ...
    }
  }
}

结构其实是:

func.func
  └── Region
      └── Block
          └── scf.if
              └── Region
                  └── Block
                      └── scf.for
                          └── Region
                              └── Block
                                  └── arith.addi

如果手动一层层找很麻烦。

walk() 可以递归遍历。


8. 一个概念版 C++ 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() << count << "\n";
  }
};

核心只有三步:

拿当前函数
   ↓
walk
   ↓
找 arith.addi

9. Pass 也可以修改 IR

比如:

%0 = arith.addi %a, %b : i32

我们想把某个 Operation 替换掉。

MLIR 一般不会建议你直接乱改结构,而是通过:

Rewriter

或:

Pattern Rewrite

来做。

后面我们会专门学。


10. 为什么不能随便改?

因为 IR 里有很多关系:

Def-Use
SSA
Region ownership
Block structure
Type consistency

比如:

%0 = arith.addi %a, %b : i32
%1 = arith.muli %0, %c : i32

如果你直接把 %0 对应的 Operation 删掉:

arith.addi 消失

那:

%1 还在使用 %0

IR 就坏了。

所以修改 IR 时必须保证:

所有 use 被正确更新

11. RAUW

这里介绍一个以后会经常见的词:

RAUW

全称:

Replace All Uses With

意思是:

把一个 Value 的所有使用替换成另一个 Value。

比如:

%0 = arith.addi %a, %zero : i32
%1 = arith.muli %0, %b : i32

如果我们知道:

a + 0 = a

那么可以把:

%0 的所有 use

替换为:

%a

变成:

%1 = arith.muli %a, %b : i32

然后 %0 没人用了,就可以删除。


12. 这就是很多优化的基本套路

很多优化本质上就是:

匹配某种模式
    ↓
构造更好的 IR
    ↓
替换旧 Value
    ↓
删除旧 Operation

比如:

x + 0

变成:

x

或者:

x * 1

变成:

x

13. Pass 和 Rewrite Pattern 的关系

Pass 是:

一次遍历 / 一次处理过程

Pattern 是:

一个局部改写规则

比如:

AddZeroPattern:

匹配:
  x + 0

改成:
  x

然后一个 Pass 可以运行很多 Pattern:

Canonicalization Pass
├── AddZeroPattern
├── MulOnePattern
├── FoldConstantPattern
└── ...

14. Pass 可以做 Dialect Lowering

这个是 MLIR 里非常重要的一类 Pass。

比如:

scf.if

Lower 成:

cf.cond_br

也就是:

结构化控制流
       ↓
CFG 控制流

再比如:

memref
   ↓
llvm

最终:

LLVM Dialect

这些通常都由 Pass 完成。


15. Pass Pipeline

假设有:

Pass A
Pass B
Pass C

组合起来:

IR
 ↓
Pass A
 ↓
IR'
 ↓
Pass B
 ↓
IR''
 ↓
Pass C
 ↓
IR'''

这就是:

Pass Pipeline

比如:

canonicalize
↓
cse
↓
convert-scf-to-cf
↓
convert-arith-to-llvm

16. 为什么 Pass 顺序重要?

因为前一个 Pass 的结果会影响后一个。

例如:

Pass A:
linalg → scf

然后:

Pass B:
scf → cf

如果顺序反过来:

先 scf → cf

但当前还全是:

linalg

那这个 Pass 可能什么都做不了。

所以:

Pass Pipeline 的设计本身就是编译器设计的一部分。


17. 一个实际例子

初始:

%0 = arith.constant 0 : i32
%1 = arith.addi %a, %0 : i32
%2 = arith.addi %a, %0 : i32
%3 = arith.muli %1, %2 : i32

先跑:

canonicalize

可能变成:

%3 = arith.muli %a, %a : i32

因为:

a + 0 → a

然后再跑:

cse

可能已经没有多少事可做了。

但如果一些重复表达式仍在,就继续消除。


18. Analysis 和 Transform 的区别

比如:

统计函数有多少个 Operation

这是:

Analysis

因为没改 IR。

而:

删除多余的 add

是:

Transformation

MLIR 里很多 Pass 会同时:

先分析
再变换

19. Pass Manager

所有 Pass 一般由:

PassManager

统一管理。

概念上:

PassManager pm(context);

pm.addPass(...);
pm.addPass(...);
pm.addPass(...);

然后:

pm.run(module)

整个 pipeline 就跑起来了。


20. 你现在应该建立的模型

看到:

Pass

脑子里想到:

输入 IR
  ↓
遍历 Operation
  ↓
分析 / 匹配
  ↓
可选:修改 IR
  ↓
输出新的 IR

第 7 课总结

今天最重要的 5 个点:

Pass = 对 IR 的一次处理
Pass 运行在某类 Operation 上
walk() 可以递归遍历 Operation
修改 IR 时必须维护 SSA 和 Def-Use 关系
多个 Pass 按顺序组成 Pass Pipeline

再记一个以后会经常遇到的词:

RAUW
= Replace All Uses With

下一课我们就进入一个非常关键的主题:

Pattern Rewrite。

会正式学习这种思路:

匹配:
x + 0

替换:
x

然后继续扩展到:

匹配某个 Dialect 的 Operation
        ↓
改写成另一个 Dialect

这一步学会以后,你就会开始真正理解 MLIR 的各种优化和 Lowering 是怎么写出来的。

评论

暂无评论