标签 编译器 下的文章

通过实例理解Go静态单赋值(SSA)

本文永久链接 – https://tonybai.com/2022/10/21/understand-go-ssa-by-example

在上一篇文章《通过实例理解Go内联优化》中,我们探讨了Go编译器在编译中端进行的内联优化。内联优化基于IR中间表示进行,不过Go编译过程不止有一种IR表示,这点和龙书《编译原理(第二版)》的在第六章“中间代码生成”一开始处的讲解是一致的,即在将给定源语言的一个程序翻译成特定的目标机器代码的过程中,一个编译器可能构造出一系列中间表示(IR),如下图:

高层中间表示更接近于源语言,而低层的中间表示则更接近于目标机器。在Go编译过程中,如果说内联优化使用的IR是高层中间表示,那么低层中间表示非支持静态单赋值(SSA)的中间代码形式莫属。

在这一篇中,我们将沿着Go编译器的后端优化之路继续走下去,我们来认识一下静态单赋值(SSA)

1. 静态单赋值(SSA)的历史

静态单赋值(Static Single Assignment,SSA),也有称为Single Static Assignment的,是一种中间代码的表示形式(IR),或者说是某种中间代码所具备的属性,它是由IBM的三位研究员:Barry K. Rosen、Mark N. Wegman和F. Kenneth Zadeck于1988年提出的。

具有SSA属性的IR都具有这样的特征:

  • 每个变量在使用前都需要被定义
  • 每个变量被精确地赋值一次(使得一个变量的值与它在程序中的位置无关)

下面是一个简单的例子(伪代码):

y = 1
y = 2
x = y

转换为SSA形式为:

y1 = 1
y2 = 2
x1 = y2

我们看到由于SSA要求每个变量只能赋值一次,因此在转换为SSA后,变量y用y1和y2来表示,后面的序号越大,表明y的版本越新。从这一段三行的代码我们也可以看到,在SSA层面,y1 = 1这行代码就是一行死代码(dead code),即对结果不会产生影响的代码,可以在中间代码优化时被移除掉。

1991年,同样来自IBM研究院的Ron Cytron和Jeanne Ferrante以及前面的三位研究员又一起给出了构建SSA的快速算法,这进一步推动了SSA在编译器领域的快速应用。

SSA的提出以及后续的流行正是因为SSA形式中间代码具有很好的优化空间,基于SSA可以开启一些新的编译器优化算法或增强现有的优化算法,因此自SSA提出后,各种主流语言编译器后端均逐渐开始支持SSA,包括GCC、llvm、hotspot JVM、v8 js等。SSA也成为了一种IR表示的事实标准。

那么Go语言是何时开始与SSA结缘的呢?我们继续往下看。

2. Go与SSA

相对于GCC、LLVM,Go编译器还相对年轻,因此SSA加入Go的时间还不算太长。

Go SSA的工作始于Go 1.5版本实现自举之前,2015年2月初,负责编译器后端的Go团队核心成员的Keith Randall博士就在golang-dev google group上提出要让Go支持SSA的工作计划:

“我想从目前基于语法树的IR转换到更现代的基于SSA的IR。有了SSA IR,我们可以实现很多在当前编译器中难以做到的优化” - Keith Randall

同期,Keith Randall博士还编写了“New SSA Backend for the Go Compiler”文档,具体介绍了Go要支持SSA的理由以及分几步走的实现方案。

在为什么选择自己实现SSA IR,而不是转换为当时现成的诸如gcc, llvm等支持的IR形式并利用成熟后端进行中间代码优化这个问题上,Keith Randall博士给出了三点理由:

  • 从Go编译速度考虑:Go团队和社区对编译速度有着格外的青睐,Randall的目标是设计一个线性时间的SSA算法,实现快速SSA优化,但gcc, llmv等IR显然没有在速度方面给予额外的考虑;

  • 从功能完整性上考虑:Go运行时需要精确的栈帧地图(the map of stack frame),用来支持GC和栈拷贝,这些在gcc, llvm中都不会提供;

  • 从Go核心开发者的编译器使用体验方面考虑:如果使用llvm、gcc等ir,显然Go核心开发人员在编译go的时候还需要依赖llvm或gcc,这种额外的依赖对他们来说很难说是体验友好的。

2016年3月1日,在Go 1.7版本的master分支提交权限刚刚打开之后,Keith Randall就将支持ssa的dev.ssa分支合并到Go项目主线中了。

Go 1.7版本中,Go正式支持SSA,不过由于时间有限,Go 1.7 SSA仅支持针对amd64架构的优化。即便如此,Go支持SSA后,Keith Randall的benchmark显示性能提升12%,代码段缩小13%:


图:go 1.7 benchmark(图来自keith博士的slide)

Go 1.7正式发布时,其发布文档称Go程序的性能因对SSA的支持而提升5%-35%以上。由此看,Go SSA的实现达到了Keith Randall博士的预期目标,也为Go编译器后续的持续优化奠定了基础。

在2017年2月发布的Go 1.8版本中,Go SSA的支持范围扩展到其他所有Go支持的cpu架构,包括arm和arm64、mips和mips64、ppc64等。

了解了Go SSA的演进后,我们再来简单说说Go编译器中SSA的实现。

3. 转换为SSA

我们先来看看转换为SSA以及SSA优化在编译过程中所处的位置:


图:Go SSA所处的环节(图来自keith博士的slide)

上图是keith博士在2017年gophercon大会上slide中的一幅图,这幅图中明确了生成SSA形式以及SSA优化所处的环节。不过较新的Go版本中,convert to SSA之前也有一种不同于最初的抽象语法树的ir(比如:Go 1.19),SSA是由此种ir转换过来的。

从代码上来看,ir到SSA形式的转换发生在下面环节(Go 1.19版本代码,其他版本可能代码位置和内容均由不同):

