Regresses NodeSet interface

This is to keep the new TrimTree functionality from breaking any code
currently using the public interface. We do this by separating NodeSet
from nodePtrSet and creating different functions for each.

internal/graph/graph.go

 type NodeMap map[NodeInfo]*Node
 
 // NodeSet maps is a collection of node info structs.
-type NodeSet struct {
-	Info map[NodeInfo]bool
-	Ptr  map[*Node]bool
-}
+type NodeSet map[NodeInfo]bool
+
+type nodePtrSet map[*Node]bool
 
 // 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 {
-	if kept.Info != nil {
-		if _, ok := kept.Info[info]; !ok {
+	if kept != nil {
+		if _, ok := kept[info]; !ok {
 			return nil
 		}
 	}
 
 // Trims a Graph that is in forest form to contain only the nodes in kept. This
 // will not work correctly in the case that a node has multiple parents.
-func (g *Graph) TrimTree(kept NodeSet) {
+func (g *Graph) TrimTree(kept nodePtrSet) {
 	// Creates a new list of nodes
 	oldNodes := g.Nodes
-	g.Nodes = make(Nodes, 0, len(kept.Ptr))
+	g.Nodes = make(Nodes, 0, len(kept))
 
 	for _, cur := range oldNodes {
 		// A node may not have multiple parents
 		}
 
 		// If a node should be kept, add it to the next list of nodes
-		if _, ok := kept.Ptr[cur]; ok {
+		if _, ok := kept[cur]; ok {
 			g.Nodes = append(g.Nodes, cur)
 			continue
 		}
 	return makeNodeSet(g.Nodes, nodeCutoff)
 }
 
+// discardLowFrequencyNodePtrs returns a NodePtrSet of nodes at or over a
+// specific cum value cutoff.
+func (g *Graph) DiscardLowFrequencyNodePtrs(nodeCutoff int64) nodePtrSet {
+	cutNodes := getNodesWithCumCutoff(g.Nodes, nodeCutoff)
+	kept := make(nodePtrSet, len(cutNodes))
+	for _, n := range cutNodes {
+		kept[n] = true
+	}
+	return kept
+}
+
 func makeNodeSet(nodes Nodes, nodeCutoff int64) NodeSet {
-	kept := NodeSet{
-		Info: make(map[NodeInfo]bool, len(nodes)),
-		Ptr:  make(map[*Node]bool, len(nodes)),
+	cutNodes := getNodesWithCumCutoff(nodes, nodeCutoff)
+	kept := make(NodeSet, len(cutNodes))
+	for _, n := range cutNodes {
+		kept[n.Info] = true
 	}
+	return kept
+}
+
+// Returns all the nodes who have a Cum value greater than or equal to cutoff
+func getNodesWithCumCutoff(nodes Nodes, nodeCutoff int64) Nodes {
+	cutoffNodes := make(Nodes, 0, len(nodes))
 	for _, n := range nodes {
 		if abs64(n.Cum) < nodeCutoff {
 			continue
 		}
-		kept.Info[n.Info] = true
-		kept.Ptr[n] = true
+		cutoffNodes = append(cutoffNodes, n)
 	}
-	return kept
+	return cutoffNodes
 }
 
 // TrimLowFrequencyTags removes tags that have less than
 	}
 }
 
+// selectTopNodePtrs returns a set of the top maxNodes *Node in a graph.
+func (g *Graph) SelectTopNodePtrs(maxNodes int, visualMode bool) nodePtrSet {
+	set := make(nodePtrSet)
+	for _, node := range g.selectTopNodes(maxNodes, visualMode) {
+		set[node] = true
+	}
+	return set
+}
+
 // SelectTopNodes returns a set of the top maxNodes nodes in a graph.
 func (g *Graph) SelectTopNodes(maxNodes int, visualMode bool) NodeSet {
+	return makeNodeSet(g.selectTopNodes(maxNodes, visualMode), 0)
+}
+
+// selectTopNodes returns a slice of the top maxNodes nodes in a graph
+func (g *Graph) selectTopNodes(maxNodes int, visualMode bool) Nodes {
 	if maxNodes > 0 {
 		if visualMode {
 			var count int
 	if maxNodes > len(g.Nodes) {
 		maxNodes = len(g.Nodes)
 	}
-	return makeNodeSet(g.Nodes[:maxNodes], 0)
+	return g.Nodes[:maxNodes]
 }
 
 // countTags counts the tags with flat count. This underestimates the

internal/graph/graph_test.go

 type TrimTreeTestCase struct {
 	Initial  *Graph
 	Expected []ExpectedNode
-	Keep     NodeSet
+	Keep nodePtrSet
 }
 
 // Makes the edge from parent to child residual
 }
 
 // Creates an array of ExpectedNodes from nodes.
-func createExpectedNodes(nodes ...*Node) ([]ExpectedNode, NodeSet) {
+func createExpectedNodes(nodes ...*Node) ([]ExpectedNode, nodePtrSet) {
 	Expected := make([]ExpectedNode, len(nodes))
-	Keep := NodeSet{
-		Ptr: make(map[*Node]bool, len(nodes)),
-	}
+	Keep := make(nodePtrSet, len(nodes))
 
 	for i, node := range nodes {
 		Expected[i] = ExpectedNode{
 			In:   make(EdgeMap),
 			Out:  make(EdgeMap),
 		}
-		Keep.Ptr[node] = true
+		Keep[node] = true
 	}
 
 	return Expected, Keep

internal/report/report.go

 	cumSort := o.CumSort
 
 	// First step: Build complete graph to identify low frequency nodes, based on their cum weight.
-	g = rpt.newGraph(graph.NodeSet{nil, nil})
+	g = rpt.newGraph(nil)
 	totalValue, _ := g.Nodes.Sum()
 	nodeCutoff := abs64(int64(float64(totalValue) * o.NodeFraction))
 	edgeCutoff := abs64(int64(float64(totalValue) * o.EdgeFraction))
 
 	// Filter out nodes with cum value below nodeCutoff.
 	if nodeCutoff > 0 {
-		if nodesKept := g.DiscardLowFrequencyNodes(nodeCutoff); len(g.Nodes) != len(nodesKept.Ptr) {
-			droppedNodes = len(g.Nodes) - len(nodesKept.Ptr)
-			if o.CallTree {
+		if o.CallTree {
+			if nodesKept := g.DiscardLowFrequencyNodePtrs(nodeCutoff); len(g.Nodes) != len(nodesKept) {
+				droppedNodes = len(g.Nodes) - len(nodesKept)
 				g.TrimTree(nodesKept)
-			} else {
+			}
+		} else {
+			if nodesKept := g.DiscardLowFrequencyNodes(nodeCutoff); len(g.Nodes) != len(nodesKept) {
+				droppedNodes = len(g.Nodes) - len(nodesKept)
 				g = rpt.newGraph(nodesKept)
 			}
 		}
 		// Remove low frequency tags and edges as they affect selection.
 		g.TrimLowFrequencyTags(nodeCutoff)
 		g.TrimLowFrequencyEdges(edgeCutoff)
-		if nodesKept := g.SelectTopNodes(nodeCount, visualMode); len(nodesKept.Ptr) != len(g.Nodes) {
-			if o.CallTree {
+		if o.CallTree {
+			if nodesKept := g.SelectTopNodePtrs(nodeCount, visualMode); len(g.Nodes) != len(nodesKept) {
 				g.TrimTree(nodesKept)
-			} else {
+				g.SortNodes(cumSort, visualMode)
+			}
+		} else {
+			if nodesKept := g.SelectTopNodes(nodeCount, visualMode); len(g.Nodes) != len(nodesKept) {
 				g = rpt.newGraph(nodesKept)
+				g.SortNodes(cumSort, visualMode)
 			}
-			g.SortNodes(cumSort, visualMode)
 		}
 	}
 
 	o := rpt.options
 	prof := rpt.prof
 
-	g := rpt.newGraph(graph.NodeSet{nil, nil})
+	g := rpt.newGraph(nil)
 
 	// If the regexp source can be parsed as an address, also match
 	// functions that land on that address.
 
 	const separator = "-----------+-------------------------------------------------------"
 
-	_, locations := graph.CreateNodes(prof, false, graph.NodeSet{nil, nil})
+	_, locations := graph.CreateNodes(prof, false, nil)
 	for _, sample := range prof.Sample {
 		var stack graph.Nodes
 		for _, loc := range sample.Location {

internal/report/source.go

 // eliminate potential nondeterminism.
 func printSource(w io.Writer, rpt *Report) error {
 	o := rpt.options
-	g := rpt.newGraph(graph.NodeSet{nil, nil})
+	g := rpt.newGraph(nil)
 
 	// Identify all the functions that match the regexp provided.
 	// Group nodes for each matching function.
 // functions with samples that match the regexp rpt.options.symbol.
 func printWebSource(w io.Writer, rpt *Report, obj plugin.ObjTool) error {
 	o := rpt.options
-	g := rpt.newGraph(graph.NodeSet{nil, nil})
+	g := rpt.newGraph(nil)
 
 	// If the regexp source can be parsed as an address, also match
 	// functions that land on that address.