第 9 课:Dialect Conversion 和 Lowering
文章目录
好,继续第 9 课。
这节我们讲 MLIR 里非常重要的一套机制:
第 9 课:Dialect Conversion 和 Lowering
前面你已经知道:
Pattern Rewrite
可以把:
A → B
做局部改写。
那 Dialect Conversion 是什么?
可以先记一句:
Dialect Conversion = 有规则、有约束地把一套 Dialect 转换成另一套 Dialect。
比如:
scf
↓
cf
或者:
arith
↓
llvm
或者:
自定义 Dialect
↓
标准 Dialect
1. 普通 Rewrite 和 Dialect Conversion 的区别
普通 Rewrite:
看到 x + 0
↓
替换成 x
它更像:
局部优化
但 Dialect Conversion 通常目标更明确:
我要把某种高层 IR 消灭掉
比如:
最终不能再出现 mydialect.*
那就需要更严格的机制。
2. 什么叫 Legal 和 Illegal?
Dialect Conversion 里有个非常核心的概念:
Legal
Illegal
比如我们正在做:
mydialect
↓
arith
那我们可以规定:
mydialect.* = Illegal
arith.* = Legal
func.* = Legal
意思是:
转换结束后,不能再有
mydialect.*
比如原始:
%0 = mydialect.add %a, %b : i32
如果转换后还是:
%0 = mydialect.add %a, %b : i32
那就算:
conversion failed
3. ConversionTarget
这个“什么允许、什么不允许”的规则,就是由:
ConversionTarget
描述的。
概念代码:
ConversionTarget target(context);
target.addIllegalDialect<MyDialect>();
target.addLegalDialect<arith::ArithDialect>();
target.addLegalDialect<func::FuncDialect>();
意思是:
MyDialect
❌ 不允许留下
arith
✅ 可以留下
func
✅ 可以留下
4. Conversion Pattern
然后我们需要告诉 MLIR:
遇到非法 Operation 时,应该怎么改。
比如:
mydialect.add
改成:
arith.addi
这就是一个:
ConversionPattern
概念上:
struct LowerMyAdd
: OpConversionPattern<MyAddOp> {
using OpConversionPattern::OpConversionPattern;
LogicalResult matchAndRewrite(
MyAddOp op,
OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
rewriter.replaceOpWithNewOp<arith::AddIOp>(
op,
adaptor.getLhs(),
adaptor.getRhs());
return success();
}
};
你会发现它和上一课的 Pattern 非常像。
区别主要是:
它运行在 Dialect Conversion 框架里
5. OpAdaptor 是什么?
这里出现了一个新东西:
OpAdaptor adaptor
为什么不直接:
op.getLhs()
呢?
因为 Dialect Conversion 过程中:
Operand 的 Type 可能已经被转换
例如原来:
tensor<4xf32>
后来可能变成:
memref<4xf32>
那:
原始 op 的 operand
和:
转换后的 operand
可能不是同一个类型。
adaptor 可以理解成:
已经转换过类型的 operand 视图。
所以在 Conversion Pattern 里,经常优先使用:
adaptor.getXXX()
6. 为什么类型也要转换?
假设我们有一个自定义类型:
!mydialect.tensor
Lowering 以后,希望变成:
tensor<4xf32>
或者:
memref<4xf32>
这时不只是 Operation 要变:
my.foo → arith.foo
连:
Type
也要一起变。
所以需要:
TypeConverter
7. TypeConverter
TypeConverter 的职责就是:
定义一种 Type 应该转换成什么 Type。
比如:
MyType
↓
i32
概念代码:
TypeConverter typeConverter;
typeConverter.addConversion([](MyType type) {
return IntegerType::get(type.getContext(), 32);
});
于是:
!mydialect.foo
就可能被转换为:
i32
8. 一个更直观的例子
假设我们自己有:
!toy.number
然后 Operation:
%0 = toy.add %a, %b : !toy.number
我们想 Lower 为:
%0 = arith.addi %a, %b : i32
那整个转换分两部分:
Operation:
toy.add
↓
arith.addi
以及:
Type:
!toy.number
↓
i32
所以 Dialect Conversion 不只是:
改 Operation
而是:
Operation Conversion
+
Type Conversion
9. Conversion Driver
然后需要一个 driver 真正执行转换。
常见有几种:
applyFullConversion(...)
applyPartialConversion(...)
applyAnalysisConversion(...)
先重点理解前两个。
10. applyFullConversion
它要求:
转换结束后,所有 Operation 都必须 legal。
比如:
mydialect.* = illegal
arith.* = legal
那么只要还剩一个:
mydialect.foo
整个 conversion 就失败。
所以它很严格。
11. applyPartialConversion
这个比较宽松。
意思是:
只转换我要求转换的部分。
也就是说有些没被标成 illegal 的东西,可以保留。
所以:
Full Conversion
更适合:
我要彻底清掉某种 Dialect
而:
Partial Conversion
更适合:
只降低其中一部分
12. 一个完整转换流程
假设输入:
func.func @foo(%a: i32, %b: i32) -> i32 {
%0 = my.add %a, %b : i32
func.return %0 : i32
}
目标:
my Dialect 全部消失
第一步:
定义 target
my = illegal
arith = legal
func = legal
第二步:
注册 pattern
my.add
↓
arith.addi
第三步:
applyFullConversion
结果:
func.func @foo(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
func.return %0 : i32
}
然后检查:
还有 my.* 吗?
没有:
success
13. 如果缺一个 Pattern 会怎么样?
比如输入:
%0 = my.add ...
%1 = my.mul ...
但你只写了:
my.add → arith.addi
没写:
my.mul → arith.muli
如果:
my dialect = illegal
那最后:
my.mul
还存在。
于是:
applyFullConversion
失败。
这就是 Dialect Conversion 比普通 Pattern Rewrite 更“严格”的地方。
14. Dynamic Legality
Legal / Illegal 还不一定是死的。
可以根据条件动态判断。
比如:
func.func
只有参数类型全部转换完成以后才算 legal。
概念代码:
target.addDynamicallyLegalOp<func::FuncOp>(
[&](func::FuncOp op) {
return typeConverter.isSignatureLegal(
op.getFunctionType());
});
也就是:
同一个 Operation
可能:
某些情况下 legal
某些情况下 illegal
这叫:
Dynamic Legality
15. 为什么这个设计很强?
因为 MLIR 不只是说:
“尽量帮我改一下”
而是可以声明:
最终 IR 必须满足什么不变量
比如:
不允许 tensor
只允许 memref
或者:
不允许 scf
只允许 cf
或者:
不允许自定义 Dialect
只允许 LLVM Dialect
这让整个 Lowering 过程非常可控。
16. Lowering 本质是什么?
你可以把 Lowering 理解成:
把高抽象层级的 IR,改成更低抽象层级的 IR。
例如:
linalg.matmul
高层语义:
矩阵乘法
Lower 后:
scf.for
已经变成:
循环
再 Lower:
cf.br
变成:
基本块跳转
再 Lower:
llvm.*
接近 LLVM IR。
所以:
Lowering ≠ 优化
Lowering 主要是在:
降低抽象层级
17. 优化和 Lowering 的区别
优化:
x + 0
↓
x
语义层级没怎么变,只是更高效。
Lowering:
scf.for
↓
cf.br
语义层级变低了。
所以可以粗略区分:
Optimization
= 同一抽象层级上的改善
Lowering
= 从高层向低层转换
当然实际编译器里两者会交织。
18. Progressive Lowering
MLIR 最核心的思想之一就是:
Progressive Lowering
也就是:
不要一下子从最高层直接跳到 LLVM。
而是:
High-level
↓
Medium-level
↓
Low-level
↓
LLVM
例如:
my.tensor_op
↓
linalg
↓
scf
↓
memref
↓
llvm
这样每一层都还能做适合自己的优化。
19. 为什么不一步直接 Lower 到 LLVM?
因为太早 Lower 会丢高层语义。
例如:
matmul
如果直接变:
load
mul
add
store
后面的 Pass 就很难知道:
这原来是矩阵乘法
于是:
tile
fusion
vectorization
这些高层优化会难很多。
所以 MLIR 强调:
在合适的阶段才丢掉高层信息。
20. Conversion 和 Pattern Rewrite 的关系
可以这样理解:
Pattern Rewrite
是:
局部 IR 图改写机制
而:
Dialect Conversion
是在 Pattern Rewrite 之上又加了:
Legal / Illegal 约束
Type Conversion
完整性检查
所以:
Dialect Conversion
=
Pattern Rewrite
+
ConversionTarget
+
TypeConverter
+
Conversion Driver
21. 一个总图
现在整个系统可以串起来:
Pass
│
├── ConversionTarget
│ ├── legal
│ └── illegal
│
├── TypeConverter
│
├── ConversionPatterns
│
└── applyFullConversion
│
▼
新的 IR
22. 一个真实的 Lowering 思维
假设你以后自己设计:
hello.print %x
然后想 Lower 到:
func.call @printf(...)
那你要做的大致是:
1. 定义 hello.print 是 illegal
2. func / llvm / arith 是 legal
3. 写一个 ConversionPattern
4. 把 hello.print 替换成低层 ops
5. 跑 full conversion
6. 检查 hello.print 是否全部消失
这就是一个标准 MLIR Lowering Pass 的基本结构。
第 9 课总结
今天最需要记住 5 个词:
ConversionTarget
定义:
哪些合法,哪些非法
ConversionPattern
定义:
非法 Operation 怎么改
TypeConverter
定义:
Type 怎么改
applyFullConversion
要求:
最终必须全部合法
Progressive Lowering
就是:
高层
↓
中层
↓
低层
↓
LLVM
最核心的一句话:
Dialect Conversion = Pattern Rewrite + 合法性约束 + Type 转换。
到这里,你已经开始真正接触 MLIR 的“核心编译流程”了。
下一课我们可以继续 第 10 课:TableGen / ODS,正式开始讲:
怎么定义自己的 Operation
怎么定义 operand / result
怎么定义 attribute
怎么自动生成 C++ Op 类
这会是你从“使用 MLIR”走向“扩展 MLIR”的关键一步。

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