Πόι bytes καταλαμβάνει ένας χάρτης (map) στο Golang;

El tamaño del mapa en Golang no es fijo y depende de muchos factores:

• Cantidad de elementos: Cuantos más elementos, más memoria se necesita para almacenarlos.
• Tamaño de las claves y valores: Cada clave y valor ocupa memoria. Cadenas, slices, estructuras — todo esto afecta al tamaño total.
• Datos auxiliares de la estructura hmap: el mapa es un puntero a la estructura hmap. Esta estructura contiene campos auxiliares:
  • contador de elementos
  • punteros a los buckets
  • contador de migraciones (crecer/reducir)
  • y otros metadatos
• Tamaño de los buckets: Los elementos se almacenan en buckets. Cada bucket tiene un tamaño fijo (normalmente 8 pares clave-valor), pero los datos de las claves y valores se almacenan por separado, a los que apuntan los punteros desde el bucket. Los buckets pueden contener espacio no utilizado.
• Densidad de llenado: Al añadir elementos, el mapa puede volver a hash y aumentar el número de buckets, lo que requiere asignar nueva memoria.
• Alineación de memoria: Go alinea los datos en memoria, lo que puede llevar a bytes adicionales para garantizar un acceso correcto.

Por lo tanto, no es posible nombrar una cantidad exacta de bytes, ya que cambia dinámicamente dependiendo del contenido y el crecimiento del mapa. Se puede estimar un límite inferior (memoria para hmap y el primer bucket) y un límite superior (suma de tamaños de claves, valores, buckets y datos auxiliares), pero el tamaño exacto lo determina el runtime de Go.

Para estimar el tamaño, se puede usar el paquete unsafe o herramientas de depuración, pero darán el tamaño en un momento específico para un contenido específico.

// Ejemplo de estructura `hmap` (simplificada)
// La estructura no está destinada para uso directo
// y sus campos pueden cambiar entre versiones de Go.
type hmap struct {
	// Nota: el formato de `hmap` se describe en ../runtime/map.go.
	// Es una tabla hash con buckets asignados desde el montón de Go.
	// hmap.buckets apunta a un slice de buckets (puede ser nil).
	// Cada bucket es un array de entradas `hmap.B` de tamaño B.
	// Una entrada de bucket almacena la clave y el valor para una sola entrada del mapa,
	// además de un byte tophash. Las claves y los valores se almacenan en la misma
	// entrada del bucket, con los valores siguiendo a las claves.
	// Si los tamaños de clave/valor son grandes, se escriben indirectamente en
	// buckets de desbordamiento, comenzando por punteros de overflow en los buckets principales.

	count     int // número de celdas vivas; diferente de 0 si el mapa tiene entradas
	flags     uint8
	B         uint8  // log_2 del número de buckets (puede contener hasta 2^B entradas)
	noverflow uint16 // número aproximado de buckets de overflow
	hash0     uint32 // semilla hash

	buckets    unsafe.Pointer // array de buckets de 2^B, asignado en el montón
	oldbuckets unsafe.Pointer // array anterior de buckets de 2^B, asignado en el montón

	nevacuate uintptr // contador de progreso para evacuación (bucket movido a uno nuevo)

	// verdadero cuando el tipo de clave o valor tiene punteros que necesitan escaneo
	keysize  uint8 // tamaño del tipo de clave
	valuesize uint8 // tamaño del tipo de valor
	elemsize  uint16 // tamaño de clave + valor (para almacenamiento en el lugar)

	// puntero a un slice de buckets de overflow, asignado en el montón
	overflow *[]*bmap
}

// Ejemplo de estructura `bmap` (simplificada)
// Tipo de bucket.
type bmap struct {
	// La disposición de un bucket es compleja.
	// Ver src/runtime/hashmap.go para detalles.
	tophash [8]uint8 // 8 bytes de tophash (uno por par kv)
	// seguido por claves y luego valores
	// seguido por un puntero de overflow
}