github.com/goproxy0/go@v0.0.0-20171111080102-49cc0c489d2c/src/runtime/pprof/protomem.go (about)

     1  // Copyright 2016 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 pprof
     6  
     7  import (
     8  	"io"
     9  	"math"
    10  	"runtime"
    11  	"strings"
    12  )
    13  
    14  // writeHeapProto writes the current heap profile in protobuf format to w.
    15  func writeHeapProto(w io.Writer, p []runtime.MemProfileRecord, rate int64) error {
    16  	b := newProfileBuilder(w)
    17  	b.pbValueType(tagProfile_PeriodType, "space", "bytes")
    18  	b.pb.int64Opt(tagProfile_Period, rate)
    19  	b.pbValueType(tagProfile_SampleType, "alloc_objects", "count")
    20  	b.pbValueType(tagProfile_SampleType, "alloc_space", "bytes")
    21  	b.pbValueType(tagProfile_SampleType, "inuse_objects", "count")
    22  	b.pbValueType(tagProfile_SampleType, "inuse_space", "bytes")
    23  
    24  	values := []int64{0, 0, 0, 0}
    25  	var locs []uint64
    26  	for _, r := range p {
    27  		locs = locs[:0]
    28  		hideRuntime := true
    29  		for tries := 0; tries < 2; tries++ {
    30  			for _, addr := range r.Stack() {
    31  				// For heap profiles, all stack
    32  				// addresses are return PCs, which is
    33  				// what locForPC expects.
    34  				if hideRuntime {
    35  					if f := runtime.FuncForPC(addr); f != nil && strings.HasPrefix(f.Name(), "runtime.") {
    36  						continue
    37  					}
    38  					// Found non-runtime. Show any runtime uses above it.
    39  					hideRuntime = false
    40  				}
    41  				l := b.locForPC(addr)
    42  				if l == 0 { // runtime.goexit
    43  					continue
    44  				}
    45  				locs = append(locs, l)
    46  			}
    47  			if len(locs) > 0 {
    48  				break
    49  			}
    50  			hideRuntime = false // try again, and show all frames
    51  		}
    52  
    53  		values[0], values[1] = scaleHeapSample(r.AllocObjects, r.AllocBytes, rate)
    54  		values[2], values[3] = scaleHeapSample(r.InUseObjects(), r.InUseBytes(), rate)
    55  		var blockSize int64
    56  		if values[0] > 0 {
    57  			blockSize = values[1] / values[0]
    58  		}
    59  		b.pbSample(values, locs, func() {
    60  			if blockSize != 0 {
    61  				b.pbLabel(tagSample_Label, "bytes", "", blockSize)
    62  			}
    63  		})
    64  	}
    65  	b.build()
    66  	return nil
    67  }
    68  
    69  // scaleHeapSample adjusts the data from a heap Sample to
    70  // account for its probability of appearing in the collected
    71  // data. heap profiles are a sampling of the memory allocations
    72  // requests in a program. We estimate the unsampled value by dividing
    73  // each collected sample by its probability of appearing in the
    74  // profile. heap profiles rely on a poisson process to determine
    75  // which samples to collect, based on the desired average collection
    76  // rate R. The probability of a sample of size S to appear in that
    77  // profile is 1-exp(-S/R).
    78  func scaleHeapSample(count, size, rate int64) (int64, int64) {
    79  	if count == 0 || size == 0 {
    80  		return 0, 0
    81  	}
    82  
    83  	if rate <= 1 {
    84  		// if rate==1 all samples were collected so no adjustment is needed.
    85  		// if rate<1 treat as unknown and skip scaling.
    86  		return count, size
    87  	}
    88  
    89  	avgSize := float64(size) / float64(count)
    90  	scale := 1 / (1 - math.Exp(-avgSize/float64(rate)))
    91  
    92  	return int64(float64(count) * scale), int64(float64(size) * scale)
    93  }