第 10 课:TableGen / ODS 是什么?

好,继续第 10 课。

这节开始进入“自己扩展 MLIR”的关键部分:TableGen / ODS。

第 10 课:TableGen / ODS 是什么?

前面我们一直在用现成的 Operation:

arith.addi
func.func
scf.for

但如果你想定义自己的:

my.add
my.mul
my.print

就需要告诉 MLIR:

Operation 名字是什么
有几个 operand
有几个 result
类型要求是什么
有哪些 attribute
是否有 region
怎么验证

如果这些全手写 C++,会很麻烦。

所以 MLIR 用:

ODS

来描述 Operation。

ODS 全称:

Operation Definition Specification

它建立在 LLVM 的:

TableGen

之上。


1. 为什么需要 ODS?

假设你自己定义:

%0 = my.add %a, %b : i32

那 MLIR 需要知道:

Operation 名:
my.add

Operands:
%a
%b

Result:
%0

Type:
i32

还要生成对应的 C++ 类,比如:

my::AddOp

然后你才能:

op.getLhs()
op.getRhs()
op.getResult()

这些便利 API。

ODS 就是用来自动生成这些东西的。


2. .td 文件

TableGen 定义一般写在:

.td

文件里。

比如:

MyOps.td

里面可以定义:

def My_AddOp : My_Op<"add"> {
  let arguments = (ins
    I32:$lhs,
    I32:$rhs
  );

  let results = (outs
    I32:$result
  );
}

先别急着记语法。

只看表达的意思:

输入:
lhs : i32
rhs : i32

输出:
result : i32

3. def

TableGen 经常这样写:

def My_AddOp : ...

这里:

My_AddOp

是 TableGen 里的定义名。

以后会参与生成:

AddOp

之类的 C++ 类。

可以先理解成:

定义一个 Operation 描述

4. Operation 的名字

比如:

My_Op<"add">

如果 Dialect 名是:

my

那最终 Operation 名通常就是:

my.add

所以:

Dialect Namespace + Operation Name

得到:

my.add

5. arguments

看:

let arguments = (ins
  I32:$lhs,
  I32:$rhs
);

表示这个 Operation 有两个输入。

对应:

my.add %a, %b

所以:

lhs → %a
rhs → %b

ODS 会根据这些名字,帮你生成访问器。

于是 C++ 里可能就可以写:

op.getLhs();
op.getRhs();

而不是:

op->getOperand(0);
op->getOperand(1);

这就是 ODS 很实用的地方。


6. results

看:

let results = (outs
  I32:$result
);

表示 Operation 有一个结果:

%0 = my.add ...

所以:

%0

对应:

$result

然后 C++ 里通常可以:

op.getResult();

7. Attribute 也可以定义

比如想定义:

my.scale %x {factor = 10}

这里:

factor = 10

是 Attribute。

ODS 里概念上可以:

let arguments = (ins
  I32:$input,
  I64Attr:$factor
);

这样:

input

是 Operand,

而:

factor

是 Attribute。

ODS 会把两种东西一起描述出来。


8. Operand 和 Attribute 为什么都放 arguments?

这个地方初学时容易困惑。

因为:

arguments = (ins ...)

里面不一定全是 SSA Operand。

它可以包含:

Operand
Attribute
Property

它表达的是:

构造这个 Operation 所需要的输入信息。

所以名字叫:

arguments

而不是单纯:

operands

9. Type 约束

ODS 可以表达很多类型约束。

比如:

I32

表示必须是:

i32

还有类似:

AnyInteger
AnyFloat
AnyType

等等。

所以你可以描述:

这个 operand 必须是整数

或者:

这个 result 可以是任意类型

这些约束会用于:

生成 verifier
生成 builder
生成 matcher

等。


10. Trait

ODS 里还有一个很重要的概念:

Trait

Trait 可以理解成:

Operation 具备的某种结构性质。

比如:

没有副作用
交换律
只有一个结果
terminator

有些 Trait 可以帮助:

验证
优化
Canonicalization
分析

比如一个加法 Operation 如果满足交换律:

a + b = b + a

那就可以通过某种 Trait 告诉框架。


11. 一个更完整的自定义 AddOp

概念上可能长这样:

def My_AddOp : My_Op<"add"> {
  let summary = "integer add";

  let arguments = (ins
    I32:$lhs,
    I32:$rhs
  );

  let results = (outs
    I32:$result
  );
}

然后你就希望能写:

%0 = my.add %a, %b : i32

同时生成 C++:

my::AddOp

并可以:

op.getLhs();
op.getRhs();
op.getResult();

12. mlir-tblgen

谁把 .td 转成 C++?

靠:

mlir-tblgen

也就是 MLIR 的 TableGen 工具。

整体流程:

MyOps.td
   ↓
mlir-tblgen
   ↓
生成 .h.inc / .cpp.inc
   ↓
