src/runtime/pprof/internal/profile/profile.go - go - Git at Google

 // Copyright 2014 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Package profile provides a representation of profile.proto and
 // methods to encode/decode profiles in this format.
 //
 // This package is only for testing runtime/pprof.
 // It is not used by production Go programs.
 package profile

 import (
 	"bytes"
 	"compress/gzip"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"regexp"
 	"strings"
 	"time"
 )

 // Profile is an in-memory representation of profile.proto.
 type Profile struct {
 	SampleType []*ValueType
 	Sample     []*Sample
 	Mapping    []*Mapping
 	Location   []*Location
 	Function   []*Function

 	DropFrames string
 	KeepFrames string

 	TimeNanos     int64
 	DurationNanos int64
 	PeriodType    *ValueType
 	Period        int64

 	dropFramesX int64
 	keepFramesX int64
 	stringTable []string
 }

 // ValueType corresponds to Profile.ValueType
 type ValueType struct {
 	Type string // cpu, wall, inuse_space, etc
 	Unit string // seconds, nanoseconds, bytes, etc

 	typeX int64
 	unitX int64
 }

 // Sample corresponds to Profile.Sample
 type Sample struct {
 	Location []*Location
 	Value    []int64
 	Label    map[string][]string
 	NumLabel map[string][]int64

 	locationIDX []uint64
 	labelX      []Label
 }

 // Label corresponds to Profile.Label
 type Label struct {
 	keyX int64
 	// Exactly one of the two following values must be set
 	strX int64
 	numX int64 // Integer value for this label
 }

 // Mapping corresponds to Profile.Mapping
 type Mapping struct {
 	ID              uint64
 	Start           uint64
 	Limit           uint64
 	Offset          uint64
 	File            string
 	BuildID         string
 	HasFunctions    bool
 	HasFilenames    bool
 	HasLineNumbers  bool
 	HasInlineFrames bool

 	fileX    int64
 	buildIDX int64
 }

 // Location corresponds to Profile.Location
 type Location struct {
 	ID      uint64
 	Mapping *Mapping
 	Address uint64
 	Line    []Line

 	mappingIDX uint64
 }

 // Line corresponds to Profile.Line
 type Line struct {
 	Function *Function
 	Line     int64

 	functionIDX uint64
 }

 // Function corresponds to Profile.Function
 type Function struct {
 	ID         uint64
 	Name       string
 	SystemName string
 	Filename   string
 	StartLine  int64

 	nameX       int64
 	systemNameX int64
 	filenameX   int64
 }

 // Parse parses a profile and checks for its validity. The input
 // may be a gzip-compressed encoded protobuf or one of many legacy
 // profile formats which may be unsupported in the future.
 func Parse(r io.Reader) (*Profile, error) {
 	orig, err := ioutil.ReadAll(r)
 	if err != nil {
 		return nil, err
 	}

 	var p *Profile
 	if len(orig) >= 2 && orig[0] == 0x1f && orig[1] == 0x8b {
 		gz, err := gzip.NewReader(bytes.NewBuffer(orig))
 		if err != nil {
 			return nil, fmt.Errorf("decompressing profile: %v", err)
 		}
 		data, err := ioutil.ReadAll(gz)
 		if err != nil {
 			return nil, fmt.Errorf("decompressing profile: %v", err)
 		}
 		orig = data
 	}
 	if p, err = parseUncompressed(orig); err != nil {
 		if p, err = parseLegacy(orig); err != nil {
 			return nil, fmt.Errorf("parsing profile: %v", err)
 		}
 	}

 	if err := p.CheckValid(); err != nil {
 		return nil, fmt.Errorf("malformed profile: %v", err)
 	}
 	return p, nil
 }

 var errUnrecognized = fmt.Errorf("unrecognized profile format")
 var errMalformed = fmt.Errorf("malformed profile format")

 func parseLegacy(data []byte) (*Profile, error) {
 	parsers := []func([]byte) (*Profile, error){
 		parseCPU,
 		parseHeap,
 		parseGoCount, // goroutine, threadcreate
 		parseThread,
 		parseContention,
 	}

 	for _, parser := range parsers {
 		p, err := parser(data)
 		if err == nil {
 			p.setMain()
 			p.addLegacyFrameInfo()
 			return p, nil
 		}
 		if err != errUnrecognized {
 			return nil, err
 		}
 	}
 	return nil, errUnrecognized
 }

 func parseUncompressed(data []byte) (*Profile, error) {
 	p := &Profile{}
 	if err := unmarshal(data, p); err != nil {
 		return nil, err
 	}

 	if err := p.postDecode(); err != nil {
 		return nil, err
 	}

 	return p, nil
 }

 var libRx = regexp.MustCompile(`([.]so$|[.]so[._][0-9]+)`)

 // setMain scans Mapping entries and guesses which entry is main
 // because legacy profiles don't obey the convention of putting main
 // first.
 func (p *Profile) setMain() {
 	for i := 0; i < len(p.Mapping); i++ {
 		file := strings.TrimSpace(strings.Replace(p.Mapping[i].File, "(deleted)", "", -1))
 		if len(file) == 0 {
 			continue
 		}
 		if len(libRx.FindStringSubmatch(file)) > 0 {
 			continue
 		}
 		if strings.HasPrefix(file, "[") {
 			continue
 		}
 		// Swap what we guess is main to position 0.
 		tmp := p.Mapping[i]
 		p.Mapping[i] = p.Mapping[0]
 		p.Mapping[0] = tmp
 		break
 	}
 }

 // Write writes the profile as a gzip-compressed marshaled protobuf.
 func (p *Profile) Write(w io.Writer) error {
 	p.preEncode()
 	b := marshal(p)
 	zw := gzip.NewWriter(w)
 	defer zw.Close()
 	_, err := zw.Write(b)
 	return err
 }

 // CheckValid tests whether the profile is valid. Checks include, but are
 // not limited to:
 //   - len(Profile.Sample[n].value) == len(Profile.value_unit)
 //   - Sample.id has a corresponding Profile.Location
 func (p *Profile) CheckValid() error {
 	// Check that sample values are consistent
 	sampleLen := len(p.SampleType)
 	if sampleLen == 0 && len(p.Sample) != 0 {
 		return fmt.Errorf("missing sample type information")
 	}
 	for _, s := range p.Sample {
 		if len(s.Value) != sampleLen {
 			return fmt.Errorf("mismatch: sample has: %d values vs. %d types", len(s.Value), len(p.SampleType))
 		}
 	}

 	// Check that all mappings/locations/functions are in the tables
 	// Check that there are no duplicate ids
 	mappings := make(map[uint64]*Mapping, len(p.Mapping))
 	for _, m := range p.Mapping {
 		if m.ID == 0 {
 			return fmt.Errorf("found mapping with reserved ID=0")
 		}
 		if mappings[m.ID] != nil {
 			return fmt.Errorf("multiple mappings with same id: %d", m.ID)
 		}
 		mappings[m.ID] = m
 	}
 	functions := make(map[uint64]*Function, len(p.Function))
 	for _, f := range p.Function {
 		if f.ID == 0 {
 			return fmt.Errorf("found function with reserved ID=0")
 		}
 		if functions[f.ID] != nil {
 			return fmt.Errorf("multiple functions with same id: %d", f.ID)
 		}
 		functions[f.ID] = f
 	}
 	locations := make(map[uint64]*Location, len(p.Location))
 	for _, l := range p.Location {
 		if l.ID == 0 {
 			return fmt.Errorf("found location with reserved id=0")
 		}
 		if locations[l.ID] != nil {
 			return fmt.Errorf("multiple locations with same id: %d", l.ID)
 		}
 		locations[l.ID] = l
 		if m := l.Mapping; m != nil {
 			if m.ID == 0 || mappings[m.ID] != m {
 				return fmt.Errorf("inconsistent mapping %p: %d", m, m.ID)
 			}
 		}
 		for _, ln := range l.Line {
 			if f := ln.Function; f != nil {
 				if f.ID == 0 || functions[f.ID] != f {
 					return fmt.Errorf("inconsistent function %p: %d", f, f.ID)
 				}
 			}
 		}
 	}
 	return nil
 }

 // Aggregate merges the locations in the profile into equivalence
 // classes preserving the request attributes. It also updates the
 // samples to point to the merged locations.
 func (p *Profile) Aggregate(inlineFrame, function, filename, linenumber, address bool) error {
 	for _, m := range p.Mapping {
 		m.HasInlineFrames = m.HasInlineFrames && inlineFrame
 		m.HasFunctions = m.HasFunctions && function
 		m.HasFilenames = m.HasFilenames && filename
 		m.HasLineNumbers = m.HasLineNumbers && linenumber
 	}

 	// Aggregate functions
 	if !function || !filename {
 		for _, f := range p.Function {
 			if !function {
 				f.Name = ""
 				f.SystemName = ""
 			}
 			if !filename {
 				f.Filename = ""
 			}
 		}
 	}

 	// Aggregate locations
 	if !inlineFrame || !address || !linenumber {
 		for _, l := range p.Location {
 			if !inlineFrame && len(l.Line) > 1 {
 				l.Line = l.Line[len(l.Line)-1:]
 			}
 			if !linenumber {
 				for i := range l.Line {
 					l.Line[i].Line = 0
 				}
 			}
 			if !address {
 				l.Address = 0
 			}
 		}
 	}

 	return p.CheckValid()
 }

 // Print dumps a text representation of a profile. Intended mainly
 // for debugging purposes.
 func (p *Profile) String() string {

 	ss := make([]string, 0, len(p.Sample)+len(p.Mapping)+len(p.Location))
 	if pt := p.PeriodType; pt != nil {
 		ss = append(ss, fmt.Sprintf("PeriodType: %s %s", pt.Type, pt.Unit))
 	}
 	ss = append(ss, fmt.Sprintf("Period: %d", p.Period))
 	if p.TimeNanos != 0 {
 		ss = append(ss, fmt.Sprintf("Time: %v", time.Unix(0, p.TimeNanos)))
 	}
 	if p.DurationNanos != 0 {
 		ss = append(ss, fmt.Sprintf("Duration: %v", time.Duration(p.DurationNanos)))
 	}

 	ss = append(ss, "Samples:")
 	var sh1 string
 	for _, s := range p.SampleType {
 		sh1 = sh1 + fmt.Sprintf("%s/%s ", s.Type, s.Unit)
 	}
 	ss = append(ss, strings.TrimSpace(sh1))
 	for _, s := range p.Sample {
 		var sv string
 		for _, v := range s.Value {
 			sv = fmt.Sprintf("%s %10d", sv, v)
 		}
 		sv = sv + ": "
 		for _, l := range s.Location {
 			sv = sv + fmt.Sprintf("%d ", l.ID)
 		}
 		ss = append(ss, sv)
 		const labelHeader = "                "
 		if len(s.Label) > 0 {
 			ls := labelHeader
 			for k, v := range s.Label {
 				ls = ls + fmt.Sprintf("%s:%v ", k, v)
 			}
 			ss = append(ss, ls)
 		}
 		if len(s.NumLabel) > 0 {
 			ls := labelHeader
 			for k, v := range s.NumLabel {
 				ls = ls + fmt.Sprintf("%s:%v ", k, v)
 			}
 			ss = append(ss, ls)
 		}
 	}

 	ss = append(ss, "Locations")
 	for _, l := range p.Location {
 		locStr := fmt.Sprintf("%6d: %#x ", l.ID, l.Address)
 		if m := l.Mapping; m != nil {
 			locStr = locStr + fmt.Sprintf("M=%d ", m.ID)
 		}
 		if len(l.Line) == 0 {
 			ss = append(ss, locStr)
 		}
 		for li := range l.Line {
 			lnStr := "??"
 			if fn := l.Line[li].Function; fn != nil {
 				lnStr = fmt.Sprintf("%s %s:%d s=%d",
 					fn.Name,
 					fn.Filename,
 					l.Line[li].Line,
 					fn.StartLine)
 				if fn.Name != fn.SystemName {
 					lnStr = lnStr + "(" + fn.SystemName + ")"
 				}
 			}
 			ss = append(ss, locStr+lnStr)
 			// Do not print location details past the first line
 			locStr = "             "
 		}
 	}

 	ss = append(ss, "Mappings")
 	for _, m := range p.Mapping {
 		bits := ""
 		if m.HasFunctions {
 			bits = bits + "[FN]"
 		}
 		if m.HasFilenames {
 			bits = bits + "[FL]"
 		}
 		if m.HasLineNumbers {
 			bits = bits + "[LN]"
 		}
 		if m.HasInlineFrames {
 			bits = bits + "[IN]"
 		}
 		ss = append(ss, fmt.Sprintf("%d: %#x/%#x/%#x %s %s %s",
 			m.ID,
 			m.Start, m.Limit, m.Offset,
 			m.File,
 			m.BuildID,
 			bits))
 	}

 	return strings.Join(ss, "\n") + "\n"
 }

 // Merge adds profile p adjusted by ratio r into profile p. Profiles
 // must be compatible (same Type and SampleType).
 // TODO(rsilvera): consider normalizing the profiles based on the
 // total samples collected.
 func (p *Profile) Merge(pb *Profile, r float64) error {
 	if err := p.Compatible(pb); err != nil {
 		return err
 	}

 	pb = pb.Copy()

 	// Keep the largest of the two periods.
 	if pb.Period > p.Period {
 		p.Period = pb.Period
 	}

 	p.DurationNanos += pb.DurationNanos

 	p.Mapping = append(p.Mapping, pb.Mapping...)
 	for i, m := range p.Mapping {
 		m.ID = uint64(i + 1)
 	}
 	p.Location = append(p.Location, pb.Location...)
 	for i, l := range p.Location {
 		l.ID = uint64(i + 1)
 	}
 	p.Function = append(p.Function, pb.Function...)
 	for i, f := range p.Function {
 		f.ID = uint64(i + 1)
 	}

 	if r != 1.0 {
 		for _, s := range pb.Sample {
 			for i, v := range s.Value {
 				s.Value[i] = int64((float64(v) * r))
 			}
 		}
 	}
 	p.Sample = append(p.Sample, pb.Sample...)
 	return p.CheckValid()
 }

 // Compatible determines if two profiles can be compared/merged.
 // returns nil if the profiles are compatible; otherwise an error with
 // details on the incompatibility.
 func (p *Profile) Compatible(pb *Profile) error {
 	if !compatibleValueTypes(p.PeriodType, pb.PeriodType) {
 		return fmt.Errorf("incompatible period types %v and %v", p.PeriodType, pb.PeriodType)
 	}

 	if len(p.SampleType) != len(pb.SampleType) {
 		return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
 	}

 	for i := range p.SampleType {
 		if !compatibleValueTypes(p.SampleType[i], pb.SampleType[i]) {
 			return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
 		}
 	}

 	return nil
 }

 // HasFunctions determines if all locations in this profile have
 // symbolized function information.
 func (p *Profile) HasFunctions() bool {
 	for _, l := range p.Location {
 		if l.Mapping == nil || !l.Mapping.HasFunctions {
 			return false
 		}
 	}
 	return true
 }

 // HasFileLines determines if all locations in this profile have
 // symbolized file and line number information.
 func (p *Profile) HasFileLines() bool {
 	for _, l := range p.Location {
 		if l.Mapping == nil || (!l.Mapping.HasFilenames || !l.Mapping.HasLineNumbers) {
 			return false
 		}
 	}
 	return true
 }

 func compatibleValueTypes(v1, v2 *ValueType) bool {
 	if v1 == nil || v2 == nil {
 		return true // No grounds to disqualify.
 	}
 	return v1.Type == v2.Type && v1.Unit == v2.Unit
 }

 // Copy makes a fully independent copy of a profile.
 func (p *Profile) Copy() *Profile {
 	p.preEncode()
 	b := marshal(p)

 	pp := &Profile{}
 	if err := unmarshal(b, pp); err != nil {
 		panic(err)
 	}
 	if err := pp.postDecode(); err != nil {
 		panic(err)
 	}

 	return pp
 }

 // Demangler maps symbol names to a human-readable form. This may
 // include C++ demangling and additional simplification. Names that
 // are not demangled may be missing from the resulting map.
 type Demangler func(name []string) (map[string]string, error)

 // Demangle attempts to demangle and optionally simplify any function
 // names referenced in the profile. It works on a best-effort basis:
 // it will silently preserve the original names in case of any errors.
 func (p *Profile) Demangle(d Demangler) error {
 	// Collect names to demangle.
 	var names []string
 	for _, fn := range p.Function {
 		names = append(names, fn.SystemName)
 	}

 	// Update profile with demangled names.
 	demangled, err := d(names)
 	if err != nil {
 		return err
 	}
 	for _, fn := range p.Function {
 		if dd, ok := demangled[fn.SystemName]; ok {
 			fn.Name = dd
 		}
 	}
 	return nil
 }

 // Empty returns true if the profile contains no samples.
 func (p *Profile) Empty() bool {
 	return len(p.Sample) == 0
 }
	// Copyright 2014 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Package profile provides a representation of profile.proto and
	// methods to encode/decode profiles in this format.
	//
	// This package is only for testing runtime/pprof.
	// It is not used by production Go programs.
	package profile

	import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"io/ioutil"
	"regexp"
	"strings"
	"time"
	)

	// Profile is an in-memory representation of profile.proto.
	type Profile struct {
	SampleType []*ValueType
	Sample []*Sample
	Mapping []*Mapping
	Location []*Location
	Function []*Function

	DropFrames string
	KeepFrames string

	TimeNanos int64
	DurationNanos int64
	PeriodType *ValueType
	Period int64

	dropFramesX int64
	keepFramesX int64
	stringTable []string
	}

	// ValueType corresponds to Profile.ValueType
	type ValueType struct {
	Type string // cpu, wall, inuse_space, etc
	Unit string // seconds, nanoseconds, bytes, etc

	typeX int64
	unitX int64
	}

	// Sample corresponds to Profile.Sample
	type Sample struct {
	Location []*Location
	Value []int64
	Label map[string][]string
	NumLabel map[string][]int64

	locationIDX []uint64
	labelX []Label
	}

	// Label corresponds to Profile.Label
	type Label struct {
	keyX int64
	// Exactly one of the two following values must be set
	strX int64
	numX int64 // Integer value for this label
	}

	// Mapping corresponds to Profile.Mapping
	type Mapping struct {
	ID uint64
	Start uint64
	Limit uint64
	Offset uint64
	File string
	BuildID string
	HasFunctions bool
	HasFilenames bool
	HasLineNumbers bool
	HasInlineFrames bool

	fileX int64
	buildIDX int64
	}

	// Location corresponds to Profile.Location
	type Location struct {
	ID uint64
	Mapping *Mapping
	Address uint64
	Line []Line

	mappingIDX uint64
	}

	// Line corresponds to Profile.Line
	type Line struct {
	Function *Function
	Line int64

	functionIDX uint64
	}

	// Function corresponds to Profile.Function
	type Function struct {
	ID uint64
	Name string
	SystemName string
	Filename string
	StartLine int64

	nameX int64
	systemNameX int64
	filenameX int64
	}

	// Parse parses a profile and checks for its validity. The input
	// may be a gzip-compressed encoded protobuf or one of many legacy
	// profile formats which may be unsupported in the future.
	func Parse(r io.Reader) (*Profile, error) {
	orig, err := ioutil.ReadAll(r)
	if err != nil {
	return nil, err
	}

	var p *Profile
	if len(orig) >= 2 && orig[0] == 0x1f && orig[1] == 0x8b {
	gz, err := gzip.NewReader(bytes.NewBuffer(orig))
	if err != nil {
	return nil, fmt.Errorf("decompressing profile: %v", err)
	}
	data, err := ioutil.ReadAll(gz)
	if err != nil {
	return nil, fmt.Errorf("decompressing profile: %v", err)
	}
	orig = data
	}
	if p, err = parseUncompressed(orig); err != nil {
	if p, err = parseLegacy(orig); err != nil {
	return nil, fmt.Errorf("parsing profile: %v", err)
	}
	}

	if err := p.CheckValid(); err != nil {
	return nil, fmt.Errorf("malformed profile: %v", err)
	}
	return p, nil
	}

	var errUnrecognized = fmt.Errorf("unrecognized profile format")
	var errMalformed = fmt.Errorf("malformed profile format")

	func parseLegacy(data []byte) (*Profile, error) {
	parsers := []func([]byte) (*Profile, error){
	parseCPU,
	parseHeap,
	parseGoCount, // goroutine, threadcreate
	parseThread,
	parseContention,
	}

	for _, parser := range parsers {
	p, err := parser(data)
	if err == nil {
	p.setMain()
	p.addLegacyFrameInfo()
	return p, nil
	}
	if err != errUnrecognized {
	return nil, err
	}
	}
	return nil, errUnrecognized
	}

	func parseUncompressed(data []byte) (*Profile, error) {
	p := &Profile{}
	if err := unmarshal(data, p); err != nil {
	return nil, err
	}

	if err := p.postDecode(); err != nil {
	return nil, err
	}

	return p, nil
	}

	var libRx = regexp.MustCompile(`([.]so$\|[.]so[._][0-9]+)`)

	// setMain scans Mapping entries and guesses which entry is main
	// because legacy profiles don't obey the convention of putting main
	// first.
	func (p *Profile) setMain() {
	for i := 0; i < len(p.Mapping); i++ {
	file := strings.TrimSpace(strings.Replace(p.Mapping[i].File, "(deleted)", "", -1))
	if len(file) == 0 {
	continue
	}
	if len(libRx.FindStringSubmatch(file)) > 0 {
	continue
	}
	if strings.HasPrefix(file, "[") {
	continue
	}
	// Swap what we guess is main to position 0.
	tmp := p.Mapping[i]
	p.Mapping[i] = p.Mapping[0]
	p.Mapping[0] = tmp
	break
	}
	}

	// Write writes the profile as a gzip-compressed marshaled protobuf.
	func (p *Profile) Write(w io.Writer) error {
	p.preEncode()
	b := marshal(p)
	zw := gzip.NewWriter(w)
	defer zw.Close()
	_, err := zw.Write(b)
	return err
	}

	// CheckValid tests whether the profile is valid. Checks include, but are
	// not limited to:
	// - len(Profile.Sample[n].value) == len(Profile.value_unit)
	// - Sample.id has a corresponding Profile.Location
	func (p *Profile) CheckValid() error {
	// Check that sample values are consistent
	sampleLen := len(p.SampleType)
	if sampleLen == 0 && len(p.Sample) != 0 {
	return fmt.Errorf("missing sample type information")
	}
	for _, s := range p.Sample {
	if len(s.Value) != sampleLen {
	return fmt.Errorf("mismatch: sample has: %d values vs. %d types", len(s.Value), len(p.SampleType))
	}
	}

	// Check that all mappings/locations/functions are in the tables
	// Check that there are no duplicate ids
	mappings := make(map[uint64]*Mapping, len(p.Mapping))
	for _, m := range p.Mapping {
	if m.ID == 0 {
	return fmt.Errorf("found mapping with reserved ID=0")
	}
	if mappings[m.ID] != nil {
	return fmt.Errorf("multiple mappings with same id: %d", m.ID)
	}
	mappings[m.ID] = m
	}
	functions := make(map[uint64]*Function, len(p.Function))
	for _, f := range p.Function {
	if f.ID == 0 {
	return fmt.Errorf("found function with reserved ID=0")
	}
	if functions[f.ID] != nil {
	return fmt.Errorf("multiple functions with same id: %d", f.ID)
	}
	functions[f.ID] = f
	}
	locations := make(map[uint64]*Location, len(p.Location))
	for _, l := range p.Location {
	if l.ID == 0 {
	return fmt.Errorf("found location with reserved id=0")
	}
	if locations[l.ID] != nil {
	return fmt.Errorf("multiple locations with same id: %d", l.ID)
	}
	locations[l.ID] = l
	if m := l.Mapping; m != nil {
	if m.ID == 0 \|\| mappings[m.ID] != m {
	return fmt.Errorf("inconsistent mapping %p: %d", m, m.ID)
	}
	}
	for _, ln := range l.Line {
	if f := ln.Function; f != nil {
	if f.ID == 0 \|\| functions[f.ID] != f {
	return fmt.Errorf("inconsistent function %p: %d", f, f.ID)
	}
	}
	}
	}
	return nil
	}

	// Aggregate merges the locations in the profile into equivalence
	// classes preserving the request attributes. It also updates the
	// samples to point to the merged locations.
	func (p *Profile) Aggregate(inlineFrame, function, filename, linenumber, address bool) error {
	for _, m := range p.Mapping {
	m.HasInlineFrames = m.HasInlineFrames && inlineFrame
	m.HasFunctions = m.HasFunctions && function
	m.HasFilenames = m.HasFilenames && filename
	m.HasLineNumbers = m.HasLineNumbers && linenumber
	}

	// Aggregate functions
	if !function \|\| !filename {
	for _, f := range p.Function {
	if !function {
	f.Name = ""
	f.SystemName = ""
	}
	if !filename {
	f.Filename = ""
	}
	}
	}

	// Aggregate locations
	if !inlineFrame \|\| !address \|\| !linenumber {
	for _, l := range p.Location {
	if !inlineFrame && len(l.Line) > 1 {
	l.Line = l.Line[len(l.Line)-1:]
	}
	if !linenumber {
	for i := range l.Line {
	l.Line[i].Line = 0
	}
	}
	if !address {
	l.Address = 0
	}
	}
	}

	return p.CheckValid()
	}

	// Print dumps a text representation of a profile. Intended mainly
	// for debugging purposes.
	func (p *Profile) String() string {

	ss := make([]string, 0, len(p.Sample)+len(p.Mapping)+len(p.Location))
	if pt := p.PeriodType; pt != nil {
	ss = append(ss, fmt.Sprintf("PeriodType: %s %s", pt.Type, pt.Unit))
	}
	ss = append(ss, fmt.Sprintf("Period: %d", p.Period))
	if p.TimeNanos != 0 {
	ss = append(ss, fmt.Sprintf("Time: %v", time.Unix(0, p.TimeNanos)))
	}
	if p.DurationNanos != 0 {
	ss = append(ss, fmt.Sprintf("Duration: %v", time.Duration(p.DurationNanos)))
	}

	ss = append(ss, "Samples:")
	var sh1 string
	for _, s := range p.SampleType {
	sh1 = sh1 + fmt.Sprintf("%s/%s ", s.Type, s.Unit)
	}
	ss = append(ss, strings.TrimSpace(sh1))
	for _, s := range p.Sample {
	var sv string
	for _, v := range s.Value {
	sv = fmt.Sprintf("%s %10d", sv, v)
	}
	sv = sv + ": "
	for _, l := range s.Location {
	sv = sv + fmt.Sprintf("%d ", l.ID)
	}
	ss = append(ss, sv)
	const labelHeader = " "
	if len(s.Label) > 0 {
	ls := labelHeader
	for k, v := range s.Label {
	ls = ls + fmt.Sprintf("%s:%v ", k, v)
	}
	ss = append(ss, ls)
	}
	if len(s.NumLabel) > 0 {
	ls := labelHeader
	for k, v := range s.NumLabel {
	ls = ls + fmt.Sprintf("%s:%v ", k, v)
	}
	ss = append(ss, ls)
	}
	}

	ss = append(ss, "Locations")
	for _, l := range p.Location {
	locStr := fmt.Sprintf("%6d: %#x ", l.ID, l.Address)
	if m := l.Mapping; m != nil {
	locStr = locStr + fmt.Sprintf("M=%d ", m.ID)
	}
	if len(l.Line) == 0 {
	ss = append(ss, locStr)
	}
	for li := range l.Line {
	lnStr := "??"
	if fn := l.Line[li].Function; fn != nil {
	lnStr = fmt.Sprintf("%s %s:%d s=%d",
	fn.Name,
	fn.Filename,
	l.Line[li].Line,
	fn.StartLine)
	if fn.Name != fn.SystemName {
	lnStr = lnStr + "(" + fn.SystemName + ")"
	}
	}
	ss = append(ss, locStr+lnStr)
	// Do not print location details past the first line
	locStr = " "
	}
	}

	ss = append(ss, "Mappings")
	for _, m := range p.Mapping {
	bits := ""
	if m.HasFunctions {
	bits = bits + "[FN]"
	}
	if m.HasFilenames {
	bits = bits + "[FL]"
	}
	if m.HasLineNumbers {
	bits = bits + "[LN]"
	}
	if m.HasInlineFrames {
	bits = bits + "[IN]"
	}
	ss = append(ss, fmt.Sprintf("%d: %#x/%#x/%#x %s %s %s",
	m.ID,
	m.Start, m.Limit, m.Offset,
	m.File,
	m.BuildID,
	bits))
	}

	return strings.Join(ss, "\n") + "\n"
	}

	// Merge adds profile p adjusted by ratio r into profile p. Profiles
	// must be compatible (same Type and SampleType).
	// TODO(rsilvera): consider normalizing the profiles based on the
	// total samples collected.
	func (p Profile) Merge(pb Profile, r float64) error {
	if err := p.Compatible(pb); err != nil {
	return err
	}

	pb = pb.Copy()

	// Keep the largest of the two periods.
	if pb.Period > p.Period {
	p.Period = pb.Period
	}

	p.DurationNanos += pb.DurationNanos

	p.Mapping = append(p.Mapping, pb.Mapping...)
	for i, m := range p.Mapping {
	m.ID = uint64(i + 1)
	}
	p.Location = append(p.Location, pb.Location...)
	for i, l := range p.Location {
	l.ID = uint64(i + 1)
	}
	p.Function = append(p.Function, pb.Function...)
	for i, f := range p.Function {
	f.ID = uint64(i + 1)
	}

	if r != 1.0 {
	for _, s := range pb.Sample {
	for i, v := range s.Value {
	s.Value[i] = int64((float64(v) * r))
	}
	}
	}
	p.Sample = append(p.Sample, pb.Sample...)
	return p.CheckValid()
	}

	// Compatible determines if two profiles can be compared/merged.
	// returns nil if the profiles are compatible; otherwise an error with
	// details on the incompatibility.
	func (p Profile) Compatible(pb Profile) error {
	if !compatibleValueTypes(p.PeriodType, pb.PeriodType) {
	return fmt.Errorf("incompatible period types %v and %v", p.PeriodType, pb.PeriodType)
	}

	if len(p.SampleType) != len(pb.SampleType) {
	return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
	}

	for i := range p.SampleType {
	if !compatibleValueTypes(p.SampleType[i], pb.SampleType[i]) {
	return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
	}
	}

	return nil
	}

	// HasFunctions determines if all locations in this profile have
	// symbolized function information.
	func (p *Profile) HasFunctions() bool {
	for _, l := range p.Location {
	if l.Mapping == nil \|\| !l.Mapping.HasFunctions {
	return false
	}
	}
	return true
	}

	// HasFileLines determines if all locations in this profile have
	// symbolized file and line number information.
	func (p *Profile) HasFileLines() bool {
	for _, l := range p.Location {
	if l.Mapping == nil \|\| (!l.Mapping.HasFilenames \|\| !l.Mapping.HasLineNumbers) {
	return false
	}
	}
	return true
	}

	func compatibleValueTypes(v1, v2 *ValueType) bool {
	if v1 == nil \|\| v2 == nil {
	return true // No grounds to disqualify.
	}
	return v1.Type == v2.Type && v1.Unit == v2.Unit
	}

	// Copy makes a fully independent copy of a profile.
	func (p Profile) Copy() Profile {
	p.preEncode()
	b := marshal(p)

	pp := &Profile{}
	if err := unmarshal(b, pp); err != nil {
	panic(err)
	}
	if err := pp.postDecode(); err != nil {
	panic(err)
	}

	return pp
	}

	// Demangler maps symbol names to a human-readable form. This may
	// include C++ demangling and additional simplification. Names that
	// are not demangled may be missing from the resulting map.
	type Demangler func(name []string) (map[string]string, error)

	// Demangle attempts to demangle and optionally simplify any function
	// names referenced in the profile. It works on a best-effort basis:
	// it will silently preserve the original names in case of any errors.
	func (p *Profile) Demangle(d Demangler) error {
	// Collect names to demangle.
	var names []string
	for _, fn := range p.Function {
	names = append(names, fn.SystemName)
	}

	// Update profile with demangled names.
	demangled, err := d(names)
	if err != nil {
	return err
	}
	for _, fn := range p.Function {
	if dd, ok := demangled[fn.SystemName]; ok {
	fn.Name = dd
	}
	}
	return nil
	}

	// Empty returns true if the profile contains no samples.
	func (p *Profile) Empty() bool {
	return len(p.Sample) == 0
	}