Quanti byte occupa una mappa (map) in Golang?

La dimensione della mappa in Golang non è fissa e dipende da molti fattori:

• Numero di elementi: Più elementi ci sono, più memoria è necessaria per memorizzarli.
• Dimensione delle chiavi e dei valori: Ogni chiave e valore occupa memoria. Stringhe, slices, strutture – tutto ciò influisce sulla dimensione totale.
• Dati di servizio della struttura hmap: una mappa è un puntatore alla struttura hmap. Questa struttura contiene campi di servizio:
  • contatore di elementi
  • puntatori ai bucket
  • contatore di migrazioni (aumentare/diminuire)
  • e altri metadati
• Dimensione dei bucket: Gli elementi sono memorizzati nei bucket. Ogni bucket ha una dimensione fissa (di solito 8 coppie chiave-valore), ma i dati di chiavi e valori sono memorizzati separatamente, puntati dai puntatori all'interno del bucket. I bucket possono contenere spazio inutilizzato.
• Densità di riempimento: Quando si aggiungono elementi, la mappa può ricalcolare l'hash e aumentare il numero di bucket, il che richiede l'allocazione di nuova memoria.
• Allineamento della memoria: Go allinea i dati in memoria, il che può portare a byte aggiuntivi per garantire un accesso corretto.

Pertanto, non è possibile indicare una quantità precisa di byte, poiché cambia dinamicamente in base al contenuto e alla crescita della mappa. Si può stimare un limite inferiore (memoria per hmap e il primo bucket) e un limite superiore (somma delle dimensioni di chiavi, valori, bucket e metadati), ma la dimensione esatta è determinata dal runtime di Go.

Per stimare la dimensione, si può usare il pacchetto unsafe o strumenti di debug, ma forniranno la dimensione in un momento specifico per un contenuto specifico.

// Esempio di struttura hmap (semplificata)
// La struttura non è destinata all'uso diretto
// e i suoi campi possono cambiare tra le versioni di Go.
type hmap struct {
	// Il formato di hmap è descritto in ../runtime/map.go.
	// È una tabella hash con bucket allocati dal heap di Go.
	// hmap.buckets punta alla slice di bucket (può essere nil).
	// Ogni bucket è un array di voci hmap.B, dove B è la dimensione del bucket.
	// Una voce di bucket memorizza la chiave e il valore per una singola entry della mappa,
	// più un byte tophash. Chiavi e valori sono memorizzati nella stessa
	// entry del bucket, con i valori che seguono le chiavi.
	// Se le dimensioni di chiave/valore sono grandi, vengono scritte indirettamente in
	// bucket di overflow, a partire da puntatori di overflow nei
	// bucket principali.

	count     int // numero di celle vive; diverso da zero se la mappa ha delle entry
	flags     uint8
	B         uint8  // log_2 del numero di bucket (può contenere fino a 2^B entry)
	noverflow uint16 // numero approssimativo di bucket di overflow
	hash0     uint32 // seme di hash

	buckets    unsafe.Pointer // array di 2^B bucket, allocato in heap
	oldbuckets unsafe.Pointer // array precedente di 2^B bucket, allocato in heap

	nevacuate uintptr // contatore di progresso per evacuazione (bucket spostati in nuovo)

	// vero quando il tipo di chiave o valore ha puntatori che necessitano di scansione
	keysize  uint8 // dimensione del tipo di chiave
	valuesize uint8 // dimensione del tipo di valore
	elemsize  uint16 // dimensione di chiave + valore (per memorizzazione in-place)

	// puntatore a una slice di bucket di overflow, allocato in heap
	overflow *[]*bmap
}

// Esempio di struttura bmap (semplificata)
// Tipo di bucket.
type bmap struct {
	// La disposizione di un bucket è complessa.
	// Vedere src/runtime/hashmap.go per i dettagli.
	tophash [8]uint8 // 8 byte di tophash (uno per coppia chiave-valore)
	// seguito da chiavi e poi valori
	// seguito da un puntatore di overflow
}