encode.go

     1  // Copyright 2014 Google Inc. All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package profile
    16  
    17  import (
    18  	"errors"
    19  	"sort"
    20  )
    21  
    22  func (p *Profile) decoder() []decoder {
    23  	return profileDecoder
    24  }
    25  
    26  // preEncode populates the unexported fields to be used by encode
    27  // (with suffix X) from the corresponding exported fields. The
    28  // exported fields are cleared up to facilitate testing.
    29  func (p *Profile) preEncode() {
    30  	strings := make(map[string]int)
    31  	addString(strings, "")
    32  
    33  	for _, st := range p.SampleType {
    34  		st.typeX = addString(strings, st.Type)
    35  		st.unitX = addString(strings, st.Unit)
    36  	}
    37  
    38  	for _, s := range p.Sample {
    39  		s.labelX = nil
    40  		var keys []string
    41  		for k := range s.Label {
    42  			keys = append(keys, k)
    43  		}
    44  		sort.Strings(keys)
    45  		for _, k := range keys {
    46  			vs := s.Label[k]
    47  			for _, v := range vs {
    48  				s.labelX = append(s.labelX,
    49  					label{
    50  						keyX: addString(strings, k),
    51  						strX: addString(strings, v),
    52  					},
    53  				)
    54  			}
    55  		}
    56  		var numKeys []string
    57  		for k := range s.NumLabel {
    58  			numKeys = append(numKeys, k)
    59  		}
    60  		sort.Strings(numKeys)
    61  		for _, k := range numKeys {
    62  			keyX := addString(strings, k)
    63  			vs := s.NumLabel[k]
    64  			units := s.NumUnit[k]
    65  			for i, v := range vs {
    66  				var unitX int64
    67  				if len(units) != 0 {
    68  					unitX = addString(strings, units[i])
    69  				}
    70  				s.labelX = append(s.labelX,
    71  					label{
    72  						keyX:  keyX,
    73  						numX:  v,
    74  						unitX: unitX,
    75  					},
    76  				)
    77  			}
    78  		}
    79  		s.locationIDX = make([]uint64, len(s.Location))
    80  		for i, loc := range s.Location {
    81  			s.locationIDX[i] = loc.ID
    82  		}
    83  	}
    84  
    85  	for _, m := range p.Mapping {
    86  		m.fileX = addString(strings, m.File)
    87  		m.buildIDX = addString(strings, m.BuildID)
    88  	}
    89  
    90  	for _, l := range p.Location {
    91  		for i, ln := range l.Line {
    92  			if ln.Function != nil {
    93  				l.Line[i].functionIDX = ln.Function.ID
    94  			} else {
    95  				l.Line[i].functionIDX = 0
    96  			}
    97  		}
    98  		if l.Mapping != nil {
    99  			l.mappingIDX = l.Mapping.ID
   100  		} else {
   101  			l.mappingIDX = 0
   102  		}
   103  	}
   104  	for _, f := range p.Function {
   105  		f.nameX = addString(strings, f.Name)
   106  		f.systemNameX = addString(strings, f.SystemName)
   107  		f.filenameX = addString(strings, f.Filename)
   108  	}
   109  
   110  	p.dropFramesX = addString(strings, p.DropFrames)
   111  	p.keepFramesX = addString(strings, p.KeepFrames)
   112  
   113  	if pt := p.PeriodType; pt != nil {
   114  		pt.typeX = addString(strings, pt.Type)
   115  		pt.unitX = addString(strings, pt.Unit)
   116  	}
   117  
   118  	p.commentX = nil
   119  	for _, c := range p.Comments {
   120  		p.commentX = append(p.commentX, addString(strings, c))
   121  	}
   122  
   123  	p.defaultSampleTypeX = addString(strings, p.DefaultSampleType)
   124  
   125  	p.stringTable = make([]string, len(strings))
   126  	for s, i := range strings {
   127  		p.stringTable[i] = s
   128  	}
   129  }
   130  
   131  func (p *Profile) encode(b *buffer) {
   132  	for _, x := range p.SampleType {
   133  		encodeMessage(b, 1, x)
   134  	}
   135  	for _, x := range p.Sample {
   136  		encodeMessage(b, 2, x)
   137  	}
   138  	for _, x := range p.Mapping {
   139  		encodeMessage(b, 3, x)
   140  	}
   141  	for _, x := range p.Location {
   142  		encodeMessage(b, 4, x)
   143  	}
   144  	for _, x := range p.Function {
   145  		encodeMessage(b, 5, x)
   146  	}
   147  	encodeStrings(b, 6, p.stringTable)
   148  	encodeInt64Opt(b, 7, p.dropFramesX)
   149  	encodeInt64Opt(b, 8, p.keepFramesX)
   150  	encodeInt64Opt(b, 9, p.TimeNanos)
   151  	encodeInt64Opt(b, 10, p.DurationNanos)
   152  	if pt := p.PeriodType; pt != nil && (pt.typeX != 0 || pt.unitX != 0) {
   153  		encodeMessage(b, 11, p.PeriodType)
   154  	}
   155  	encodeInt64Opt(b, 12, p.Period)
   156  	encodeInt64s(b, 13, p.commentX)
   157  	encodeInt64(b, 14, p.defaultSampleTypeX)
   158  }
   159  
   160  var profileDecoder = []decoder{
   161  	nil, // 0
   162  	// repeated ValueType sample_type = 1
   163  	func(b *buffer, m message) error {
   164  		x := new(ValueType)
   165  		pp := m.(*Profile)
   166  		pp.SampleType = append(pp.SampleType, x)
   167  		return decodeMessage(b, x)
   168  	},
   169  	// repeated Sample sample = 2
   170  	func(b *buffer, m message) error {
   171  		x := new(Sample)
   172  		pp := m.(*Profile)
   173  		pp.Sample = append(pp.Sample, x)
   174  		return decodeMessage(b, x)
   175  	},
   176  	// repeated Mapping mapping = 3
   177  	func(b *buffer, m message) error {
   178  		x := new(Mapping)
   179  		pp := m.(*Profile)
   180  		pp.Mapping = append(pp.Mapping, x)
   181  		return decodeMessage(b, x)
   182  	},
   183  	// repeated Location location = 4
   184  	func(b *buffer, m message) error {
   185  		x := new(Location)
   186  		x.Line = make([]Line, 0, 8) // Pre-allocate Line buffer
   187  		pp := m.(*Profile)
   188  		pp.Location = append(pp.Location, x)
   189  		err := decodeMessage(b, x)
   190  		var tmp []Line
   191  		x.Line = append(tmp, x.Line...) // Shrink to allocated size
   192  		return err
   193  	},
   194  	// repeated Function function = 5
   195  	func(b *buffer, m message) error {
   196  		x := new(Function)
   197  		pp := m.(*Profile)
   198  		pp.Function = append(pp.Function, x)
   199  		return decodeMessage(b, x)
   200  	},
   201  	// repeated string string_table = 6
   202  	func(b *buffer, m message) error {
   203  		err := decodeStrings(b, &m.(*Profile).stringTable)
   204  		if err != nil {
   205  			return err
   206  		}
   207  		if m.(*Profile).stringTable[0] != "" {
   208  			return errors.New("string_table[0] must be ''")
   209  		}
   210  		return nil
   211  	},
   212  	// int64 drop_frames = 7
   213  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).dropFramesX) },
   214  	// int64 keep_frames = 8
   215  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).keepFramesX) },
   216  	// int64 time_nanos = 9
   217  	func(b *buffer, m message) error {
   218  		if m.(*Profile).TimeNanos != 0 {
   219  			return errConcatProfile
   220  		}
   221  		return decodeInt64(b, &m.(*Profile).TimeNanos)
   222  	},
   223  	// int64 duration_nanos = 10
   224  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).DurationNanos) },
   225  	// ValueType period_type = 11
   226  	func(b *buffer, m message) error {
   227  		x := new(ValueType)
   228  		pp := m.(*Profile)
   229  		pp.PeriodType = x
   230  		return decodeMessage(b, x)
   231  	},
   232  	// int64 period = 12
   233  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).Period) },
   234  	// repeated int64 comment = 13
   235  	func(b *buffer, m message) error { return decodeInt64s(b, &m.(*Profile).commentX) },
   236  	// int64 defaultSampleType = 14
   237  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).defaultSampleTypeX) },
   238  }
   239  
   240  // postDecode takes the unexported fields populated by decode (with
   241  // suffix X) and populates the corresponding exported fields.
   242  // The unexported fields are cleared up to facilitate testing.
   243  func (p *Profile) postDecode() error {
   244  	var err error
   245  	mappings := make(map[uint64]*Mapping, len(p.Mapping))
   246  	mappingIds := make([]*Mapping, len(p.Mapping)+1)
   247  	for _, m := range p.Mapping {
   248  		m.File, err = getString(p.stringTable, &m.fileX, err)
   249  		m.BuildID, err = getString(p.stringTable, &m.buildIDX, err)
   250  		if m.ID < uint64(len(mappingIds)) {
   251  			mappingIds[m.ID] = m
   252  		} else {
   253  			mappings[m.ID] = m
   254  		}
   255  	}
   256  
   257  	functions := make(map[uint64]*Function, len(p.Function))
   258  	functionIds := make([]*Function, len(p.Function)+1)
   259  	for _, f := range p.Function {
   260  		f.Name, err = getString(p.stringTable, &f.nameX, err)
   261  		f.SystemName, err = getString(p.stringTable, &f.systemNameX, err)
   262  		f.Filename, err = getString(p.stringTable, &f.filenameX, err)
   263  		if f.ID < uint64(len(functionIds)) {
   264  			functionIds[f.ID] = f
   265  		} else {
   266  			functions[f.ID] = f
   267  		}
   268  	}
   269  
   270  	locations := make(map[uint64]*Location, len(p.Location))
   271  	locationIds := make([]*Location, len(p.Location)+1)
   272  	for _, l := range p.Location {
   273  		if id := l.mappingIDX; id < uint64(len(mappingIds)) {
   274  			l.Mapping = mappingIds[id]
   275  		} else {
   276  			l.Mapping = mappings[id]
   277  		}
   278  		l.mappingIDX = 0
   279  		for i, ln := range l.Line {
   280  			if id := ln.functionIDX; id != 0 {
   281  				l.Line[i].functionIDX = 0
   282  				if id < uint64(len(functionIds)) {
   283  					l.Line[i].Function = functionIds[id]
   284  				} else {
   285  					l.Line[i].Function = functions[id]
   286  				}
   287  			}
   288  		}
   289  		if l.ID < uint64(len(locationIds)) {
   290  			locationIds[l.ID] = l
   291  		} else {
   292  			locations[l.ID] = l
   293  		}
   294  	}
   295  
   296  	for _, st := range p.SampleType {
   297  		st.Type, err = getString(p.stringTable, &st.typeX, err)
   298  		st.Unit, err = getString(p.stringTable, &st.unitX, err)
   299  	}
   300  
   301  	for _, s := range p.Sample {
   302  		labels := make(map[string][]string, len(s.labelX))
   303  		numLabels := make(map[string][]int64, len(s.labelX))
   304  		numUnits := make(map[string][]string, len(s.labelX))
   305  		for _, l := range s.labelX {
   306  			var key, value string
   307  			key, err = getString(p.stringTable, &l.keyX, err)
   308  			if l.strX != 0 {
   309  				value, err = getString(p.stringTable, &l.strX, err)
   310  				labels[key] = append(labels[key], value)
   311  			} else if l.numX != 0 || l.unitX != 0 {
   312  				numValues := numLabels[key]
   313  				units := numUnits[key]
   314  				if l.unitX != 0 {
   315  					var unit string
   316  					unit, err = getString(p.stringTable, &l.unitX, err)
   317  					units = padStringArray(units, len(numValues))
   318  					numUnits[key] = append(units, unit)
   319  				}
   320  				numLabels[key] = append(numLabels[key], l.numX)
   321  			}
   322  		}
   323  		if len(labels) > 0 {
   324  			s.Label = labels
   325  		}
   326  		if len(numLabels) > 0 {
   327  			s.NumLabel = numLabels
   328  			for key, units := range numUnits {
   329  				if len(units) > 0 {
   330  					numUnits[key] = padStringArray(units, len(numLabels[key]))
   331  				}
   332  			}
   333  			s.NumUnit = numUnits
   334  		}
   335  		s.Location = make([]*Location, len(s.locationIDX))
   336  		for i, lid := range s.locationIDX {
   337  			if lid < uint64(len(locationIds)) {
   338  				s.Location[i] = locationIds[lid]
   339  			} else {
   340  				s.Location[i] = locations[lid]
   341  			}
   342  		}
   343  		s.locationIDX = nil
   344  	}
   345  
   346  	p.DropFrames, err = getString(p.stringTable, &p.dropFramesX, err)
   347  	p.KeepFrames, err = getString(p.stringTable, &p.keepFramesX, err)
   348  
   349  	if pt := p.PeriodType; pt == nil {
   350  		p.PeriodType = &ValueType{}
   351  	}
   352  
   353  	if pt := p.PeriodType; pt != nil {
   354  		pt.Type, err = getString(p.stringTable, &pt.typeX, err)
   355  		pt.Unit, err = getString(p.stringTable, &pt.unitX, err)
   356  	}
   357  
   358  	for _, i := range p.commentX {
   359  		var c string
   360  		c, err = getString(p.stringTable, &i, err)
   361  		p.Comments = append(p.Comments, c)
   362  	}
   363  
   364  	p.commentX = nil
   365  	p.DefaultSampleType, err = getString(p.stringTable, &p.defaultSampleTypeX, err)
   366  	p.stringTable = nil
   367  	return err
   368  }
   369  
   370  // padStringArray pads arr with enough empty strings to make arr
   371  // length l when arr's length is less than l.
   372  func padStringArray(arr []string, l int) []string {
   373  	if l <= len(arr) {
   374  		return arr
   375  	}
   376  	return append(arr, make([]string, l-len(arr))...)
   377  }
   378  
   379  func (p *ValueType) decoder() []decoder {
   380  	return valueTypeDecoder
   381  }
   382  
   383  func (p *ValueType) encode(b *buffer) {
   384  	encodeInt64Opt(b, 1, p.typeX)
   385  	encodeInt64Opt(b, 2, p.unitX)
   386  }
   387  
   388  var valueTypeDecoder = []decoder{
   389  	nil, // 0
   390  	// optional int64 type = 1
   391  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*ValueType).typeX) },
   392  	// optional int64 unit = 2
   393  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*ValueType).unitX) },
   394  }
   395  
   396  func (p *Sample) decoder() []decoder {
   397  	return sampleDecoder
   398  }
   399  
   400  func (p *Sample) encode(b *buffer) {
   401  	encodeUint64s(b, 1, p.locationIDX)
   402  	encodeInt64s(b, 2, p.Value)
   403  	for _, x := range p.labelX {
   404  		encodeMessage(b, 3, x)
   405  	}
   406  }
   407  
   408  var sampleDecoder = []decoder{
   409  	nil, // 0
   410  	// repeated uint64 location = 1
   411  	func(b *buffer, m message) error { return decodeUint64s(b, &m.(*Sample).locationIDX) },
   412  	// repeated int64 value = 2
   413  	func(b *buffer, m message) error { return decodeInt64s(b, &m.(*Sample).Value) },
   414  	// repeated Label label = 3
   415  	func(b *buffer, m message) error {
   416  		s := m.(*Sample)
   417  		n := len(s.labelX)
   418  		s.labelX = append(s.labelX, label{})
   419  		return decodeMessage(b, &s.labelX[n])
   420  	},
   421  }
   422  
   423  func (p label) decoder() []decoder {
   424  	return labelDecoder
   425  }
   426  
   427  func (p label) encode(b *buffer) {
   428  	encodeInt64Opt(b, 1, p.keyX)
   429  	encodeInt64Opt(b, 2, p.strX)
   430  	encodeInt64Opt(b, 3, p.numX)
   431  	encodeInt64Opt(b, 4, p.unitX)
   432  }
   433  
   434  var labelDecoder = []decoder{
   435  	nil, // 0
   436  	// optional int64 key = 1
   437  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*label).keyX) },
   438  	// optional int64 str = 2
   439  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*label).strX) },
   440  	// optional int64 num = 3
   441  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*label).numX) },
   442  	// optional int64 num = 4
   443  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*label).unitX) },
   444  }
   445  
   446  func (p *Mapping) decoder() []decoder {
   447  	return mappingDecoder
   448  }
   449  
   450  func (p *Mapping) encode(b *buffer) {
   451  	encodeUint64Opt(b, 1, p.ID)
   452  	encodeUint64Opt(b, 2, p.Start)
   453  	encodeUint64Opt(b, 3, p.Limit)
   454  	encodeUint64Opt(b, 4, p.Offset)
   455  	encodeInt64Opt(b, 5, p.fileX)
   456  	encodeInt64Opt(b, 6, p.buildIDX)
   457  	encodeBoolOpt(b, 7, p.HasFunctions)
   458  	encodeBoolOpt(b, 8, p.HasFilenames)
   459  	encodeBoolOpt(b, 9, p.HasLineNumbers)
   460  	encodeBoolOpt(b, 10, p.HasInlineFrames)
   461  }
   462  
   463  var mappingDecoder = []decoder{
   464  	nil, // 0
   465  	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).ID) },            // optional uint64 id = 1
   466  	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).Start) },         // optional uint64 memory_offset = 2
   467  	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).Limit) },         // optional uint64 memory_limit = 3
   468  	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).Offset) },        // optional uint64 file_offset = 4
   469  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Mapping).fileX) },          // optional int64 filename = 5
   470  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Mapping).buildIDX) },       // optional int64 build_id = 6
   471  	func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasFunctions) },    // optional bool has_functions = 7
   472  	func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasFilenames) },    // optional bool has_filenames = 8
   473  	func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasLineNumbers) },  // optional bool has_line_numbers = 9
   474  	func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasInlineFrames) }, // optional bool has_inline_frames = 10
   475  }
   476  
   477  func (p *Location) decoder() []decoder {
   478  	return locationDecoder
   479  }
   480  
   481  func (p *Location) encode(b *buffer) {
   482  	encodeUint64Opt(b, 1, p.ID)
   483  	encodeUint64Opt(b, 2, p.mappingIDX)
   484  	encodeUint64Opt(b, 3, p.Address)
   485  	for i := range p.Line {
   486  		encodeMessage(b, 4, &p.Line[i])
   487  	}
   488  	encodeBoolOpt(b, 5, p.IsFolded)
   489  }
   490  
   491  var locationDecoder = []decoder{
   492  	nil, // 0
   493  	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Location).ID) },         // optional uint64 id = 1;
   494  	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Location).mappingIDX) }, // optional uint64 mapping_id = 2;
   495  	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Location).Address) },    // optional uint64 address = 3;
   496  	func(b *buffer, m message) error { // repeated Line line = 4
   497  		pp := m.(*Location)
   498  		n := len(pp.Line)
   499  		pp.Line = append(pp.Line, Line{})
   500  		return decodeMessage(b, &pp.Line[n])
   501  	},
   502  	func(b *buffer, m message) error { return decodeBool(b, &m.(*Location).IsFolded) }, // optional bool is_folded = 5;
   503  }
   504  
   505  func (p *Line) decoder() []decoder {
   506  	return lineDecoder
   507  }
   508  
   509  func (p *Line) encode(b *buffer) {
   510  	encodeUint64Opt(b, 1, p.functionIDX)
   511  	encodeInt64Opt(b, 2, p.Line)
   512  }
   513  
   514  var lineDecoder = []decoder{
   515  	nil, // 0
   516  	// optional uint64 function_id = 1
   517  	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Line).functionIDX) },
   518  	// optional int64 line = 2
   519  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Line).Line) },
   520  }
   521  
   522  func (p *Function) decoder() []decoder {
   523  	return functionDecoder
   524  }
   525  
   526  func (p *Function) encode(b *buffer) {
   527  	encodeUint64Opt(b, 1, p.ID)
   528  	encodeInt64Opt(b, 2, p.nameX)
   529  	encodeInt64Opt(b, 3, p.systemNameX)
   530  	encodeInt64Opt(b, 4, p.filenameX)
   531  	encodeInt64Opt(b, 5, p.StartLine)
   532  }
   533  
   534  var functionDecoder = []decoder{
   535  	nil, // 0
   536  	// optional uint64 id = 1
   537  	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Function).ID) },
   538  	// optional int64 function_name = 2
   539  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).nameX) },
   540  	// optional int64 function_system_name = 3
   541  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).systemNameX) },
   542  	// repeated int64 filename = 4
   543  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).filenameX) },
   544  	// optional int64 start_line = 5
   545  	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).StartLine) },
   546  }
   547  
   548  func addString(strings map[string]int, s string) int64 {
   549  	i, ok := strings[s]
   550  	if !ok {
   551  		i = len(strings)
   552  		strings[s] = i
   553  	}
   554  	return int64(i)
   555  }
   556  
   557  func getString(strings []string, strng *int64, err error) (string, error) {
   558  	if err != nil {
   559  		return "", err
   560  	}
   561  	s := int(*strng)
   562  	if s < 0 || s >= len(strings) {
   563  		return "", errMalformed
   564  	}
   565  	*strng = 0
   566  	return strings[s], nil
   567  }
   568
View as plain text