第 1 课:为什么会有 MLIR?
文章目录
可以。你前面已经在学 LLVM,这对学习 MLIR 很有帮助,因为 MLIR 最终经常会 Lower 到 LLVM IR。不过学习 MLIR 时,我们先暂时不要急着把它理解成“LLVM 的另一种 IR”,而要先建立一个更重要的概念:
MLIR 是一个“用来构建各种 IR 的 IR 框架”。
官方也把 Dialect 视为 MLIR 最核心的扩展机制:你可以定义自己的 Operation、Type、Attribute,然后逐层把高层语义降低到更低层,最终甚至 Lower 到 LLVM Dialect / LLVM IR。(MLIR)
我建议我们按下面这条路线学:
- MLIR 到底解决什么问题
- MLIR IR 的基本结构:Operation / Value / Type / Attribute
- Region 和 Block
- SSA 在 MLIR 里的表现
- Dialect 是什么
- 熟悉
arith、func、scf、memref、tensor - 使用
mlir-opt - Pass
- Pattern Rewrite
- Dialect Conversion / Lowering
- TableGen / ODS
- 自己实现一个简单 Dialect
- 从自定义 Dialect Lower 到标准 Dialect
- Lower 到 LLVM Dialect
- 最后自己做一个迷你语言编译器
这也基本对应官方 Toy Tutorial 的学习路线:自定义语言 → Dialect → Rewrite → Lowering → LLVM code generation。(MLIR)
第 1 课:为什么会有 MLIR?
先从 LLVM IR 的局限讲起。
假设我们写:
int add(int a, int b) {
return a + b;
}
经过 Clang 后可能变成类似:
define i32 @add(i32 %a, i32 %b) {
entry:
%0 = add i32 %a, %b
ret i32 %0
}
LLVM IR 很适合做:
机器无关优化
↓
指令选择
↓
寄存器分配
↓
机器码
但现在假设我们不是编译普通 C,而是编译:
C = matmul(A, B)
这是一个矩阵乘法。
在很高的抽象层次,我们知道:
C = A × B
于是可以做一些矩阵级优化。
例如:
matmul
fusion
tiling
vectorization
GPU mapping
但是如果一上来就把它变成低级循环:
for (i = 0; i < M; i++)
for (j = 0; j < N; j++)
for (k = 0; k < K; k++)
C[i][j] += A[i][k] * B[k][j];
甚至继续变成 LLVM IR:
load
load
fmul
fadd
store
那么:
“这是一个矩阵乘法”
这个高层语义基本已经丢了。
这就是 MLIR 要解决的重要问题之一。
MLIR 的核心思想:保留多个抽象层级
MLIR 全称:
Multi-Level Intermediate Representation
也就是:
多层次中间表示。
例如一个 AI 编译器可能经历:
PyTorch / TensorFlow
│
▼
┌────────────────────┐
│ 高层 Tensor IR │
│ matmul / conv │
└────────────────────┘
│
▼
┌────────────────────┐
│ Linalg Dialect │
│ linalg.matmul │
└────────────────────┘
│
▼
┌────────────────────┐
│ SCF / Affine │
│ for loops │
└────────────────────┘
│
▼
┌────────────────────┐
│ Vector Dialect │
│ vector operations │
└────────────────────┘
│
▼
┌────────────────────┐
│ LLVM Dialect │
└────────────────────┘
│
▼
LLVM IR
│
▼
机器码
这里最关键的就是:
高层
matmul
↓
循环
↓
vector
↓
LLVM
↓
machine code
低层
不是一下子从 AST 跳到 LLVM IR。
一个真正的 MLIR 长什么样?
先看一个非常简单的:
func.func @add(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
return %0 : i32
}
暂时不用全部理解。
只看这一行:
%0 = arith.addi %a, %b : i32
它大概相当于:
int x = a + b;
可以拆成:
%0
│
│ result
▼
arith.addi
│
├── %a
└── %b
type = i32
也就是:
arith.addi
/ \
%a %b
\ /
\ /
%0
这里已经出现 MLIR 最重要的几个概念:
Operation
Value
Type
Dialect
以后你看到任何 MLIR,都可以用这几个东西去拆。
arith.addi 是什么意思?
这一点特别重要。
arith.addi
可以拆成:
arith . addi
│ │
│ └── Operation
│
└───────── Dialect
也就是:
Dialect = arith
Operation = addi
所以完整名字:
arith.addi
意思就是:
arith Dialect 中的整数加法 Operation。
类似:
arith.addi
arith.muli
arith.constant
func.func
func.call
memref.load
memref.store
scf.for
scf.if
你会看到 MLIR 世界里到处都是:
dialect.operation
这种形式。
官方当前维护了大量 Dialect,例如 arith、func、gpu、linalg、memref、scf、tensor、vector、llvm 等。(MLIR)
为什么叫 Dialect?
可以把 MLIR 想象成一个国家:
MLIR
┌───────────────┐
│ │
arith语言 linalg语言
│ │
addi/muli matmul/fill
│
│
scf语言
│
for / if
│
llvm语言
│
llvm.load
llvm.store
不同领域可以设计不同的“方言”。
所以叫:
Dialect
比如做机器学习:
tensor
linalg
tosa
做循环:
scf
affine
做 GPU:
gpu
nvvm
amdgpu
最后:
llvm
可以接 LLVM 后端。
MLIR 和 LLVM IR 的一个重要区别
LLVM IR 的指令集合基本是确定的。
例如:
add
sub
mul
load
store
br
call
而 MLIR:
允许你创造新的 Operation。
假设我们自己做一个神经网络编译器。
甚至可以定义:
myai.conv
或者:
myai.relu
例如:
%1 = myai.conv %input, %weight
以后再 Lower:
myai.conv
↓
linalg.conv
↓
scf.for
↓
vector
↓
llvm
这正是 MLIR 很强的地方。
官方把 Dialect 定义为扩展 MLIR 生态的基本机制,它可以定义自己的 operations、attributes 和 types。(MLIR)
今天只需要真正记住 3 件事
第一:
MLIR = Multi-Level Intermediate Representation
它允许:
高层 IR
↓
中层 IR
↓
低层 IR
↓
LLVM IR
第二:
MLIR 的核心单位不是传统意义上的“instruction”,而是:
Operation
第三:
Operation 通常属于某个:
Dialect
例如:
arith.addi
就是:
arith Dialect
+
addi Operation
还有一个很重要的认知,可以先种下:
LLVM:
设计了一套 IR
MLIR:
设计了一套“设计 IR 的框架”
这个区别理解了,MLIR 后面的很多东西就会突然变得合理。
下一课我会带你正式拆解这段代码:
func.func @add(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
return %0 : i32
}
我们重点学习 Operation、Operand、Result、Value、Type、Attribute,并且我会把它画成结构图。这个是后面理解 Block、Region、Dialect、Pass 的地基。

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