//go:build ignore

// Множество на карте: сколько памяти экономит значение struct{}.
//
// ЗАЧЕМ ЭТА ПРОГРАММА. map[string]struct{} советуют как множество, «потому что
// пустая структура весит 0 байт». Само утверждение верно — unsafe.Sizeof
// пустой структуры равен нулю (internals.go, раздел 6). Но карта хранит не
// значение отдельно, а пару ключ–значение, и пара — это тоже структура. Если
// пустое значение стоит в ней последним, компилятор добавляет к паре байт, а
// выравнивание превращает его в целое слово. Сколько от экономии остаётся,
// видно только замером.
//
// ЧТО МЕРИТСЯ. Три карты на один и тот же миллион строковых ключей:
// значения struct{}, bool и int64. Ключи создаются заранее и в замер не
// входят. Мерится прирост HeapAlloc после runtime.GC(): то, что карта держит
// живым. Каждая карта строится трижды, берётся наименьший прирост; округление
// до целого мегабайта убирает шум в сотню килобайт между запусками.
//
// ВТОРОЙ РАЗДЕЛ — модель слота: структура из ключа и значения, такая же, какую
// компилятор строит для слота карты (cmd/compile/internal/reflectdata/
// map_swiss.go, SwissMapGroupType). Её размер печатает unsafe.Sizeof.
//
// ЗАПУСК:
//
//	go run bench/gostruct/sets.go
//	GOEXPERIMENT=noswissmap go run bench/gostruct/sets.go   # прежняя реализация карт
package main

import (
	"fmt"
	"os"
	"runtime"
	"strconv"
	"strings"
	"unsafe"
)

const N = 1_000_000

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

func heap() uint64 {
	runtime.GC()
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	return m.HeapAlloc
}

var (
	sinkEmpty map[string]struct{}
	sinkBool  map[string]bool
	sinkInt   map[string]int64
)

// grow строит карту и возвращает, сколько байт кучи она держит. Карта
// остаётся в глобальной переменной до замера, затем отпускается.
func grow(keys []string, build func([]string)) uint64 {
	best := ^uint64(0)
	for round := 0; round < 3; round++ {
		before := heap()
		build(keys)
		if d := heap() - before; d < best {
			best = d
		}
		sinkEmpty, sinkBool, sinkInt = nil, nil, nil
	}
	return best
}

type slotEmpty struct {
	key  string
	elem struct{}
}

type slotBool struct {
	key  string
	elem bool
}

type slotInt struct {
	key  string
	elem int64
}

func main() {
	exp := os.Getenv("GOEXPERIMENT")
	if exp == "" {
		exp = "по умолчанию"
	}
	fmt.Printf("%s %s/%s | множество на карте: сколько весит значение (GOEXPERIMENT: %s)\n",
		runtime.Version(), runtime.GOOS, runtime.GOARCH, exp)

	keys := make([]string, N)
	for i := range keys {
		keys[i] = "key-" + strconv.Itoa(i)
	}

	empty := grow(keys, func(ks []string) {
		sinkEmpty = make(map[string]struct{})
		for _, k := range ks {
			sinkEmpty[k] = struct{}{}
		}
	})
	boolean := grow(keys, func(ks []string) {
		sinkBool = make(map[string]bool)
		for _, k := range ks {
			sinkBool[k] = true
		}
	})
	integer := grow(keys, func(ks []string) {
		sinkInt = make(map[string]int64)
		for _, k := range ks {
			sinkInt[k] = 1
		}
	})

	mb := func(b uint64) float64 { return float64(b) / 1e6 }
	show("1) КАРТА НА 1 000 000 СТРОКОВЫХ КЛЮЧЕЙ")
	fmt.Printf("  map[string]struct{}   %3.0f МБ\n", mb(empty))
	fmt.Printf("  map[string]bool       %3.0f МБ\n", mb(boolean))
	fmt.Printf("  map[string]int64      %3.0f МБ\n", mb(integer))
	fmt.Printf("  bool против struct{}: %.2f\n", float64(boolean)/float64(empty))
	fmt.Println("  Наименьший прирост HeapAlloc из 3 построений; ключи созданы")
	fmt.Println("  заранее и в замер не входят.")

	show("2) СЛОТ КАРТЫ: КЛЮЧ И ЗНАЧЕНИЕ ОДНОЙ СТРУКТУРОЙ")
	fmt.Printf("  struct{ key string; elem struct{} }  %d байт\n", unsafe.Sizeof(slotEmpty{}))
	fmt.Printf("  struct{ key string; elem bool }      %d байт\n", unsafe.Sizeof(slotBool{}))
	fmt.Printf("  struct{ key string; elem int64 }     %d байт\n", unsafe.Sizeof(slotInt{}))
	if strings.Contains(exp, "noswissmap") {
		fmt.Println("  Эта реализация карт так пары не хранит: в корзине сначала лежат")
		fmt.Println("  все ключи, затем все значения (runtime/map_noswiss.go), и")
		fmt.Println("  выравнивать пустое значение не к чему.")
		return
	}
	fmt.Println("  Пустое значение в конце пары получает байт, и выравнивание до 8")
	fmt.Println("  делает из пары те же 24 байта, что у bool и int64.")
}