graph

Documentation

Overview

Package graph represents a pprof profile as a directed graph.

This package is a simplified fork of github.com/google/pprof/github.com/go-asm/go/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 (e EdgeMap) Sort() []*Edge
  • func (e 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 (e 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 (e 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