Mengapa alokasi C++ (m) pertama selalu 72 KB?

Misteri Dibalik Alokasi C++ Pertama Anda

Anda menulis program C++ sederhana. Satu int baru. Empat byte. Anda menjalankan strace atau profiler memori favorit Anda, dan itu dia — proses Anda baru saja meminta sekitar 72 KB dari sistem operasi. Bukan 4 byte. Bukan 64 byte. Penuh 72 KB. Jika Anda pernah menatap nomor itu dan bertanya-tanya apakah peralatan Anda berbohong kepada Anda, Anda tidak sendirian. Perilaku yang tampaknya aneh ini adalah salah satu pertanyaan yang paling sering diajukan di kalangan pengembang C++ yang menggali internal memori untuk pertama kalinya, dan jawabannya membawa kita pada perjalanan menarik melalui lapisan yang berada di antara kode Anda dan perangkat keras sebenarnya.

Apa Yang Terjadi Saat Anda Menelepon baru

Untuk memahami angka 72 KB, Anda perlu menelusuri rantai alokasi penuh. Saat kode C++ Anda mengeksekusi int baru, kompiler menerjemahkannya menjadi panggilan ke operator new, yang pada sebagian besar sistem Linux didelegasikan ke malloc dari glibc. Tetapi malloc tidak secara langsung meminta memori 4 byte kepada kernel. Kernel beroperasi dalam halaman — biasanya 4 KB pada x86_64 — dan biaya panggilan sistem sangat besar dibandingkan dengan akses memori sederhana. Memanggil brk() atau mmap() untuk setiap alokasi individual akan membuat program non-sepele terhenti.

Sebaliknya, pengalokasi memori glibc — sebuah implementasi yang disebut ptmalloc2, yang merupakan turunan dari dlmalloc klasik Doug Lea — bertindak sebagai perantara. Ia meminta blok memori yang besar dari kernel terlebih dahulu, lalu membaginya menjadi bagian-bagian yang lebih kecil sesuai kebutuhan program Anda. Inilah alasan mendasar mengapa alokasi 4 byte pertama Anda memicu permintaan yang jauh lebih besar ke sistem operasi. Pengalokasi tidak boros. Hal ini bersifat strategis.

Membedah 72 KB: Kemana Perginya Byte

Overhead alokasi awal berasal dari beberapa komponen berbeda yang harus diinisialisasi oleh runtime sebelum dapat memberi Anda satu byte pun memori yang dapat digunakan. Memahami setiap komponen menjelaskan mengapa angka tersebut berada di tempatnya.

Pertama, malloc glibc menginisialisasi arena utama — struktur pembukuan utama yang melacak semua alokasi di thread utama. Arena ini mencakup metadata untuk heap, penunjuk daftar bebas, dan struktur bin untuk ukuran alokasi berbeda. Pengalokasi memperluas jeda program melalui sbrk(), dan ekstensi awal diatur oleh parameter internal yang disebut M_TOP_PAD, yang defaultnya adalah padding 128 KB. Namun, permintaan awal yang sebenarnya disesuaikan dengan perataan halaman dan posisi jeda yang ada, yang sering kali menghasilkan permintaan pertama yang lebih kecil — biasanya mendekati angka 72 KB tersebut pada proses yang baru dimulai.

Kedua, sejak glibc 2.26, pengalokasi menginisialisasi cache lokal thread (tcache) pada penggunaan pertama. Tcache berisi 64 bin (satu per kelas ukuran alokasi kecil), masing-masing mampu menampung hingga 7 potongan cache. Tcache_perthread_struct sendiri memakan sekitar 1 KB, namun tindakan menginisialisasinya memicu pengaturan arena yang lebih luas. Ketiga, runtime C++ telah melakukan alokasi sebelum main() Anda berjalan — konstruktor statis, inisialisasi buffer iostream untuk std::cout dan teman-teman, dan pengaturan lokal semuanya berkontribusi pada jejak heap awal tersebut.

Sistem Arena dan Mengapa Pra-Alokasi Itu Cerdas