C++ 编译
   ↓
得到真正的 Operation 类

所以 ODS 本质上是:

声明

而 mlir-tblgen 负责:

生成代码

13. 为什么不用纯 C++?

因为如果每个 Operation 都手写:

Parser
Printer
Builder
Verifier
Accessor
Type checking

会非常重复。

假设一个 Dialect 有:

100 个 Operation

手写会很痛苦。

ODS 可以把大量模板化代码自动生成。

所以你可以把它理解成:

Operation 的 schema 定义语言

14. Dialect 也可以用 TableGen 定义

不只是 Operation。

Dialect 本身也可以定义。

比如概念上:

def My_Dialect : Dialect {
  let name = "my";
  let cppNamespace = "::my";
}

意思是:

文本 namespace:
my

C++ namespace:
::my

于是:

my.add

C++ 里:

my::AddOp

15. 自定义 Type 也可以定义

以后如果你想搞:

!my.number

这也是自定义 Type。

比如:

my Dialect

可以自己拥有:

Operation
Type
Attribute

所以 Dialect 的完整扩展能力是:

Dialect
├── Operations
├── Types
└── Attributes

这也是为什么我们前面一直说:

Dialect 不只是“一组 Operation”。


16. ODS 和 C++ 的关系

可以这样理解:

ODS

负责:

结构性描述

比如:

有几个 operand
有几个 result
类型是什么
有哪些 attribute
有哪些 trait

而 C++ 通常负责:

复杂逻辑

比如:

复杂 verifier
Canonicalization
Rewrite
Lowering
自定义 parse / print

所以两者关系:

ODS
= 声明“它长什么样”

C++
= 实现“它怎么工作”

17. Verifier 也能由 ODS 帮忙生成

例如你写:

I32:$lhs
I32:$rhs

那么如果有人写:

my.add %a, %b

但:

%a = i32
%b = f32

那类型约束不满足。

ODS 生成的验证逻辑就可能把它拒绝掉。

所以 ODS 还能减少:

手写 verifier

的工作。


18. Builder

ODS 还会帮助生成构造 Operation 的 C++ Builder。

比如以后在 Rewrite 里:

rewriter.create<my::AddOp>(
    loc,
    lhs,
    rhs);

为什么能这么舒服地写?

因为 ODS 知道:

AddOp 需要哪些 operand
返回什么类型
有哪些 attributes

所以能生成很多 Builder 接口。


19. Parser 和 Printer

我们前面学过:

Custom Syntax

例如:

%0 = my.add %a, %b : i32

也可以通过 ODS 的:

assemblyFormat

描述。

概念上可能类似:

let assemblyFormat =
  "$lhs `,` $rhs attr-dict `:` type($result)";

这样 TableGen 可以帮助生成:

Parser
Printer

这也是 ODS 非常强的地方。


20. 先建立“自动生成”的概念

现在你看到:

arith::AddIOp

不要以为这个类全部都是某个工程师一行一行手写出来的。

很多 Operation 的:

Accessor
Builder
Verifier
Parser/Printer

都来自:

ODS + TableGen

自动生成。

这会帮助你以后读 MLIR 源码。


21. 一个完整流程图

假设我们自己做:

My Dialect

流程大概:

MyDialect.td
   │
   └── 定义 Dialect

MyOps.td
   │
   └── 定义 Operations
          │
          ▼
      mlir-tblgen
          │
          ▼
   生成 C++ 代码
          │
          ▼
    编译进项目
          │
          ▼
可以解析:

%0 = my.add %a, %b : i32

22. 以后我们会自己定义一个 Dialect

我们后面可以做一个非常小的:

ToyMath Dialect

比如:

%0 = toy.const 10
%1 = toy.const 20
%2 = toy.add %0, %1

然后:

toy.add
   ↓
arith.addi

再:

arith
   ↓
llvm

最终:

LLVM IR

这样你就能亲手跑通完整 MLIR 编译链。


第 10 课总结

今天最重要的几个概念:

ODS
= Operation Definition Specification

它用来描述:

Operation
Operand
Result
Attribute
Type
Trait
Assembly Format

底层依赖:

TableGen

然后:

mlir-tblgen

负责生成 C++。

最终:

.td
 ↓
自动生成 C++
 ↓
得到 XxxOp

最值得记住的一句话:

ODS 描述 Operation 的结构,TableGen 把这些描述生成成真正的 C++ 基础代码。

以及:

ODS
负责“长什么样”

C++
负责“怎么工作”

下一课我们就可以不再只讲概念,正式进入 第 11 课:自己设计第一个 Dialect。

我们会亲手设计:

toy.const
toy.add
toy.mul
toy.print

并把每个 Operation 的:

operand
result
type
attribute

全部先设计清楚。

这一课会开始真正有“自己造 MLIR IR”的感觉。

评论

暂无评论