// $GOROOT/src/cmd/compile/internal/gc/main.go
func Main(archInit func(*ssagen.ArchInfo)) {
    base.Timer.Start("fe", "init")

    defer handlePanic()

    archInit(&ssagen.Arch)
    ... ...

    // Compile top level functions.
    // Don't use range--walk can add functions to Target.Decls.
    base.Timer.Start("be", "compilefuncs")
    fcount := int64(0)
    for i := 0; i < len(typecheck.Target.Decls); i++ {
        if fn, ok := typecheck.Target.Decls[i].(*ir.Func); ok {
            // Don't try compiling dead hidden closure.
            if fn.IsDeadcodeClosure() {
                continue
            }
            enqueueFunc(fn)
            fcount++
        }
    }
    base.Timer.AddEvent(fcount, "funcs")

    compileFunctions()

    ... ...
}

在Main中,我们看到代码会将所有Target.Decls(函数)通过enqueueFunc入队列(compilequeue),然后调用compileFunctions来实现各个函数从AST ir到SSA形式的转换,compileFunctions在compile.go中,其实现如下:

// $GOROOT/src/cmd/compile/internal/gc/compile.go
func compileFunctions() {
    if len(compilequeue) == 0 {
        return
    }

    ... ...
    // By default, we perform work right away on the current goroutine
    // as the solo worker.
    queue := func(work func(int)) {
        work(0)
    }
    ... ...

    var compile func([]*ir.Func)
    compile = func(fns []*ir.Func) {
        wg.Add(len(fns))
        for _, fn := range fns {
            fn := fn
            queue(func(worker int) {
                ssagen.Compile(fn, worker)
                compile(fn.Closures)
                wg.Done()
            })
        }
    }
    types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
    base.Ctxt.InParallel = true

    compile(compilequeue)
    ... ...
}

在compileFunctions中我们看到,编译器从compilequeue取出AST IR形式的函数,并调用ssagen.Compile将其编译为SSA形式。下面是ssagen.Compile的代码:

// $GOROOT/src/cmd/compile/internal/ssagen/pgen.go

// Compile builds an SSA backend function,
// uses it to generate a plist,
// and flushes that plist to machine code.
// worker indicates which of the backend workers is doing the processing.
func Compile(fn *ir.Func, worker int) {
    f := buildssa(fn, worker)
    // Note: check arg size to fix issue 25507.
    if f.Frontend().(*ssafn).stksize >= maxStackSize || f.OwnAux.ArgWidth() >= maxStackSize {
        largeStackFramesMu.Lock()
        largeStackFrames = append(largeStackFrames, largeStack{locals: f.Frontend().(*ssafn).stksize, args: f.OwnAux.ArgWidth(), pos: fn.Pos()})
        largeStackFramesMu.Unlock()
        return
    }
    pp := objw.NewProgs(fn, worker)
    defer pp.Free()
    genssa(f, pp)
    // Check frame size again.
    // The check above included only the space needed for local variables.
    // After genssa, the space needed includes local variables and the callee arg region.
    // We must do this check prior to calling pp.Flush.
    // If there are any oversized stack frames,
    // the assembler may emit inscrutable complaints about invalid instructions.
    if pp.Text.To.Offset >= maxStackSize {
        largeStackFramesMu.Lock()
        locals := f.Frontend().(*ssafn).stksize
        largeStackFrames = append(largeStackFrames, largeStack{locals: locals, args: f.OwnAux.ArgWidth(), callee: pp.Text.To.Offset - locals, pos: fn.Pos()})
        largeStackFramesMu.Unlock()
        return
    }

    pp.Flush() // assemble, fill in boilerplate, etc.
    // fieldtrack must be called after pp.Flush. See issue 20014.
    fieldtrack(pp.Text.From.Sym, fn.FieldTrack)
}

这里贴出了Compile的完整实现,Compile函数中真正负责生成具有SSA属性的中间代码的是buildssa函数,看了一下buildssa函数有近300行代码,有点复杂,这里挑挑拣拣,把主要的调用摘录出来:

// $GOROOT/src/cmd/compile/internal/ssagen/ssa.go

// buildssa builds an SSA function for fn.
// worker indicates which of the backend workers is doing the processing.
func buildssa(fn *ir.Func, worker int) *ssa.Func {
    name := ir.FuncName(fn)
    ... ...

    // Convert the AST-based IR to the SSA-based IR
    s.stmtList(fn.Enter)
    s.zeroResults()
    s.paramsToHeap()
    s.stmtList(fn.Body)

    // fallthrough to exit
    if s.curBlock != nil {
        s.pushLine(fn.Endlineno)
        s.exit()
        s.popLine()
    }
    ... ...

    // Main call to ssa package to compile function
    ssa.Compile(s.f)
    ... ...
}

buildssa中的ssa.Compile咱们后续再看,那个涉及到SSA的多轮(pass)优化,我们看一下从基于AST形式的IR到基于SSA形式的IR的转换,无论是fn.Enter还是fn.Body,本质都是一组ir Node,stmtList将这些node逐个转换为SSA形式。Go提供了可视化的ssa dump工具,我们可以更直观的来看一下。

Go语言隶属于命令式编程语言(imperative programming language),这类编程范式有三大典型控制结构:顺序结构、选择结构和循环结构,我们先来看看一个最简单的顺序结构是如何翻译为SSA的:

// github.com/bigwhite/experiments/tree/master/ssa-examples/sequential.go

package main

func sum(a, b, c int) int {
    d := a + b
    e := d + c
    return e
}

func main() {
    println(sum(1, 2, 3))
}

我们通过下面命令来生成函数sum的SSA转换过程:

$GOSSAFUNC=sum go build sequential.go
dumped SSA to ./ssa.html
$mv ssa.html ssa-sequential.html
$open ./ssa-sequential.html

上面的open命令会在本地打开浏览器并显示ssa-sequential.html页面:

上图中,最左侧是源码(源码显示两次,感觉是bug),中间的是AST形式的IR,最右侧的框框中就是Go编译器生成的第一版SSA,为了更好说明,我们将其贴到下面来:

// github.com/bigwhite/experiments/tree/master/ssa-examples/ssa-sequential.html

