第 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。

评论

暂无评论