Golang 中的defer性能提升

在Golang 1.14中新加入了开放编码（Open-coded）defer类型，编译器在ssa过程中会把被延迟的方法直接插入到函数的尾部，避免了运行时的deferproc及deferprocStack操作。

避免了在没有运行时判断下的deferreturn调用。如有运行时判断的逻辑，则 deferreturn 也进一步优化，开放编码下的 deferreturn 不会进行jmpdefer的尾递归调用，而直接在一个循环里遍历执行。

在1.14中defer的实现原理,共有三种defer模式类型，编译后一个函数里只会一种defer模式。

堆上分配

在 Golang 1.13 之前的版本中，所有 defer 都是在堆上分配 (deferProc)，该机制在编译时会进行两个步骤：

  1. 在 defer 语句的位置插入 runtime.deferproc，当被执行时，延迟调用会被保存为一个 _defer 记录，并将被延迟调用的入口地址及其参数复制保存，存入 Goroutine 的调用链表中。

  2. 在函数返回之前的位置插入 runtime.deferreturn，当被执行时，会将延迟调用从 Goroutine 链表中取出并执行，多个延迟调用则以 jmpdefer 尾递归调用方式连续执行。

这种机制的主要性能问题存在于每个 defer 语句产生记录时的内存分配，以及记录参数和完成调用时参数移动的系统调用开销。

栈上分配

在Golang 1.13 版本中新加入 deferprocStack 实现了在栈上分配的形式来取代 deferproc，相比后者，栈上分配在函数返回后 _defer 便得到释放，省去了内存分配时产生的性能开销，只需适当维护 _defer 的链表即可。

编译器可以去选择使用deferproc 还是 deferprocStack，通常情况下都会使用deferprocStack，性能会提升约 30%。不过在 defer 语句出现在了循环语句里，或者无法执行更高阶的编译器优化时，亦或者同一个函数中使用了过多的 defer 时，依然会使用 deferproc。

栈上分配 (deferprocStack)，基本跟堆上差不多，只是分配方式改为在栈上分配，压入的函数调用栈存有_defer记录，另外编译器在ssa过程中会预留defer空间。

