libgo/go/runtime/metrics_test.go

   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 }