Колко байта заема картата (мапа) в Golang?

Размерът на map в Golang не е фиксиран и зависи от много фактори:

• Брой елементи: Колкото повече елементи, толкова повече памет е необходима за тяхното съхранение.
• Размер на ключовете и стойностите: Всеки ключ и стойност заема памет. Стринг, слайсове, структури — всичко това влияе върху общия размер.
• Помощни данни на структурата hmap: map е указател към структурата hmap. Тази структура съдържа помощни полета:
  • брояч на елементи
  • указатели към кошове (buckets)
  • брояч на миграции (разрастване/намаляване)
  • и други метаданни
• Размер на кошовете (buckets): елементите се съхраняват в кошове. Всеки кош има фиксиран размер (обикновено 8 двойки ключ-стойност), но данните за ключовете и стойностите се съхраняват отделно, към които сочат указатели от коша. Кошовете могат да съдържат неизползвано пространство.
• Плътност на запълване: При добавяне на елементи map може да се пренасочва и да увеличава броя на кошовете, което изисква заделяне на нова памет.
• Подравняване на паметта: Go подравнява данните в паметта, което може да доведе до допълнителни байтове за осигуряване на правилен достъп.

Следователно, не е възможно да се посочи точен брой байтове, тъй като той се променя динамично в зависимост от съдържанието и растежа на map. Може да се оцени долна граница (памет за hmap и първия кош) и горна граница (сума от размерите на ключовете, стойностите, кошовете и помощните данни), но точният размер се определя от runtime на Go.

За оценка на размера може да се използва пакетът unsafe или инструменти за отстраняване на грешки, но те ще дадат размера в конкретен момент за конкретно съдържание.

// Пример за структура `hmap` (опростена)
// Структурата не е предназначена за директна употреба
// и полетата ѝ могат да се променят между версии на Go.
type hmap struct {
	// Забележка: форматът на `hmap` е описан в ../runtime/map.go.
	// Това е хеш таблица с кошове, заделени от heap на Go.
	// hmap.buckets сочи към срез от кошове (може да е nil).
	// Всеки кош е масив от `hmap.B` с размер B.
	// Позицията в коша съхранява ключ и стойност за един запис в map,
	// плюс байт tophash. Ключовете и стойностите се съхраняват в същия
	// запис на коша, като стойностите следват ключовете.
	// Ако размерите на ключ/стойност са големи, те се записват индиректно в
	// overflow кошове, започвайки от указатели за overflow в основните кошове.

	count     int // брой живи клетки; не е равно на 0, ако map има записи
	flags     uint8
	B         uint8  // логаритъм база 2 на броя кошове (може да побере до 2^B записи)
	noverflow uint16 // приблизителен брой overflow кошове
	hash0     uint32 // семе за хеш

	buckets    unsafe.Pointer // масив от 2^B коша, заделен в heap
	oldbuckets unsafe.Pointer // предишен масив от 2^B коша, заделен в heap

	nevacuate uintptr // брояч за напредък при евакуация (пренасяне на кошове към нови)

	// истина, когато типът на ключ или стойност има указатели, които трябва да се сканират
	keysize  uint8 // размер на типа ключ
	valuesize uint8 // размер на типа стойност
	elemsize  uint16 // размер на ключ + стойност (за in-place съхранение)

	// указател към срез от overflow кошове, заделен в heap
	overflow *[]*bmap
}

// Пример за структура `bmap` (опростена)
// Тип на кош.
type bmap struct {
	// Разположението на коша е сложно.
	// Вижте src/runtime/hashmap.go за подробности.
	tophash [8]uint8 // 8 байта tophash (един за всяка kv двойка)
	// следват ключове и след това стойности
	// следва указател за overflow
}