SSA 代表 static single-assignment，是一种IR(中间表示代码)，要保证每个变量只被赋值一次。这个能帮助简化编译器的优化算法。简单来说,使用ssa可以使二进制文件大小减少了30%，性能提升5%-35%等.

  1. // buildssa builds an SSA function for fn.
  2. // worker indicates which of the backend workers is doing the processing.
  3. func buildssa(fn *Node, worker int) *ssa.Func {
  4.     name := fn.funcname()
  5.     printssa := name == ssaDump
  6.     var astBuf *bytes.Buffer
  7.     if printssa {
  8.         astBuf = &bytes.Buffer{}
  9.         fdumplist(astBuf, "buildssa-enter", fn.Func.Enter)
  10.         fdumplist(astBuf, "buildssa-body", fn.Nbody)
  11.         fdumplist(astBuf, "buildssa-exit", fn.Func.Exit)
  12.         if ssaDumpStdout {
  13.             fmt.Println("generating SSA for", name)
  14.             fmt.Print(astBuf.String())
  15.         }
  16.     }
  18.     var s state
  19.     s.pushLine(fn.Pos)
  20.     defer s.popLine()
  22.     s.hasdefer = fn.Func.HasDefer()
  23.     if fn.Func.Pragma&CgoUnsafeArgs != 0 {
  24.         s.cgoUnsafeArgs = true
  25.     }
  27.     fe := ssafn{
  28.         curfn: fn,
  29.         log:   printssa && ssaDumpStdout,
  30.     }
  31.     s.curfn = fn
  33.     s.f = ssa.NewFunc(&fe)
  34.     s.config = ssaConfig
  35.     s.f.Type = fn.Type
  36.     s.f.Config = ssaConfig
  37.     s.f.Cache = &ssaCaches[worker]
  38.     s.f.Cache.Reset()
  39.     s.f.DebugTest = s.f.DebugHashMatch("GOSSAHASH", name)
  40.     s.f.Name = name
  41.     s.f.PrintOrHtmlSSA = printssa
  42.     if fn.Func.Pragma&Nosplit != 0 {
  43.         s.f.NoSplit = true
  44.     }
  45.     s.panics = map[funcLine]*ssa.Block{}
  46.     s.softFloat = s.config.SoftFloat
  48.     if printssa {
  49.         s.f.HTMLWriter = ssa.NewHTMLWriter(ssaDumpFile, s.f.Frontend(), name, ssaDumpCFG)
  50.         // TODO: generate and print a mapping from nodes to values and blocks
  51.         dumpSourcesColumn(s.f.HTMLWriter, fn)
  52.         s.f.HTMLWriter.WriteAST("AST", astBuf)
  53.     }
  55.     // Allocate starting block
  56.     s.f.Entry = s.f.NewBlock(ssa.BlockPlain)
  58.     // Allocate starting values
  59.     s.labels = map[string]*ssaLabel{}
  60.     s.labeledNodes = map[*Node]*ssaLabel{}
  61.     s.fwdVars = map[*Node]*ssa.Value{}
  62.     s.startmem = s.entryNewValue0(ssa.OpInitMem, types.TypeMem)
  64.     s.hasOpenDefers = Debug['N'] == 0 && s.hasdefer && !s.curfn.Func.OpenCodedDeferDisallowed()
  65.     switch {
  66.     case s.hasOpenDefers && (Ctxt.Flag_shared || Ctxt.Flag_dynlink) && thearch.LinkArch.Name == "386":
  67.         // Don't support open-coded defers for 386 ONLY when using shared
  68.         // libraries, because there is extra code (added by rewriteToUseGot())
  69.         // preceding the deferreturn/ret code that is generated by gencallret()
  70.         // that we don't track correctly.
  71.         s.hasOpenDefers = false
  72.     }
  73.     if s.hasOpenDefers && s.curfn.Func.Exit.Len() > 0 {
  74.         // Skip doing open defers if there is any extra exit code (likely
  75.         // copying heap-allocated return values or race detection), since
  76.         // we will not generate that code in the case of the extra
  77.         // deferreturn/ret segment.
  78.         s.hasOpenDefers = false
  79.     }
  80.     if s.hasOpenDefers &&
  81.         s.curfn.Func.numReturns*s.curfn.Func.numDefers > 15 {
  82.         // Since we are generating defer calls at every exit for
  83.         // open-coded defers, skip doing open-coded defers if there are
  84.         // too many returns (especially if there are multiple defers).
  85.         // Open-coded defers are most important for improving performance
  86.         // for smaller functions (which don't have many returns).
  87.         s.hasOpenDefers = false
  88.     }
  90.     s.sp = s.entryNewValue0(ssa.OpSP, types.Types[TUINTPTR]) // TODO: use generic pointer type (unsafe.Pointer?) instead
  91.     s.sb = s.entryNewValue0(ssa.OpSB, types.Types[TUINTPTR])
  93.     s.startBlock(s.f.Entry)
  94.     s.vars[&memVar] = s.startmem
  95.     if s.hasOpenDefers {
  96.         // Create the deferBits variable and stack slot.  deferBits is a
  97.         // bitmask showing which of the open-coded defers in this function
  98.         // have been activated.
  99.         deferBitsTemp := tempAt(src.NoXPos, s.curfn, types.Types[TUINT8])
  100.         s.deferBitsTemp = deferBitsTemp
  101.         // For this value, AuxInt is initialized to zero by default
  102.         startDeferBits := s.entryNewValue0(ssa.OpConst8, types.Types[TUINT8])
  103.         s.vars[&deferBitsVar] = startDeferBits
  104.         s.deferBitsAddr = s.addr(deferBitsTemp, false)
  105.         s.store(types.Types[TUINT8], s.deferBitsAddr, startDeferBits)
  106.         // Make sure that the deferBits stack slot is kept alive (for use
  107.         // by panics) and stores to deferBits are not eliminated, even if
  108.         // all checking code on deferBits in the function exit can be
  109.         // eliminated, because the defer statements were all
  110.         // unconditional.
  111.         s.vars[&memVar] = s.newValue1Apos(ssa.OpVarLive, types.TypeMem, deferBitsTemp, s.mem(), false)
  112.     }
  114.     // Generate addresses of local declarations
  115.     s.decladdrs = map[*Node]*ssa.Value{}
  116.     for _, n := range fn.Func.Dcl {
  117.         switch n.Class() {
  118.         case PPARAM, PPARAMOUT:
  119.             s.decladdrs[n] = s.entryNewValue2A(ssa.OpLocalAddr, types.NewPtr(n.Type), n, s.sp, s.startmem)
  120.             if n.Class() == PPARAMOUT && s.canSSA(n) {
  121.                 // Save ssa-able PPARAMOUT variables so we can
  122.                 // store them back to the stack at the end of
  123.                 // the function.
  124.                 s.returns = append(s.returns, n)
  125.             }
  126.         case PAUTO:
  127.             // processed at each use, to prevent Addr coming
  128.             // before the decl.
  129.         case PAUTOHEAP:
  130.             // moved to heap - already handled by frontend
  131.         case PFUNC:
  132.             // local function - already handled by frontend
  133.         default:
  134.             s.Fatalf("local variable with class %v unimplemented", n.Class())
  135.         }
  136.     }
  138.     // Populate SSAable arguments.
  139.     for _, n := range fn.Func.Dcl {
  140.         if n.Class() == PPARAM && s.canSSA(n) {
  141.             v := s.newValue0A(ssa.OpArg, n.Type, n)
  142.             s.vars[n] = v
  143.             s.addNamedValue(n, v) // This helps with debugging information, not needed for compilation itself.
  144.         }
  145.     }
  147.     // Convert the AST-based IR to the SSA-based IR
  148.     s.stmtList(fn.Func.Enter)
  149.     s.stmtList(fn.Nbody)
  151.     // fallthrough to exit
  152.     if s.curBlock != nil {
  153.         s.pushLine(fn.Func.Endlineno)
  154.         s.exit()
  155.         s.popLine()
  156.     }
  158.     for _, b := range s.f.Blocks {
  159.         if b.Pos != src.NoXPos {
  160.             s.updateUnsetPredPos(b)
  161.         }
  162.     }
  164.     s.insertPhis()
  166.     // Main call to ssa package to compile function
  167.     ssa.Compile(s.f)
  169.     if s.hasOpenDefers {
  170.         s.emitOpenDeferInfo()
  171.     }
  173.     return s.f
  174. }

