¿Por qué la primera asignación de C++ (m) es siempre de 72 KB?

El misterio detrás de su primera asignación de C++

Escribes un programa simple en C++. Un único nuevo int. Cuatro bytes. Inicias strace o tu perfilador de memoria favorito, y ahí está: tu proceso acaba de solicitar aproximadamente 72 KB del sistema operativo. No 4 bytes. No 64 bytes. 72 KB completos. Si alguna vez miró fijamente ese número y se preguntó si sus herramientas le estaban mintiendo, no está solo. Este comportamiento aparentemente extraño es una de las preguntas más frecuentes entre los desarrolladores de C++ que investigan por primera vez los componentes internos de la memoria, y la respuesta nos lleva a un viaje fascinante a través de las capas que se encuentran entre el código y el hardware real.

¿Qué sucede cuando llamas nuevo?

Para comprender la cifra de 72 KB, es necesario rastrear la cadena de asignación completa. Cuando su código C++ ejecuta new int, el compilador lo traduce en una llamada al operador new, que en la mayoría de los sistemas Linux delega a malloc desde glibc. Pero malloc no solicita directamente al kernel 4 bytes de memoria. El kernel opera en páginas (generalmente 4 KB en x86_64) y el costo de una llamada al sistema es enorme en comparación con un simple acceso a la memoria. Llamar a brk() o mmap() para cada asignación individual haría que cualquier programa no trivial se detuviera.

En cambio, el asignador de memoria de glibc (una implementación llamada ptmalloc2, que a su vez desciende del clásico dlmalloc de Doug Lea) actúa como intermediario. Solicita grandes bloques de memoria del kernel por adelantado y luego los divide en pedazos más pequeños a medida que su programa los necesita. Esta es la razón fundamental por la que su primera asignación de 4 bytes desencadena una solicitud mucho mayor al sistema operativo. El asignador no está desperdiciando. Es ser estratégico.

Diseccionando los 72 KB: adónde van los bytes

La sobrecarga de asignación inicial proviene de varios componentes distintos que el tiempo de ejecución debe inicializar antes de poder entregarle incluso un solo byte de memoria utilizable. Comprender cada componente explica por qué el número llega a donde llega.

Primero, malloc de glibc inicializa la arena principal: la estructura de contabilidad principal que rastrea todas las asignaciones en el hilo principal. Este campo incluye metadatos para el montón, punteros de lista libre y estructuras de contenedores para diferentes tamaños de asignación. El asignador extiende la interrupción del programa a través de sbrk(), y la extensión inicial se rige por un parámetro interno llamado M_TOP_PAD, cuyo valor predeterminado es 128 KB de relleno. Sin embargo, la solicitud inicial real se ajusta según la alineación de la página y la posición de interrupción existente, lo que a menudo da como resultado una primera solicitud más pequeña, que generalmente se acerca a esa cifra de 72 KB en un proceso recién iniciado.

En segundo lugar, desde glibc 2.26, el asignador inicializa un caché local de subprocesos (tcache) en el primer uso. El tchache contiene 64 contenedores (uno por clase de tamaño de asignación pequeña), cada uno de ellos capaz de contener hasta 7 fragmentos almacenados en caché. El tcache_perthread_struct en sí consume alrededor de 1 KB, pero el acto de inicializarlo desencadena la configuración de arena más amplia. En tercer lugar, el tiempo de ejecución de C++ ya ha realizado asignaciones antes de que se ejecute main(): los constructores estáticos, la inicialización del búfer iostream para std::cout y amigos, y la configuración regional contribuyen a esa huella inicial del montón.

El sistema Arena y por qué la preasignación es inteligente

La decisión de preasignar una porción sustancial de memoria en lugar de solicitarla poco a poco no es un accidente de implementación. Es una compensación de ingeniería deliberada arraigada en décadas de experiencia en programación de sistemas. Cada llamada a brk() o mmap() implica un cambio de contexto del espacio del usuario al espacio del kernel, modificación de las asignaciones de memoria virtual del proceso y posibles actualizaciones de la tabla de páginas. En el hardware moderno, una sola llamada al sistema cuesta aproximadamente entre 100 y 200 nanosegundos: algo trivial de forma aislada, pero catastrófico a escala.

Considere un programa que realiza 10.000 asignaciones pequeñas durante la inicialización. Sin preasignación, eso significaría 10.000 llamadas al sistema, lo que costaría aproximadamente entre 1 y 2 milisegundos de gastos generales. Con un asignador basado en arena, la primera activación de asignación

Related Posts

• PayPal revela violación de datos que expuso la información del usuario durante 6 meses
• La Odisea Criptográfica de DJB: De Héroe del Código a Crítico de Estándares
• Show HN: Fostrom, una plataforma IoT en la nube creada para desarrolladores
• La mafia tecnológica gay

Frequently Asked Questions

¿Qué son exactamente estos 72 KB que asigna mi programa de C++?

Es la reserva de memoria inicial que el gestor de memoria dinámica (heap) de tu biblioteca estándar de C++ (como glibc en Linux) solicita al sistema operativo. Esta primera asignación, a menudo llamada "arena", no es para tu variable de 4 bytes, sino que es un bloque pre-reservado para futuras operaciones `new` o `malloc`. Esto evita tener que hacer una llamada al sistema por cada pequeña asignación posterior, mejorando significativamente el rendimiento. Herramientas como las de Mewayz (207 módulos, $19/mes) te permiten visualizar este comportamiento en tiempo real.

¿Por qué la biblioteca no asigna solo los 4 bytes que necesito?

Las llamadas al sistema operativo para gestionar memoria (como `sbrk` o `mmap`) son operaciones costosas. Si el runtime tuviera que pedir memoria al SO cada vez que usas `new`, el programa sería extremadamente lento. Al solicitar un bloque más grande (como 72 KB) de una vez, la biblioteca crea un "montón" inicial. Así, las siguientes asignaciones pequeñas se sirven de este bloque pre-asignado de manera muy eficiente, sin la sobrecarga de una nueva llamada al sistema por cada una.

¿Este tamaño de 72 KB es siempre el mismo?

No, el tamaño exacto puede variar. Depende de la implementación específica de la biblioteca estándar de C++ que uses (por ejemplo, glibc, musl, la de Microsoft VC++), la versión de dicha biblioteca y la configuración del sistema. 72 KB es un valor común para glibc en muchas configuraciones, pero no es una constante universal. Puedes encontrar este valor específico en la documentación de tu biblioteca o mediante herramientas de profiling.

¿Cómo puedo monitorear y analizar este comportamiento en mis programas?

Puedes usar herramientas como `strace` en Linux para ver las llamadas al sistema `mmap` o `brk`, o perfiladores de memoria específicos. Estas herramientas te muestran exactamente cuándo y cuánta memoria solicita tu proceso. Para un análisis más profundo y continuo del uso de memoria, incluyendo la detección de fugas, plataformas como Mewayz ofrecen módulos de profiling que detallan cada asignación, ayudándote a entender no solo el inicio, sino todo el ciclo de vida de la memoria en tu aplicación.