第 3 课:Block 和 Region

好,继续第 3 课。这节我们学习 MLIR 里非常关键的两个概念:

Block(基本块) 和 Region(区域)。

它们是理解函数、if、for、控制流,以及为什么 MLIR 能表达“嵌套结构”的基础。

第 3 课:Block 和 Region

先看最熟悉的代码:

func.func @add(%a: i32, %b: i32) -> i32 {
  %0 = arith.addi %a, %b : i32
  return %0 : i32
}

你可能自然地认为:

{
   ...
}

只是“函数体”。

但从 MLIR 的角度看,这里面其实是:

func.func Operation
        │
        ▼
      Region
        │
        ▼
       Block
        │
        ├── arith.addi
        └── return

这就是今天最核心的结构。


1. Block 是什么?

Block 可以先理解为:

一组顺序执行的 Operation。

例如:

^bb0(%a: i32, %b: i32):
  %0 = arith.addi %a, %b : i32
  return %0 : i32

这里:

^bb0

就是一个 Block。

它里面包含:

arith.addi
return

两个 Operation。

所以:

Block
├── Operation
├── Operation
├── Operation
└── ...

你可以暂时把它类比成 LLVM IR 的 basic block。


2. Block 可以有参数

注意:

^bb0(%a: i32, %b: i32):

这里:

%a
%b

叫:

Block Arguments

也就是 Block 参数。

它们也是:

Value

所以我们上一课说:

Value 的来源主要有:

1. Operation Result
2. Block Argument

比如:

^bb0(%a: i32, %b: i32):
  %0 = arith.addi %a, %b : i32

这里:

%a
%b

来自 Block Argument,

而:

%0

来自 Operation Result。

因此:

        Block Arguments
         %a       %b
          \       /
           \     /
          arith.addi
              |
              v
             %0

3. 为什么函数参数看起来不像 Block Argument?

看这个:

func.func @add(%a: i32, %b: i32) -> i32 {
  %0 = arith.addi %a, %b : i32
  return %0 : i32
}

你看不到:

^bb0

这是因为 MLIR 的文本格式把函数入口块做了简写。

概念上,可以理解为:

func.func @add(%a: i32, %b: i32) -> i32 {
^bb0(%a: i32, %b: i32):
  %0 = arith.addi %a, %b : i32
  return %0 : i32
}

虽然实际语法并不是要求你这么重复写,但从结构上理解是对的:

函数参数,本质上就是函数 body 中入口 Block 的 arguments。

这一点非常重要。


4. Region 是什么?

Region 可以理解为:

一个包含若干 Block 的容器。

结构是:

Region
├── Block 0
├── Block 1
├── Block 2
└── ...

所以完整层次变成:

Operation
   │
   ▼
Region
   │
   ├── Block
   │     ├── Operation
   │     └── Operation
   │
   └── Block
         ├── Operation
         └── Operation

你会发现这里出现了递归:

Operation
  contains Region

Region
  contains Block

Block
  contains Operation

于是:

Operation
  ↓
Region
  ↓
Block
  ↓
Operation
  ↓
Region
  ↓
Block
  ↓
...

这就是 MLIR 很强的地方之一。


5. func.func 本身也是 Operation

这是很多初学者第一次学 MLIR 时容易忽略的。

比如:

func.func @add(%a: i32, %b: i32) -> i32 {
  %0 = arith.addi %a, %b : i32
  return %0 : i32
}

你可能觉得:

func.func

是某种特殊语法。

但其实:

func.func 也是 Operation

它大概长这样:

func.func Operation
│
├── Attributes
│   ├── 函数名 = add
│   └── 函数类型 = (i32, i32) -> i32
│
└── Region
     │
     └── Block
          ├── arith.addi
          └── func.return

所以函数不是 MLIR 之外的特殊结构。

它只是:

一个拥有 Region 的 Operation。

这句话非常关键。


6. 为什么 Operation 里要允许 Region?

因为这样可以表达:

嵌套控制结构

比如 if。

看一个简单示意:

scf.if %cond {
  %0 = arith.addi %a, %b : i32
  ...
} else {
  %1 = arith.subi %a, %b : i32
  ...
}

scf.if 本身是一个 Operation。

但它内部有两个 Region:

scf.if Operation
│
├── then Region
│     └── Block
│          └── ...
│
└── else Region
      └── Block
           └── ...

也就是:

               scf.if
              /      \
             /        \
      then Region    else Region
          |               |
        Block           Block
          |               |
       Operations      Operations

这和很多传统 IR 很不一样。


7. for 也一样

比如:

scf.for %i = %c0 to %c10 step %c1 {
  ...
}

这里:

scf.for

也是一个 Operation。

它内部带一个 Region:

scf.for Operation
        │
        ▼
      Region
        │
        ▼
       Block
        │
        └── loop body operations

所以循环体不是“特殊语法”。

它就是:

Operation 的 Region

8. 这和 LLVM IR 有什么区别?

LLVM IR 通常会把 if:

if (x < 10) {
    foo();
} else {
    bar();
}

展开成基本块:

entry
  |
  v
cond
 /  \
v    v
then else
 \    /
  v  v
 merge

也就是说控制流结构很早就“扁平化”了。

