Add default_sample_type field

Add field for profile sources to indicate what is the primary
sample value, which visualizers should display by default.
Previously there was a convention for pprof to use the last
sample_index by default, this provides more flexibility.

internal/driver/commands.go

 	return message + "\n"
 }
 
+// AddCommand adds an additional command to the set of commands
+// accepted by pprof. This enables extensions to add new commands for
+// specialized visualization formats. If the command specified already
+// exists, it is overwritten.
 func AddCommand(cmd string, format int, post PostProcessor, desc, usage string) {
 	pprofCommands[cmd] = &command{format, post, false, desc, usage}
 }
 		"For memory profiles, report average memory per allocation.",
 		"For time-based profiles, report average time per event.")},
 	"sample_index": &variable{stringKind, "", "", helpText(
-		"Sample value to report",
+		"Sample value to report (0-based index or name)",
 		"Profiles contain multiple values per sample.",
-		"Use sample_value=index to select the ith value or select it by name.")},
+		"Use sample_index=i to select the ith value (starting at 0).")},
 
 	// Data sorting criteria
 	"flat": &variable{boolKind, "t", "cumulative", helpText("Sort entries based on own weight")},
 	case "windows":
 		return append(cmds, "cmd /c start")
 	default:
-		user_browser := os.Getenv("BROWSER")
-		if user_browser != "" {
-			cmds = append([]string{user_browser, "sensible-browser"}, cmds...)
+		userBrowser := os.Getenv("BROWSER")
+		if userBrowser != "" {
+			cmds = append([]string{userBrowser, "sensible-browser"}, cmds...)
 		} else {
 			cmds = append([]string{"sensible-browser"}, cmds...)
 		}
 // profile sample types.
 func locateSampleIndex(p *profile.Profile, sampleIndex string) (int, error) {
 	if sampleIndex == "" {
+		if dst := p.DefaultSampleType; dst != "" {
+			for i, t := range sampleTypes(p) {
+				if t == dst {
+					return i, nil
+				}
+			}
+		}
 		// By default select the last sample value
 		return len(p.SampleType) - 1, nil
 	}
 	// "inuse_space" and "inuse_objects" for profiles containing types
 	// "space" and "objects".
 	noInuse := strings.TrimPrefix(sampleIndex, "inuse_")
-	sampleTypes := make([]string, len(p.SampleType))
 	for i, t := range p.SampleType {
 		if t.Type == sampleIndex || t.Type == noInuse {
 			return i, nil
 		}
-		sampleTypes[i] = t.Type
 	}
 
-	return 0, fmt.Errorf("sample_index %q must be one of: %v", sampleIndex, sampleTypes)
+	return 0, fmt.Errorf("sample_index %q must be one of: %v", sampleIndex, sampleTypes(p))
+}
+
+func sampleTypes(p *profile.Profile) []string {
+	types := make([]string, len(p.SampleType))
+	for i, t := range p.SampleType {
+		types[i] = t.Type
+	}
+	return types
 }
 
 // variables describe the configuration parameters recognized by pprof.

internal/driver/interactive.go

 	// Enter command processing loop.
 	o.UI.SetAutoComplete(newCompleter(functionNames(p)))
 	pprofVariables.set("compact_labels", "true")
+	pprofVariables["sample_index"].help += fmt.Sprintf("Or use sample_index=name, with name in %v.\n", sampleTypes(p))
 
 	// Do not wait for the visualizer to complete, to allow multiple
 	// graphs to be visualized simultaneously.
 	ropt, err := reportOptions(p, pprofVariables)
 	if err == nil {
 		ui.Print(strings.Join(report.ProfileLabels(report.New(p, ropt)), "\n"))
+		ui.Print(fmt.Sprintf("Sample types: %v\n", sampleTypes(p)))
 	}
 	ui.Print("Entering interactive mode (type \"help\" for commands)")
 }

profile/encode.go

 		p.commentX = append(p.commentX, addString(strings, c))
 	}
 