如果在构建ssa时如发现gcflags有N禁止优化的参数 或者 return数量 * defer数量超过了15不适用open-coded模式。

此外逃逸分析会判断循序的层数，如果有轮询，那么强制使用栈分配模式。

  1. // augmentParamHole augments parameter holes as necessary for use in
  2. // go/defer statements.
  3. func (e *Escape) augmentParamHole(k EscHole, call, where *Node) EscHole {
  4.     k = k.note(call, "call parameter")
  5.     if where == nil {
  6.         return k
  7.     }
  9.     // Top level defers arguments don't escape to heap, but they
  10.     // do need to last until end of function. Tee with a
  11.     // non-transient location to avoid arguments from being
  12.     // transiently allocated.
  13.     if where.Op == ODEFER && e.loopDepth == 1 {
  14.         // force stack allocation of defer record, unless open-coded
  15.         // defers are used (see ssa.go)
  16.         where.Esc = EscNever
  17.         return e.later(k)
  18.     }
  20.     return e.heapHole().note(where, "call parameter")
  21. }

开放编码

Golang 1.14 版本继续加入了开发编码（open coded），该机制会将延迟调用直接插入函数返回之前，省去了运行时的 deferproc 或 deferprocStack 操作，在运行时的 deferreturn 也不会进行尾递归调用，而是直接在一个循环中遍历所有延迟函数执行。

这种机制使得 defer 的开销几乎可以忽略，唯一的运行时成本就是存储参与延迟调用的相关信息，不过使用这个机制还需要三个条件：

  1. 没有禁用编译器优化，即没有设置 -gcflags “-N”.
  2. 函数内 defer 的数量不超过 8 个，且返回语句与延迟语句个数的乘积不超过 15.
  3. defer 不是在循环语句中。

此外该机制还引入了一种元素 —— 延迟比特（defer bit）,用于运行时记录每个 defer 是否被执行（尤其是在条件判断分支中的 defer），从而便于判断最后的延迟调用该执行哪些函数。

