//go:build ignore

// Профилирование в Go: что именно показывает каждый профиль и чего он не
// показывает по умолчанию.
//
// ЗАЧЕМ ЭТА ПРОГРАММА. «Сними pprof и посмотри» — совет, на котором ответ
// обычно заканчивается. А вопросы начинаются с того, ЧТО именно снимать и как
// читать: чем flat отличается от cum, почему функция, которая выделила
// гигабайт, не видна в профиле кучи, почему профиль блокировок пуст. Всё это
// здесь не пересказывается, а получается на одной нагрузке.
//
// ШЕСТЬ СЮЖЕТОВ:
//
//  1. Профиль CPU и частота сэмплов: 100 в секунду, по исходнику runtime/pprof.
//  2. flat против cum на одной и той же функции.
//  3. Профиль кучи: alloc_space против inuse_space.
//  4. Профили блокировок и мьютексов выключены по умолчанию.
//  5. Профиль горутин находит утечку.
//  6. Цена профиля CPU для самой программы.
//
// Таблицы печатает `go tool pprof -top`; строки с путями к файлам и временем
// снятия убраны — они меняются от запуска к запуску и к сути не относятся.
//
// ЗАПУСК:
//
//	go run bench/goprof/internals.go
package main

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

func show(title string) {
	fmt.Println()
	fmt.Println(title)
	fmt.Println(strings.Repeat("─", len([]rune(title))))
}

// ----------------------------------------------------------------- нагрузка

var sink []byte

// hashAll — тяжёлая работа процессора: свой собственный flat.
//
//go:noinline
func hashAll(rounds int) {
	b := make([]byte, 64)
	for i := 0; i < rounds; i++ {
		s := sha256.Sum256(b)
		b = s[:]
	}
	sink = b
}

// parse — лёгкая работа: малая доля сэмплов.
//
//go:noinline
func parse(rounds int) int {
	n := 0
	for i := 0; i < rounds; i++ {
		n += i % 7
	}
	return n
}

// handle сам почти ничего не делает — только зовёт двоих. Его flat около
// нуля, а cum — почти всё время.
//
//go:noinline
func handle() int {
	hashAll(2000)
	return parse(20000)
}

// churn выделяет много короткоживущей памяти: ничего не удерживает.
//
//go:noinline
func churn(n int) {
	for i := 0; i < n; i++ {
		sink = make([]byte, 4096)
	}
}

var kept [][]byte

// retain выделяет немного, но держит всё выделенное до конца программы.
//
//go:noinline
func retain(n int) {
	for i := 0; i < n; i++ {
		kept = append(kept, make([]byte, 1<<20))
	}
}

// ----------------------------------------------------------------- pprof top

var dropPrefixes = []string{"File:", "Build ID:", "Time:", "Type:"}

func top(profile string, extra ...string) string {
	args := append([]string{"tool", "pprof", "-top", "-nodecount=6"}, extra...)
	args = append(args, profile)
	out, err := exec.Command("go", args...).CombinedOutput()
	if err != nil {
		panic(fmt.Sprintf("%v\n%s", err, out))
	}
	var keep []string
	for _, line := range strings.Split(strings.TrimRight(string(out), "\n"), "\n") {
		skip := false
		for _, p := range dropPrefixes {
			if strings.HasPrefix(line, p) {
				skip = true
			}
		}
		if !skip {
			keep = append(keep, "  "+line)
		}
	}
	return strings.Join(keep, "\n")
}

func grepLine(text, fn string) string {
	for _, line := range strings.Split(text, "\n") {
		if strings.HasSuffix(strings.TrimSpace(line), fn) {
			return line
		}
	}
	return "  в выводе нет строки " + fn
}

func cpuWork(d time.Duration) int {
	n := 0
	for start := time.Now(); time.Since(start) < d; {
		n += handle()
		churn(50)
	}
	return n
}

