[WIP]Profile-guided optimization for Golang v1.17

Author: Raj Barik

src/cmd/compile/internal/base/flag.go

@@ -121,7 +121,13 @@ type CmdFlags struct {
 	TraceProfile       string       "help:\"write an execution trace to `file`\""
 	TrimPath           string       "help:\"remove `prefix` from recorded source file paths\""
 	WB                 bool         "help:\"enable write barrier\"" // TODO: remove
-
+	FpprofProfileUse   string       "help:\"read profile from `file`\""
+	WBudget            bool         "help:\"Inline using caller budget\""
+	PprofInline        bool         "help:\"perform inlining based on profile\""
+	CodeLayout         bool         "help:\"perform code layout optimization based on profile\""
+	Devirtualize       bool         "help:\"preform code type specialization based on profile\""
+	Specialize         bool         "help:\"preform code type specialization based on profile\""
+	CsInline           bool         "help:\"perform context-sensitive inlining based on profile\""
 	// Configuration derived from flags; not a flag itself.
 	Cfg struct {
 		Embed struct { // set by -embedcfg

src/cmd/compile/internal/gc/main.go

@@ -16,6 +16,7 @@ import (
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/noder"
+	"cmd/compile/internal/pgo"
 	"cmd/compile/internal/pkginit"
 	"cmd/compile/internal/reflectdata"
 	"cmd/compile/internal/ssa"
@@ -223,10 +224,32 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		typecheck.AllImportedBodies()
 	}
 
+	// Pprofprofileuse
+	base.Timer.Start("fe", "pprofprofileuse")
+	if base.Flag.FpprofProfileUse != "" {
+		pgo.WeightedCG = pgo.WeightedCallGraph(base.Flag.FpprofProfileUse, &pgo.Options{
+			CallTree:    false,
+			SampleValue: func(v []int64) int64 { return v[1] },
+		})
+	}
+
+	// Specializer
+	base.Timer.Start("fe", "specialize")
+	if pgo.WeightedCG != nil && base.Flag.Specialize {
+		pgo.Specializer(pgo.WeightedCG)
+	}
+
 	// Inlining
 	base.Timer.Start("fe", "inlining")
 	if base.Flag.LowerL != 0 {
-		inline.InlinePackage()
+		InliningDone := false
+		if base.Flag.FpprofProfileUse != "" && pgo.WeightedCG != nil && base.Flag.PprofInline {
+			pgo.PprofInline()
+			InliningDone = true
+		}
+		if InliningDone == false {
+			inline.InlinePackage()
+		}
 	}
 
 	// Devirtualize.
@@ -251,7 +274,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	// because large values may contain pointers, it must happen early.
 	base.Timer.Start("fe", "escapes")
 	escape.Funcs(typecheck.Target.Decls)
-
 	// Collect information for go:nowritebarrierrec
 	// checking. This must happen before transforming closures during Walk
 	// We'll do the final check after write barriers are
@@ -260,6 +282,26 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		ssagen.EnableNoWriteBarrierRecCheck()
 	}
 
+	// CodeLayout optimization based on profiles.
+	base.Timer.Start("fe", "codelayout")
+	if base.Flag.CodeLayout && base.Flag.FpprofProfileUse != "" {
+		if pgo.WeightedCG == nil {
+			pgo.WeightedCG = pgo.WeightedCallGraph(base.Flag.FpprofProfileUse, &pgo.Options{
+				CallTree:    false,
+				SampleValue: func(v []int64) int64 { return v[1] },
+			})
+		}
+		if pgo.WeightedCG != nil {
+			pgo.FuncList = make(map[*ir.Func]struct{})
+			for i := 0; i < len(typecheck.Target.Decls); i++ {
+				if fn, ok := typecheck.Target.Decls[i].(*ir.Func); ok {
+					pgo.AddFunc(fn)
+				}
+			}
+			pgo.PerformCodeLayout()
+		}
+	}
+
 	// Prepare for SSA compilation.
 	// This must be before CompileITabs, because CompileITabs
 	// can trigger function compilation.
@@ -290,7 +332,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		// Write barriers are now known. Check the call graph.
 		ssagen.NoWriteBarrierRecCheck()
 	}
-
 	// Finalize DWARF inline routine DIEs, then explicitly turn off
 	// DWARF inlining gen so as to avoid problems with generated
 	// method wrappers.
@@ -299,7 +340,6 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		base.Ctxt.DwFixups = nil
 		base.Flag.GenDwarfInl = 0
 	}
-
 	// Write object data to disk.
 	base.Timer.Start("be", "dumpobj")
 	dumpdata()
@@ -308,17 +348,14 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 	if base.Flag.AsmHdr != "" {
 		dumpasmhdr()
 	}
