//go:build ignore

// Две задачи урока про указатели: обе отвечают прогоном.
//
// ЗАДАЧА 1 — ПРЕДСКАЗАТЬ ВЫВОД. Три места, где интуиция «указатель — это
// ссылка» подводит: присваивание параметру-указателю не видно снаружи,
// изменение через него — видно; указатель на элемент среза после append,
// который перевыделил массив, пишет в старый массив.
//
// ЗАДАЧА 2 — ОЦЕНИТЬ КРАТНОСТЬ. Во сколько раз функция, которая создаёт
// структуру в килобайт и возвращает указатель на неё (newBig), дороже той,
// что возвращает ту же структуру значением (makeBig). Указатель на
// переменную функции заставляет её уйти в кучу, а выделение дороже копии.
//
// Рядом — цена «для раздела Глубже»: передача в функцию 16 Б и 1 КБ по
// значению и по указателю. Она объясняет, откуда берётся совет «передавайте
// большое по указателю», и показывает, что он верен только для передачи.
//
// ЗАПУСК:
//
//	go run bench/goptr/practice.go
package main

import (
	"fmt"
	"runtime"
	"testing"
	"unsafe"
)

// ---------------------------------------------------------------- задача 1

func reset(p *int) { p = nil }
func set(p *int)   { *p = 7 }

func task1() {
	x := 1
	p := &x
	reset(p)
	fmt.Println(p == nil)
	set(p)
	fmt.Println(x)
	s := []int{1, 2, 3}
	q := &s[0]
	s = append(s, 4)
	*q = 100
	fmt.Println(s[0], *q)
}

// ---------------------------------------------------------------- задача 2

type Small struct{ A, B int64 } // 16 байт
type Big struct{ A [128]int64 } // 1024 байта

//go:noinline
func smallByValue(s Small) int64 { return s.A + s.B }

//go:noinline
func smallByPointer(s *Small) int64 { return s.A + s.B }

//go:noinline
func bigByValue(b Big) int64 { return b.A[0] + b.A[127] }

//go:noinline
func bigByPointer(b *Big) int64 { return b.A[0] + b.A[127] }

// makeBig возвращает значение: копия, но без кучи.
//
//go:noinline
func makeBig() Big {
	var b Big
	b.A[0] = 1
	return b
}

// newBig возвращает указатель на свою переменную: она уходит в кучу.
//
//go:noinline
func newBig() *Big {
	b := &Big{}
	b.A[0] = 1
	return b
}

var sink int64

type result struct {
	ns     float64
	allocs int64
	bytes  int64
}

// best — лучший из 11 кругов testing.Benchmark: минимум отсекает помехи
// соседей по машине, но не делает число свойством языка.
func best(f func(b *testing.B)) result {
	lo := result{ns: 1e18}
	for round := 0; round < 11; round++ {
		r := testing.Benchmark(func(b *testing.B) {
			b.ReportAllocs()
			f(b)
		})
		if ns := float64(r.T.Nanoseconds()) / float64(r.N); ns < lo.ns {
			lo = result{ns: ns, allocs: r.AllocsPerOp(), bytes: r.AllocedBytesPerOp()}
		}
	}
	return lo
}

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

	fmt.Println()
	fmt.Println("ЗАДАЧА 2 — цена: значение против указателя")
	fmt.Println()
	small := Small{1, 2}
	big := Big{}
	big.A[0], big.A[127] = 1, 2

	sv := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sink = smallByValue(small)
		}
	})
	sp := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sink = smallByPointer(&small)
		}
	})
	bv := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sink = bigByValue(big)
		}
	})
	bp := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			sink = bigByPointer(&big)
		}
	})
	fmt.Printf("  размер   значение   указатель   кратность\n")
	fmt.Printf("  %4d Б   %6.2f нс  %6.2f нс   %5.2f\n", unsafe.Sizeof(small), sv.ns, sp.ns, sv.ns/sp.ns)
	fmt.Printf("  %4d Б   %6.2f нс  %6.2f нс   %5.2f\n", unsafe.Sizeof(big), bv.ns, bp.ns, bv.ns/bp.ns)

	fmt.Println()
	fmt.Println("  Оговорка: указатель, возвращённый из функции, — это куча")
	mv := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			v := makeBig()
			sink += v.A[0]
		}
	})
	np := best(func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			p := newBig()
			sink += p.A[0]
		}
	})
	fmt.Printf("  makeBig() Big    %6.2f нс   выделений %d, байт %d\n", mv.ns, mv.allocs, mv.bytes)
	fmt.Printf("  newBig()  *Big   %6.2f нс   выделений %d, байт %d\n", np.ns, np.allocs, np.bytes)
	fmt.Printf("  кратность newBig / makeBig        %.1f\n", np.ns/mv.ns)

	fmt.Println()
	fmt.Printf("  Лучший из 11 кругов. %s %s/%s, GOMAXPROCS=%d\n",
		runtime.Version(), runtime.GOOS, runtime.GOARCH, runtime.GOMAXPROCS(0))
}