第 4 课:SSA 和 Block Argument

好,继续第 4 课。这一课我们把 SSA、Block Argument、phi node 串起来。

第 4 课:SSA 和 Block Argument

先看一个简单例子:

func.func @max(%a: i32, %b: i32) -> i32 {
  %cond = arith.cmpi sgt, %a, %b : i32
  %result = scf.if %cond -> (i32) {
    scf.yield %a : i32
  } else {
    scf.yield %b : i32
  }
  return %result : i32
}

这段代码的意思就是:

int max(int a, int b) {
    if (a > b)
        return a;
    else
        return b;
}

这里最值得注意的是:

%result = scf.if ...

也就是说,scf.if 本身可以“产生一个值”。

这和传统语言里的 if 很不一样。


1. SSA 再回顾一下

SSA:

Static Single Assignment

核心规则:

一个 SSA Value 只能被定义一次。

比如:

%x = arith.addi %a, %b : i32

之后不能再:

%x = arith.muli %a, %b : i32

你必须新建:

%y = arith.muli %a, %b : i32

所以 MLIR 里的 %x 更像:

“某一次计算产生出来的结果”

而不是传统语言里的“可变变量”。


2. 那 if 两条路径怎么办?

比如 C:

int x;

if (cond)
    x = 10;
else
    x = 20;

return x;

这里变量 x 被赋值两次。

这显然不符合 SSA。

SSA 通常会改造成类似:

if cond:
    x1 = 10
else:
    x2 = 20

x3 = merge(x1, x2)

其中:

x3

根据控制流决定来自:

x1

还是:

x2

在 LLVM IR 里,通常使用:

phi

3. LLVM 的 phi node

比如 LLVM IR 大概会写成:

entry:
  br i1 %cond, label %then, label %else

then:
  br label %merge

else:
  br label %merge

merge:
  %x = phi i32 [ 10, %then ], [ 20, %else ]
  ret i32 %x

这里:

%x = phi ...

意思是:

如果从 then 来:
    x = 10

如果从 else 来:
    x = 20

也就是:

then ── 10 ──┐
             ├── phi ──> %x
else ── 20 ──┘

4. MLIR 更常用 Block Argument 表达这个

在 MLIR 的 CFG 风格里,可以写成:

^entry:
  cf.cond_br %cond, ^then, ^else

^then:
  %a = arith.constant 10 : i32
  cf.br ^merge(%a : i32)

^else:
  %b = arith.constant 20 : i32
  cf.br ^merge(%b : i32)

^merge(%x: i32):
  return %x : i32

重点看:

^merge(%x: i32):

这里 %x 是:

Block Argument

然后:

cf.br ^merge(%a : i32)

表示跳转到 merge 时,把 %a 传给 %x。

另外一边:

cf.br ^merge(%b : i32)

把 %b 传给 %x。

所以数据流是:

then:
  %a = 10
     \
      \
       ──────> ^merge(%x)
      /
     /
else:
  %b = 20

这其实就完成了 phi 的作用。


5. 为什么 Block Argument 很自然?

因为一个 Block 本来就可以带参数:

^bb1(%x: i32):

那从别的 Block 跳进来的时候:

cf.br ^bb1(%value : i32)

不就正好相当于“调用”这个 Block 吗?

你甚至可以这样类比:

Block

有点像一个小函数:

^bb1(%x)

而:

cf.br ^bb1(%value)

有点像:

bb1(value)

当然,它不是真的函数调用,但这个理解很有帮助。


6. Block Argument 也是 SSA Value

这一点很重要。

比如:

^merge(%x: i32):

这里的 %x:

不是普通变量
不是内存槽

它仍然是一个 SSA Value。

它的“定义位置”就是:

Block 参数列表

所以我们现在可以更完整地说:

SSA 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。

它们全都是 SSA Value。


7. Structured Control Flow 更漂亮

不过 MLIR 很有特色的一点是:

对于 if、for 这种结构化控制流,很多时候连显式 merge Block 都不用写。

比如刚才的 max:

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

这里:

then region
   │
   └── yield %a
          \
           \
            scf.if ──> %result
           /
          /
else region
   │
   └── yield %b

也就是说:

scf.yield

把 Region 里面的 Value 传给:

scf.if Operation 的 Result

于是:

%result

最终就是两条路径合并后的 SSA Value。


8. 把这两种方式放一起看

低层 CFG:

        cond
       /    \
    then    else
      \      /
       merge
         |
        %x

MLIR 可能写:

^merge(%x: i32):

而结构化 scf.if:

        scf.if
       /      \
 then region  else region
      \       /
       yield
         |
      %result

这两种方式,本质上都在解决:

控制流汇合时,SSA Value 怎么合并?


9. 为什么不直接用变量?

你可能会想:

为什么不能就写:

x = 10
x = 20

因为编译器优化更喜欢:

每个值只定义一次

这样:

%x 是谁产生的?

答案永远唯一。

比如:

%1 = arith.addi %a, %b : i32
%2 = arith.muli %1, %c : i32

看到 %1,你马上知道:

它一定来自 arith.addi

不会出现:

%x 到底是之前哪个赋值产生的?

这让:

def-use analysis
constant propagation
dead code elimination
common subexpression elimination

都更容易做。


10. Def 和 Use

再介绍两个以后会经常看到的词:

Def
Use

比如:

%0 = arith.addi %a, %b : i32
%1 = arith.muli %0, %c : i32

对 %0 来说:

Def:
    arith.addi

Use:
    arith.muli

也就是:

%0 在哪里定义?
    addi

%0 被谁使用?
    muli

可以画成:

arith.addi
    |
    | defines
    v
   %0
    |
    | used by
    v
arith.muli

这叫:

def-use chain

MLIR 的很多 Rewrite 和优化都会依赖它。


11. 一个很常见的误区

比如:

%x = arith.addi %a, %b : i32

不要理解成:

把 a+b 存到变量 x

更准确的是:

arith.addi 产生了一个 SSA Value,这个 Value 在文本中名字叫 %x。

所以 %x 只是:

SSA 名字

不是一个内存地址。

它和:

int x;

不是同一个概念。


12. 真正的“可变变量”怎么办?

如果真的需要类似:

x = x + 1;

这种可变状态,通常需要:

内存

比如:

memref.load
memref.store

这时候变的是内存里的内容,不是 SSA Value 本身。

所以:

SSA Value

是不可重新定义的,

但:

Memory

里的数据可以变。

这个区别以后学 memref 时非常重要。


第 4 课总结

今天最需要记住的是这几句话:

SSA = 一个 Value 只定义一次
SSA Value 主要来自:
1. Operation Result
2. Block Argument
Block Argument 可以承担类似 phi node 的作用
scf.if / scf.for 可以通过 yield 返回 Value

以及:

Def → Value → Use

如果你现在能理解下面这个图:

           cond
          /    \
       %a       %b
        \       /
         \     /
        merge
          |
         %x

以及 MLIR 可以通过:

Block Argument

或者:

scf.yield

来完成这个“merge”,那这一课就已经掌握了。

下一课我建议正式进入 Dialect,我们会系统讲清楚:

arith
func
scf
memref
tensor
linalg
llvm

这些 Dialect 各自是干什么的,以及为什么 MLIR 要把 IR 拆成这么多“方言”。

评论

暂无评论