-
 	ssagen.CheckLargeStacks()
 	typecheck.CheckFuncStack()
-
 	if len(compilequeue) != 0 {
 		base.Fatalf("%d uncompiled functions", len(compilequeue))
 	}
 
 	logopt.FlushLoggedOpts(base.Ctxt, base.Ctxt.Pkgpath)
 	base.ExitIfErrors()
-
 	base.FlushErrors()
 	base.Timer.Stop()
 

src/cmd/compile/internal/inline/inl.go

@@ -27,27 +27,28 @@
 package inline
 
 import (
-	"fmt"
-	"go/constant"
-	"strings"
-
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/ir"
 	"cmd/compile/internal/logopt"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
 	"cmd/internal/src"
+	"fmt"
+	"go/constant"
+	"strings"
 )
 
 // Inlining budget parameters, gathered in one place
 const (
-	inlineMaxBudget       = 80
-	inlineExtraAppendCost = 0
+	inlineMaxBudget        = 80
+	profileinlineMaxBudget = 1000
+	Threshold              = float64(2)
+	inlineExtraAppendCost  = 0
 	// default is to inline if there's at most one call. -l=4 overrides this by using 1 instead.
-	inlineExtraCallCost  = 57              // 57 was benchmarked to provided most benefit with no bad surprises; see https://github.com/golang/go/issues/19348#issuecomment-439370742
-	inlineExtraPanicCost = 1               // do not penalize inlining panics.
-	inlineExtraThrowCost = inlineMaxBudget // with current (2018-05/1.11) code, inlining runtime.throw does not help.
+	inlineExtraCallCost  = 57   // 57 was benchmarked to provided most benefit with no bad surprises; see https://github.com/golang/go/issues/19348#issuecomment-439370742
+	inlineExtraPanicCost = 1    // do not penalize inlining panics.
+	inlineExtraThrowCost = 1000 // with current (2018-05/1.11) code, inlining runtime.throw does not help.
 
 	inlineBigFunctionNodes   = 5000 // Functions with this many nodes are considered "big".
 	inlineBigFunctionMaxCost = 20   // Max cost of inlinee when inlining into a "big" function.
@@ -62,7 +63,7 @@ func InlinePackage() {
 				// We allow inlining if there is no
 				// recursion, or the recursion cycle is
 				// across more than one function.
-				CanInline(n)
+				CanInline(n, int32(inlineMaxBudget))
 			} else {
 				if base.Flag.LowerM > 1 {
 					fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(n), n.Nname)
@@ -76,11 +77,10 @@ func InlinePackage() {
 // CanInline determines whether fn is inlineable.
 // If so, CanInline saves copies of fn.Body and fn.Dcl in fn.Inl.
 // fn and fn.Body will already have been typechecked.
-func CanInline(fn *ir.Func) {
+func CanInline(fn *ir.Func, maxBudget int32) {
 	if fn.Nname == nil {
 		base.Fatalf("CanInline no nname %+v", fn)
 	}
-
 	var reason string // reason, if any, that the function was not inlined
 	if base.Flag.LowerM > 1 || logopt.Enabled() {
 		defer func() {
@@ -167,16 +167,16 @@ func CanInline(fn *ir.Func) {
 	// list. See issue 25249 for more context.
 
 	visitor := hairyVisitor{
-		budget:        inlineMaxBudget,
+		budget:        maxBudget,
 		extraCallCost: cc,
 	}
-	if visitor.tooHairy(fn) {
+	if visitor.tooHairy(fn, maxBudget) {
 		reason = visitor.reason
 		return
 	}
 
 	n.Func.Inl = &ir.Inline{
-		Cost: inlineMaxBudget - visitor.budget,
+		Cost: maxBudget - visitor.budget,
 		Dcl:  pruneUnusedAutos(n.Defn.(*ir.Func).Dcl, &visitor),
 		Body: inlcopylist(fn.Body),
 	}
@@ -257,13 +257,13 @@ type hairyVisitor struct {
 	do            func(ir.Node) bool
 }
 
-func (v *hairyVisitor) tooHairy(fn *ir.Func) bool {
+func (v *hairyVisitor) tooHairy(fn *ir.Func, maxBudget int32) bool {
 	v.do = v.doNode // cache closure
 	if ir.DoChildren(fn, v.do) {
 		return true
 	}
 	if v.budget < 0 {
-		v.reason = fmt.Sprintf("function too complex: cost %d exceeds budget %d", inlineMaxBudget-v.budget, inlineMaxBudget)
+		v.reason = fmt.Sprintf("function too complex: cost %d exceeds budget %d", maxBudget-v.budget, maxBudget)
 		return true
 	}
 	return false
@@ -711,7 +711,7 @@ func inlCallee(fn ir.Node) *ir.Func {
 	case ir.OCLOSURE:
 		fn := fn.(*ir.ClosureExpr)
 		c := fn.Func
-		CanInline(c)
+		CanInline(c, int32(inlineMaxBudget))
 		return c
 	}
 	return nil

src/cmd/compile/internal/pgo/callgraph.go

@@ -0,0 +1,114 @@
+package pgo
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"log"
+	"os"
+)
+
+var (
+	// WeightedCG represents the IrGraph built from pprof profile, which we will update as part of inlining.
+	WeightedCG *IrGraph
+	// Aggrehated Node and EdgeWeights across the entore IrGraph.
+	TotalNodeWeight = int64(0)
+	TotalEdgeWeight = int64(0)
+)
+
+// WeightedCallGraph generates a callgraph from the pprof profile.
+func WeightedCallGraph(profileFile string, opt *Options) *IrGraph {
+	// open the pprof profile file
+	f, err := os.Open(profileFile)
+	if err != nil {
+		log.Fatal("WeightedCG: failed to open file " + profileFile)
+		return nil
+	}
+	defer f.Close()
+	p, err := Parse(f)
+	if err != nil {
+		log.Fatal("WeightedCG: Failed to Parse profile file.")
+		return nil
+	}
+	g := New(p, opt)
+	if g != nil && base.Flag.LowerM > 1 {
+		log.Println("WeightedCG: Pprof callgraph created successfully")
+	}
+	// Compute TotalNodeWeight and EdgeWeights across all nodes in the pprof graph.
+	for _, n := range g.Nodes {
+		TotalNodeWeight += n.FlatValue()
+		for _, e := range n.Out {
+			TotalEdgeWeight += e.WeightValue()
+		}
+	}
+	// Create IrGraph nodes from PProf.
+	NodeMap := CreateIRGraphNodes(g)
+	// Create the WeightCallgraph from PProf.
+	WeightedCG := CreateIRGraph(NodeMap)
+	if WeightedCG != nil && base.Flag.LowerM > 1 {
+		log.Println("WeightedCG: garph created successfully")
+	}
+	return WeightedCG
+}
+
+// RedirectEdges deletes and redirect out-edges from node cur.
+func RedirectEdges(g *IrGraph, cur *IrNode) {
+	for i, outEdge := range g.OutEdges[cur] {
+		if !InlMap[outEdge.CallSite] {
+			for _, InEdge := range g.InEdges[cur] {
+				if InlMap[InEdge.CallSite] {
+					weight := calculteweight(g, InEdge.Src, cur)
+					redirectEdge(g, InEdge.Src, cur, outEdge, weight, i)
+				}
+			}
+		} else {
+			remove(g, cur, i, outEdge.Dst.NodeIr.Nname)
+		}
+	}
+	removeall(g, cur)
+}
+
+// calculteweight calculates the weight of the new redircted edges.
+func calculteweight(g *IrGraph, parent *IrNode, cur *IrNode) int64 {
+	sum := int64(0)
+	pw := int64(0)
+	for _, InEdge := range g.InEdges[cur] {
+		sum = sum + InEdge.Weight
+		if InEdge.Src == parent {
+			pw = InEdge.Weight
+		}
+	}
+	weight := int64(0)
+	if sum != 0 {
+		weight = pw / sum
+	} else {
+		weight = pw
+	}
+	return weight
+}
+
+// redirectEdge deletes the cur-node's out-edges and redirct them so now these edges are the parent node out-edges.
+func redirectEdge(g *IrGraph, parent *IrNode, cur *IrNode, outEdge *IrEdge, weight int64, idx int) {
+	outEdge.Src = parent
+	outEdge.Weight = weight * outEdge.Weight
+	g.OutEdges[parent] = append(g.OutEdges[parent], outEdge)
+	remove(g, cur, idx, outEdge.Dst.NodeIr.Nname)
+}
+
+// remove deletes the cur-node's out-edges at index idx.
+func remove(g *IrGraph, cur *IrNode, idx int, name *ir.Name) {
+	if len(g.OutEdges[cur]) >= 2 {
+		g.OutEdges[cur][idx] = &IrEdge{CallSite: "removed"}
+	} else {
+		delete(g.OutEdges, cur)
+	}
+}
+
+// removeall deletes all cur-node's out-edges that marked to be removed .
+func removeall(g *IrGraph, cur *IrNode) {
+	for i := len(g.OutEdges[cur]) - 1; i >= 0; i-- {
+		if g.OutEdges[cur][i].CallSite == "removed" {
+			g.OutEdges[cur][i] = g.OutEdges[cur][len(g.OutEdges[cur])-1]
+			g.OutEdges[cur] = g.OutEdges[cur][:len(g.OutEdges[cur])-1]
+		}
+	}
+}