第 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)

我建议我们按下面这条路线学:

  1. MLIR 到底解决什么问题
  2. MLIR IR 的基本结构:Operation / Value / Type / Attribute
  3. Region 和 Block
  4. SSA 在 MLIR 里的表现
  5. Dialect 是什么
  6. 熟悉 arith、func、scf、memref、tensor
  7. 使用 mlir-opt
  8. Pass
  9. Pattern Rewrite
  10. Dialect Conversion / Lowering
  11. TableGen / ODS
  12. 自己实现一个简单 Dialect
  13. 从自定义 Dialect Lower 到标准 Dialect
  14. Lower 到 LLVM Dialect
  15. 最后自己做一个迷你语言编译器

这也基本对应官方 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 的地基。

评论

暂无评论