metrics_test.go

Documentation: runtime

		 1  // Copyright 2020 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 runtime_test
		 6  
		 7  import (
		 8  	"runtime"
		 9  	"runtime/metrics"
		10  	"sort"
		11  	"strings"
		12  	"testing"
		13  	"time"
		14  	"unsafe"
		15  )
		16  
		17  func prepareAllMetricsSamples() (map[string]metrics.Description, []metrics.Sample) {
		18  	all := metrics.All()
		19  	samples := make([]metrics.Sample, len(all))
		20  	descs := make(map[string]metrics.Description)
		21  	for i := range all {
		22  		samples[i].Name = all[i].Name
		23  		descs[all[i].Name] = all[i]
		24  	}
		25  	return descs, samples
		26  }
		27  
		28  func TestReadMetrics(t *testing.T) {
		29  	// Tests whether readMetrics produces values aligning
		30  	// with ReadMemStats while the world is stopped.
		31  	var mstats runtime.MemStats
		32  	_, samples := prepareAllMetricsSamples()
		33  	runtime.ReadMetricsSlow(&mstats, unsafe.Pointer(&samples[0]), len(samples), cap(samples))
		34  
		35  	checkUint64 := func(t *testing.T, m string, got, want uint64) {
		36  		t.Helper()
		37  		if got != want {
		38  			t.Errorf("metric %q: got %d, want %d", m, got, want)
		39  		}
		40  	}
		41  
		42  	// Check to make sure the values we read line up with other values we read.
		43  	var allocsBySize *metrics.Float64Histogram
		44  	var tinyAllocs uint64
		45  	var mallocs, frees uint64
		46  	for i := range samples {
		47  		switch name := samples[i].Name; name {
		48  		case "/memory/classes/heap/free:bytes":
		49  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.HeapIdle-mstats.HeapReleased)
		50  		case "/memory/classes/heap/released:bytes":
		51  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.HeapReleased)
		52  		case "/memory/classes/heap/objects:bytes":
		53  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.HeapAlloc)
		54  		case "/memory/classes/heap/unused:bytes":
		55  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.HeapInuse-mstats.HeapAlloc)
		56  		case "/memory/classes/heap/stacks:bytes":
		57  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.StackInuse)
		58  		case "/memory/classes/metadata/mcache/free:bytes":
		59  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.MCacheSys-mstats.MCacheInuse)
		60  		case "/memory/classes/metadata/mcache/inuse:bytes":
		61  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.MCacheInuse)
		62  		case "/memory/classes/metadata/mspan/free:bytes":
		63  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.MSpanSys-mstats.MSpanInuse)
		64  		case "/memory/classes/metadata/mspan/inuse:bytes":
		65  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.MSpanInuse)
		66  		case "/memory/classes/metadata/other:bytes":
		67  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.GCSys)
		68  		case "/memory/classes/os-stacks:bytes":
		69  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.StackSys-mstats.StackInuse)
		70  		case "/memory/classes/other:bytes":
		71  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.OtherSys)
		72  		case "/memory/classes/profiling/buckets:bytes":
		73  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.BuckHashSys)
		74  		case "/memory/classes/total:bytes":
		75  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.Sys)
		76  		case "/gc/heap/allocs-by-size:bytes":
		77  			hist := samples[i].Value.Float64Histogram()
		78  			// Skip size class 0 in BySize, because it's always empty and not represented
		79  			// in the histogram.
		80  			for i, sc := range mstats.BySize[1:] {
		81  				if b, s := hist.Buckets[i+1], float64(sc.Size+1); b != s {
		82  					t.Errorf("bucket does not match size class: got %f, want %f", b, s)
		83  					// The rest of the checks aren't expected to work anyway.
		84  					continue
		85  				}
		86  				if c, m := hist.Counts[i], sc.Mallocs; c != m {
		87  					t.Errorf("histogram counts do not much BySize for class %d: got %d, want %d", i, c, m)
		88  				}
		89  			}
		90  			allocsBySize = hist
		91  		case "/gc/heap/allocs:bytes":
		92  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.TotalAlloc)
		93  		case "/gc/heap/frees-by-size:bytes":
		94  			hist := samples[i].Value.Float64Histogram()
		95  			// Skip size class 0 in BySize, because it's always empty and not represented
		96  			// in the histogram.
		97  			for i, sc := range mstats.BySize[1:] {
		98  				if b, s := hist.Buckets[i+1], float64(sc.Size+1); b != s {
		99  					t.Errorf("bucket does not match size class: got %f, want %f", b, s)
	 100  					// The rest of the checks aren't expected to work anyway.
	 101  					continue
	 102  				}
	 103  				if c, f := hist.Counts[i], sc.Frees; c != f {
	 104  					t.Errorf("histogram counts do not match BySize for class %d: got %d, want %d", i, c, f)
	 105  				}
	 106  			}
	 107  		case "/gc/heap/frees:bytes":
	 108  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.TotalAlloc-mstats.HeapAlloc)
	 109  		case "/gc/heap/tiny/allocs:objects":
	 110  			// Currently, MemStats adds tiny alloc count to both Mallocs AND Frees.
	 111  			// The reason for this is because MemStats couldn't be extended at the time
	 112  			// but there was a desire to have Mallocs at least be a little more representative,
	 113  			// while having Mallocs - Frees still represent a live object count.
	 114  			// Unfortunately, MemStats doesn't actually export a large allocation count,
	 115  			// so it's impossible to pull this number out directly.
	 116  			//
	 117  			// Check tiny allocation count outside of this loop, by using the allocs-by-size
	 118  			// histogram in order to figure out how many large objects there are.
	 119  			tinyAllocs = samples[i].Value.Uint64()
	 120  			// Because the next two metrics tests are checking against Mallocs and Frees,
	 121  			// we can't check them directly for the same reason: we need to account for tiny
	 122  			// allocations included in Mallocs and Frees.
	 123  		case "/gc/heap/allocs:objects":
	 124  			mallocs = samples[i].Value.Uint64()
	 125  		case "/gc/heap/frees:objects":
	 126  			frees = samples[i].Value.Uint64()
	 127  		case "/gc/heap/objects:objects":
	 128  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.HeapObjects)
	 129  		case "/gc/heap/goal:bytes":
	 130  			checkUint64(t, name, samples[i].Value.Uint64(), mstats.NextGC)
	 131  		case "/gc/cycles/automatic:gc-cycles":
	 132  			checkUint64(t, name, samples[i].Value.Uint64(), uint64(mstats.NumGC-mstats.NumForcedGC))
	 133  		case "/gc/cycles/forced:gc-cycles":
	 134  			checkUint64(t, name, samples[i].Value.Uint64(), uint64(mstats.NumForcedGC))
	 135  		case "/gc/cycles/total:gc-cycles":
	 136  			checkUint64(t, name, samples[i].Value.Uint64(), uint64(mstats.NumGC))
	 137  		}
	 138  	}
	 139  
	 140  	// Check tinyAllocs.
	 141  	nonTinyAllocs := uint64(0)
	 142  	for _, c := range allocsBySize.Counts {
	 143  		nonTinyAllocs += c
	 144  	}
	 145  	checkUint64(t, "/gc/heap/tiny/allocs:objects", tinyAllocs, mstats.Mallocs-nonTinyAllocs)
	 146  
	 147  	// Check allocation and free counts.
	 148  	checkUint64(t, "/gc/heap/allocs:objects", mallocs, mstats.Mallocs-tinyAllocs)
	 149  	checkUint64(t, "/gc/heap/frees:objects", frees, mstats.Frees-tinyAllocs)
	 150  }
	 151  
	 152  func TestReadMetricsConsistency(t *testing.T) {
	 153  	// Tests whether readMetrics produces consistent, sensible values.
	 154  	// The values are read concurrently with the runtime doing other
	 155  	// things (e.g. allocating) so what we read can't reasonably compared
	 156  	// to runtime values.
	 157  
	 158  	// Run a few GC cycles to get some of the stats to be non-zero.
	 159  	runtime.GC()
	 160  	runtime.GC()
	 161  	runtime.GC()
	 162  
	 163  	// Read all the supported metrics through the metrics package.
	 164  	descs, samples := prepareAllMetricsSamples()
	 165  	metrics.Read(samples)
	 166  
	 167  	// Check to make sure the values we read make sense.
	 168  	var totalVirtual struct {
	 169  		got, want uint64
	 170  	}
	 171  	var objects struct {
	 172  		alloc, free						 *metrics.Float64Histogram
	 173  		allocs, frees					 uint64
	 174  		allocdBytes, freedBytes uint64
	 175  		total, totalBytes			 uint64
	 176  	}
	 177  	var gc struct {
	 178  		numGC	uint64
	 179  		pauses uint64
	 180  	}
	 181  	for i := range samples {
	 182  		kind := samples[i].Value.Kind()
	 183  		if want := descs[samples[i].Name].Kind; kind != want {
	 184  			t.Errorf("supported metric %q has unexpected kind: got %d, want %d", samples[i].Name, kind, want)
	 185  			continue
	 186  		}
	 187  		if samples[i].Name != "/memory/classes/total:bytes" && strings.HasPrefix(samples[i].Name, "/memory/classes") {
	 188  			v := samples[i].Value.Uint64()
	 189  			totalVirtual.want += v
	 190  
	 191  			// None of these stats should ever get this big.
	 192  			// If they do, there's probably overflow involved,
	 193  			// usually due to bad accounting.
	 194  			if int64(v) < 0 {
	 195  				t.Errorf("%q has high/negative value: %d", samples[i].Name, v)
	 196  			}
	 197  		}
	 198  		switch samples[i].Name {
	 199  		case "/memory/classes/total:bytes":
	 200  			totalVirtual.got = samples[i].Value.Uint64()
	 201  		case "/memory/classes/heap/objects:bytes":
	 202  			objects.totalBytes = samples[i].Value.Uint64()
	 203  		case "/gc/heap/objects:objects":
	 204  			objects.total = samples[i].Value.Uint64()
	 205  		case "/gc/heap/allocs:bytes":
	 206  			objects.allocdBytes = samples[i].Value.Uint64()
	 207  		case "/gc/heap/allocs:objects":
	 208  			objects.allocs = samples[i].Value.Uint64()
	 209  		case "/gc/heap/allocs-by-size:bytes":
	 210  			objects.alloc = samples[i].Value.Float64Histogram()
	 211  		case "/gc/heap/frees:bytes":
	 212  			objects.freedBytes = samples[i].Value.Uint64()
	 213  		case "/gc/heap/frees:objects":
	 214  			objects.frees = samples[i].Value.Uint64()
	 215  		case "/gc/heap/frees-by-size:bytes":
	 216  			objects.free = samples[i].Value.Float64Histogram()
	 217  		case "/gc/cycles:gc-cycles":
	 218  			gc.numGC = samples[i].Value.Uint64()
	 219  		case "/gc/pauses:seconds":
	 220  			h := samples[i].Value.Float64Histogram()
	 221  			gc.pauses = 0
	 222  			for i := range h.Counts {
	 223  				gc.pauses += h.Counts[i]
	 224  			}
	 225  		case "/sched/goroutines:goroutines":
	 226  			if samples[i].Value.Uint64() < 1 {
	 227  				t.Error("number of goroutines is less than one")
	 228  			}
	 229  		}
	 230  	}
	 231  	if totalVirtual.got != totalVirtual.want {
	 232  		t.Errorf(`"/memory/classes/total:bytes" does not match sum of /memory/classes/**: got %d, want %d`, totalVirtual.got, totalVirtual.want)
	 233  	}
	 234  	if got, want := objects.allocs-objects.frees, objects.total; got != want {
	 235  		t.Errorf("mismatch between object alloc/free tallies and total: got %d, want %d", got, want)
	 236  	}
	 237  	if got, want := objects.allocdBytes-objects.freedBytes, objects.totalBytes; got != want {
	 238  		t.Errorf("mismatch between object alloc/free tallies and total: got %d, want %d", got, want)
	 239  	}
	 240  	if b, c := len(objects.alloc.Buckets), len(objects.alloc.Counts); b != c+1 {
	 241  		t.Errorf("allocs-by-size has wrong bucket or counts length: %d buckets, %d counts", b, c)
	 242  	}
	 243  	if b, c := len(objects.free.Buckets), len(objects.free.Counts); b != c+1 {
	 244  		t.Errorf("frees-by-size has wrong bucket or counts length: %d buckets, %d counts", b, c)
	 245  	}
	 246  	if len(objects.alloc.Buckets) != len(objects.free.Buckets) {
	 247  		t.Error("allocs-by-size and frees-by-size buckets don't match in length")
	 248  	} else if len(objects.alloc.Counts) != len(objects.free.Counts) {
	 249  		t.Error("allocs-by-size and frees-by-size counts don't match in length")
	 250  	} else {
	 251  		for i := range objects.alloc.Buckets {
	 252  			ba := objects.alloc.Buckets[i]
	 253  			bf := objects.free.Buckets[i]
	 254  			if ba != bf {
	 255  				t.Errorf("bucket %d is different for alloc and free hists: %f != %f", i, ba, bf)
	 256  			}
	 257  		}
	 258  		if !t.Failed() {
	 259  			var gotAlloc, gotFree uint64
	 260  			want := objects.total
	 261  			for i := range objects.alloc.Counts {
	 262  				if objects.alloc.Counts[i] < objects.free.Counts[i] {
	 263  					t.Errorf("found more allocs than frees in object dist bucket %d", i)
	 264  					continue
	 265  				}
	 266  				gotAlloc += objects.alloc.Counts[i]
	 267  				gotFree += objects.free.Counts[i]
	 268  			}
	 269  			if got := gotAlloc - gotFree; got != want {
	 270  				t.Errorf("object distribution counts don't match count of live objects: got %d, want %d", got, want)
	 271  			}
	 272  			if gotAlloc != objects.allocs {
	 273  				t.Errorf("object distribution counts don't match total allocs: got %d, want %d", gotAlloc, objects.allocs)
	 274  			}
	 275  			if gotFree != objects.frees {
	 276  				t.Errorf("object distribution counts don't match total allocs: got %d, want %d", gotFree, objects.frees)
	 277  			}
	 278  		}
	 279  	}
	 280  	// The current GC has at least 2 pauses per GC.
	 281  	// Check to see if that value makes sense.
	 282  	if gc.pauses < gc.numGC*2 {
	 283  		t.Errorf("fewer pauses than expected: got %d, want at least %d", gc.pauses, gc.numGC*2)
	 284  	}
	 285  }
	 286  
	 287  func BenchmarkReadMetricsLatency(b *testing.B) {
	 288  	stop := applyGCLoad(b)
	 289  
	 290  	// Spend this much time measuring latencies.
	 291  	latencies := make([]time.Duration, 0, 1024)
	 292  	_, samples := prepareAllMetricsSamples()
	 293  
	 294  	// Hit metrics.Read continuously and measure.
	 295  	b.ResetTimer()
	 296  	for i := 0; i < b.N; i++ {
	 297  		start := time.Now()
	 298  		metrics.Read(samples)
	 299  		latencies = append(latencies, time.Now().Sub(start))
	 300  	}
	 301  	// Make sure to stop the timer before we wait! The load created above
	 302  	// is very heavy-weight and not easy to stop, so we could end up
	 303  	// confusing the benchmarking framework for small b.N.
	 304  	b.StopTimer()
	 305  	stop()
	 306  
	 307  	// Disable the default */op metrics.
	 308  	// ns/op doesn't mean anything because it's an average, but we
	 309  	// have a sleep in our b.N loop above which skews this significantly.
	 310  	b.ReportMetric(0, "ns/op")
	 311  	b.ReportMetric(0, "B/op")
	 312  	b.ReportMetric(0, "allocs/op")
	 313  
	 314  	// Sort latencies then report percentiles.
	 315  	sort.Slice(latencies, func(i, j int) bool {
	 316  		return latencies[i] < latencies[j]
	 317  	})
	 318  	b.ReportMetric(float64(latencies[len(latencies)*50/100]), "p50-ns")
	 319  	b.ReportMetric(float64(latencies[len(latencies)*90/100]), "p90-ns")
	 320  	b.ReportMetric(float64(latencies[len(latencies)*99/100]), "p99-ns")
	 321  }
	 322
View as plain text