第 5 课:Dialect 到底是什么?
文章目录
好,继续第 5 课。
这一课我们正式系统认识 Dialect(方言)。这是真正理解 MLIR 设计哲学的一课。
第 5 课:Dialect 到底是什么?
先看几个你已经见过的名字:
arith.addi
func.func
scf.if
memref.load
tensor.empty
linalg.matmul
llvm.add
它们前面的:
arith
func
scf
memref
tensor
linalg
llvm
就是不同的 Dialect。
而后面的:
addi
func
if
load
empty
matmul
add
就是这个 Dialect 里的 Operation。
所以:
dialect.operation
是 MLIR 里非常常见的命名方式。
1. 为什么 MLIR 不设计一套固定 IR?
这是理解 Dialect 的关键。
LLVM IR 的思路更像:
我定义一套比较固定的中间语言
比如:
add
mul
load
store
br
call
然后所有语言最终都往这里降。
但 MLIR 的思路是:
不同抽象层次,需要不同的 IR。
比如矩阵乘法在高层可以是:
linalg.matmul
降低以后可能变成:
scf.for
再往下变成:
vector.contract
再往下:
llvm.*
所以同一个程序在不同阶段,可以用完全不同的 Dialect 表达。
2. Dialect 可以理解成“IR 语言包”
可以把 Dialect 理解成:
一组相关的 Operation、Type、Attribute 的集合。
比如 arith Dialect 负责基本算术。
你可能看到:
arith.constant
arith.addi
arith.subi
arith.muli
arith.cmpi
arith.addf
arith.mulf
这些都和“算术”有关。
所以:
arith Dialect
可以理解成:
算术领域的一套 IR 词汇
3. func Dialect
func 主要表示函数相关内容。
例如:
func.func @add(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
func.return %0 : i32
}
这里:
func.func
func.call
func.return
都属于:
func Dialect
它负责:
函数定义
函数调用
函数返回
注意:
func.func
里面完全可以嵌套其他 Dialect 的 Operation。
例如:
func.func
└── arith.addi
这就是 MLIR 很重要的特性:
一个 IR 里可以混合多个 Dialect。
4. arith Dialect
这个比较容易。
例如:
%0 = arith.constant 10 : i32
%1 = arith.constant 20 : i32
%2 = arith.addi %0, %1 : i32
对应:
10 + 20
再比如:
%cond = arith.cmpi slt, %a, %b : i32
表示:
a < b
所以 arith 主要负责:
整数运算
浮点运算
比较
常量
5. scf Dialect
scf:
Structured Control Flow
也就是:
结构化控制流。
主要有:
scf.if
scf.for
scf.while
scf.yield
例如:
scf.for %i = %c0 to %c10 step %c1 {
...
}
这保留了:
这是一个 for 循环
的信息。
而不是马上变成:
block
branch
block
branch
这种低层 CFG。
这就是“保留高层语义”。
6. cf Dialect
和 scf 不一样,cf 更低层。
cf:
Control Flow
你会看到:
cf.br
cf.cond_br
例如:
cf.cond_br %cond, ^bb1, ^bb2
这种形式已经非常像 LLVM IR 了。
可以简单理解:
scf
高层结构化控制流
cf
低层基本块控制流
例如:
scf.if
↓ lowering
cf.cond_br
7. memref Dialect
这个非常重要。
memref 是:
memory reference
也就是:
对内存对象的抽象。
例如:
memref<10xi32>
可以理解成:
10 个 i32 的内存区域
常见 Operation:
memref.alloc
memref.load
memref.store
例如:
%buffer = memref.alloc() : memref<10xi32>
%v = memref.load %buffer[%i] : memref<10xi32>
memref.store %x, %buffer[%i] : memref<10xi32>
你可以先把它类比:
int buffer[10];
v = buffer[i];
buffer[i] = x;
8. tensor Dialect
tensor 和 memref 很容易混。
先建立一个粗略认识:
tensor
更偏“值”
memref
更偏“内存”
比如:
tensor<4x4xf32>
表示一个:
4 × 4 的 f32 Tensor
Tensor 更接近:
一个数学意义上的多维值
而:
memref<4x4xf32>
更接近:
一块真实可访问的内存
以后你会看到一个很重要的概念:
bufferization
也就是:
tensor
↓
memref
把“值语义”转换为“内存语义”。
9. linalg Dialect
这个 Dialect 特别重要,尤其是在 AI / 数值计算领域。
linalg:
Linear Algebra
例如:
linalg.matmul
表示:
矩阵乘法
还有:
linalg.fill
linalg.copy
linalg.generic
例如:
高层:
linalg.matmul
↓
循环:
scf.for
↓
向量:
vector.*
↓
低层:
llvm.*
所以 linalg 是一个非常典型的高层 Dialect。
10. vector Dialect
vector 用来表达 SIMD / 向量计算。
例如:
vector<4xf32>
你可以理解成:
4 个 f32 一起算
比如:
[a0 a1 a2 a3]
+
[b0 b1 b2 b3]
一次完成:
[c0 c1 c2 c3]
所以编译链里经常有:
linalg
↓
vector
↓
LLVM
11. gpu Dialect
gpu 用来表达 GPU 相关结构。
例如:
gpu.launch
gpu.thread_id
gpu.block_id
它保留:
线程
线程块
kernel
这样的 GPU 语义。
后面还可能继续 Lower 到:
NVVM
或者:
ROCDL / AMDGPU
对应 NVIDIA 或 AMD 后端。
12. llvm Dialect
这是非常关键的一层。
注意:
LLVM Dialect
不等于:
LLVM IR
它是:
MLIR 世界里,对 LLVM IR 语义的一种 Dialect 表示。
例如:
高层 MLIR
↓
LLVM Dialect
↓
真正 LLVM IR
所以常见流程是:
arith
scf
memref
...
↓
LLVM Dialect
↓
LLVM IR
↓
机器码
13. MLIR 里可以同时存在多个 Dialect
这是最重要的一点之一。
例如:
func.func @foo(%a: i32, %b: i32) -> i32 {
%c = arith.addi %a, %b : i32
scf.if %cond {
...
}
func.return %c : i32
}
这里同时用了:
func
arith
scf
三个 Dialect。
MLIR 不要求一个文件只能用一个 Dialect。
相反:
多 Dialect 混合存在,本来就是 MLIR 的设计目标。
14. Dialect 之间怎么转换?
靠:
Pass
Rewrite
Dialect Conversion
比如:
linalg.matmul
可能经过某个 Pass 变成:
scf.for
然后:
scf.for
再被 Lower 成:
cf.br
然后:
arith.addi
可能继续变成:
llvm.add
最终:
LLVM Dialect
转成真正 LLVM IR。
所以整个编译过程可以理解成:
Dialect A
↓
Dialect B
↓
Dialect C
↓
Dialect D
15. 一个典型 MLIR lowering 流程
比如一个 AI 编译器:
高层 AI IR
|
v
tensor
|
v
linalg
|
v
scf
|
v
vector
|
v
memref
|
v
llvm
|
v
LLVM IR
|
v
machine code
这里并不是固定流程。
不同编译器可能路线完全不同。
这也是 MLIR 强大的地方:
你可以自由组合自己的编译 pipeline。
16. 最关键的:你也可以定义自己的 Dialect
假设你做一个自己的语言:
MyLang
你完全可以定义:
mylang.print
mylang.add
mylang.for
或者做神经网络:
myai.conv
myai.relu
myai.softmax
然后:
myai.conv
↓
linalg.conv
↓
scf
↓
vector
↓
llvm
所以 MLIR 不只是:
使用现成 IR
更重要的是:
允许你创造自己的 IR。
17. 为什么 Dialect 这么重要?
因为编译器最难的问题之一是:
到底什么时候丢掉高层信息?
假设:
matmul
太早变成:
for
for
for
那么后面的 Pass 就很难知道:
原来这是矩阵乘法
但 MLIR 可以先保留:
linalg.matmul
做高层优化。
优化完再:
Lower
成循环。
这就是:
Progressive Lowering
也就是:
渐进式降低抽象层级。
这是 MLIR 非常核心的设计思想。
18. 你现在应该建立这张地图
以后看到 Dialect,可以大概按层次这么理解:
高层
AI / Domain Specific
|
v
linalg
|
v
tensor
|
v
scf
|
v
vector
|
v
memref
|
v
llvm
低层
不是说一定严格按这个顺序走,而是帮助你建立“抽象层级”的感觉。
第 5 课总结
今天最重要的是 4 个点。
第一:
Dialect = 一组相关 Operation / Type / Attribute
第二:
MLIR 可以同时混合多个 Dialect
第三:
不同 Dialect 可以代表不同抽象层级
第四,也是最重要的:
MLIR 通过 Dialect + Lowering
实现渐进式降低抽象层级
你以后看到:
linalg.matmul
应该想到:
“这是高层矩阵乘法语义”
看到:
scf.for
应该想到:
“这是结构化循环”
看到:
memref.load
应该想到:
“开始接近真实内存了”
看到:
llvm.*
应该想到:
“已经接近 LLVM IR 了”
下一课我建议开始真正“用起来”:学习 MLIR 文本格式和 mlir-opt。
我们会自己写一个 .mlir 文件,然后一步步看:
mlir-opt 是干什么的
怎么检查 IR
怎么跑 Pass
怎么观察 IR 被一步步转换
从下一课开始,就从“理解概念”进入“亲手操作 MLIR”。

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