func main() {
	fmt.Printf("%s %s/%s, GOMAXPROCS=%d | профилирование\n",
		runtime.Version(), runtime.GOOS, runtime.GOARCH, runtime.GOMAXPROCS(0))
	dir, _ := os.MkdirTemp("", "goprof")
	defer os.RemoveAll(dir)

	// ---------------------------------------------------------- 1 и 2: CPU
	cpuPath := filepath.Join(dir, "cpu.pprof")
	f, _ := os.Create(cpuPath)
	pprof.StartCPUProfile(f)
	cpuWork(2 * time.Second)
	pprof.StopCPUProfile()
	f.Close()
	cpuTop := top(cpuPath, "-unit=ms")

	show("1) ПРОФИЛЬ CPU: 2 СЕКУНДЫ РАБОТЫ ОДНОЙ ГОРУТИНЫ")
	fmt.Println(cpuTop)
	fmt.Println()
	fmt.Println("  Сэмпл снимается 100 раз в секунду, то есть каждый весит 10 мс.")
	fmt.Println("  «Total samples» — это не число сэмплов, а сумма их времени.")

	show("2) FLAT ПРОТИВ CUM НА ОДНОЙ И ТОЙ ЖЕ ЦЕПОЧКЕ")
	full := top(cpuPath, "-nodecount=40", "-unit=ms")
	fmt.Println("        flat  flat%   sum%        cum   cum%")
	for _, fn := range []string{"main.hashAll", "main.parse", "main.handle"} {
		fmt.Println(grepLine(full, fn))
	}
	fmt.Println()
	fmt.Println("  flat — время в самой функции, cum — вместе со всеми, кого она")
	fmt.Println("  вызвала. handle почти ничего не делает сам, и по flat его не")
	fmt.Println("  видно; по cum он наверху, потому что под ним hashAll.")

	// ---------------------------------------------------------- 3: куча
	churn(20000) // ≈ 80 МиБ выделено и выброшено
	retain(16)   // 16 МиБ выделено и удержано
	runtime.GC() // профиль кучи отражает состояние на последнюю сборку
	heapPath := filepath.Join(dir, "heap.pprof")
	h, _ := os.Create(heapPath)
	pprof.Lookup("heap").WriteTo(h, 0)
	h.Close()

	show("3) ПРОФИЛЬ КУЧИ: alloc_space ПРОТИВ inuse_space")
	alloc := top(heapPath, "-sample_index=alloc_space", "-nodecount=40", "-unit=MB")
	inuse := top(heapPath, "-sample_index=inuse_space", "-nodecount=40", "-unit=MB")
	fmt.Println("  alloc_space — сколько выделено за всё время:")
	fmt.Println(grepLine(alloc, "main.churn"))
	fmt.Println(grepLine(alloc, "main.retain"))
	fmt.Println("  inuse_space — сколько удерживается сейчас:")
	fmt.Println(grepLine(inuse, "main.churn"))
	fmt.Println(grepLine(inuse, "main.retain"))
	fmt.Println()
	fmt.Println("  churn выделил больше всех, но ничего не держит — в inuse его")
	fmt.Println("  нет. Утечку ищут по inuse, нагрузку на сборщик — по alloc.")
	fmt.Printf("  Профиль кучи сэмплирует: в среднем одно выделение на\n")
	fmt.Printf("  runtime.MemProfileRate = %d байт.\n", runtime.MemProfileRate)

	// ---------------------------------------------------------- 4: блокировки
	show("4) ПРОФИЛИ БЛОКИРОВОК И МЬЮТЕКСОВ ПО УМОЛЧАНИЮ")
	contend := func() {
		var mu sync.Mutex
		var wg sync.WaitGroup
		ch := make(chan int)
		wg.Add(4)
		for g := 0; g < 4; g++ {
			go func() {
				defer wg.Done()
				for i := 0; i < 2000; i++ {
					mu.Lock()
					time.Sleep(time.Microsecond)
					mu.Unlock()
				}
			}()
		}
		go func() { time.Sleep(20 * time.Millisecond); ch <- 1 }()
		<-ch
		wg.Wait()
	}
	contend()
	fmt.Printf("  без настройки:  block %d записей, mutex %d записей\n",
		pprof.Lookup("block").Count(), pprof.Lookup("mutex").Count())
	runtime.SetBlockProfileRate(1)
	runtime.SetMutexProfileFraction(1)
	contend()
	fmt.Printf("  после SetBlockProfileRate(1) и SetMutexProfileFraction(1):\n")
	fmt.Printf("                  block %d записей, mutex %d записей\n",
		pprof.Lookup("block").Count(), pprof.Lookup("mutex").Count())
	runtime.SetBlockProfileRate(0)
	runtime.SetMutexProfileFraction(0)
	fmt.Println()
	fmt.Println("  Оба профиля выключены, пока их не включить в коде. Снятый")
	fmt.Println("  без этого профиль пуст — и пустой не значит «блокировок нет».")

	// ---------------------------------------------------------- 5: горутины
	show("5) ПРОФИЛЬ ГОРУТИН НАХОДИТ УТЕЧКУ")
	before := pprof.Lookup("goroutine").Count()
	block := make(chan int)
	for i := 0; i < 100; i++ {
		go func() { <-block }() // никто никогда не отправит
	}
	time.Sleep(50 * time.Millisecond)
	after := pprof.Lookup("goroutine").Count()
	var buf bytes.Buffer
	pprof.Lookup("goroutine").WriteTo(&buf, 1)
	fmt.Printf("  горутин до: %d, после: %d\n", before, after)
	for _, line := range strings.Split(buf.String(), "\n") {
		if strings.HasPrefix(line, "100 @") {
			fmt.Println("  в профиле:", strings.Fields(line)[0], "горутин с одним и тем же стеком:")
		}
	}
	inStack := false
	for _, line := range strings.Split(buf.String(), "\n") {
		if strings.HasPrefix(line, "100 @") {
			inStack = true
			continue
		}
		if inStack {
			if !strings.HasPrefix(strings.TrimSpace(line), "#") {
				break
			}
			parts := strings.Fields(line) // #  адрес  функция+смещение  файл:строка
			fn := parts[2]
			if i := strings.Index(fn, "+0x"); i >= 0 {
				fn = fn[:i]
			}
			fmt.Printf("    %-28s %s\n", fn, filepath.Base(parts[3]))
		}
	}
	fmt.Println()
	fmt.Println("  Профиль горутин группирует их по стеку. Сотня одинаковых стеков,")
	fmt.Println("  стоящих на одном и том же приёме из канала, — и есть утечка.")

	// ---------------------------------------------------------- 6: цена
	show("6) ЦЕНА ПРОФИЛЯ CPU ДЛЯ САМОЙ ПРОГРАММЫ")
	measure := func(profiled bool) float64 {
		best := 1e18
		for r := 0; r < 5; r++ {
			if profiled {
				pprof.StartCPUProfile(&bytes.Buffer{})
			}
			start := time.Now()
			for i := 0; i < 400; i++ {
				handle()
			}
			el := float64(time.Since(start).Microseconds()) / 1000
			if profiled {
				pprof.StopCPUProfile()
			}
			if el < best {
				best = el
			}
		}
		return best
	}
	fmt.Printf("  %-7s %22s %18s %10s\n", "серия", "400 вызовов без профиля", "с профилем CPU", "надбавка")
	for series := 1; series <= 3; series++ {
		off, on := measure(false), measure(true)
		fmt.Printf("  %-7d %19.1f мс %15.1f мс %9.1f%%\n", series, off, on, 100*(on/off-1))
	}
	fmt.Println()
	fmt.Println("  В каждой серии — лучший из 5 кругов. Надбавка в пределах шума: сэмпл")
	fmt.Println("  берётся 100 раз в секунду, а не на каждом вызове. Поэтому")
	fmt.Println("  профиль CPU снимают и в продакшене, а -race — нет.")
}