¿Cuántos bytes ocupa un mapa en 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. Las cadenas, slices, estructuras, todo esto afecta al tamaño total.
• Datos de servicio de la estructura hmap: map es un puntero a la estructura hmap. Esta estructura contiene campos de servicio:
  • contador de elementos
  • punteros a las cubetas (buckets)
  • contador de migraciones (crecer/reducir)
  • y otros metadatos
• Tamaño de las cubetas (buckets): Los elementos se almacenan en cubetas. Cada cubeta tiene un tamaño fijo (normalmente 8 pares clave-valor), pero los datos de claves y valores se almacenan por separado, a los que apuntan los punteros desde la cubeta. Las cubetas pueden contener espacio no utilizado.
• Densidad de llenado: Al agregar elementos, el mapa puede volver a hash y aumentar el número de cubetas, 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 se puede 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 la primera cubeta) y un límite superior (suma de tamaños de claves, valores, cubetas y datos de servicio), 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 del hmap se describe en ../runtime/map.go.
	// Es una tabla hash con cubetas asignadas desde el montón de Go.
	// hmap.buckets apunta a la rebanada de cubetas (puede ser nil).
	// Cada cubeta es un array de entradas hmap.B, donde B es el tamaño de la cubeta.
	// Una entrada de cubeta almacena la clave y el valor para una sola entrada del mapa,
	// además de un byte tophash. Las claves y valores se almacenan en la misma
	// entrada de cubeta, con los valores siguiendo a las claves.
	// Si los tamaños de clave/valor son grandes, se escriben indirectamente en
	// cubetas de desbordamiento, comenzando a través de punteros de desbordamiento en
	// las cubetas principales.

	count     int // # de celdas vivas; no es cero si el mapa tiene entradas
	flags     uint8
	B         uint8  // log_2 de # cubetas (puede contener hasta 2^B entradas)
	noverflow uint16 // número aproximado de cubetas de desbordamiento
	hash0     uint32 // semilla hash

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

	nevacuate uintptr // contador de progreso para evacuación (cubetas movidas a nuevas)

	// 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 lugar)

	// puntero a una rebanada de cubetas de desbordamiento, asignado en el montón
	overflow *[]*bmap
}

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