b1:-
  v1 (?) = InitMem <mem>
  v2 (?) = SP <uintptr>
  v3 (?) = SB <uintptr>
  v4 (?) = LocalAddr <*int> {a} v2 v1
  v5 (?) = LocalAddr <*int> {b} v2 v1
  v6 (?) = LocalAddr <*int> {c} v2 v1
  v7 (?) = LocalAddr <*int> {~r0} v2 v1
  v8 (3) = Arg <int> {a} (a[int])
  v9 (3) = Arg <int> {b} (b[int])
  v10 (3) = Arg <int> {c} (c[int])
  v11 (?) = Const64 <int> [0]
  v12 (+4) = Add64 <int> v8 v9 (d[int])
  v13 (+5) = Add64 <int> v12 v10 (e[int])
  v14 (+6) = MakeResult <int,mem> v13 v1
Ret v14 (+6)

name a[int]: v8
name b[int]: v9
name c[int]: v10
name d[int]: v12
name e[int]: v13

从结构上来看,SSA分为两部分,一部分是由b1、Ret组成的blocks,另一部分则是命名变量与SSA value的对应关系。

在SSA中,一个block代表了一个函数控制流图(control flow graph)中的基本代码块(basic block),从代码注释中可以看到SSA有四种block类型:Plain,If、Exit和Defer:

// $GOROOT/src/cmd/compile/internal/ssa/block.go

// BlockKind is the kind of SSA block.
//
//    kind          controls        successors
//  ------------------------------------------
//    Exit      [return mem]                []
//   Plain                []            [next]
//      If   [boolean Value]      [then, else]
//   Defer             [mem]  [nopanic, panic]  (control opcode should be OpStaticCall to runtime.deferproc)
type BlockKind int16

但实际的BlockKind已经与注释不一致了,opGen.go是一个自动生成的文件,其中的BlockKind类型的常量值有数十个,即便滤掉CPU架构相关的常量,剩下的还有8个(从BlockPlain到BlockFirst):

// $GOROOT/src/cmd/compile/internal/ssa/opGen.go

const (
    BlockInvalid BlockKind = iota
    ... ...

    BlockPlain
    BlockIf
    BlockDefer
    BlockRet
    BlockRetJmp
    BlockExit
    BlockJumpTable
    BlockFirst
)

上面的sum函数的SSA代码例子中,b1应该就是Plain类型的,Ret显然是BlockRet类型。

Plain类型的Block中是一组values,value是SSA的基本构成要素。根据SSA的定义,一个value只能被精确地定义一次,但是它可以被使用任意多次。如示例,一个value主要包括一个唯一的标识符,一个操作符,一个类型和一些参数,下面的Value类型的LongString和LongHTML方法返回的字符串更能说明Value的格式。尤其是LongHTML方法就是输出ssa html中内容的方法:

// $GOROOT/src/cmd/compile/internal/ssa/value.go

// long form print.  v# = opcode <type> [aux] args [: reg] (names)
func (v *Value) LongString() string {
    ... ...
}

// $GOROOT/src/cmd/compile/internal/ssa/html.go
func (v *Value) LongHTML() string {
    // TODO: Any intra-value formatting?
    // I'm wary of adding too much visual noise,
    // but a little bit might be valuable.
    // We already have visual noise in the form of punctuation
    // maybe we could replace some of that with formatting.
    s := fmt.Sprintf("<span class=\"%s ssa-long-value\">", v.String())

    linenumber := "<span class=\"no-line-number\">(?)</span>"
    if v.Pos.IsKnown() {
        linenumber = fmt.Sprintf("<span class=\"l%v line-number\">(%s)</span>", v.Pos.LineNumber(), v.Pos.LineNumberHTML())
    }

    s += fmt.Sprintf("%s %s = %s", v.HTML(), linenumber, v.Op.String())

    s += " &lt;" + html.EscapeString(v.Type.String()) + "&gt;"
    s += html.EscapeString(v.auxString())
    for _, a := range v.Args {
        s += fmt.Sprintf(" %s", a.HTML())
    }
    r := v.Block.Func.RegAlloc
    if int(v.ID) < len(r) && r[v.ID] != nil {
        s += " : " + html.EscapeString(r[v.ID].String())
    }
    var names []string
    for name, values := range v.Block.Func.NamedValues {
        for _, value := range values {
            if value == v {
                names = append(names, name.String())
                break // drop duplicates.
            }
        }
    }
    if len(names) != 0 {
        s += " (" + strings.Join(names, ", ") + ")"
    }

    s += "</span>"
    return s
}

以例子中的v12这一个value为例:

  v12 (+4) = Add64 <int> v8 v9 (d[int])
  • v12是该value的唯一标识符,其中的12为ID,ID是从1开始的整数;
  • (+4)是对应的源码的行号;
  • Add64是操作符;
  • 是value的类型(v.Type());
  • v8, v9则是Add64操作符的参数;
  • (d[int])是v12对应的LocalSlot,LocalSlot代表栈帧上的一个位置(location),用来识别和存储输出参数、输出参数或其他变量node。

ssa dump输出的另一部分则是命名变量与SSA value的对应关系,其格式也是:name LocalSlot: value:

name a[int]: v8
name b[int]: v9
name c[int]: v10
name d[int]: v12
name e[int]: v13

输出上述第二部分的代码如下:

// $GOROOT/src/cmd/compile/internal/ssa/print.go
func (p stringFuncPrinter) named(n LocalSlot, vals []*Value) {
    fmt.Fprintf(p.w, "name %s: %v\n", n, vals)
}

顺序结构的代码执行流是从上到下的,每个block后面仅有一个后继block,这样的SSA转换较为好理解。

下面我们再来看看一个选择控制结构 – if控制语句的ssa,下面是我们的示例Go源码:

// github.com/bigwhite/experiments/tree/master/ssa-examples/selection_if.go

package main

func foo(b bool) int {
    if b {
        return 2
    }
    return 3
}

func main() {
    println(foo(true))
}

我们通过下面命令输出函数foo的SSA中间代码:

$GOSSAFUNC=foo go build selection_if.go
dumped SSA to ./ssa.html
$mv ssa.html ssa-selection-if.html
$open ./ssa-selection-if.html

