...
Run Format

Source file src/runtime/pprof/internal/profile/profile.go

Documentation: runtime/pprof/internal/profile

  // 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
  }
  

View as plain text