而 MLIR 可以在较高层继续保持:

if
 ├── then region
 └── else region

甚至:

for
 └── loop body region

这种结构。

这叫:

Structured Control Flow

也就是结构化控制流。

这样做的好处是:

编译器还能知道“这是一个 if”、“这是一个 for”。

高层语义没有过早丢失。


9. 一个完整层次图

现在来看:

func.func @foo(%a: i32, %b: i32) -> i32 {
  %0 = arith.addi %a, %b : i32
  return %0 : i32
}

可以拆成:

Module
│
└── func.func
    │
    └── Region
        │
        └── Block
            │
            ├── arith.addi
            │     ├── operand: %a
            │     ├── operand: %b
            │     └── result: %0
            │
            └── func.return
                  └── operand: %0

其实再往外一层通常还有:

module {
  func.func @foo(...) {
    ...
  }
}

这里:

module

同样是一个 Operation。

所以:

builtin.module Operation
│
└── Region
    │
    └── Block
        │
        └── func.func Operation
             │
             └── Region
                 │
                 └── Block
                     │
                     ├── arith.addi
                     └── func.return

看到没有?

MLIR 本质上是一棵嵌套树。


10. 一个很重要的思想:Operation 是统一抽象

传统编译器里可能有很多不同概念:

函数
循环
if
加法
调用
模块

而 MLIR 尝试统一成:

Operation

区别只是:

有的 Operation 有 Region
有的没有

有的有 Result
有的没有

有的有 Operand
有的没有

有的有 Attribute
有的没有

例如:

arith.addi

没有 Region。

但:

func.func

有 Region。

scf.if

甚至可以有两个 Region。


11. Region 不一定只有一个 Block

这是一个非常重要的点。

Region 可以是:

Region
└── Block

也可以是:

Region
├── Block A
├── Block B
└── Block C

例如低层控制流:

^bb0:
  cf.cond_br %cond, ^bb1, ^bb2

^bb1:
  ...
  cf.br ^bb3

^bb2:
  ...
  cf.br ^bb3

^bb3:
  return

这时 Region 里就有多个 Block。

结构变成:

Region
│
├── ^bb0
│
├── ^bb1
│
├── ^bb2
│
└── ^bb3

这已经和 LLVM IR 的 CFG 很接近了。


12. Block 之间怎么传值?

这是下一步很关键的地方。

假设:

^bb0:
  cf.br ^bb1(%x : i32)

^bb1(%y: i32):
  ...

可以理解成:

bb0 里面的 %x
      │
      │ branch
      ▼
bb1 的参数 %y

也就是说:

Block Argument

除了函数参数之外,还可以承担类似 LLVM IR 里 phi 的作用。

你现在先知道这一点就够了,后面学控制流时我们会专门讲。


13. Region 和 Scope

Region 通常还会形成 Value 的作用域。

例如:

scf.if %cond {
  %0 = arith.addi %a, %b : i32
}

这里 %0 是在这个 Region 内创建的。

通常不能随便在 Region 外直接引用:

inside region:
    %0

然后:

outside region:
    使用 %0

如果你想把值从 Region 传出去,一般需要通过 Operation 的 Result/yield 机制。

例如以后你会看到:

%result = scf.if %cond -> (i32) {
  %x = ...
  scf.yield %x : i32
} else {
  %y = ...
  scf.yield %y : i32
}

这里就是:

Region 内部 Value
       ↓
    scf.yield
       ↓
scf.if Operation Result
       ↓
    %result

这个机制很漂亮,后面会专门讲。


现在把前 3 课连起来

我们目前已经学到:

MLIR
│
├── Operation
│    │
│    ├── Operand
│    ├── Result
│    ├── Attribute
│    └── Region
│
├── Region
│    └── Block
│
└── Block
     │
     ├── Arguments
     └── Operations

而:

Operand
Result
Block Argument

都和:

Value

有关。

可以画成完整关系:

                    Operation
               ┌──────┼──────┐
               │      │      │
          Operands  Results  Regions
               │      │      │
               │      │      ▼
               │      │     Block
               │      │      │
               │      │      ├── Block Arguments
               │      │      └── Operations
               │      │
               └── Value ─────┘

一个检查题

看看下面代码:

func.func @square(%x: i32) -> i32 {
  %result = arith.muli %x, %x : i32
  return %result : i32
}

你现在应该能说出:

func.func

是一个 Operation。

它内部有:

1 个 Region

这个 Region 里有:

1 个 Block

Block 参数是:

%x

Block 内有两个 Operation:

arith.muli
func.return

arith.muli 有:

2 个 Operand
1 个 Result

Result 是:

%result

如果这些你都能顺下来,第 3 课就掌握了。


第 3 课只记 4 句话

第一句:

Block = 一组 Operation

第二句:

Region = 一组 Block

第三句:

Operation 可以拥有 Region

第四句最重要:

Operation → Region → Block → Operation

这让 MLIR 能自然表达:

函数
if
for
嵌套循环
各种高层结构

而不用一开始就把它们扁平化成 CFG。

下一课我们继续学习 SSA、Block Argument,以及它为什么可以替代 LLVM 中很多 phi node 的使用方式。这节之后,你会开始真正看懂 MLIR 的控制流。

评论

暂无评论