package graph

import "cmd/compile/internal/pgo/internal/graph"

Package graph represents a pprof profile as a directed graph.

This package is a simplified fork of github.com/google/pprof/internal/graph.

Index ¶

• type Edge
• func (e *Edge) WeightValue() int64
• type EdgeMap
• func (em *EdgeMap) Add(e *Edge)
• func (em *EdgeMap) Delete(e *Edge)
• func (em EdgeMap) FindTo(n *Node) *Edge
• func (em EdgeMap) Sort() []*Edge
• func (em EdgeMap) Sum() int64
• type Graph
• func NewGraph(prof *profile.Profile, o *Options) *Graph
• func (g *Graph) String() string
• type Node
• func (n *Node) AddToEdge(to *Node, v int64, residual, inline bool)
• func (n *Node) AddToEdgeDiv(to *Node, dv, v int64, residual, inline bool)
• func (n *Node) CumValue() int64
• func (n *Node) FlatValue() int64
• type NodeInfo
• func (i *NodeInfo) NameComponents() []string
• func (i *NodeInfo) PrintableName() string
• type NodeMap
• func (nm NodeMap) FindOrInsertNode(info NodeInfo, kept NodeSet) *Node
• type NodePtrSet
• type NodeSet
• type Nodes
• func CreateNodes(prof *profile.Profile, o *Options) (Nodes, locationMap)
• func (ns Nodes) Sum() (flat int64, cum int64)
• type Options

Types ¶

type Edge ¶

type Edge struct {
	Src, Dest *Node
	// The summary weight of the edge
	Weight, WeightDiv int64

	// residual edges connect nodes that were connected through a
	// separate node, which has been removed from the report.
	Residual bool
	// An inline edge represents a call that was inlined into the caller.
	Inline bool
}

Edge contains any attributes to be represented about edges in a graph.

func (*Edge) WeightValue ¶

func (e *Edge) WeightValue() int64

WeightValue returns the weight value for this edge, normalizing if a divisor is available.

type EdgeMap ¶

type EdgeMap []*Edge

EdgeMap is used to represent the incoming/outgoing edges from a node.

func (*EdgeMap) Add ¶

func (em *EdgeMap) Add(e *Edge)

func (*EdgeMap) Delete ¶

func (em *EdgeMap) Delete(e *Edge)

func (EdgeMap) FindTo ¶

func (em EdgeMap) FindTo(n *Node) *Edge

func (EdgeMap) Sort ¶

func (em EdgeMap) Sort() []*Edge

Sort returns a slice of the edges in the map, in a consistent order. The sort order is first based on the edge weight (higher-to-lower) and then by the node names to avoid flakiness.

func (EdgeMap) Sum ¶

func (em EdgeMap) Sum() int64

Sum returns the total weight for a set of nodes.

type Graph ¶

type Graph struct {
	Nodes Nodes
}

Graph summarizes a performance profile into a format that is suitable for visualization.

func NewGraph ¶

func NewGraph(prof *profile.Profile, o *Options) *Graph

NewGraph computes a graph from a profile.

func (*Graph) String ¶

func (g *Graph) String() string

String returns a text representation of a graph, for debugging purposes.

type Node ¶

type Node struct {
	// Info describes the source location associated to this node.
	Info NodeInfo

	// Function represents the function that this node belongs to. On
	// graphs with sub-function resolution (eg line number or
	// addresses), two nodes in a NodeMap that are part of the same
	// function have the same value of Node.Function. If the Node
	// represents the whole function, it points back to itself.
	Function *Node

	// Values associated to this node. Flat is exclusive to this node,
	// Cum includes all descendents.
	Flat, FlatDiv, Cum, CumDiv int64

	// In and out Contains the nodes immediately reaching or reached by
	// this node.
	In, Out EdgeMap
}

Node is an entry on a profiling report. It represents a unique program location.

func (*Node) AddToEdge ¶

func (n *Node) AddToEdge(to *Node, v int64, residual, inline bool)

AddToEdge increases the weight of an edge between two nodes. If there isn't such an edge one is created.

func (*Node) AddToEdgeDiv ¶

func (n *Node) AddToEdgeDiv(to *Node, dv, v int64, residual, inline bool)

AddToEdgeDiv increases the weight of an edge between two nodes. If there isn't such an edge one is created.

func (*Node) CumValue ¶

func (n *Node) CumValue() int64

CumValue returns the inclusive value for this node, computing the mean if a divisor is available.

func (*Node) FlatValue ¶

func (n *Node) FlatValue() int64

FlatValue returns the exclusive value for this node, computing the mean if a divisor is available.

type NodeInfo ¶

type NodeInfo struct {
	Name              string
	Address           uint64
	StartLine, Lineno int
}

NodeInfo contains the attributes for a node.

func (*NodeInfo) NameComponents ¶

func (i *NodeInfo) NameComponents() []string

NameComponents returns the components of the printable name to be used for a node.

func (*NodeInfo) PrintableName ¶

func (i *NodeInfo) PrintableName() string

PrintableName calls the Node's Formatter function with a single space separator.

type NodeMap ¶

type NodeMap map[NodeInfo]*Node

NodeMap maps from a node info struct to a node. It is used to merge report entries with the same info.

func (NodeMap) FindOrInsertNode ¶

func (nm NodeMap) FindOrInsertNode(info NodeInfo, kept NodeSet) *Node

FindOrInsertNode takes the info for a node and either returns a matching node from the node map if one exists, or adds one to the map if one does not. If kept is non-nil, nodes are only added if they can be located on it.

type NodePtrSet ¶

type NodePtrSet map[*Node]bool

NodePtrSet is a collection of nodes. Trimming a graph or tree requires a set of objects which uniquely identify the nodes to keep. In a graph, NodeInfo works as a unique identifier; however, in a tree multiple nodes may share identical NodeInfos. A *Node does uniquely identify a node so we can use that instead. Though a *Node also uniquely identifies a node in a graph, currently, during trimming, graphs are rebuilt from scratch using only the NodeSet, so there would not be the required context of the initial graph to allow for the use of *Node.

type NodeSet ¶

type NodeSet map[NodeInfo]bool

NodeSet is a collection of node info structs.

type Nodes ¶

type Nodes []*Node

Nodes is an ordered collection of graph nodes.

func CreateNodes ¶

func CreateNodes(prof *profile.Profile, o *Options) (Nodes, locationMap)

CreateNodes creates graph nodes for all locations in a profile. It returns set of all nodes, plus a mapping of each location to the set of corresponding nodes (one per location.Line).

func (Nodes) Sum ¶

func (ns Nodes) Sum() (flat int64, cum int64)

Sum adds the flat and cum values of a set of nodes.

type Options ¶

type Options struct {
	SampleValue       func(s []int64) int64 // Function to compute the value of a sample
	SampleMeanDivisor func(s []int64) int64 // Function to compute the divisor for mean graphs, or nil

	DropNegative bool // Drop nodes with overall negative values

	KeptNodes NodeSet // If non-nil, only use nodes in this set
}

Options encodes the options for constructing a graph

Source Files ¶

graph.go