第 6 课:MLIR 文本格式和 mlir-opt

好,继续第 6 课。

这节开始进入“真正动手看 MLIR”的阶段:MLIR 文本格式 + mlir-opt。

第 6 课:MLIR 文本格式和 mlir-opt

先看一个最小的完整 MLIR 文件:

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

你已经认识里面绝大多数东西了。

从外往里看:

module
  └── func.func
        └── Region
              └── Block
                    ├── arith.addi
                    └── func.return

1. module 是什么?

module 不是普通语法糖,它本身也是一个 Operation。

完整名字其实可以理解为:

builtin.module

它的作用是:

作为顶层容器,装函数、全局对象等。

例如:

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

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

也就是:

module
├── foo
└── bar

这和 LLVM IR 里的 Module 概念比较接近。


2. MLIR 文件后缀

通常你会把代码写进:

test.mlir

比如:

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

然后用工具处理它。

最重要的工具之一就是:

mlir-opt

3. mlir-opt 是干什么的?

可以先把它类比成 LLVM 的:

opt

mlir-opt 主要负责:

读取 MLIR
   ↓
解析
   ↓
验证
   ↓
执行 Pass
   ↓
输出新的 MLIR

所以:

mlir-opt test.mlir

最基础的作用,就是:

解析并打印 MLIR。


4. 最简单的使用

假设:

mlir-opt test.mlir

如果代码合法,通常会输出格式化后的 MLIR。

例如:

module {
  func.func @add(%arg0: i32, %arg1: i32) -> i32 {
    %0 = arith.addi %arg0, %arg1 : i32
    return %0 : i32
  }
}

注意:

%a
%b

有时可能变成:

%arg0
%arg1

这没关系。

因为:

SSA 名字通常只是打印出来方便人看的名字。

真正重要的是 Value 之间的关系,而不是 %a 这个文本名字。


5. MLIR 有“自定义语法”和“通用语法”

这是一个很重要的概念。

我们平时写:

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

这是比较好看的:

custom syntax

也就是 Dialect 自己定义的打印格式。

但 MLIR 还有一种更通用的表示方式。

可以用:

mlir-opt test.mlir --mlir-print-op-generic

你可能会看到类似:

"builtin.module"() ({
  "func.func"() <{function_type = (i32, i32) -> i32, sym_name = "add"}> ({
  ^bb0(%arg0: i32, %arg1: i32):
    %0 = "arith.addi"(%arg0, %arg1) : (i32, i32) -> i32
    "func.return"(%0) : (i32) -> ()
  }) : () -> ()
}) : () -> ()

第一次看到通常会觉得:

这是什么东西……

但它非常重要。


6. Generic Form

我们重点看:

%0 = "arith.addi"(%arg0, %arg1) : (i32, i32) -> i32

它把一个 Operation 的结构完整暴露出来了:

"arith.addi"
    │
    ├── operands:
    │     %arg0
    │     %arg1
    │
    └── result:
          i32

也就是:

Operation Name
Operands
Attributes
Regions
Result Types

都能统一表示。

这说明一个非常深的设计思想:

MLIR 的各种漂亮语法,最终都建立在统一的 Operation 模型上。


7. 为什么 Generic Form 很重要?

因为以后你自己定义 Dialect 时:

哪怕你还没写漂亮的 Parser / Printer,

MLIR 仍然可以用 Generic Form 表达你的 Operation。

比如你自己定义:

mydialect.foo

即使没有特殊语法,也可以写成类似:

"mydialect.foo"(%a, %b) : (i32, i32) -> i32

这让 MLIR 非常通用。


8. 一个 Operation 的通用结构

现在可以把 Operation 更完整地记成:

Operation
├── Name
├── Operands
├── Results
├── Attributes
├── Regions
└── Successors

其中 Successors 是控制流跳转目标。

比如:

cf.br ^bb1

它就有 successor:

^bb1

9. mlir-opt 还能验证 IR

比如你写:

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

问题是什么?

函数声明返回:

i32

但函数体没有:

func.return

这可能会导致 verifier 报错。

所以 MLIR 不只是“语法解析”。

它还会检查:

Operation 是否满足规则
Type 是否匹配
Region 是否正确
Terminator 是否存在

这叫:

verification

10. Verifier 非常重要

比如:

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

如果 %a 是:

i32

但 %b 是:

f32

那显然不能直接做 arith.addi。

MLIR verifier 会检查这类约束。

所以:

Parser

只是确认:

“语法像不像 MLIR”

而:

Verifier

确认:

“这个 IR 在语义结构上是否合法”

11. mlir-opt 最重要的用途:跑 Pass

例如:

mlir-opt test.mlir --canonicalize

这里:

--canonicalize

就是一个 Pass。