open命令启动浏览器显示foo函数的SSA形式:

有了上面关Go SSA格式的基础,这段SSA代码分析起来就容易一些了。

这段SSA中有多个block,包括plain block、if block、ret block等。我们重点关注SSA对if语句的处理。

经典SSA转换理论中,SSA将if分支转换为带有Φ函数的SSA代码(如下图):


图:if语句的SSA转换(图来自keith博士的slide)

Φ函数(希腊字母fài)是代码中的一个merge point,它可以将其前置的n个block的执行路径汇聚在一起。不过它仅用于代码分析使用,最终生成的代码中并不会有Φ函数的存在。关于在何处插入Φ函数等算法太理论了,这里就不展开了。

我们看看现实中go针对if语句的处理:

b1:
  v1 (?) = InitMem <mem>
  v2 (?) = SP <uintptr>
  v3 (?) = SB <uintptr>
  v4 (?) = LocalAddr <*bool> {b} v2 v1
  v5 (?) = LocalAddr <*int> {~r0} v2 v1
  v6 (3) = Arg <bool> {b} (b[bool])
  v7 (?) = Const64 <int> [0]
  v8 (?) = Const64 <int> [2]
  v11 (?) = Const64 <int> [3]
If v6 → b3 b2 (4)

b2: ← b1
  v13 (7) = Copy <mem> v1
  v12 (7) = MakeResult <int,mem> v11 v13
Ret v12 (+7)

b3: ← b1
  v10 (5) = Copy <mem> v1
  v9 (5) = MakeResult <int,mem> v8 v10
Ret v9 (+5)

name b[bool]: v6

这里关键是if block,if判断v6即变量b的值,如果为true,代码执行就流向block b3,否则流向block b2。

下面的b2、b3 block也都包含了前置block的属性,以b2为例,对于来自b1 block的流,执行对应block的代码。基于switch的选择语句更为复杂,有兴趣的朋友可以自己看一下ssa-selection-switch.html。

我们最后看一下循环结构,下面是Go代码:

// github.com/bigwhite/experiments/tree/master/ssa-examples/for_loop.go
package main

func sumN(n int) int {
    var r int
    for i := 1; i <= n; i++ {
        r = r + i
    }
    return r
}

func main() {
    println(sumN(10))
}

其生成的SSA如下图:

我们看到循环结构的ssa block更多,流向更为复杂,如果将其转换为一张图的话,那就应该是这样的:

我们看到:无论是选择结构还是循环结构,SSA实质上构建了一个函数的控制流图(control flow graph),图中每个节点就是一个block,函数的执行控制流在各个block间转移。而后续基于SSA的优化就是基于block中value的仅赋值一次的特性以及block的控制流图进行的

接下来,我们简单看看目前Go基于SSA IR都做了哪些优化。

4. 基于SSA的多轮(pass)优化

buildssa函数中ssa.Compile调用执行了基于SSA IR的多轮(passes)优化:

// $GOROOT/src/cmd/compile/internal/ssa/compile.go

func Compile(f *Func) {
    ... ...
    for _, p := range passes {
        ... ...
        tStart := time.Now()
        p.fn(f)
        tEnd := time.Now()
        ... ...
    }
}

我们看到,针对某个函数,Compile函数对其安装预置的passes进行多轮优化,都有哪些pass呢?我们来看看:

// $GOROOT/src/cmd/compile/internal/ssa/compile.go

// list of passes for the compiler
var passes = [...]pass{
    {name: "number lines", fn-3693: numberLines, required: true},
    {name: "early phielim", fn-3693: phielim},
    {name: "early copyelim", fn-3693: copyelim},
    {name: "early deadcode", fn-3693: deadcode}, // remove generated dead code to avoid doing pointless work during opt
    {name: "short circuit", fn-3693: shortcircuit},
    {name: "decompose user", fn-3693: decomposeUser, required: true},
    {name: "pre-opt deadcode", fn-3693: deadcode},
    ... ...
    {name: "regalloc", fn-3693: regalloc, required: true},   // allocate int & float registers + stack slots
    {name: "loop rotate", fn-3693: loopRotate},
    {name: "stackframe", fn-3693: stackframe, required: true},
    {name: "trim", fn-3693: trim}, // remove empty blocks
}

粗略数了一下,这里约有50个pass(其中包含多轮的deadcode清理),每个pass执行的代码都位于$GOROOT/src/cmd/compile/internal/ssa目录下,我们也可以通过dump出的html查看每一pass后得到的SSA结果,以ssa-sequential.html为例,其多轮优化的示意图如下:

点击浏览器页面上的黑体字优化标题(比如:lowered deadcode for cse),这一步产生的SSA代码都会显示出来,最后一个框框中是基于SSA生成目标架构的汇编代码。

每一个pass都有其独特性,比如cse,代表Common Subexpression Elimination(共同子表达式删除) ,下面是一个cse优化的例子:

y = x + 5
...
z = x + 5

cse优化后(前提中间过程中x值没变过):

y = x + 5
...
z = y

在这个示例中,经过一轮cse,Go便可以节省下一次没必要的加法运算(z = x + 5)。别看一次加法运算不起眼,积累多了也是不小的性能提升,

如果你对某一pass的优化动作感兴趣,可以对照$GOROOT/src/cmd/compile/internal/ssa目录下的代码与浏览器中生成的SSA来对其进行深入研究。

5. 小结

编译器后端的逻辑总是很难理解的,本文对Go编译器与SSA的渊源、Go编译器中驱动SSA转换和优化的环节以及Go生成的SSA的形式与过程做了介绍,算是对SSA入了个门。但要想真正搞懂SSA转换以及基于SSA的优化步骤的细节,认真阅读SSA相关的paper和资料(见参考资料)以及相关code是不可或缺的。

本文涉及的代码在这里可以下载。

