Pourquoi la première allocation C++ (m) est-elle toujours de 72 Ko ?

Le mystère derrière votre première allocation C++

Vous écrivez un programme C++ simple. Un seul nouvel int. Quatre octets. Vous lancez strace ou votre profileur de mémoire préféré, et le voilà : votre processus vient de demander environ 72 Ko au système d'exploitation. Pas 4 octets. Pas 64 octets. Un plein 72 Ko. Si vous avez déjà regardé ce chiffre et vous êtes demandé si votre outillage vous mentait, vous n'êtes pas seul. Ce comportement apparemment bizarre est l'une des questions les plus fréquemment posées par les développeurs C++ qui explorent pour la première fois les composants internes de la mémoire, et la réponse nous emmène dans un voyage fascinant à travers les couches qui se situent entre votre code et le matériel réel.

Que se passe-t-il lorsque vous appelez un nouveau

Pour comprendre le chiffre de 72 Ko, vous devez retracer la chaîne d'allocation complète. Lorsque votre code C++ exécute new int, le compilateur traduit cela en un appel à l'opérateur new, qui, sur la plupart des systèmes Linux, délègue à malloc depuis la glibc. Mais malloc ne demande pas directement au noyau 4 octets de mémoire. Le noyau fonctionne par pages – généralement 4 Ko sur x86_64 – et le coût d'un appel système est énorme par rapport à un simple accès mémoire. Appeler brk() ou mmap() pour chaque allocation individuelle arrêterait tout programme non trivial.

Au lieu de cela, l'allocateur de mémoire de la glibc — une implémentation appelée ptmalloc2, elle-même issue du classique dlmalloc de Doug Lea — agit comme un intermédiaire. Il demande dès le départ de gros blocs de mémoire au noyau, puis les découpe en morceaux plus petits selon les besoins de votre programme. C'est la raison fondamentale pour laquelle votre première allocation de 4 octets déclenche une requête beaucoup plus importante adressée au système d'exploitation. L'allocateur ne gaspille pas. C’est être stratégique.

Disséquer les 72 Ko : où vont les octets

La surcharge d'allocation initiale provient de plusieurs composants distincts que le runtime doit initialiser avant de pouvoir vous fournir ne serait-ce qu'un seul octet de mémoire utilisable. Comprendre chaque composant explique pourquoi le nombre atterrit là où il arrive.

Premièrement, le malloc de la glibc initialise l'arène principale — la structure comptable principale qui suit toutes les allocations sur le thread principal. Cette arène comprend des métadonnées pour le tas, des pointeurs de liste libre et des structures de bacs pour différentes tailles d'allocation. L'allocateur étend l'interruption du programme via sbrk(), et l'extension initiale est régie par un paramètre interne appelé M_TOP_PAD, qui est par défaut de 128 Ko de remplissage. Cependant, la requête initiale réelle est ajustée en fonction de l'alignement de la page et de la position des sauts existants, ce qui entraîne souvent une première requête plus petite – atterrissant généralement près de ce chiffre de 72 Ko sur un processus fraîchement démarré.

Deuxièmement, depuis la glibc 2.26, l'allocateur initialise un cache local de thread (tcache) lors de la première utilisation. Le tcache contient 64 bacs (un par classe de petite taille d'allocation), chacun capable de contenir jusqu'à 7 morceaux mis en cache. Le tcache_perthread_struct lui-même consomme environ 1 Ko, mais le fait de l'initialiser déclenche la configuration de l'arène plus large. Troisièmement, le runtime C++ a déjà effectué des allocations avant même l'exécution de votre main() : les constructeurs statiques, l'initialisation du tampon iostream pour std::cout et ses amis, et la configuration des paramètres régionaux contribuent tous à cette empreinte initiale du tas.

Le système Arena et pourquoi la pré-allocation est intelligente

La décision de pré-allouer une part importante de mémoire plutôt que de la demander au coup par coup n'est pas un hasard de mise en œuvre. Il s’agit d’un compromis d’ingénierie délibéré ancré dans des décennies d’expérience en programmation système. Chaque appel à brk() ou mmap() implique un changement de contexte de l'espace utilisateur à l'espace noyau, une modification des mappages de mémoire virtuelle du processus et des mises à jour potentielles de la table des pages. Sur le matériel moderne, un seul appel système coûte environ 100 à 200 nanosecondes, ce qui est trivial isolément, catastrophique à grande échelle.

Considérons un programme qui effectue 10 000 petites allocations lors de l'initialisation. Sans pré-allocation, cela signifierait 10 000 appels système, ce qui coûterait environ 1 à 2 millisecondes de temps système pur. Avec un allocateur basé sur l'arène, le premier déclencheur d'allocation

Related Posts

• L'IRS a perdu 40 % de son personnel informatique et 80 % de ses dirigeants technologiques lors d'une restructuration pour plus d'« efficacité »
• LCM : Gestion du contexte sans perte [pdf]
• Outil de sandboxing en ligne de commande peu connu de macOS (2025)
• Un seul vaccin pourrait protéger contre toutes les toux, rhumes et grippes

Frequently Asked Questions

D'où viennent ces 72 Ko exactement ?

Ces 72 Ko proviennent de l'« allocation initiale » du gestionnaire de tas (heap) de votre bibliothèque d'exécution C++ (souvent celle de GCC ou LLVM). Au premier appel à new ou malloc, l'allocateur ne demande pas seulement les octets nécessaires, mais une « zone » de mémoire plus importante au système d'exploitation. Cette zone, d'environ 64 Ko plus des en-têtes de gestion, sert de réserve pour les futures allocations, évitant ainsi des appels système coûteux pour chaque petit objet.

Est-ce que cela signifie que mon programme gaspille 72 Ko de mémoire ?

Pas exactement. Bien que 72 Ko soient réservés (ou « mappés ») par le processus, le système d'exploitation ne leur alloue de la mémoire physique que lorsqu'ils sont réellement écrits. Ce mécanisme, appelé « mémoire virtuelle », signifie que la mémoire physique n'est pas gaspillée. Cependant, cette réserve compte dans la taille de l'espace d'adressage virtuel du processus. Pour une analyse précise de l'utilisation mémoire, un outil comme Mewayz (207 modules, 19$/mois) est idéal.

Ce comportement est-il spécifique à C++ ?

Non, ce n'est pas spécifique au langage C++. C'est un comportement typique des gestionnaires de mémoire dynamique (malloc/free) fournis par la bibliothèque standard C (libc), que C++ utilise via l'opérateur new. Les programmes en C pur présentent le même phénomène. Le comportement exact (la taille de l'allocation initiale) peut varier selon la bibliothèque utilisée (par exemple, glibc sous Linux vs la CRT sous Windows).

Peut-on éviter ou réduire cette allocation initiale ?

En pratique, il est généralement déconseillé de le faire. Cette optimisation de l'allocateur réduit considérablement la surcharge des appels système pour les programmes qui effectuent de nombreuses petites allocations, améliorant les performances globales. Pour des cas d'usage très spécifiques où le contrôle fin de la mémoire est critique (p. ex., systèmes embarqués), on peut envisager des allocateurs personnalisés ou des pools mémoire, mais cela ajoute une complexité significative au développement.