//go:build ignore

// Цена рефлексии: присвоить одно поле структуры четырьмя способами.
//
// ЗАЧЕМ ЭТОТ ЗАМЕР. «Рефлексия медленная» — правда, но без числа это не
// ответ. Здесь видно, ИЗ ЧЕГО складывается цена: поиск поля по имени,
// получение reflect.Value и сама запись через него. И видно, что делают
// библиотеки вроде encoding/json, чтобы платить меньше: ищут поле по имени
// один раз на тип и дальше ходят по запомненному индексу.
//
// ЧЕТЫРЕ СПОСОБА:
//
//  1. cfg.Port = n — обычное присваивание, компилятор знает смещение поля.
//  2. ValueOf(&cfg).Elem().FieldByName("Port").SetInt — поиск по имени на
//     каждый вызов.
//  3. ValueOf(&cfg).Elem().Field(idx).SetInt — индекс поля найден заранее.
//  4. field.SetInt — заранее найден и сам reflect.Value поля.
//
// И отдельно — только поиск, без записи: FieldByName("Host") (первое поле,
// одно сравнение имён) против FieldByName("Port") (седьмое, семь сравнений).
// Разница между ними — цена шести лишних сравнений имён; то, что стоит
// первое поле, — постоянная часть: сборка описания поля StructField
// (reflect/type.go:1101) и переход к полю по индексу.
//
// Время — лучший из 15 кругов testing.Benchmark по 300 мс, наносекунды на
// операцию, округлены до сотых. Круги способов чередуются. Аллокации — из
// того же круга.
//
// ЗАПУСК:
//
//	go run bench/goreflect/cost.go
package main

import (
	"flag"
	"fmt"
	"reflect"
	"runtime"
	"strings"
	"testing"
)

type Config struct {
	Host     string
	User     string
	Password string
	Database string
	Timeout  int
	Retries  int
	Port     int
	Debug    bool
}

var cfg Config

// sinkV не даёт компилятору выбросить результат поиска.
var sinkV reflect.Value

const rounds = 15

type result struct {
	ns     float64
	allocs int64
	bytes  int64
}

// measure прогоняет все способы по кругу и для каждого берёт лучший круг.
// Круги чередуются, а не идут подряд для одного способа: на общей машине
// фоновая нагрузка тогда достаётся всем способам поровну, а не одному.
func measure(fs []func(b *testing.B)) []result {
	out := make([]result, len(fs))
	for i := range out {
		out[i].ns = 1e18
	}
	for round := 0; round < rounds; round++ {
		for i, f := range fs {
			br := testing.Benchmark(func(b *testing.B) {
				b.ReportAllocs()
				f(b)
			})
			if ns := float64(br.T.Nanoseconds()) / float64(br.N); ns < out[i].ns {
				out[i] = result{ns: ns, allocs: br.AllocsPerOp(), bytes: br.AllocedBytesPerOp()}
			}
		}
	}
	return out
}

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

func main() {
	fmt.Printf("%s %s/%s | цена рефлексии: запись одного поля\n",
		runtime.Version(), runtime.GOOS, runtime.GOARCH)

	// Короче стандартной секунды на круг: кругов больше, и лучший из них
	// чаще попадает на спокойную машину.
	testing.Init()
	flag.Set("test.benchtime", "300ms")

	sf, _ := reflect.TypeOf(Config{}).FieldByName("Port")
	idx := sf.Index[0]
	field := reflect.ValueOf(&cfg).Elem().Field(idx)

	rs := measure([]func(b *testing.B){
		func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				cfg.Port = i
			}
		},
		func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				reflect.ValueOf(&cfg).Elem().FieldByName("Port").SetInt(int64(i))
			}
		},
		func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				reflect.ValueOf(&cfg).Elem().Field(idx).SetInt(int64(i))
			}
		},
		func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				field.SetInt(int64(i))
			}
		},
		func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				sinkV = reflect.ValueOf(&cfg).Elem().FieldByName("Host")
			}
		},
		func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				sinkV = reflect.ValueOf(&cfg).Elem().FieldByName("Port")
			}
		},
	})
	direct, byName, byIndex, cached := rs[0], rs[1], rs[2], rs[3]
	findFirst, findSeventh := rs[4], rs[5]

	show("1) ЗАПИСЬ ПОЛЯ PORT ЧЕТЫРЬМЯ СПОСОБАМИ")
	fmt.Printf("  поле Port — седьмое из восьми, индекс %d\n", idx)
	fmt.Println()
	fmt.Printf("  %-36s %7s %6s %5s\n", "способ", "нс/оп", "аллок", "байт")
	rows := []struct {
		name string
		r    result
	}{
		{"cfg.Port = n", direct},
		{"ValueOf(&cfg).Elem().FieldByName", byName},
		{"ValueOf(&cfg).Elem().Field(idx)", byIndex},
		{"field.SetInt (Value поля запомнен)", cached},
	}
	for _, row := range rows {
		fmt.Printf("  %-36s %7.2f %6d %5d\n",
			row.name, row.r.ns, row.r.allocs, row.r.bytes)
	}
	fmt.Println()
	fmt.Printf("  FieldByName дороже Field(idx)          в %4.1f раза\n", byName.ns/byIndex.ns)
	fmt.Printf("  Field(idx) дороже запомненного Value   в %4.1f раза\n", byIndex.ns/cached.ns)
	fmt.Println("  Прямое присваивание — одна запись в память; кратность к нему")
	fmt.Println("  не печатается: делитель меньше наносекунды и сам по себе шум.")
	fmt.Println()
	fmt.Printf("  Лучший из %d кругов. %s %s/%s, GOMAXPROCS=%d\n",
		rounds, runtime.Version(), runtime.GOOS, runtime.GOARCH, runtime.GOMAXPROCS(0))
	fmt.Println()
	fmt.Println("  Дороже всего поиск по имени: FieldByName на каждый вызов")
	fmt.Println("  перебирает поля типа и собирает описание найденного поля.")
	fmt.Println("  Индекс, найденный один раз, убирает поиск; запомненный Value")
	fmt.Println("  поля убирает и ValueOf с Elem. Остаётся проверка флагов и Kind")
	fmt.Println("  в SetInt.")

	show("2) ПОИСК ПО ИМЕНИ: ПЕРВОЕ ПОЛЕ ПРОТИВ СЕДЬМОГО")
	fmt.Printf("  %-36s %7s %6s %5s\n", "только поиск, без записи", "нс/оп", "аллок", "байт")
	for _, row := range []struct {
		name string
		r    result
	}{
		{"FieldByName(\"Host\") — 1-е поле", findFirst},
		{"FieldByName(\"Port\") — 7-е поле", findSeventh},
	} {
		fmt.Printf("  %-36s %7.2f %6d %5d\n",
			row.name, row.r.ns, row.r.allocs, row.r.bytes)
	}
	fmt.Println()
	fmt.Printf("  поиск 1-го поля / поиск 7-го поля     %5.2f\n", findFirst.ns/findSeventh.ns)
	fmt.Println()
	fmt.Println("  У первого поля одно сравнение имён, у седьмого — семь, а цена")
	fmt.Println("  различается далеко не в семь раз. Большая её часть постоянна:")
	fmt.Println("  это то, что делается после того, как поле найдено, — сборка")
	fmt.Println("  описания StructField и переход к полю по индексу.")
}