Keputusan untuk melakukan pra-alokasi sejumlah besar memori daripada memintanya sedikit demi sedikit bukanlah suatu kebetulan dalam implementasi. Ini adalah pengorbanan teknik yang disengaja yang berakar pada pengalaman pemrograman sistem selama beberapa dekade. Setiap panggilan ke brk() atau mmap() melibatkan peralihan konteks dari ruang pengguna ke ruang kernel, modifikasi pemetaan memori virtual proses, dan potensi pembaruan tabel halaman. Pada perangkat keras modern, satu panggilan sistem membutuhkan waktu sekitar 100-200 nanodetik — hal yang sepele jika dilakukan secara terpisah, namun dalam skala yang sangat besar.

Pertimbangkan sebuah program yang menghasilkan 10.000 alokasi kecil selama inisialisasi. Tanpa pra-alokasi, hal ini berarti 10.000 panggilan sistem, yang menghabiskan biaya overhead murni sekitar 1-2 milidetik. Dengan pengalokasi berbasis arena, alokasi pertama terpicu

Frequently Asked Questions

Mengapa alokasi pertama untuk satu `int` saja bisa meminta memori sebanyak 72 KB?

Alokasi kecil seperti `int baru` tidak langsung diteruskan ke sistem operasi. Sebaliknya, pengalokasi memori (memory allocator) runtime C++ (sering glibc's malloc) meminta blok memori yang besar terlebih dahulu dari OS. Blok awal ini, yang dikenal sebagai "heap" atau "arena" utama, berukuran sekitar 132 KB. Namun, karena overhead internal pengalokasi untuk menyimpan metadata (seperti informasi ukuran dan tipe blok), ukuran yang terlihat oleh alat seperti `strace` adalah sekitar 72 KB. Ini adalah ruang yang siap digunakan untuk memenuhi permintaan alokasi berikutnya tanpa harus memanggil sistem operasi lagi.

Apakah angka 72 KB ini selalu tetap sama di semua sistem?

Tidak, angka 72 KB bukan nilai yang mutlak dan bisa berbeda tergantung pada beberapa faktor. Variasi utama berasal dari versi library C (seperti glibc) yang digunakan, kebijakan pengalokasi memori yang spesifik, dan ukuran halaman memori sistem operasi. Meskipun 128 KB (dengan overhead menjadi ~72 KB) adalah ukuran awal yang umum untuk heap utama, pengalokasi dapat menyesuaikan perilaku ini berdasarkan pola penggunaan aplikasi. Untuk analisis yang mendalam dan otomatis terhadap perilaku memori seperti ini di berbagai lingkungan, platform seperti Mewayz (dengan 207 modul analisis) dapat sangat membantu.

Apa tujuan dari perilaku ini? Bukankah ini boros memori?

Tujuannya adalah untuk meningkatkan kinerja (performance). Memanggil sistem operasi untuk setiap alokasi kecil, seperti `malloc` atau `new`, adalah operasi yang relatif lambat karena melibatkan konteks switching. Dengan meminta blok memori yang besar di awal, pengalokasi dapat melayani banyak permintaan alokasi berikutnya secara instan dari ruang yang sudah dialokasikan di ruang pengguna (user-space). Meskipun tampak boros untuk satu `int`, pendekatan ini sangat efisien untuk eksekusi program yang berkelanjutan, karena mengurangi gesekan (friction) antara aplikasi dan kernel OS.

Bagaimana cara saya menganalisis penggunaan memori program saya secara lebih detail?

Anda dapat menggunakan alat seperti `strace` (pada Linux) untuk melacak panggilan sistem seperti `brk` dan `mmap`, atau profiler memori khusus seperti Valgrind's Massif. Alat-alat ini membantu memvisualisasikan tidak hanya alokasi awal tetapi juga pola penggunaan heap selama waktu hidup program. Untuk pengembang yang membutuhkan wawasan yang lebih mendalam dan berkelanjutan ke dalam manajemen memori aplikasi mereka, layanan seperti Mewayz (tersedia dengan berlangganan $19/bulan) menawarkan pemantauan dan analitik yang komprehensif di seluruh 207 modul yang berbeda, mengungkap detail yang sulit ditangani dengan alat manual.

Related Posts

• Selamat Tinggal, Rust untuk Web
• Pendekatan yang banyak menggunakan JavaScript tidak sesuai dengan sasaran kinerja jangka panjang
• Alat Sandboxing Command-Line macOS yang Kurang Dikenal (2025)
• CXMT telah menawarkan chip DDR4 dengan harga sekitar setengah dari harga pasar yang berlaku