第 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”的关键一步。

评论

暂无评论