//go:build ignore

// Детектор гонок: что он находит, чего не находит и сколько стоит.
//
// ЗАЧЕМ ОТДЕЛЬНАЯ ПРОГРАММА. Отчёт детектора появляется только у бинарника,
// собранного с -race, а главные вопросы о детекторе — сравнительные: тот же
// код с флагом и без, тот же код с гонкой на выполненном пути и на
// невыполненном. Поэтому здесь программы из racy/ собираются дважды и
// запускаются как отдельные процессы, а их вывод и коды выхода печатаются.
//
// ЧЕТЫРЕ СЮЖЕТА:
//
//  1. Гонка, которая не испортила результат. Детектор её всё равно видит:
//     он ищет не неверный ответ, а доступы без happens-before.
//  2. Гонка на пути, который не выполнился. Детектор её не видит.
//  3. Состязание без гонки данных (проверка и действие под разными захватами
//     замка). Детектор молчит, а ошибка есть.
//  4. Цена: время и пиковая память той же нагрузки с -race и без.
//
// ОТЧЁТ ПЕЧАТАЕТСЯ НЕ ЦЕЛИКОМ. Адреса в памяти, абсолютные пути и смещения
// (+0x99) меняются от машины к машине и от сборки к сборке; они заменены, а
// строки с номерами строк исходника оставлены как есть.
//
// ЗАПУСК:
//
//	go run bench/gorace/detector.go
package main

import (
	"bytes"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"runtime"
	"sort"
	"strings"
	"syscall"
	"time"
)

var here string

func build(dir string, race bool) string {
	out := filepath.Join(os.TempDir(), "gorace-"+filepath.Base(dir)+map[bool]string{true: "-race", false: ""}[race])
	args := []string{"build", "-o", out}
	if race {
		args = append(args, "-race")
	}
	args = append(args, ".")
	cmd := exec.Command("go", args...)
	cmd.Dir = filepath.Join(here, "racy", dir)
	if b, err := cmd.CombinedOutput(); err != nil {
		panic(fmt.Sprintf("сборка %s: %v\n%s", dir, err, b))
	}
	return out
}

type result struct {
	out      string
	code     int
	wall     time.Duration
	maxrssKB int64
}

func run(bin string, args ...string) result {
	var buf bytes.Buffer
	cmd := exec.Command(bin, args...)
	cmd.Stdout, cmd.Stderr = &buf, &buf
	start := time.Now()
	err := cmd.Run()
	wall := time.Since(start)
	code := 0
	if ee, ok := err.(*exec.ExitError); ok {
		code = ee.ExitCode()
	} else if err != nil {
		panic(err)
	}
	ru := cmd.ProcessState.SysUsage().(*syscall.Rusage)
	return result{buf.String(), code, wall, ru.Maxrss}
}

var (
	addr   = regexp.MustCompile(`0x[0-9a-f]{6,}`)
	offset = regexp.MustCompile(` \+0x[0-9a-f]+$`)
	path   = regexp.MustCompile(`\S*/racy/`)
)

func clean(s string) string {
	var out []string
	for _, line := range strings.Split(strings.TrimRight(s, "\n"), "\n") {
		line = addr.ReplaceAllString(line, "0x…")
		line = offset.ReplaceAllString(line, "")
		line = path.ReplaceAllString(line, "racy/")
		if strings.TrimSpace(line) == "" {
			out = append(out, "")
			continue
		}
		out = append(out, "    "+line)
	}
	return strings.Join(out, "\n")
}

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

func median(xs []float64) float64 {
	sort.Float64s(xs)
	return xs[len(xs)/2]
}

func main() {
	_, file, _, _ := runtime.Caller(0)
	here = filepath.Dir(file)
	fmt.Printf("%s %s/%s, GOMAXPROCS=%d | детектор гонок\n", runtime.Version(), runtime.GOOS, runtime.GOARCH, runtime.GOMAXPROCS(0))

	show("1) ГОНКА, КОТОРАЯ НЕ ИСПОРТИЛА РЕЗУЛЬТАТ")
	plain := run(build("counter", false))
	fmt.Printf("  без -race: %s, код выхода %d\n", strings.TrimSpace(plain.out), plain.code)
	raced := run(build("counter", true))
	fmt.Printf("  с -race, код выхода %d:\n", raced.code)
	fmt.Println(clean(raced.out))

	show("2) ГОНКА НА ПУТИ, КОТОРЫЙ НЕ ВЫПОЛНИЛСЯ")
	bin := build("branch", true)
	common := run(bin)
	fmt.Printf("  с -race, обычный путь: код выхода %d, отчётов %d\n",
		common.code, strings.Count(common.out, "WARNING: DATA RACE"))
	rare := run(bin, "rare")
	fmt.Printf("  с -race, редкий путь:  код выхода %d, отчётов %d\n",
		rare.code, strings.Count(rare.out, "WARNING: DATA RACE"))
	for _, l := range strings.Split(clean(rare.out), "\n") {
		if strings.Contains(l, "main.go:") {
			fmt.Println("  в отчёте:", strings.TrimSpace(l))
			break
		}
	}

	show("3) СОСТЯЗАНИЕ БЕЗ ГОНКИ ДАННЫХ")
	ca := run(build("checkact", true))
	fmt.Printf("  с -race: %s; код выхода %d, отчётов %d\n",
		strings.TrimSpace(ca.out), ca.code, strings.Count(ca.out, "WARNING: DATA RACE"))
	fmt.Println("  Каждое обращение к балансу под замком, поэтому гонки данных")
	fmt.Println("  нет и детектору нечего сообщить. Ошибка — в том, что проверка")
	fmt.Println("  и списание сделаны под РАЗНЫМИ захватами.")

	show("4) ЦЕНА: ТА ЖЕ НАГРУЗКА С -race И БЕЗ")
	const rounds = 5
	plainBin, raceBin := build("workload", false), build("workload", true)
	measure := func(b string) (float64, float64) {
		var ts, ms []float64
		for i := 0; i < rounds; i++ {
			r := run(b)
			ts = append(ts, float64(r.wall.Microseconds())/1000)
			ms = append(ms, float64(r.maxrssKB)/1024)
		}
		return median(ts), median(ms)
	}
	fmt.Printf("  %-8s %10s %10s %9s %10s %10s %9s\n", "серия",
		"время", "с -race", "кратн.", "память", "с -race", "кратн.")
	for series := 1; series <= 3; series++ {
		t0, m0 := measure(plainBin)
		t1, m1 := measure(raceBin)
		fmt.Printf("  %-8d %7.0f мс %7.0f мс %8.1fx %6.1f МиБ %6.1f МиБ %8.1fx\n",
			series, t0, t1, t1/t0, m0, m1, m1/m0)
	}
	fmt.Println()
	fmt.Printf("  В каждой серии — медиана из %d запусков. Кратность зависит от\n", rounds)
	fmt.Println("  нагрузки и от прогона к прогону гуляет заметно — особенно по")
	fmt.Println("  времени. Число переносить нельзя, порядок — можно: -race — это")
	fmt.Println("  режим тестов и стендов, а не продакшена.")
}