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

     1	// Copyright 2014 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package profile
     6	
     7	import (
     8		"errors"
     9		"fmt"
    10		"sort"
    11	)
    12	
    13	func (p *Profile) decoder() []decoder {
    14		return profileDecoder
    15	}
    16	
    17	// preEncode populates the unexported fields to be used by encode
    18	// (with suffix X) from the corresponding exported fields. The
    19	// exported fields are cleared up to facilitate testing.
    20	func (p *Profile) preEncode() {
    21		strings := make(map[string]int)
    22		addString(strings, "")
    23	
    24		for _, st := range p.SampleType {
    25			st.typeX = addString(strings, st.Type)
    26			st.unitX = addString(strings, st.Unit)
    27		}
    28	
    29		for _, s := range p.Sample {
    30			s.labelX = nil
    31			var keys []string
    32			for k := range s.Label {
    33				keys = append(keys, k)
    34			}
    35			sort.Strings(keys)
    36			for _, k := range keys {
    37				vs := s.Label[k]
    38				for _, v := range vs {
    39					s.labelX = append(s.labelX,
    40						Label{
    41							keyX: addString(strings, k),
    42							strX: addString(strings, v),
    43						},
    44					)
    45				}
    46			}
    47			var numKeys []string
    48			for k := range s.NumLabel {
    49				numKeys = append(numKeys, k)
    50			}
    51			sort.Strings(numKeys)
    52			for _, k := range numKeys {
    53				vs := s.NumLabel[k]
    54				for _, v := range vs {
    55					s.labelX = append(s.labelX,
    56						Label{
    57							keyX: addString(strings, k),
    58							numX: v,
    59						},
    60					)
    61				}
    62			}
    63			s.locationIDX = nil
    64			for _, l := range s.Location {
    65				s.locationIDX = append(s.locationIDX, l.ID)
    66			}
    67		}
    68	
    69		for _, m := range p.Mapping {
    70			m.fileX = addString(strings, m.File)
    71			m.buildIDX = addString(strings, m.BuildID)
    72		}
    73	
    74		for _, l := range p.Location {
    75			for i, ln := range l.Line {
    76				if ln.Function != nil {
    77					l.Line[i].functionIDX = ln.Function.ID
    78				} else {
    79					l.Line[i].functionIDX = 0
    80				}
    81			}
    82			if l.Mapping != nil {
    83				l.mappingIDX = l.Mapping.ID
    84			} else {
    85				l.mappingIDX = 0
    86			}
    87		}
    88		for _, f := range p.Function {
    89			f.nameX = addString(strings, f.Name)
    90			f.systemNameX = addString(strings, f.SystemName)
    91			f.filenameX = addString(strings, f.Filename)
    92		}
    93	
    94		p.dropFramesX = addString(strings, p.DropFrames)
    95		p.keepFramesX = addString(strings, p.KeepFrames)
    96	
    97		if pt := p.PeriodType; pt != nil {
    98			pt.typeX = addString(strings, pt.Type)
    99			pt.unitX = addString(strings, pt.Unit)
   100		}
   101	
   102		p.stringTable = make([]string, len(strings))
   103		for s, i := range strings {
   104			p.stringTable[i] = s
   105		}
   106	}
   107	
   108	func (p *Profile) encode(b *buffer) {
   109		for _, x := range p.SampleType {
   110			encodeMessage(b, 1, x)
   111		}
   112		for _, x := range p.Sample {
   113			encodeMessage(b, 2, x)
   114		}
   115		for _, x := range p.Mapping {
   116			encodeMessage(b, 3, x)
   117		}
   118		for _, x := range p.Location {
   119			encodeMessage(b, 4, x)
   120		}
   121		for _, x := range p.Function {
   122			encodeMessage(b, 5, x)
   123		}
   124		encodeStrings(b, 6, p.stringTable)
   125		encodeInt64Opt(b, 7, p.dropFramesX)
   126		encodeInt64Opt(b, 8, p.keepFramesX)
   127		encodeInt64Opt(b, 9, p.TimeNanos)
   128		encodeInt64Opt(b, 10, p.DurationNanos)
   129		if pt := p.PeriodType; pt != nil && (pt.typeX != 0 || pt.unitX != 0) {
   130			encodeMessage(b, 11, p.PeriodType)
   131		}
   132		encodeInt64Opt(b, 12, p.Period)
   133	}
   134	
   135	var profileDecoder = []decoder{
   136		nil, // 0
   137		// repeated ValueType sample_type = 1
   138		func(b *buffer, m message) error {
   139			x := new(ValueType)
   140			pp := m.(*Profile)
   141			pp.SampleType = append(pp.SampleType, x)
   142			return decodeMessage(b, x)
   143		},
   144		// repeated Sample sample = 2
   145		func(b *buffer, m message) error {
   146			x := new(Sample)
   147			pp := m.(*Profile)
   148			pp.Sample = append(pp.Sample, x)
   149			return decodeMessage(b, x)
   150		},
   151		// repeated Mapping mapping = 3
   152		func(b *buffer, m message) error {
   153			x := new(Mapping)
   154			pp := m.(*Profile)
   155			pp.Mapping = append(pp.Mapping, x)
   156			return decodeMessage(b, x)
   157		},
   158		// repeated Location location = 4
   159		func(b *buffer, m message) error {
   160			x := new(Location)
   161			pp := m.(*Profile)
   162			pp.Location = append(pp.Location, x)
   163			return decodeMessage(b, x)
   164		},
   165		// repeated Function function = 5
   166		func(b *buffer, m message) error {
   167			x := new(Function)
   168			pp := m.(*Profile)
   169			pp.Function = append(pp.Function, x)
   170			return decodeMessage(b, x)
   171		},
   172		// repeated string string_table = 6
   173		func(b *buffer, m message) error {
   174			err := decodeStrings(b, &m.(*Profile).stringTable)
   175			if err != nil {
   176				return err
   177			}
   178			if *&m.(*Profile).stringTable[0] != "" {
   179				return errors.New("string_table[0] must be ''")
   180			}
   181			return nil
   182		},
   183		// repeated int64 drop_frames = 7
   184		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).dropFramesX) },
   185		// repeated int64 keep_frames = 8
   186		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).keepFramesX) },
   187		// repeated int64 time_nanos = 9
   188		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).TimeNanos) },
   189		// repeated int64 duration_nanos = 10
   190		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).DurationNanos) },
   191		// optional string period_type = 11
   192		func(b *buffer, m message) error {
   193			x := new(ValueType)
   194			pp := m.(*Profile)
   195			pp.PeriodType = x
   196			return decodeMessage(b, x)
   197		},
   198		// repeated int64 period = 12
   199		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).Period) },
   200		// repeated int64 comment = 13
   201		func(b *buffer, m message) error { return decodeInt64s(b, &m.(*Profile).commentX) },
   202		// int64 defaultSampleType = 14
   203		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).defaultSampleTypeX) },
   204	}
   205	
   206	// postDecode takes the unexported fields populated by decode (with
   207	// suffix X) and populates the corresponding exported fields.
   208	// The unexported fields are cleared up to facilitate testing.
   209	func (p *Profile) postDecode() error {
   210		var err error
   211	
   212		mappings := make(map[uint64]*Mapping)
   213		for _, m := range p.Mapping {
   214			m.File, err = getString(p.stringTable, &m.fileX, err)
   215			m.BuildID, err = getString(p.stringTable, &m.buildIDX, err)
   216			mappings[m.ID] = m
   217		}
   218	
   219		functions := make(map[uint64]*Function)
   220		for _, f := range p.Function {
   221			f.Name, err = getString(p.stringTable, &f.nameX, err)
   222			f.SystemName, err = getString(p.stringTable, &f.systemNameX, err)
   223			f.Filename, err = getString(p.stringTable, &f.filenameX, err)
   224			functions[f.ID] = f
   225		}
   226	
   227		locations := make(map[uint64]*Location)
   228		for _, l := range p.Location {
   229			l.Mapping = mappings[l.mappingIDX]
   230			l.mappingIDX = 0
   231			for i, ln := range l.Line {
   232				if id := ln.functionIDX; id != 0 {
   233					l.Line[i].Function = functions[id]
   234					if l.Line[i].Function == nil {
   235						return fmt.Errorf("Function ID %d not found", id)
   236					}
   237					l.Line[i].functionIDX = 0
   238				}
   239			}
   240			locations[l.ID] = l
   241		}
   242	
   243		for _, st := range p.SampleType {
   244			st.Type, err = getString(p.stringTable, &st.typeX, err)
   245			st.Unit, err = getString(p.stringTable, &st.unitX, err)
   246		}
   247	
   248		for _, s := range p.Sample {
   249			labels := make(map[string][]string)
   250			numLabels := make(map[string][]int64)
   251			for _, l := range s.labelX {
   252				var key, value string
   253				key, err = getString(p.stringTable, &l.keyX, err)
   254				if l.strX != 0 {
   255					value, err = getString(p.stringTable, &l.strX, err)
   256					labels[key] = append(labels[key], value)
   257				} else {
   258					numLabels[key] = append(numLabels[key], l.numX)
   259				}
   260			}
   261			if len(labels) > 0 {
   262				s.Label = labels
   263			}
   264			if len(numLabels) > 0 {
   265				s.NumLabel = numLabels
   266			}
   267			s.Location = nil
   268			for _, lid := range s.locationIDX {
   269				s.Location = append(s.Location, locations[lid])
   270			}
   271			s.locationIDX = nil
   272		}
   273	
   274		p.DropFrames, err = getString(p.stringTable, &p.dropFramesX, err)
   275		p.KeepFrames, err = getString(p.stringTable, &p.keepFramesX, err)
   276	
   277		if pt := p.PeriodType; pt == nil {
   278			p.PeriodType = &ValueType{}
   279		}
   280	
   281		if pt := p.PeriodType; pt != nil {
   282			pt.Type, err = getString(p.stringTable, &pt.typeX, err)
   283			pt.Unit, err = getString(p.stringTable, &pt.unitX, err)
   284		}
   285		for _, i := range p.commentX {
   286			var c string
   287			c, err = getString(p.stringTable, &i, err)
   288			p.Comments = append(p.Comments, c)
   289		}
   290	
   291		p.commentX = nil
   292		p.DefaultSampleType, err = getString(p.stringTable, &p.defaultSampleTypeX, err)
   293		p.stringTable = nil
   294		return nil
   295	}
   296	
   297	func (p *ValueType) decoder() []decoder {
   298		return valueTypeDecoder
   299	}
   300	
   301	func (p *ValueType) encode(b *buffer) {
   302		encodeInt64Opt(b, 1, p.typeX)
   303		encodeInt64Opt(b, 2, p.unitX)
   304	}
   305	
   306	var valueTypeDecoder = []decoder{
   307		nil, // 0
   308		// optional int64 type = 1
   309		func(b *buffer, m message) error { return decodeInt64(b, &m.(*ValueType).typeX) },
   310		// optional int64 unit = 2
   311		func(b *buffer, m message) error { return decodeInt64(b, &m.(*ValueType).unitX) },
   312	}
   313	
   314	func (p *Sample) decoder() []decoder {
   315		return sampleDecoder
   316	}
   317	
   318	func (p *Sample) encode(b *buffer) {
   319		encodeUint64s(b, 1, p.locationIDX)
   320		for _, x := range p.Value {
   321			encodeInt64(b, 2, x)
   322		}
   323		for _, x := range p.labelX {
   324			encodeMessage(b, 3, x)
   325		}
   326	}
   327	
   328	var sampleDecoder = []decoder{
   329		nil, // 0
   330		// repeated uint64 location = 1
   331		func(b *buffer, m message) error { return decodeUint64s(b, &m.(*Sample).locationIDX) },
   332		// repeated int64 value = 2
   333		func(b *buffer, m message) error { return decodeInt64s(b, &m.(*Sample).Value) },
   334		// repeated Label label = 3
   335		func(b *buffer, m message) error {
   336			s := m.(*Sample)
   337			n := len(s.labelX)
   338			s.labelX = append(s.labelX, Label{})
   339			return decodeMessage(b, &s.labelX[n])
   340		},
   341	}
   342	
   343	func (p Label) decoder() []decoder {
   344		return labelDecoder
   345	}
   346	
   347	func (p Label) encode(b *buffer) {
   348		encodeInt64Opt(b, 1, p.keyX)
   349		encodeInt64Opt(b, 2, p.strX)
   350		encodeInt64Opt(b, 3, p.numX)
   351	}
   352	
   353	var labelDecoder = []decoder{
   354		nil, // 0
   355		// optional int64 key = 1
   356		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Label).keyX) },
   357		// optional int64 str = 2
   358		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Label).strX) },
   359		// optional int64 num = 3
   360		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Label).numX) },
   361	}
   362	
   363	func (p *Mapping) decoder() []decoder {
   364		return mappingDecoder
   365	}
   366	
   367	func (p *Mapping) encode(b *buffer) {
   368		encodeUint64Opt(b, 1, p.ID)
   369		encodeUint64Opt(b, 2, p.Start)
   370		encodeUint64Opt(b, 3, p.Limit)
   371		encodeUint64Opt(b, 4, p.Offset)
   372		encodeInt64Opt(b, 5, p.fileX)
   373		encodeInt64Opt(b, 6, p.buildIDX)
   374		encodeBoolOpt(b, 7, p.HasFunctions)
   375		encodeBoolOpt(b, 8, p.HasFilenames)
   376		encodeBoolOpt(b, 9, p.HasLineNumbers)
   377		encodeBoolOpt(b, 10, p.HasInlineFrames)
   378	}
   379	
   380	var mappingDecoder = []decoder{
   381		nil, // 0
   382		func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).ID) },            // optional uint64 id = 1
   383		func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).Start) },         // optional uint64 memory_offset = 2
   384		func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).Limit) },         // optional uint64 memory_limit = 3
   385		func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).Offset) },        // optional uint64 file_offset = 4
   386		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Mapping).fileX) },          // optional int64 filename = 5
   387		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Mapping).buildIDX) },       // optional int64 build_id = 6
   388		func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasFunctions) },    // optional bool has_functions = 7
   389		func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasFilenames) },    // optional bool has_filenames = 8
   390		func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasLineNumbers) },  // optional bool has_line_numbers = 9
   391		func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasInlineFrames) }, // optional bool has_inline_frames = 10
   392	}
   393	
   394	func (p *Location) decoder() []decoder {
   395		return locationDecoder
   396	}
   397	
   398	func (p *Location) encode(b *buffer) {
   399		encodeUint64Opt(b, 1, p.ID)
   400		encodeUint64Opt(b, 2, p.mappingIDX)
   401		encodeUint64Opt(b, 3, p.Address)
   402		for i := range p.Line {
   403			encodeMessage(b, 4, &p.Line[i])
   404		}
   405	}
   406	
   407	var locationDecoder = []decoder{
   408		nil, // 0
   409		func(b *buffer, m message) error { return decodeUint64(b, &m.(*Location).ID) },         // optional uint64 id = 1;
   410		func(b *buffer, m message) error { return decodeUint64(b, &m.(*Location).mappingIDX) }, // optional uint64 mapping_id = 2;
   411		func(b *buffer, m message) error { return decodeUint64(b, &m.(*Location).Address) },    // optional uint64 address = 3;
   412		func(b *buffer, m message) error { // repeated Line line = 4
   413			pp := m.(*Location)
   414			n := len(pp.Line)
   415			pp.Line = append(pp.Line, Line{})
   416			return decodeMessage(b, &pp.Line[n])
   417		},
   418	}
   419	
   420	func (p *Line) decoder() []decoder {
   421		return lineDecoder
   422	}
   423	
   424	func (p *Line) encode(b *buffer) {
   425		encodeUint64Opt(b, 1, p.functionIDX)
   426		encodeInt64Opt(b, 2, p.Line)
   427	}
   428	
   429	var lineDecoder = []decoder{
   430		nil, // 0
   431		// optional uint64 function_id = 1
   432		func(b *buffer, m message) error { return decodeUint64(b, &m.(*Line).functionIDX) },
   433		// optional int64 line = 2
   434		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Line).Line) },
   435	}
   436	
   437	func (p *Function) decoder() []decoder {
   438		return functionDecoder
   439	}
   440	
   441	func (p *Function) encode(b *buffer) {
   442		encodeUint64Opt(b, 1, p.ID)
   443		encodeInt64Opt(b, 2, p.nameX)
   444		encodeInt64Opt(b, 3, p.systemNameX)
   445		encodeInt64Opt(b, 4, p.filenameX)
   446		encodeInt64Opt(b, 5, p.StartLine)
   447	}
   448	
   449	var functionDecoder = []decoder{
   450		nil, // 0
   451		// optional uint64 id = 1
   452		func(b *buffer, m message) error { return decodeUint64(b, &m.(*Function).ID) },
   453		// optional int64 function_name = 2
   454		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).nameX) },
   455		// optional int64 function_system_name = 3
   456		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).systemNameX) },
   457		// repeated int64 filename = 4
   458		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).filenameX) },
   459		// optional int64 start_line = 5
   460		func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).StartLine) },
   461	}
   462	
   463	func addString(strings map[string]int, s string) int64 {
   464		i, ok := strings[s]
   465		if !ok {
   466			i = len(strings)
   467			strings[s] = i
   468		}
   469		return int64(i)
   470	}
   471	
   472	func getString(strings []string, strng *int64, err error) (string, error) {
   473		if err != nil {
   474			return "", err
   475		}
   476		s := int(*strng)
   477		if s < 0 || s >= len(strings) {
   478			return "", errMalformed
   479		}
   480		*strng = 0
   481		return strings[s], nil
   482	}
   483	

View as plain text