6. 参考资料

  • 《编译原理(第二版)》- https://book.douban.com/subject/3296317/
  • SSA: Static Single-Assignment Form – https://www.slideserve.com/heidi-farmer/ssa-static-single-assignment-form
  • 《Static Single Assignment Book》 – https://pfalcon.github.io/ssabook/latest/book-full.pdf
  • Static single-assignment form – https://en.wikipedia.org/wiki/Static_single_assignment_form
  • GopherCon 2017: Keith Randall – Generating Better Machine Code with SSA – https://about.sourcegraph.com/blog/go/generating-better-machine-code-with-ssa
  • Generating Better Machine Code with SSA(slide) – https://raw.githubusercontent.com/gophercon/2017-talks/master/KeithRandall-GeneratingBetterMachineCodeWithSSA/GeneratingBetterMachineCodeWithSSA.pdf
  • New SSA Backend for the Go Compiler – https://docs.google.com/document/d/1szwabPJJc4J-igUZU4ZKprOrNRNJug2JPD8OYi3i1K0/edit

“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2022年,Gopher部落全面改版,将持续分享Go语言与Go应用领域的知识、技巧与实践,并增加诸多互动形式。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博:https://weibo.com/bigwhite20xx
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

通过实例理解Go内联优化

本文永久链接 – https://tonybai.com/2022/10/17/understand-go-inlining-optimisations-by-example


移动互联网时代,直面C端用户的业务系统规模一般都很庞大,系统消耗的机器资源也很可观,系统使用的CPU核数、内存都是在消耗公司的真金白银。在服务水平不下降的前提下尽量降低单服务实例的资源消耗,即我们俗称的“少吃草多产奶”,一直是各个公司经营人员的目标,有些公司每降低1%的CPU核数使用,每年都能节省几十万的开销。

在编程语言选择不变的情况下,要想持续降低服务资源消耗,一方面要靠开发人员对代码性能持续地打磨,另一方面依靠编程语言编译器在编译优化方面提升带来的效果则更为自然和直接。不过,这两方面也是相辅相成的,开发人员如果能对编译器的优化场景和手段理解更为透彻的话,就能写出对编译优化更为友好的代码,从而获得更好的性能优化效果。

Go核心团队在Go编译器优化方面一直在持续投入并取得了不俗的效果,虽然和老牌的GCCllvm的代码优化功力相比还有不小的空间。近期看到的一篇文章“字节大规模微服务语言发展之路”中也有提到:字节内部通过修改Go编译器的内联优化(收益最大的改动),从而让字节内部服务的Go代码获得了更多的优化机会,实现了线上服务10-20%的性能提升以及内存资源使用的下降,节约了大概了十几万个核。

看到这么明显的效果,想必各位读者都很想了解一下Go编译器的内联优化了。别急,在这一篇文章中,我就和大家一起来学习和理解一下Go编译器的内联优化。希望通过本文的学习,能让大家掌握如下内容:

  • 什么是内联优化以及它的好处是什么
  • 内联优化在Go编译过程中所处的环节和实现原理
  • 哪些代码能被内联优化,哪些还不能被内联优化
  • 如何控制Go编译器的内联优化
  • 内联优化的弊端有哪些

下面我们就先来了解一下什么是内联优化。


1. 什么是编译器的内联优化

内联(inlining)是编程语言编译器常用的优化手段,其优化的对象为函数,也称为函数内联。如果某函数F支持内联,则意味着编译器可以用F的函数体/函数定义替换掉对函数F进行调用的代码,以消除函数调用带来的额外开销,这个过程如下图所示:

我们知道Go从1.17版本才改为基于寄存器的调用规约,之前的版本一直是基于栈传递参数与返回值,函数调用的开销更大,在这样的情况下,内联优化的效果也就更为显著。

除此之外,内联优化之后,编译器的优化决策可以不局限在每个单独的函数(比如上图中的函数g)上下文中做出,而是可以在函数调用链上做出了(内联替换后,代码变得更平(flat)了)。比如上图中对g后续执行的优化将不局限在g上下文,由于f的内联,让编译器可以在g->f这个调用链的上下文上决策后续要执行的优化手段,即内联让编译器可以看得更广更远了

我们来看一个简单的例子:

// github.com/bigwhite/experiments/tree/master/inlining-optimisations/add/add.go

//go:noinline
func add(a, b int) int {
    return a + b
}

func main() {
    var a, b = 5, 6
    c := add(a, b)
    println(c)
}

这个例子中,我们的关注点是add函数,在add函数定义上方,我们用//go:noinline告知编译器对add函数关闭inline,我们构建该程序,得到可执行文件:add-without-inline;然后去掉//go:noinline这一行,再进行一次程序构建,得到可执行文件add,我们用lensm工具以图形化的方式查看一下这两个可执行文件的汇编代码,并做以下对比:

我们看到:非内联优化的版本add-without-inline如我们预期那样,在main函数中通过CALL指令调用了add函数;但在内联优化版本中,add函数的函数体并没有替换掉main函数中调用add函数位置上的代码,main函数调用add函数的位置上对应的是一个NOPL的汇编指令,这是一条不执行任何操作的空指令。那么add函数实现的汇编代码哪去了呢?

// add函数实现的汇编代码
ADDQ BX, AX
RET

结论是:被优化掉了!这就是前面说的内联为后续的优化提供更多的机会。add函数调用被替换为add函数的实现后,Go编译器直接可以确定调用结果为11,于是连加法运算都省略了,直接将add函数的结果换成了一个常数11(0xb),然后直接将常量11传给了println内置函数(MOVL 0xb, AX)。

通过一个简单的benchmark,也可以看出内联与非内联add的性能差异:

// 开启内联优化
$go test -bench .
goos: darwin
goarch: amd64
pkg: github.com/bigwhite/experiments/inlining-optimisations/add
BenchmarkAdd-8      1000000000           0.2720 ns/op
PASS
ok      github.com/bigwhite/experiments/inlining-optimisations/add  0.307s

// 关闭内联优化
$go test -bench .
goos: darwin
goarch: amd64
pkg: github.com/bigwhite/experiments/inlining-optimisations/add
BenchmarkAdd-8      818820634            1.357 ns/op
PASS
ok      github.com/bigwhite/experiments/inlining-optimisations/add  1.268s

