mprof_test.go

Documentation: runtime/pprof

		 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  //go:build !js
		 6  // +build !js
		 7  
		 8  package pprof
		 9  
		10  import (
		11  	"bytes"
		12  	"fmt"
		13  	"internal/profile"
		14  	"reflect"
		15  	"regexp"
		16  	"runtime"
		17  	"testing"
		18  	"unsafe"
		19  )
		20  
		21  var memSink interface{}
		22  
		23  func allocateTransient1M() {
		24  	for i := 0; i < 1024; i++ {
		25  		memSink = &struct{ x [1024]byte }{}
		26  	}
		27  }
		28  
		29  //go:noinline
		30  func allocateTransient2M() {
		31  	memSink = make([]byte, 2<<20)
		32  }
		33  
		34  func allocateTransient2MInline() {
		35  	memSink = make([]byte, 2<<20)
		36  }
		37  
		38  type Obj32 struct {
		39  	link *Obj32
		40  	pad	[32 - unsafe.Sizeof(uintptr(0))]byte
		41  }
		42  
		43  var persistentMemSink *Obj32
		44  
		45  func allocatePersistent1K() {
		46  	for i := 0; i < 32; i++ {
		47  		// Can't use slice because that will introduce implicit allocations.
		48  		obj := &Obj32{link: persistentMemSink}
		49  		persistentMemSink = obj
		50  	}
		51  }
		52  
		53  // Allocate transient memory using reflect.Call.
		54  
		55  func allocateReflectTransient() {
		56  	memSink = make([]byte, 2<<20)
		57  }
		58  
		59  func allocateReflect() {
		60  	rv := reflect.ValueOf(allocateReflectTransient)
		61  	rv.Call(nil)
		62  }
		63  
		64  var memoryProfilerRun = 0
		65  
		66  func TestMemoryProfiler(t *testing.T) {
		67  	// Disable sampling, otherwise it's difficult to assert anything.
		68  	oldRate := runtime.MemProfileRate
		69  	runtime.MemProfileRate = 1
		70  	defer func() {
		71  		runtime.MemProfileRate = oldRate
		72  	}()
		73  
		74  	// Allocate a meg to ensure that mcache.nextSample is updated to 1.
		75  	for i := 0; i < 1024; i++ {
		76  		memSink = make([]byte, 1024)
		77  	}
		78  
		79  	// Do the interesting allocations.
		80  	allocateTransient1M()
		81  	allocateTransient2M()
		82  	allocateTransient2MInline()
		83  	allocatePersistent1K()
		84  	allocateReflect()
		85  	memSink = nil
		86  
		87  	runtime.GC() // materialize stats
		88  
		89  	// TODO(mknyszek): Fix #45315 and remove this extra call.
		90  	//
		91  	// Unfortunately, it's possible for the sweep termination condition
		92  	// to flap, so with just one runtime.GC call, a freed object could be
		93  	// missed, leading this test to fail. A second call reduces the chance
		94  	// of this happening to zero, because sweeping actually has to finish
		95  	// to move on to the next GC, during which nothing will happen.
		96  	//
		97  	// See #46500 for more details.
		98  	runtime.GC()
		99  
	 100  	memoryProfilerRun++
	 101  
	 102  	tests := []struct {
	 103  		stk		[]string
	 104  		legacy string
	 105  	}{{
	 106  		stk: []string{"runtime/pprof.allocatePersistent1K", "runtime/pprof.TestMemoryProfiler"},
	 107  		legacy: fmt.Sprintf(`%v: %v \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
	 108  #	0x[0-9,a-f]+	runtime/pprof\.allocatePersistent1K\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test\.go:48
	 109  #	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test\.go:83
	 110  `, 32*memoryProfilerRun, 1024*memoryProfilerRun, 32*memoryProfilerRun, 1024*memoryProfilerRun),
	 111  	}, {
	 112  		stk: []string{"runtime/pprof.allocateTransient1M", "runtime/pprof.TestMemoryProfiler"},
	 113  		legacy: fmt.Sprintf(`0: 0 \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
	 114  #	0x[0-9,a-f]+	runtime/pprof\.allocateTransient1M\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:25
	 115  #	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:80
	 116  `, (1<<10)*memoryProfilerRun, (1<<20)*memoryProfilerRun),
	 117  	}, {
	 118  		stk: []string{"runtime/pprof.allocateTransient2M", "runtime/pprof.TestMemoryProfiler"},
	 119  		legacy: fmt.Sprintf(`0: 0 \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
	 120  #	0x[0-9,a-f]+	runtime/pprof\.allocateTransient2M\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:31
	 121  #	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:81
	 122  `, memoryProfilerRun, (2<<20)*memoryProfilerRun),
	 123  	}, {
	 124  		stk: []string{"runtime/pprof.allocateTransient2MInline", "runtime/pprof.TestMemoryProfiler"},
	 125  		legacy: fmt.Sprintf(`0: 0 \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
	 126  #	0x[0-9,a-f]+	runtime/pprof\.allocateTransient2MInline\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:35
	 127  #	0x[0-9,a-f]+	runtime/pprof\.TestMemoryProfiler\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:82
	 128  `, memoryProfilerRun, (2<<20)*memoryProfilerRun),
	 129  	}, {
	 130  		stk: []string{"runtime/pprof.allocateReflectTransient"},
	 131  		legacy: fmt.Sprintf(`0: 0 \[%v: %v\] @( 0x[0-9,a-f]+)+
	 132  #	0x[0-9,a-f]+	runtime/pprof\.allocateReflectTransient\+0x[0-9,a-f]+	.*/runtime/pprof/mprof_test.go:56
	 133  `, memoryProfilerRun, (2<<20)*memoryProfilerRun),
	 134  	}}
	 135  
	 136  	t.Run("debug=1", func(t *testing.T) {
	 137  		var buf bytes.Buffer
	 138  		if err := Lookup("heap").WriteTo(&buf, 1); err != nil {
	 139  			t.Fatalf("failed to write heap profile: %v", err)
	 140  		}
	 141  
	 142  		for _, test := range tests {
	 143  			if !regexp.MustCompile(test.legacy).Match(buf.Bytes()) {
	 144  				t.Fatalf("The entry did not match:\n%v\n\nProfile:\n%v\n", test.legacy, buf.String())
	 145  			}
	 146  		}
	 147  	})
	 148  
	 149  	t.Run("proto", func(t *testing.T) {
	 150  		var buf bytes.Buffer
	 151  		if err := Lookup("heap").WriteTo(&buf, 0); err != nil {
	 152  			t.Fatalf("failed to write heap profile: %v", err)
	 153  		}
	 154  		p, err := profile.Parse(&buf)
	 155  		if err != nil {
	 156  			t.Fatalf("failed to parse heap profile: %v", err)
	 157  		}
	 158  		t.Logf("Profile = %v", p)
	 159  
	 160  		stks := stacks(p)
	 161  		for _, test := range tests {
	 162  			if !containsStack(stks, test.stk) {
	 163  				t.Fatalf("No matching stack entry for %q\n\nProfile:\n%v\n", test.stk, p)
	 164  			}
	 165  		}
	 166  
	 167  		if !containsInlinedCall(TestMemoryProfiler, 4<<10) {
	 168  			t.Logf("Can't determine whether allocateTransient2MInline was inlined into TestMemoryProfiler.")
	 169  			return
	 170  		}
	 171  
	 172  		// Check the inlined function location is encoded correctly.
	 173  		for _, loc := range p.Location {
	 174  			inlinedCaller, inlinedCallee := false, false
	 175  			for _, line := range loc.Line {
	 176  				if line.Function.Name == "runtime/pprof.allocateTransient2MInline" {
	 177  					inlinedCallee = true
	 178  				}
	 179  				if inlinedCallee && line.Function.Name == "runtime/pprof.TestMemoryProfiler" {
	 180  					inlinedCaller = true
	 181  				}
	 182  			}
	 183  			if inlinedCallee != inlinedCaller {
	 184  				t.Errorf("want allocateTransient2MInline after TestMemoryProfiler in one location, got separate location entries:\n%v", loc)
	 185  			}
	 186  		}
	 187  	})
	 188  }
	 189
View as plain text