//go:build ignore

// Гонка данных изнутри: что именно ломается, когда синхронизации нет.
//
// ЗАЧЕМ ЭТА ПРОГРАММА. «Гонка — это когда счётчик теряет инкременты» — так
// тему обычно и пересказывают, и из этого вырастает опасная мысль: если
// результат не важен до единицы, гонка безобидна. Здесь две вещи, которые эту
// мысль опровергают, и обе — на программе БЕЗ -race: детектор тут не нужен,
// нужен сам эффект.
//
//  1. РАЗОРВАННОЕ ЗНАЧЕНИЕ. Структура из двух слов, писатель всегда кладёт в
//     оба поля одно число. Читатель без синхронизации видит пары, которых
//     никто никогда не записывал. Модель памяти Go называет это прямо: гонка
//     на многословных значениях может дать «значение, не соответствующее ни
//     одной записи».
//  2. ФЛАГ БЕЗ СИНХРОНИЗАЦИИ. Цикл `for !done {}` из модели памяти, о котором
//     там сказано, что он может не завершиться никогда. Печатается, что
//     произошло на этой версии Go, — и это НЕ обещание: модель памяти
//     гарантирует обратное, то есть ничего.
//
// Программа содержит гонки намеренно. С -race её запускать незачем: отчёт
// будет, а наблюдать здесь нужно сам эффект.
//
// ЗАПУСК:
//
//	go run bench/gorace/internals.go
package main

import (
	"fmt"
	"runtime"
	"strings"
	"sync/atomic"
	"time"
)

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

// ------------------------------------------------ 1. разорванное значение

type pair struct{ a, b int64 }

var shared pair

// tornRound — 200 мс писатель кладёт {i, i}, читатель копирует структуру и
// проверяет, совпадают ли поля. Возвращает число разорванных копий и всех.
func tornRound() (torn, reads int) {
	var stop atomic.Bool
	ready := make(chan struct{})
	go func() {
		close(ready)
		for i := int64(1); !stop.Load(); {
			for j := 0; j < 1024; j++ {
				shared = pair{i, i}
				i++
			}
		}
	}()
	<-ready
	deadline := time.Now().Add(200 * time.Millisecond)
	for time.Now().Before(deadline) {
		for j := 0; j < 1024; j++ {
			x := shared
			reads++
			if x.a != x.b {
				torn++
			}
		}
	}
	stop.Store(true)
	return torn, reads
}

// ------------------------------------------------- 2. флаг без синхронизации

var done bool

func main() {
	fmt.Printf("%s %s/%s, GOMAXPROCS=%d | гонка данных изнутри\n",
		runtime.Version(), runtime.GOOS, runtime.GOARCH, runtime.GOMAXPROCS(0))

	show("1) РАЗОРВАННОЕ ЗНАЧЕНИЕ: struct{ a, b int64 }")
	fmt.Println("  писатель всегда кладёт {i, i}; читатель копирует без замка")
	fmt.Printf("  %-6s %16s %16s %8s\n", "круг", "прочитано", "a != b", "доля")
	for r := 1; r <= 5; r++ {
		torn, reads := tornRound()
		fmt.Printf("  %-6d %16d %16d %7.1f%%\n", r, reads, torn, 100*float64(torn)/float64(reads))
	}
	fmt.Println()
	fmt.Println("  Ни одной пары с разными полями никто не записывал. Копия")
	fmt.Println("  структуры из двух слов — не одно неделимое чтение, и писатель")
	fmt.Println("  успевает вклиниться посередине. Доля меняется от круга к кругу")
	fmt.Println("  и от машины к машине; устойчиво только то, что она не ноль.")

	show("2) ФЛАГ БЕЗ СИНХРОНИЗАЦИИ: for !done {}")
	seen := make(chan struct{})
	go func() {
		for !done {
		}
		close(seen)
	}()
	time.Sleep(10 * time.Millisecond)
	done = true
	select {
	case <-seen:
		fmt.Println("  на этой версии цикл увидел запись и завершился")
	case <-time.After(time.Second):
		fmt.Println("  цикл не увидел запись за 1 с")
	}
	fmt.Println()
	fmt.Println("  Это наблюдение, а не гарантия. Модель памяти про этот самый")
	fmt.Println("  цикл говорит, что он может не завершиться никогда: между")
	fmt.Println("  записью и чтением нет ни одного события синхронизации.")
}