//go:build ignore

// Две задачи урока про профилирование: обе отвечают прогоном.
//
// ЗАДАЧА 1 — ПРЕДСКАЗАТЬ ВЫВОД. Три строки:
//   - сколько записей в профиле блокировок, если его не включали, а
//     блокировки были;
//   - на сколько выросло число горутин в профиле после запуска сотни
//     горутин, ждущих канала, в который никто не пишет;
//   - есть ли в inuse_space функция, которая выделила много, но ничего не
//     удержала.
//
// ЗАДАЧА 2 — ОЦЕНИТЬ ЧИСЛО. Сколько сэмплов наберёт профиль CPU за 2 секунды
// работы одной горутины. Число сэмплов печатает сам pprof в режиме -raw.
//
// ЗАПУСК:
//
//	go run bench/goprof/practice.go
package main

import (
	"crypto/sha256"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"runtime/pprof"
	"strings"
	"sync"
	"time"
)

var sink []byte

//go:noinline
func churn(n int) {
	for i := 0; i < n; i++ {
		sink = make([]byte, 4096)
	}
}

//go:noinline
func burn(d time.Duration) {
	b := make([]byte, 64)
	for start := time.Now(); time.Since(start) < d; {
		s := sha256.Sum256(b)
		b = s[:]
	}
	sink = b
}

func main() {
	dir, _ := os.MkdirTemp("", "goprof-practice")
	defer os.RemoveAll(dir)

	fmt.Println("ЗАДАЧА 1 — предсказать вывод")
	fmt.Println()

	// Блокировки были: четыре горутины дерутся за мьютекс.
	var mu sync.Mutex
	var wg sync.WaitGroup
	wg.Add(4)
	for g := 0; g < 4; g++ {
		go func() {
			defer wg.Done()
			for i := 0; i < 1000; i++ {
				mu.Lock()
				time.Sleep(time.Microsecond)
				mu.Unlock()
			}
		}()
	}
	wg.Wait()
	fmt.Println(pprof.Lookup("block").Count())

	before := pprof.Lookup("goroutine").Count()
	never := make(chan int)
	for i := 0; i < 100; i++ {
		go func() { <-never }()
	}
	time.Sleep(50 * time.Millisecond)
	fmt.Println(pprof.Lookup("goroutine").Count() - before)

	churn(20000)
	runtime.GC()
	heap := filepath.Join(dir, "heap.pprof")
	h, _ := os.Create(heap)
	pprof.Lookup("heap").WriteTo(h, 0)
	h.Close()
	out, _ := exec.Command("go", "tool", "pprof", "-top", "-nodecount=100",
		"-sample_index=inuse_space", heap).CombinedOutput()
	fmt.Println(strings.Contains(string(out), "main.churn"))

	fmt.Println()
	fmt.Println("ЗАДАЧА 2 — сколько сэмплов за 2 секунды работы одной горутины")
	fmt.Println()
	cpu := filepath.Join(dir, "cpu.pprof")
	f, _ := os.Create(cpu)
	start := time.Now()
	pprof.StartCPUProfile(f)
	burn(2 * time.Second)
	pprof.StopCPUProfile()
	wall := time.Since(start)
	f.Close()
	raw, err := exec.Command("go", "tool", "pprof", "-raw", cpu).CombinedOutput()
	if err != nil {
		panic(fmt.Sprintf("%v\n%s", err, raw))
	}
	// В выводе -raw после строки «Samples:» идёт строка с типами значений,
	// а дальше — по строке на каждую уникальную трассу: «  <count> <ns>: <адреса>».
	samples := 0
	inSamples := false
	for _, line := range strings.Split(string(raw), "\n") {
		t := strings.TrimSpace(line)
		if strings.HasPrefix(t, "Samples:") {
			inSamples = true
			continue
		}
		if inSamples {
			if t == "" || strings.HasPrefix(t, "Locations") {
				break
			}
			var count int
			if n, _ := fmt.Sscanf(t, "%d", &count); n == 1 && strings.Contains(t, ":") {
				samples += count
			}
		}
	}
	fmt.Printf("  длительность работы          %6.2f с\n", wall.Seconds())
	fmt.Printf("  сэмплов в профиле            %6d\n", samples)
	fmt.Printf("  сэмплов в секунду            %6.0f\n", float64(samples)/wall.Seconds())
	fmt.Println()
	fmt.Printf("  %s %s/%s, GOMAXPROCS=%d\n", runtime.Version(), runtime.GOOS, runtime.GOARCH, runtime.GOMAXPROCS(0))
	fmt.Println()
	fmt.Println("  Частота зашита в runtime/pprof: 100 сэмплов в секунду")
	fmt.Println("  процессорного времени. Одна горутина, 2 секунды — около 200.")
	fmt.Println("  Поэтому функция, которая работала 5 мс, в профиль может не")
	fmt.Println("  попасть вовсе: профиль — выборка, а не учёт каждого вызова.")
}