我们看到:内联版本是非内联版本性能的5倍左右

到这里,很多朋友可能会问:既然内联优化的效果这么好,为什么不将Go程序内部的所有函数都内联了,这样整个Go程序就变成了一个大函数,中间再没有任何函数调用了,这样性能是不是可以变得更高呢?虽然理论上可能是这种情况,但内联优化不是没有开销的,并且针对不同复杂性的函数,内联的效果也是不同的。下面我就和大家一起先来看看内联优化的开销!

2. 内联优化的“开销”

在真正理解内联优化的开销之前,我们先来看看内联优化在Go编译过程中的位置,即处于哪个环节。

Go编译过程

和所有静态语言编译器一样,Go编译过程大致分为如下几个阶段:

  • 编译前端

Go团队并没有刻意将Go编译过程分为我们常识中的前后端,如果非要这么分,源码分析(包括词法和语法分析)、类型检查和中间表示(Intermediate Representation)构建可以归为逻辑上的编译前端,后面的其余环节都划归为后端。

源码分析形成抽象语法树,然后是基于抽象语法树的类型检查,待类型检查通过后,Go编译器将AST转换为一个与目标平台无关的中间代码表示。

目前Go有两种IR实现方式,一种是irgen(又名”-G=3″或是”noder2″),irgen是从Go 1.18版本开始使用的实现(这也是一种类似AST的结构);另外一种是unified IR,在Go 1.19版本中,我们可以使用GOEXPERIMENT=unified启用它,根据最新消息,unified IR将在Go 1.20版本落地。

注:现代编程语言编译过程多数会多次生成中间代码(IR),比如下面要提到的静态单赋值形式(SSA)也是一种IR形式。针对每种IR,编译器都会有一些优化动作:


图:编译优化过程(图来自https://www.slideserve.com/heidi-farmer/ssa-static-single-assignment-form)

  • 编译后端

编译后端的第一步是一个被Go团队称为中端(middle end)的环节,在这个环节中,Go编译器将基于上面的中间代码进行多轮(pass)的优化,包括死代码消除、内联优化、方法调用实体化(devirtualization)和逃逸分析等。

注:devirtualization是指将通过接口变量调用的方法转换为接口的动态类型变量直接调用该方法,消除通过接口进行方法表查找的过程。

接下来是中间代码遍历(walk),这个环节是基于上述IR表示的最后一轮优化,它主要是将复杂的语句分解成单独的、更简单的语句,引入临时变量并重新评估执行顺序,同时在这个环节,它还会将一些高层次的Go结构转换为更底层、更基础的操作结构,比如将switch语句转换为二分查找或跳表,将对map和channel的操作替换为运行时的调用(如mapaccess)等。

接下来是编译后端的最后两个环节,首先是将IR转换为SSA(静态单一赋值)形式,并再次基于SSA做多轮优化,最后针对目标架构,基于SSA的最终形式生成机器相关的汇编指令,然后交给汇编器生成可重定位的目标机器码。

注: 编译器(go compiler)产生的可重定位的目标机器码最终提供给链接器(linker)生成可执行文件。

我们看到Go内联发生在中端环节,是基于IR中间代码的一种优化手段,在IR层面上实现函数是否可内联的决策,以及对可内联函数在其调用处的函数体替换

一旦了解了Go内联所处环节,我们就能大致判断出Go内联优化带来的开销了。

Go内联优化的开销

我们用一个实例来看一下Go内联优化的开销。reviewdog是一个纯Go实现的支持github、gitlab等主流代码托管平台的代码评审工具,它的规模大约有12k行(使用loccount统计):

// reviewdog代码行数统计结果:

$loccount .
all          SLOC=14903   (100.00%) LLOC=4613    in 141 files
Go           SLOC=12456   (83.58%)  LLOC=4584    in 106 files
... ...

我们在开启内联优化和关闭内联优化的情况下分别对reviewdog进行构建,采集其构建时间与构建出的二进制文件的size,结果如下:

// 开启内联优化(默认)
$time go build -o reviewdog-inline -a github.com/reviewdog/reviewdog/cmd/reviewdog
go build -o reviewdog-inline -a github.com/reviewdog/reviewdog/cmd/reviewdog  53.87s user 9.55s system 567% cpu 11.181 total

// 关闭内联优化
$time go build -o reviewdog-noinline -gcflags=all="-l" -a github.com/reviewdog/reviewdog/cmd/reviewdog
go build -o reviewdog-noinline -gcflags=all="-l" -a   43.25s user 8.09s system 566% cpu 9.069 total

$ ls -l
-rwxrwxr-x  1 tonybai tonybai 23080429 Oct 13 12:05 reviewdog-inline*
-rwxrwxr-x  1 tonybai tonybai 20745006 Oct 13 12:04 reviewdog-noinline*
... ...

我们看到开启内联优化的版本,其编译消耗时间比关闭内联优化版本的编译时间多出24%左右,并且生成的二进制文件size要大出11%左右 – 这就是内联优化带来的开销!即会拖慢编译器并导致生成的二进制文件size变大。

注:hello world级别的程序是否开启内联优化大多数情况是看不出来太多差异的,无论是编译时间,还是二进制文件的size。

由于我们知道了内联优化所处的环节,因此这种开销就可以很好地给予解释:根据内联优化的定义,一旦某个函数被决策为可内联,那么程序中所有调用该函数的位置的代码就会被替换为该函数的实现,从而消除掉函数调用带来的运行时开销,同时这也导致了在IR(中间代码)层面出现一定的代码“膨胀”。前面也说过,代码膨胀后的“副作用”是编译器可以以更广更远的视角看待代码,从而可能实施的优化手段会更多。可实施的优化轮次越多,编译器执行的就越慢,这进一步增加了编译器的耗时;同时膨胀的代码让编译器需要在后面环节处理和生成更多代码,不仅增加耗时,还增加了最终二进制文件的size。

Go向来对编译速度和binary size较为敏感,所以Go采用了相对保守的内联优化策略。那么到底Go编译器是如何决策一个函数是否可以内联呢?下面我们就来简单看看Go编译器是如何决策哪些函数可以实施内联优化的。

3. 函数内联的决策原理

前面说过,内联优化是编译中端多轮(pass)优化中的一轮,因此它的逻辑相对独立,它基于IR代码进行,改变的也是IR代码。我们可以在Go源码的$GOROOT/src/cmd/compile/internal/inline/inl.go中找到Go编译器进行内联优化的主要代码。

注:Go编译器内联优化部分的代码的位置和逻辑在以前的版本以及在未来的版本中可能有变化,目前本文提到的是代码是Go 1.19.1中的源码。

内联优化IR优化环节会做两件事:第一遍历IR中所有函数,通过CanInline判断某个函数是否可以内联,对于可内联的函数,保存相应信息,比如函数body等,供后续做内联函数替换使用;第二呢,则是对函数中调用的所有内联函数进行替换。 我们重点关注CanInline,即Go编译器究竟是如何决策一个函数是否可以内联的

内联优化过程的“驱动逻辑”在$GOROOT/src/cmd/compile/internal/gc/main.go的Main函数中:

// $GOROOT/src/cmd/compile/internal/gc/main.go
func Main(archInit func(*ssagen.ArchInfo)) {
    base.Timer.Start("fe", "init")

    defer handlePanic()

    archInit(&ssagen.Arch)
    ... ...

    // Enable inlining (after RecordFlags, to avoid recording the rewritten -l).  For now:
    //  default: inlining on.  (Flag.LowerL == 1)
    //  -l: inlining off  (Flag.LowerL == 0)
    //  -l=2, -l=3: inlining on again, with extra debugging (Flag.LowerL > 1)
    if base.Flag.LowerL <= 1 {
        base.Flag.LowerL = 1 - base.Flag.LowerL
    }
    ... ...

    // Inlining
    base.Timer.Start("fe", "inlining")
    if base.Flag.LowerL != 0 {
        inline.InlinePackage()
    }
    noder.MakeWrappers(typecheck.Target) // must happen after inlining
    ... ...
}

从代码中我们看到:如果没有全局关闭内联优化(base.Flag.LowerL != 0),那么Main就会调用inline包的InlinePackage函数执行内联优化。InlinePackage的代码如下:

// $GOROOT/src/cmd/compile/internal/inline/inl.go
func InlinePackage() {
    ir.VisitFuncsBottomUp(typecheck.Target.Decls, func(list []*ir.Func, recursive bool) {
        numfns := numNonClosures(list)
        for _, n := range list {
            if !recursive || numfns > 1 {
                // We allow inlining if there is no
                // recursion, or the recursion cycle is
                // across more than one function.
                CanInline(n)
            } else {
                if base.Flag.LowerM > 1 {
                    fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Nname)
                }
            }
            InlineCalls(n)
        }
    })
}

