pgo

Documentation

Index

• func DirectCallee(fn ir.Node) *ir.Func
• func NodeLineOffset(n ir.Node, fn *ir.Func) int
• func WeightInPercentage(value int64, total int64) float64
• type CallSiteInfo
• type IREdge
• type IRGraph
• type IRNode
  • func (i *IRNode) Name() string
• type NodeMapKey
• type Profile
  • func New(profileFile string) (*Profile, error)
  • func (p *Profile) PrintWeightedCallGraphDOT(edgeThreshold float64)
  • func (p *Profile) VisitIR(fn *ir.Func)
• type Weights

Functions

func DirectCallee

func DirectCallee(fn ir.Node) *ir.Func

DirectCallee takes a function-typed expression and returns the underlying function that it refers to if statically known. Otherwise, it returns nil.

Equivalent to inline.inlCallee without calling CanInline on closures.

func NodeLineOffset

func NodeLineOffset(n ir.Node, fn *ir.Func) int

NodeLineOffset returns the line offset of n in fn.

func WeightInPercentage

func WeightInPercentage(value int64, total int64) float64

WeightInPercentage converts profile weights to a percentage.

Types

type CallSiteInfo

type CallSiteInfo struct {
	LineOffset int // Line offset from function start line.
	Caller     *ir.Func
	Callee     *ir.Func
}

CallSiteInfo captures call-site information and its caller/callee.

type IREdge

type IREdge struct {
	// Source and destination of the edge in IRNode.
	Src, Dst       *IRNode
	Weight         int64
	CallSiteOffset int // Line offset from function start line.
}

IREdge represents a call edge in the IRGraph with source, destination, weight, callsite, and line number information.

type IRGraph

type IRGraph struct {
	// Nodes of the graph
	IRNodes map[string]*IRNode
}

IRGraph is a call graph with nodes pointing to IRs of functions and edges carrying weights and callsite information.

Nodes for indirect calls may have missing IR (IRNode.AST == nil) if the node is not visible from this package (e.g., not in the transitive deps). Keeping these nodes allows determining the hottest edge from a call even if that callee is not available.

TODO(prattmic): Consider merging this data structure with Graph. This is effectively a copy of Graph aggregated to line number and pointing to IR.

type IRNode

type IRNode struct {
	// Pointer to the IR of the Function represented by this node.
	AST *ir.Func
	// Linker symbol name of the Function represented by this node.
	// Populated only if AST == nil.
	LinkerSymbolName string

	// Set of out-edges in the callgraph. The map uniquely identifies each
	// edge based on the callsite and callee, for fast lookup.
	OutEdges map[NodeMapKey]*IREdge
}

IRNode represents a node (function) in the IRGraph.

func (*IRNode) Name

func (i *IRNode) Name() string

Name returns the symbol name of this function.

type NodeMapKey

type NodeMapKey struct {
	CallerName     string
	CalleeName     string
	CallSiteOffset int // Line offset from function start line.
}

NodeMapKey represents a hash key to identify unique call-edges in profile and in IR. Used for deduplication of call edges found in profile.

TODO(prattmic): rename to something more descriptive.

type Profile

type Profile struct {
	// Aggregated NodeWeights and EdgeWeights across the profile. This
	// helps us determine the percentage threshold for hot/cold
	// partitioning.
	TotalNodeWeight int64
	TotalEdgeWeight int64

	// NodeMap contains all unique call-edges in the profile and their
	// aggregated weight.
	NodeMap map[NodeMapKey]*Weights

	// WeightedCG represents the IRGraph built from profile, which we will
	// update as part of inlining.
	WeightedCG *IRGraph
}

Profile contains the processed PGO profile and weighted call graph used for PGO optimizations.

func New

func New(profileFile string) (*Profile, error)

New generates a profile-graph from the profile.

func (*Profile) PrintWeightedCallGraphDOT

func (p *Profile) PrintWeightedCallGraphDOT(edgeThreshold float64)

PrintWeightedCallGraphDOT prints IRGraph in DOT format.

func (*Profile) VisitIR

func (p *Profile) VisitIR(fn *ir.Func)

VisitIR traverses the body of each ir.Func and use NodeMap to determine if we need to add an edge from ir.Func and any node in the ir.Func body.

type Weights

type Weights struct {
	NFlat   int64
	NCum    int64
	EWeight int64
}

Weights capture both node weight and edge weight.