package main

import (
	"log"
	"math"
	"os"
	"runtime"
	"runtime/metrics"
	"strconv"
	"sync"
	"time"
)

var samples = []metrics.Sample{
	{Name: "/cpu/classes/gc/total:cpu-seconds"},       // 0
	{Name: "/cpu/classes/idle:cpu-seconds"},           // 1
	{Name: "/cpu/classes/scavenge/total:cpu-seconds"}, // 2
	{Name: "/cpu/classes/total:cpu-seconds"},          // 3
	{Name: "/cpu/classes/user:cpu-seconds"},           // 4
}

func main() {
	// Apply some GC load and wait for a bit. Gives a high chance of obtaining the
	// sheared result on my workstation.
	go applyGCLoad()
	time.Sleep(50 * time.Millisecond)

	// Read metrics.
	metrics.Read(samples)
	gc := samples[0].Value.Float64()
	idle := samples[1].Value.Float64()
	scav := samples[2].Value.Float64()
	total := samples[3].Value.Float64()
	user := samples[4].Value.Float64()

	// Calculate the total from the subtotals.
	calcTotal := (((scav + gc) + user) + idle)

	// Compare total read from metrics versus our own calculation.
	log.Printf("Δ = %s = total (%s) - scav+gc+user+idle (%s), there's %d floats between them\n",
		strconv.FormatFloat(total-calcTotal, 'f', -1, 64),
		strconv.FormatFloat(calcTotal, 'f', -1, 64),
		strconv.FormatFloat(total, 'f', -1, 64),
		int64(math.Float64bits(calcTotal)-math.Float64bits(total)),
	)
	if want, got := total, calcTotal; got != want && (got-want > 0.0001 || want-got > 0.0001) {
		os.Exit(1)
	}
}

func applyGCLoad() func() {
	// We’ll apply load to the runtime with maxProcs-1 goroutines
	// and use one more to actually benchmark. It doesn't make sense
	// to try to run this test with only 1 P (that's what
	// BenchmarkReadMemStats is for).
	maxProcs := runtime.GOMAXPROCS(-1)

	// Code to build a big tree with lots of pointers.
	type node struct {
		children [16]*node
	}
	var buildTree func(depth int) *node
	buildTree = func(depth int) *node {
		tree := new(node)
		if depth != 0 {
			for i := range tree.children {
				tree.children[i] = buildTree(depth - 1)
			}
		}
		return tree
	}

	// Keep the GC busy by continuously generating large trees.
	done := make(chan struct{})
	var wg sync.WaitGroup
	for i := 0; i < maxProcs-1; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			var hold *node
		loop:
			for {
				hold = buildTree(5)
				select {
				case <-done:
					break loop
				default:
				}
			}
			runtime.KeepAlive(hold)
		}()
	}
	return func() {
		close(done)
		wg.Wait()
	}
}