InlinePackage遍历每个顶层声明的函数,对于非递归函数或递归前跨越一个以上函数的递归函数,通过调用CanInline函数判断其是否可以内联,无论是否可以内联,接下来都会调用InlineCalls函数对其函数定义中调用的内联函数进行替换。

VisitFuncsBottomUp是根据函数调用图从底向上遍历的,这样可以保证每次在调用analyze时,列表中的每个函数都只调用列表中的其他函数,或者是在之前的调用中已经analyze过(在这里就是被内联函数体替换过)的函数。

什么是递归前跨越一个以上函数的递归函数,看下面这个例子就懂了:

// github.com/bigwhite/experiments/tree/master/inlining-optimisations/recursion/recursion1.go
func main() {
    f(100)
}

func f(x int) {
    if x < 0 {
        return
    }
    g(x - 1)
}
func g(x int) {
    h(x - 1)
}
func h(x int) {
    f(x - 1)
}

f是一个递归函数,但并非自己调用自己,而是通过g -> h这个函数链最终又调回自己,而这个函数链长度>1,所以f是可以内联的:

$go build -gcflags '-m=2'  recursion1.go
./recursion1.go:7:6: can inline f with cost 67 as: func(int) { if x < 0 { return  }; g(x - 1) }

我们继续看CanInline函数。CanInline函数有100多行代码,其主要逻辑分为三个部分。

首先是对一些//go:xxx指示符(directive)的判定,当该函数包含下面指示符时,则该函数不能内联:

  • //go:noinline
  • //go:norace或构建命令行中包含-race选项
  • //go:nocheckptr
  • //go:cgo_unsafe_args
  • //go:uintptrkeepalive
  • //go:uintptrescapes
  • … …

其次会对该函数的状态做判定,比如如果函数体为空,则不能内联;如果未做类型检查(typecheck),则不能内联等。

最后调用visitor.tooHairy对函数的复杂性做判定。判定方法就是先为此次遍历(visitor)设置一个初始最大预算(budget),这个初始最大预算值为一个常量(inlineMaxBudget),目前其值为80:

// $GOROOT/src/cmd/compile/internal/inline/inl.go
const (
    inlineMaxBudget       = 80
)

然后在visitor.tooHairy函数中遍历该函数实现中的各个语法元素:

// $GOROOT/src/cmd/compile/internal/inline/inl.go
func CanInline(fn *ir.Func) {
    ... ...
    visitor := hairyVisitor{
        budget:        inlineMaxBudget,
        extraCallCost: cc,
    }
    if visitor.tooHairy(fn) {
        reason = visitor.reason
        return
    }
    ... ...
}

不同元素对预算的消耗都有不同,比如调用一次append,visitor预算值就要减去inlineExtraAppendCost,再比如如果该函数是中间函数(而非叶子函数),那么visitor预算值也要减去v.extraCallCost,即57。就这样一路下来,如果预算被用光,即v.budget < 0,则说明这个函数过于复杂,不能被内联;相反,如果一路下来,预算依然有,那么说明这个函数相对简单,可以被内联优化。

注:为什么inlineExtraCallCost的值是57?这是一个经验值,是通过一个benchmark得出来的