延迟比特的原理：

同一个函数内每出现一个 defer 都会为其分配 1个比特，如果被执行到则设为 1，否则设为 0，当到达函数返回之前需要判断延迟调用时，则用掩码判断每个位置的比特，若为 1 则调用延迟函数，否则跳过。

为了轻量，官方将延迟比特限制为 1 个字节，即 8 个比特，这就是为什么不能超过 8 个 defer 的原因，若超过依然会选择堆栈分配，但显然大部分情况不会超过 8 个。

  1. // The constant is known to runtime.
  2. const tmpstringbufsize = 32
  3. const zeroValSize = 1024 // must match value of runtime/map.go:maxZero
  5. func walk(fn *Node) {
  6.     Curfn = fn
  8.     if Debug['W'] != 0 {
  9.         s := fmt.Sprintf("\nbefore walk %v", Curfn.Func.Nname.Sym)
  10.         dumplist(s, Curfn.Nbody)
  11.     }
  13.     lno := lineno
  15.     // Final typecheck for any unused variables.
  16.     for i, ln := range fn.Func.Dcl {
  17.         if ln.Op == ONAME && (ln.Class() == PAUTO || ln.Class() == PAUTOHEAP) {
  18.             ln = typecheck(ln, ctxExpr|ctxAssign)
  19.             fn.Func.Dcl[i] = ln
  20.         }
  21.     }
  23.     // Propagate the used flag for typeswitch variables up to the NONAME in its definition.
  24.     for _, ln := range fn.Func.Dcl {
  25.         if ln.Op == ONAME && (ln.Class() == PAUTO || ln.Class() == PAUTOHEAP) && ln.Name.Defn != nil && ln.Name.Defn.Op == OTYPESW && ln.Name.Used() {
  26.             ln.Name.Defn.Left.Name.SetUsed(true)
  27.         }
  28.     }
  30.     for _, ln := range fn.Func.Dcl {
  31.         if ln.Op != ONAME || (ln.Class() != PAUTO && ln.Class() != PAUTOHEAP) || ln.Sym.Name[0] == '&' || ln.Name.Used() {
  32.             continue
  33.         }
  34.         if defn := ln.Name.Defn; defn != nil && defn.Op == OTYPESW {
  35.             if defn.Left.Name.Used() {
  36.                 continue
  37.             }
  38.             yyerrorl(defn.Left.Pos, "%v declared but not used", ln.Sym)
  39.             defn.Left.Name.SetUsed(true) // suppress repeats
  40.         } else {
  41.             yyerrorl(ln.Pos, "%v declared but not used", ln.Sym)
  42.         }
  43.     }
  45.     lineno = lno
  46.     if nerrors != 0 {
  47.         return
  48.     }
  49.     walkstmtlist(Curfn.Nbody.Slice())
  50.     if Debug['W'] != 0 {
  51.         s := fmt.Sprintf("after walk %v", Curfn.Func.Nname.Sym)
  52.         dumplist(s, Curfn.Nbody)
  53.     }
  55.     zeroResults()
  56.     heapmoves()
  57.     if Debug['W'] != 0 && Curfn.Func.Enter.Len() > 0 {
  58.         s := fmt.Sprintf("enter %v", Curfn.Func.Nname.Sym)
  59.         dumplist(s, Curfn.Func.Enter)
  60.     }
  61. }

在使用open code的模式的时候,默认open coded最多支持8个defer，超过则取消。

  1. const maxOpenDefers = 8
  3. func walkstmt(n *Node) *Node {
  4.     ...
  5.     switch n.Op {
  6.     case ODEFER:
  7.         Curfn.Func.SetHasDefer(true)
  8.         Curfn.Func.numDefers++
  9.         if Curfn.Func.numDefers > maxOpenDefers {
  10.             Curfn.Func.SetOpenCodedDeferDisallowed(true)
  11.         }
  13.         if n.Esc != EscNever {
  14.             Curfn.Func.SetOpenCodedDeferDisallowed(true)
  15.         }
  16.     ...
  17. }

因此 open coded的使用条件是,最多8个defer，而且 return * defer < 15，无循环，gcflags无 “N” 并且取消优化。