第 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”。

评论

暂无评论