一旦确定可以被内联,那么Go编译器就会将一些信息保存下来,保存到IR中该函数节点的Inl字段中:

// $GOROOT/src/cmd/compile/internal/inline/inl.go
func CanInline(fn *ir.Func) {
    ... ...
    n.Func.Inl = &ir.Inline{
        Cost: inlineMaxBudget - visitor.budget,
        Dcl:  pruneUnusedAutos(n.Defn.(*ir.Func).Dcl, &visitor),
        Body: inlcopylist(fn.Body),

        CanDelayResults: canDelayResults(fn),
    }
    ... ...
}

Go编译器设置budget值为80,显然是不想让过于复杂的函数被内联优化,这是为什么呢?主要是权衡内联优化带来的收益与其开销。让更复杂的函数内联,开销会增大,但收益却可能不会有明显增加,即所谓的“投入产出比”不足。

从上面的原理描述可知,对那些size不大(复杂性较低)、被反复调用的函数施以内联的效果可能更好。而对于那些过于复杂的函数,函数调用的开销占其执行开销的比重已经十分小了,甚至可忽略不计,这样内联效果就会较差。

很多人会说:内联后不是还有更多编译器优化机会么?问题在于究竟是否有优化机会以及会实施哪些更多的优化,这是无法预测的事情。

4. 对Go编译器的内联优化进行干预

最后我们再来看看如何对Go编译器的内联优化进行干预。Go编译器默认是开启全局内联优化的,并按照上面inl.go中CanInline的决策流程来确定一个函数是否可以内联。

不过Go也给了我们控制内联的一些手段,比如我们可以在某个函数上显式告知编译器不要对该函数进行内联,我们以上面示例中的add.go为例:

//go:noinline
func add(a, b int) int {
    return a + b
}

通过//go:noinline指示符,我们可以禁止对add的内联:

$go build -gcflags '-m=2' add.go
./add.go:4:6: cannot inline add: marked go:noinline

注:禁止某个函数内联不会影响InlineCalls函数对该函数内部调用的内联函数的函数体替换。

我们也可以在更大范围关闭内联优化,借助-gcflags ‘-l’选项,我们可以在全局范围关闭优化,即Flag.LowerL == 0,Go编译器的InlinePackage将不会执行。

我们以前面提到过的reviewdog来验证一下:

// 默认开启内联
$go build -o reviewdog-inline github.com/reviewdog/reviewdog/cmd/reviewdog

// 关闭内联
$go build -o reviewdog-noinline -gcflags '-l' github.com/reviewdog/reviewdog/cmd/reviewdog

之后我们查看一下生成的binary文件size:

$ls -l |grep reviewdog
-rwxrwxr-x  1 tonybai tonybai 23080346 Oct 13 20:28 reviewdog-inline*
-rwxrwxr-x  1 tonybai tonybai 23087867 Oct 13 20:28 reviewdog-noinline*

我们发现noinline版本居然比inline版本的size还要略大!这是为什么呢?这与-gcflags参数的传递方式有关,如果只是像上面命令行那样传入-gcflags ‘-l’,关闭内联仅适用于当前package,即cmd/reviewdog,而该package的依赖等都不会受到影响。-gcflags支持pattern匹配:

-gcflags '[pattern=]arg list'
    arguments to pass on each go tool compile invocation.

我们可以通过设置不同pattern来匹配更多包,比如all这个模式就可以包括当前包的所有依赖,我们再来试试:

$go build -o reviewdog-noinline-all -gcflags='all=-l' github.com/reviewdog/reviewdog/cmd/reviewdog
$ls -l |grep reviewdog
-rw-rw-r--  1 tonybai tonybai     3154 Sep  2 10:56 reviewdog.go
-rwxrwxr-x  1 tonybai tonybai 23080346 Oct 13 20:28 reviewdog-inline*
-rwxrwxr-x  1 tonybai tonybai 23087867 Oct 13 20:28 reviewdog-noinline*
-rwxrwxr-x  1 tonybai tonybai 20745006 Oct 13 20:30 reviewdog-noinline-all*

这回我们看到reviewdog-noinline-all要比reviewdog-inline的size小了不少,这是因为all将reviewdog依赖的各个包的内联也都关闭了。

5. 小结

在这篇文章中,我带大家一起了解了Go内联相关的知识,包括内联的概念、内联的作用、内联优化的“开销”以及Go编译器进行函数内联决策的原理,最后我还给出控制Go编译器内联优化的手段。

内联优化是一种重要的优化手段,使用得当将会给你的系统带来不小的性能改善。Go编译器组也在对Go内联优化做持续改善,从之前仅支持叶子函数的内联,到现在支持非叶子节点函数的内联,相信Go开发者在未来还会继续得到这方面带来的性能红利。

本文涉及的源码可以在这里下载。

6. 参考资料

  • Introduction to the Go compiler – https://go.dev/src/cmd/compile/README
  • Proposal: Mid-stack inlining in the Go compiler – https://github.com/golang/proposal/blob/master/design/19348-midstack-inlining.md
  • Mid-stack inlining in the Go compiler – https://golang.org/s/go19inliningtalk
  • Inlining optimisations in Go – https://dave.cheney.net/2020/04/25/inlining-optimisations-in-go
  • Mid-stack inlining in Go – https://dave.cheney.net/2020/05/02/mid-stack-inlining-in-go
  • cmd/compile: relax recursive restriction while inlining – https://github.com/golang/go/issues/29737

“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2022年,Gopher部落全面改版,将持续分享Go语言与Go应用领域的知识、技巧与实践,并增加诸多互动形式。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

我爱发短信:企业级短信平台定制开发专家 https://tonybai.com/。smspush : 可部署在企业内部的定制化短信平台,三网覆盖,不惧大并发接入,可定制扩展; 短信内容你来定,不再受约束, 接口丰富,支持长短信,签名可选。2020年4月8日,中国三大电信运营商联合发布《5G消息白皮书》,51短信平台也会全新升级到“51商用消息平台”,全面支持5G RCS消息。

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博:https://weibo.com/bigwhite20xx
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats