Merge pull request #52 from rauls5382/tagunit

Have unit= apply to numeric tags

internal/driver/driver_test.go

 		{"dot,files,cum", "contention"},
 		{"tags", "cpu"},
 		{"tags,tagignore=tag[13],tagfocus=key[12]", "cpu"},
+		{"tags", "heap"},
+		{"tags,unit=bytes", "heap"},
 		{"traces", "cpu"},
 		{"dot,alloc_space,flat,focus=[234]00", "heap_alloc"},
 		{"dot,alloc_space,flat,hide=line.*1?23?", "heap_alloc"},
 		name = append(name, "ignore")
 	}
 	name = addString(name, f, []string{"hide", "show"})
-
+	if f.strings["unit"] != "minimum" {
+		name = addString(name, f, []string{"unit"})
+	}
 	return strings.Join(name, ".")
 }
 

internal/driver/testdata/pprof.heap.tags

+bytes: Total 150
+        80 (53.33%): 400kB
+        40 (26.67%): 1.56MB
+        20 (13.33%): 200kB
+        10 ( 6.67%): 100kB
+

internal/driver/testdata/pprof.heap.tags.unit

+bytes: Total 150
+        80 (53.33%): 409600B
+        40 (26.67%): 1638400B
+        20 (13.33%): 204800B
+        10 ( 6.67%): 102400B
+

internal/graph/dotgraph.go

 	Title  string   // The title of the DOT graph
 	Labels []string // The labels for the DOT's legend
 
-	FormatValue func(int64) string // A formatting function for values
-	Total       int64              // The total weight of the graph, used to compute percentages
+	FormatValue func(int64) string         // A formatting function for values
+	FormatTag   func(int64, string) string // A formatting function for numeric tags
+	Total       int64                      // The total weight of the graph, used to compute percentages
 }
 
 // Compose creates and writes a in the DOT format to the writer, using
 
 	// Collapse numeric labels into maxNumNodelets buckets, of the form:
 	// 1MB..2MB, 3MB..5MB, ...
-	for j, t := range collapsedTags(nts, maxNumNodelets, flatTags) {
+	for j, t := range b.collapsedTags(nts, maxNumNodelets, flatTags) {
 		w, attr := t.CumValue(), ` style="dotted"`
 		if flatTags || t.FlatValue() == t.CumValue() {
 			w, attr = t.FlatValue(), ""
 }
 
 // collapsedTags trims and sorts a slice of tags.
-func collapsedTags(ts []*Tag, count int, flatTags bool) []*Tag {
+func (b *builder) collapsedTags(ts []*Tag, count int, flatTags bool) []*Tag {
 	ts = SortTags(ts, flatTags)
 	if len(ts) <= count {
 		return ts
 
 	var nts []*Tag
 	for _, g := range tagGroups {
-		l, w, c := tagGroupLabel(g)
+		l, w, c := b.tagGroupLabel(g)
 		nts = append(nts, &Tag{
 			Name: l,
 			Flat: w,
 	return v - float64(t.Value)
 }
 
-func tagGroupLabel(g []*Tag) (label string, flat, cum int64) {
+func (b *builder) tagGroupLabel(g []*Tag) (label string, flat, cum int64) {
+	formatTag := b.config.FormatTag
+	if formatTag == nil {
+		formatTag = measurement.Label
+	}
+
 	if len(g) == 1 {
 		t := g[0]
-		return measurement.Label(t.Value, t.Unit), t.FlatValue(), t.CumValue()
+		return formatTag(t.Value, t.Unit), t.FlatValue(), t.CumValue()
 	}
 	min := g[0]
 	max := g[0]
 	if dc != 0 {
 		c = c / dc
 	}
-	return measurement.Label(min.Value, min.Unit) + ".." + measurement.Label(max.Value, max.Unit), f, c
+	return formatTag(min.Value, min.Unit) + ".." + formatTag(max.Value, max.Unit), f, c
 }
 
 func min64(a, b int64) int64 {

internal/graph/dotgraph_test.go

 
 	for _, tc := range tagWant {
 		var got, want []*Tag
-		got = collapsedTags(tagSource, len(tc), true)
+		b := builder{nil, &DotAttributes{}, &DotConfig{}}
+		got = b.collapsedTags(tagSource, len(tc), true)
 		want = SortTags(tc, true)
 
 		if !reflect.DeepEqual(got, want) {

internal/report/report.go

 		s.NumLabel = numLabels
 	}
 
+	formatTag := func(v int64, key string) string {
+		return measurement.ScaledLabel(v, key, o.OutputUnit)
+	}
+
 	gopt := &graph.Options{
 		SampleValue:       o.SampleValue,
 		SampleMeanDivisor: o.SampleMeanDivisor,
 	return graph.New(rpt.prof, gopt)
 }
 
-func formatTag(v int64, key string) string {
-	return measurement.Label(v, key)
-}
-
 func printTopProto(w io.Writer, rpt *Report) error {
 	p := rpt.prof
 	o := rpt.options
 func printTags(w io.Writer, rpt *Report) error {
 	p := rpt.prof
 
+	o := rpt.options
+	formatTag := func(v int64, key string) string {
+		return measurement.ScaledLabel(v, key, o.OutputUnit)
+	}
+
 	// Hashtable to keep accumulate tags as key,value,count.
 	tagMap := make(map[string]map[string]int64)
 	for _, s := range p.Sample {
 		}
 		for key, vals := range s.NumLabel {
 			for _, nval := range vals {
-				val := measurement.Label(nval, key)
+				val := formatTag(nval, key)
 				if valueMap, ok := tagMap[key]; ok {
 					valueMap[val] = valueMap[val] + s.Value[0]
 					continue
 	rpt.selectOutputUnit(g)
 	labels := reportLabels(rpt, g, origCount, droppedNodes, droppedEdges, true)
 
+	o := rpt.options
+	formatTag := func(v int64, key string) string {
+		return measurement.ScaledLabel(v, key, o.OutputUnit)
+	}
+
 	c := &graph.DotConfig{
 		Title:       rpt.options.Title,
 		Labels:      labels,
 		FormatValue: rpt.formatValue,
+		FormatTag:   formatTag,
 		Total:       rpt.total,
 	}
 	graph.ComposeDot(w, g, &graph.DotAttributes{}, c)