var javaRegExp … var goRegExp … var goVerRegExp … var cppRegExp … var cppAnonymousPrefixRegExp … type Graph … type Options … type Nodes … type Node … // FlatValue returns the exclusive value for this node, computing the // mean if a divisor is available. func (n *Node) FlatValue() int64 { … } // CumValue returns the inclusive value for this node, computing the // mean if a divisor is available. func (n *Node) CumValue() int64 { … } // AddToEdge increases the weight of an edge between two nodes. If // there isn't such an edge one is created. func (n *Node) AddToEdge(to *Node, 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 (n *Node) AddToEdgeDiv(to *Node, dv, v int64, residual, inline bool) { … } type NodeInfo … // PrintableName calls the Node's Formatter function with a single space separator. func (i *NodeInfo) PrintableName() string { … } // NameComponents returns the components of the printable name to be used for a node. func (i *NodeInfo) NameComponents() []string { … } type NodeMap … type NodeSet … type NodePtrSet … // 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. func (nm NodeMap) FindOrInsertNode(info NodeInfo, kept NodeSet) *Node { … } type EdgeMap … type Edge … // WeightValue returns the weight value for this edge, normalizing if a // divisor is available. func (e *Edge) WeightValue() int64 { … } type Tag … // FlatValue returns the exclusive value for this tag, computing the // mean if a divisor is available. func (t *Tag) FlatValue() int64 { … } // CumValue returns the inclusive value for this tag, computing the // mean if a divisor is available. func (t *Tag) CumValue() int64 { … } type TagMap … // SortTags sorts a slice of tags based on their weight. func SortTags(t []*Tag, flat bool) []*Tag { … } // New summarizes performance data from a profile into a graph. func New(prof *profile.Profile, o *Options) *Graph { … } // newGraph computes a graph from a profile. It returns the graph, and // a map from the profile location indices to the corresponding graph // nodes. func newGraph(prof *profile.Profile, o *Options) (*Graph, map[uint64]Nodes) { … } func selectNodesForGraph(nodes Nodes, dropNegative bool) *Graph { … } type nodePair … func newTree(prof *profile.Profile, o *Options) (g *Graph) { … } // ShortenFunctionName returns a shortened version of a function's name. func ShortenFunctionName(f string) string { … } // TrimTree trims a Graph in forest form, keeping only the nodes in kept. This // will not work correctly if even a single node has multiple parents. func (g *Graph) TrimTree(kept NodePtrSet) { … } func joinLabels(s *profile.Sample) string { … } // isNegative returns true if the node is considered as "negative" for the // purposes of drop_negative. func isNegative(n *Node) bool { … } // 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 CreateNodes(prof *profile.Profile, o *Options) (Nodes, map[uint64]Nodes) { … } func (nm NodeMap) nodes() Nodes { … } func (nm NodeMap) findOrInsertLine(l *profile.Location, li profile.Line, o *Options) *Node { … } func nodeInfo(l *profile.Location, line profile.Line, objfile string, o *Options) *NodeInfo { … } type tags … func (t tags) Len() int { … } func (t tags) Swap(i, j int) { … } func (t tags) Less(i, j int) bool { … } // Sum adds the flat and cum values of a set of nodes. func (ns Nodes) Sum() (flat int64, cum int64) { … } func (n *Node) addSample(dw, w int64, labels string, numLabel map[string][]int64, numUnit map[string][]string, format func(int64, string) string, flat bool) { … } func defaultLabelFormat(v int64, key string) string { … } func (m TagMap) findOrAddTag(label, unit string, value int64) *Tag { … } // String returns a text representation of a graph, for debugging purposes. func (g *Graph) String() string { … } // DiscardLowFrequencyNodes returns a set of the nodes at or over a // specific cum value cutoff. func (g *Graph) DiscardLowFrequencyNodes(nodeCutoff int64) NodeSet { … } // DiscardLowFrequencyNodePtrs returns a NodePtrSet of nodes at or over a // specific cum value cutoff. func (g *Graph) DiscardLowFrequencyNodePtrs(nodeCutoff int64) NodePtrSet { … } func makeNodeSet(nodes Nodes, nodeCutoff int64) NodeSet { … } // getNodesAboveCumCutoff returns all the nodes which have a Cum value greater // than or equal to cutoff. func getNodesAboveCumCutoff(nodes Nodes, nodeCutoff int64) Nodes { … } // TrimLowFrequencyTags removes tags that have less than // the specified weight. func (g *Graph) TrimLowFrequencyTags(tagCutoff int64) { … } func trimLowFreqTags(tags TagMap, minValue int64) TagMap { … } // TrimLowFrequencyEdges removes edges that have less than // the specified weight. Returns the number of edges removed func (g *Graph) TrimLowFrequencyEdges(edgeCutoff int64) int { … } // SortNodes sorts the nodes in a graph based on a specific heuristic. func (g *Graph) SortNodes(cum bool, visualMode bool) { … } // SelectTopNodePtrs returns a set of the top maxNodes *Node in a graph. func (g *Graph) SelectTopNodePtrs(maxNodes int, visualMode bool) NodePtrSet { … } // SelectTopNodes returns a set of the top maxNodes nodes in a graph. func (g *Graph) SelectTopNodes(maxNodes int, visualMode bool) NodeSet { … } // selectTopNodes returns a slice of the top maxNodes nodes in a graph. func (g *Graph) selectTopNodes(maxNodes int, visualMode bool) Nodes { … } // countTags counts the tags with flat count. This underestimates the // number of tags being displayed, but in practice is close enough. func countTags(n *Node) int { … } // RemoveRedundantEdges removes residual edges if the destination can // be reached through another path. This is done to simplify the graph // while preserving connectivity. func (g *Graph) RemoveRedundantEdges() { … } // isRedundantEdge determines if there is a path that allows e.Src // to reach e.Dest after removing e. func isRedundantEdge(e *Edge) bool { … } type nodeSorter … func (s nodeSorter) Len() int { … } func (s nodeSorter) Swap(i, j int) { … } func (s nodeSorter) Less(i, j int) bool { … } // Sort reorders a slice of nodes based on the specified ordering // criteria. The result is sorted in decreasing order for (absolute) // numeric quantities, alphabetically for text, and increasing for // addresses. func (ns Nodes) Sort(o NodeOrder) error { … } // compareNodes compares two nodes to provide a deterministic ordering // between them. Two nodes cannot have the same Node.Info value. func compareNodes(l, r *Node) bool { … } // entropyScore computes a score for a node representing how important // it is to include this node on a graph visualization. It is used to // sort the nodes and select which ones to display if we have more // nodes than desired in the graph. This number is computed by looking // at the flat and cum weights of the node and the incoming/outgoing // edges. The fundamental idea is to penalize nodes that have a simple // fallthrough from their incoming to the outgoing edge. func entropyScore(n *Node) int64 { … } // edgeEntropyScore computes the entropy value for a set of edges // coming in or out of a node. Entropy (as defined in information // theory) refers to the amount of information encoded by the set of // edges. A set of edges that have a more interesting distribution of // samples gets a higher score. func edgeEntropyScore(n *Node, edges EdgeMap, self int64) float64 { … } type NodeOrder … const FlatNameOrder … const FlatCumNameOrder … const CumNameOrder … const NameOrder … const FileOrder … const AddressOrder … const EntropyOrder … // 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 (e EdgeMap) Sort() []*Edge { … } // Sum returns the total weight for a set of nodes. func (e EdgeMap) Sum() int64 { … } type edgeList … func (el edgeList) Len() int { … } func (el edgeList) Less(i, j int) bool { … } func (el edgeList) Swap(i, j int) { … } func abs64(i int64) int64 { … }
Codebase Browser
go