它会做一些规范化优化。

比如:

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

在某些条件下可能被化简。

再比如:

mlir-opt test.mlir --cse

这里:

CSE

就是:

Common Subexpression Elimination
公共子表达式消除

12. CSE 举例

假设:

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

这里:

%0 = a + b
%1 = a + b

重复了。

跑:

mlir-opt test.mlir --cse

可能变成:

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

原来的第二次:

a + b

被消掉了。


13. 为什么 SSA 对优化很重要?

现在你会发现上一课学 SSA 的意义了。

原始:

%0 = arith.addi %a, %b
%1 = arith.addi %a, %b

编译器很容易看出:

Operand 一样
Operation 一样
Type 一样

所以结果可以复用。

SSA + def-use chain 让这类分析简单很多。


14. 一个很有用的选项:打印 Pass 前后 IR

以后调试 MLIR Pass 时,你经常会用:

mlir-opt test.mlir \
  --pass-pipeline='builtin.module(canonicalize,cse)'

意思是:

module
  ├── canonicalize
  └── cse

按顺序执行。

你以后会经常看到:

Pass Pipeline

这个词。

它就是:

一串按顺序执行的 Pass。


15. Pass Pipeline 是编译器的“流水线”

比如:

High-level IR
     |
     v
canonicalize
     |
     v
linalg lowering
     |
     v
scf lowering
     |
     v
vector lowering
     |
     v
LLVM lowering

每一步都是:

Pass

组合起来就是:

Pipeline

所以 MLIR 编译器本质上很大一部分工作就是:

设计 IR
+
设计 Pass Pipeline

16. mlir-opt 可以理解成“Pass 实验室”

以后你学习 MLIR 时,可以大量使用:

mlir-opt

因为它很适合做:

写一个小 IR
      ↓
跑一个 Pass
      ↓
观察发生了什么

比如:

mlir-opt input.mlir --canonicalize

或者:

mlir-opt input.mlir --cse

或者以后:

mlir-opt input.mlir --convert-scf-to-cf

你会亲眼看到:

scf
  ↓
cf

这比只看文档有效得多。


17. 如果你本地还没安装 MLIR

你后面最好准备一个 MLIR 环境。

如果你已经有 LLVM 源码,MLIR 在 LLVM monorepo 里:

llvm-project/
├── llvm/
├── clang/
└── mlir/

编译时一般需要启用 MLIR。

之后就会有:

mlir-opt
mlir-translate
mlir-tblgen

这些工具。

暂时不用急着编译,我们后面真正开始写自定义 Dialect 时,我可以专门带你一步步搭环境。


18. 再看一次完整流程

假设:

test.mlir

内容:

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

运行:

mlir-opt test.mlir --cse

整个过程:

test.mlir
   |
   v
Parser
   |
   v
MLIR 内部 IR
   |
   v
Verifier
   |
   v
CSE Pass
   |
   v
新的 MLIR
   |
   v
Printer

这张图以后非常重要。


19. MLIR 内部不是“字符串”

这一点也要建立起来。

当 MLIR 读入:

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

之后,内部并不是保存成一行字符串。

而是类似:

Operation object
│
├── name = arith.addi
├── operand[0] -> Value(%a)
├── operand[1] -> Value(%b)
├── result[0]  -> Value(%0)
└── type       -> i32

Pass 操作的是这些 IR 对象。

不是文本。

最后 Printer 再重新生成:

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

这个认识以后写 C++ Pass 时非常重要。


第 6 课总结

这一课最重要的几个点:

mlir-opt

是我们学习和调试 MLIR 最常用的工具之一。

它负责:

Parse
Verify
Run Passes
Print

第二:

MLIR Operation 有两种常见文本表现:

Custom Syntax
Generic Syntax

例如:

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

和:

%0 = "arith.addi"(%a, %b) : (i32, i32) -> i32

本质上是同一个 Operation。

第三:

Pass

就是对 IR 做分析或转换的一次处理。

多个 Pass 组合起来就是:

Pass Pipeline

第四,也是最关键的:

.mlir 文本
   ↓ Parse
Operation / Region / Block / Value 对象
   ↓ Pass
新的 IR 对象
   ↓ Print
.mlir 文本

从现在开始,你已经从“认识 MLIR 结构”进入到“编译器真正处理 MLIR”的阶段了。

下一课我们专门学习 Pass。

我会带你看清楚:

Pass 到底跑在哪一层
ModulePass 和 Function Pass 有什么区别
Pass 如何遍历 Operation
为什么一个 Pass 可以把一种 Dialect 改成另一种 Dialect

并且我们会用一个很直观的例子,把:

%0 = arith.addi %a, %b

这种 IR 的遍历和修改过程画出来。

评论

暂无评论