Perché la prima allocazione (m) C++ è sempre 72 KB?

Il mistero dietro la tua prima allocazione C++

Scrivi un semplice programma C++. Un unico nuovo int. Quattro byte. Avvia strace o il tuo profiler di memoria preferito, ed eccolo lì: il tuo processo ha appena richiesto circa 72 KB dal sistema operativo. Non 4 byte. Non 64 byte. Ben 72 KB. Se hai mai fissato quel numero e ti sei chiesto se i tuoi strumenti ti stessero mentendo, non sei il solo. Questo comportamento apparentemente bizzarro è una delle domande più frequenti tra gli sviluppatori C++ che scavano per la prima volta negli interni della memoria e la risposta ci porta in un viaggio affascinante attraverso gli strati che si trovano tra il codice e l'hardware vero e proprio.

Cosa succede quando chiami nuovo

Per comprendere la cifra di 72 KB, è necessario tracciare l'intera catena di allocazione. Quando il codice C++ esegue new int, il compilatore lo traduce in una chiamata all'operatore new, che sulla maggior parte dei sistemi Linux delega a malloc da glibc. Ma malloc non richiede direttamente al kernel 4 byte di memoria. Il kernel opera in pagine, tipicamente 4 KB su x86_64, e il costo di una chiamata di sistema è enorme rispetto a un semplice accesso alla memoria. Chiamare brk() o mmap() per ogni singola allocazione farebbe fermare qualsiasi programma non banale.

Invece, l'allocatore di memoria di glibc - un'implementazione chiamata ptmalloc2, a sua volta discendente dal classico dlmalloc di Doug Lea - funge da intermediario. Richiede in anticipo grandi blocchi di memoria dal kernel, quindi li suddivide in pezzi più piccoli quando il tuo programma ne ha bisogno. Questo è il motivo fondamentale per cui la prima allocazione di 4 byte attiva una richiesta molto più grande al sistema operativo. L'allocatore non è uno spreco. È strategico.

Analizzare i 72 KB: dove vanno i byte

L'overhead di allocazione iniziale deriva da diversi componenti distinti che il runtime deve inizializzare prima di poter fornire anche un singolo byte di memoria utilizzabile. Comprendere ciascun componente spiega perché il numero arriva dove si trova.

Per prima cosa, il malloc di glibc inizializza l'arena principale — la struttura contabile primaria che tiene traccia di tutte le allocazioni sul thread principale. Questa arena include metadati per l'heap, puntatori a elenco libero e strutture di contenitori per diverse dimensioni di allocazione. L'allocatore estende l'interruzione del programma tramite sbrk() e l'estensione iniziale è governata da un parametro interno chiamato M_TOP_PAD, che per impostazione predefinita è 128 KB di riempimento. Tuttavia, la richiesta iniziale effettiva viene modificata in base all'allineamento della pagina e alla posizione di interruzione esistente, il che spesso si traduce in una prima richiesta più piccola, che in genere si avvicina alla cifra di 72 KB su un processo appena avviato.

In secondo luogo, a partire da glibc 2.26, l'allocatore inizializza una cache thread-local (tcache) al primo utilizzo. La tcache contiene 64 contenitori (uno per classe di piccola dimensione di allocazione), ciascuno in grado di contenere fino a 7 blocchi memorizzati nella cache. La stessa tcache_perthread_struct consuma circa 1 KB, ma l'atto di inizializzarla innesca la configurazione dell'arena più ampia. In terzo luogo, il runtime C++ ha già eseguito le allocazioni prima ancora che venga eseguito main(): i costruttori statici, l'inizializzazione del buffer iostream per std::cout e amici e la configurazione locale contribuiscono tutti all'impronta dell'heap iniziale.

Il sistema Arena e perché la pre-allocazione è intelligente

La decisione di pre-allocare una parte sostanziale di memoria invece di richiederla in modo frammentario non è un incidente di implementazione. Si tratta di un compromesso ingegneristico deliberato radicato in decenni di esperienza nella programmazione di sistemi. Ogni chiamata a brk() o mmap() implica un cambio di contesto dallo spazio utente allo spazio kernel, la modifica delle mappature della memoria virtuale del processo e potenziali aggiornamenti della tabella delle pagine. Sull’hardware moderno, una singola chiamata di sistema costa circa 100-200 nanosecondi: banale se isolata, catastrofica su larga scala.

Consideriamo un programma che effettua 10.000 piccole allocazioni durante l'inizializzazione. Senza la pre-allocazione, ciò significherebbe 10.000 chiamate di sistema, con un costo di circa 1-2 millisecondi di puro sovraccarico. Con un allocatore basato su arena, il primo trigg di allocazione

Related Posts

• La FCC chiede alle emittenti una programmazione "pro-America", come il Giuramento di Fedeltà quotidiano
• Un giudice del Minnesota dichiara un avvocato federale in oltraggio civile
• CXMT offre chip DDR4 a circa la metà del prezzo di mercato prevalente
• Scegliere un Linguaggio in Base alla Sua Sintassi?

Frequently Asked Questions

Da dove arrivano esattamente questi 72 KB?

I 72 KB non sono allocati dalla tua chiamata a `new`, ma dal "runtime" di C++ durante la sua inizializzazione. Prima che il tuo `main()` inizi, il runtime imposta strutture dati critiche per gestire la memoria. Una di queste è l'"heap", un pool di memoria da cui vengono soddisfatte le successive richieste di allocazione. Questa pre-allocazione iniziale, che può variare leggermente tra compilatori e sistemi operativi, garantisce che il programma abbia subito un blocco di memoria pronto per un uso efficiente.

Questo spreca memoria se alloco solo pochi oggetti?

Non è uno spreco, ma un compromesso per l'efficienza. Richiedere memoria al sistema operativo (tramite chiamate di sistema come `sbrk` o `mmap`) è un'operazione costosa. Allocando un blocco più grande all'inizio (72 KB), il runtime evita di dover interrompere il tuo programma con una chiamata di sistema ogni volta che fai un `new` per un piccolo oggetto. Gestisce invece le richieste al suo interno, in modo molto più veloce. È un classico esempio di "spazio contro tempo".

Posso controllare o modificare la dimensione di questa allocazione iniziale?

Sì, ma dipende dal tuo compilatore e dalla libreria standard (libc). Ad esempio, con GCC e la libc di GNU, è possibile influenzare questo comportamento tramite variabili d'ambiente (come `MALLOC_TOP_PAD_`) o utilizzare allocatori di memoria alternativi che offrono un maggiore controllo. Per un'analisi approfondita delle prestazioni e del comportamento della memoria nei tuoi progetti, strumenti di profilazione come quelli inclusi nei 207 moduli di Mewayz ($19/mo) sono indispensabili.

Questo significa che il mio programma utilizza sempre almeno 72 KB di memoria?

Sostanzialmente sì. Anche un programma "vuoto" che fa solo un'allocazione di pochi byte avrà questa memoria riservata per l'heap. Tuttavia, è importante ricordare che la "memoria riservata" non è la stessa cosa della "memoria fisica utilizzata". Il sistema operativo è intelligente e, finché non scrivi effettivamente in quella memoria, potrebbe non assegnare frame di RAM fisica. Questa è una distinzione cruciale che i profiler di memoria aiutano a chiarire.