+	p.defaultSampleTypeX = addString(strings, p.DefaultSampleType)
+
 	p.stringTable = make([]string, len(strings))
 	for s, i := range strings {
 		p.stringTable[i] = s
 	}
 	encodeInt64Opt(b, 12, p.Period)
 	encodeInt64s(b, 13, p.commentX)
+	encodeInt64(b, 14, p.defaultSampleTypeX)
 }
 
 var profileDecoder = []decoder{
 	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).Period) },
 	// repeated int64 comment = 13
 	func(b *buffer, m message) error { return decodeInt64s(b, &m.(*Profile).commentX) },
+	// int64 defaultSampleType = 14
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).defaultSampleTypeX) },
 }
 
 // postDecode takes the unexported fields populated by decode (with
 	}
 
 	p.commentX = nil
+	p.DefaultSampleType, err = getString(p.stringTable, &p.defaultSampleTypeX, err)
 	p.stringTable = nil
 	return err
 }

profile/merge.go

 
 	var timeNanos, durationNanos, period int64
 	var comments []string
+	var defaultSampleType string
 	for _, s := range srcs {
 		if timeNanos == 0 || s.TimeNanos < timeNanos {
 			timeNanos = s.TimeNanos
 			period = s.Period
 		}
 		comments = append(comments, s.Comments...)
+		if defaultSampleType == "" {
+			defaultSampleType = s.DefaultSampleType
+		}
 	}
 
 	p := &Profile{
 		PeriodType:    srcs[0].PeriodType,
 		Period:        period,
 
-		Comments: comments,
+		Comments:          comments,
+		DefaultSampleType: defaultSampleType,
 	}
 	copy(p.SampleType, srcs[0].SampleType)
 	return p, nil

profile/profile.go

 
 // Profile is an in-memory representation of profile.proto.
 type Profile struct {
-	SampleType []*ValueType
-	Sample     []*Sample
-	Mapping    []*Mapping
-	Location   []*Location
-	Function   []*Function
-	Comments   []string
+	SampleType        []*ValueType
+	DefaultSampleType string
+	Sample            []*Sample
+	Mapping           []*Mapping
+	Location          []*Location
+	Function          []*Function
+	Comments          []string
 
 	DropFrames string
 	KeepFrames string
 	PeriodType    *ValueType
 	Period        int64
 
-	commentX    []int64
-	dropFramesX int64
-	keepFramesX int64
-	stringTable []string
+	commentX           []int64
+	dropFramesX        int64
+	keepFramesX        int64
+	stringTable        []string
+	defaultSampleTypeX int64
 }
 
 // ValueType corresponds to Profile.ValueType
 	ss = append(ss, "Samples:")
 	var sh1 string
 	for _, s := range p.SampleType {
-		sh1 = sh1 + fmt.Sprintf("%s/%s ", s.Type, s.Unit)
+		dflt := ""
+		if s.Type == p.DefaultSampleType {
+			dflt = "[dflt]"
+		}
+		sh1 = sh1 + fmt.Sprintf("%s/%s%s ", s.Type, s.Unit, dflt)
 	}
 	ss = append(ss, strings.TrimSpace(sh1))
 	for _, s := range p.Sample {

proto/profile.proto

   repeated Function function = 5;
   // A common table for strings referenced by various messages.
   // string_table[0] must always be "".
-  repeated string string_table = 6 [enforce_utf8 = false];
+  repeated string string_table = 6;
   // frames with Function.function_name fully matching the following
   // regexp will be dropped from the samples, along with their successors.
   int64 drop_frames = 7;   // Index into string table.
   int64 period = 12;
   // Freeform text associated to the profile.
   repeated int64 comment = 13; // Indices into string table.
+  // Index into the string table of the type of the preferred sample
+  // value. If unset, clients should default to the last sample value.
+  int64 default_sample_type = 14;
 }
 
 // ValueType describes the semantics and measurement units of a value.