Câți octeți ocupă o hartă (map) în Golang?

Dimensiunea map în Golang nu este fixă și depinde de mulți factori:

• Numărul de elemente: Cu cât sunt mai multe elemente, cu atât mai multă memorie este necesară pentru stocare.
• Dimensiunea cheilor și valorilor: Fiecare cheie și valoare ocupă memorie. Șirurile, slices, structurile – toate acestea influențează dimensiunea totală.
• Datele de serviciu ale structurii hmap: o mapă este un pointer către structura hmap. Această structură conține câmpuri de serviciu:
  • contor de elemente
  • pointeri către coșuri (buckets)
  • contor de migrații (creștere/micșorare)
  • și alte metadate
• Dimensiunea coșurilor (buckets): Elementele sunt stocate în coșuri. Fiecare coș are o dimensiune fixă (de obicei 8 perechi cheie-valoare), dar datele cheilor și valorilor sunt stocate separat, la care indică pointerii din coș. Coșurile pot conține spațiu neutilizat.
• Densitatea de umplere: La adăugarea elementelor, map-ul poate recalcula hash-ul și poate crește numărul de coșuri, ceea ce necesită alocarea de memorie nouă.
• Alinierea memoriei: Go aliniază datele în memorie, ceea ce poate duce la octeți suplimentari pentru a asigura accesul corect.

Prin urmare, nu se poate indica o cantitate exactă de octeți, deoarece aceasta se schimbă dinamic în funcție de conținut și de creșterea map-ului. Se poate estima o limită inferioară (memorie pentru hmap și primul coș) și o limită superioară (suma dimensiunilor cheilor, valorilor, coșurilor și datelor de serviciu), dar dimensiunea exactă este determinată de runtime-ul Go.

Pentru estimarea dimensiunii, se poate folosi pachetul unsafe sau instrumente de depanare, dar acestea vor oferi dimensiunea într-un anumit moment pentru un anumit conținut.

// Exemplu de structură hmap (simplificat)
// Structura nu este destinată pentru utilizare directă
// și câmpurile sale pot varia între versiunile Go.
type hmap struct {
	// Formatul hmap este descris în ../runtime/map.go.
	// Este un tabel de dispersie cu coșuri alocate din heap-ul Go.
	// hmap.buckets indică spre slice-ul de coșuri (poate fi nil).
	// Fiecare coș este un array de intrări hmap.B, unde B este dimensiunea coșului.
	// O intrare de coș stochează cheia și valoarea pentru o singură intrare de map,
	// plus un byte tophash. Cheile și valorile sunt stocate în aceeași
	// intrare de coș, cu valorile urmând cheile.
	// Dacă dimensiunile cheie/valoare sunt mari, sunt scrise indirect în
	// coșuri de overflow, începând cu pointeri de overflow în
	// coșurile principale.

	count     int // numărul de celule vii; nu este egal cu 0 dacă map-ul are intrări
	flags     uint8
	B         uint8  // log_2 al numărului de coșuri (poate conține până la 2^B intrări)
	noverflow uint16 // număr aproximativ de coșuri de overflow
	hash0     uint32 // seed-ul hash-ului

	buckets    unsafe.Pointer // array de 2^B coșuri, alocat pe heap
	oldbuckets unsafe.Pointer // array anterior de 2^B coșuri, alocat pe heap

	nevacuate uintptr // contor de progres pentru evacuare (coșuri mutate în cel nou)

	// adevărat când tipul de cheie sau valoare are pointeri care trebuie scanați
	keysize  uint8 // dimensiunea tipului de cheie
	valuesize uint8 // dimensiunea tipului de valoare
	elemsize  uint16 // dimensiunea cheie + valoare (pentru stocare in loc)

	// pointer către o slice de coșuri de overflow, alocat pe heap
	overflow *[]*bmap
}

// Exemplu de structură bmap (simplificat)
// Tipul de coș.
type bmap struct {
	// Dispunerea unui coș este complexă.
	// Vedeți src/runtime/hashmap.go pentru detalii.
	tophash [8]uint8 // 8 bytes de tophash (un pentru fiecare pereche cheie-valoare)
	// urmat de chei și apoi valori
	// urmat de un pointer de overflow
}