Virtual Memory

Ilusi yang dijual

Virtual memory adalah abstraksi yang memberi tiap process ilusi bahwa dia punya akses eksklusif ke main memory.

Tiap process melihat memory dengan tampilan yang seragam, dan tampilan itu disebut virtual address space. Seragam artinya: process apa pun, sekecil atau sebesar apa pun, melihat peta memory dengan struktur yang sama persis.

Catatan: Struktur pada Figure 1.13 adalah tata letak untuk process Linux. Sistem Unix lain memakai layout yang mirip.

Tata letak ruang alamat

Pembagian besarnya cuma dua:

• Region paling atas — disediakan untuk code dan data operating system, dan ini sama untuk semua process.
• Region bawah — menampung code dan data yang didefinisikan oleh process milik user.

⚠️

Warning
Pada Figure 1.13, alamat bertambah dari bawah ke atas. Angka 0 ada di dasar gambar. Jadi "stack di atas" berarti alamatnya tinggi, dan "heap di bawah" berarti alamatnya rendah. Salah baca arah ini bikin seluruh diagram jadi terbalik maknanya.

                                              alamat tinggi
        +---------------------------------+
        | Kernel virtual memory           |   <- tidak terlihat oleh user code
        +---------------------------------+
        | User stack                      |
        | (dibuat saat run time)          |
        |              |                  |
        |              v   tumbuh turun   |
        +---------------------------------+
        |          (ruang kosong)         |
        +---------------------------------+
        | Memory-mapped region            |
        | untuk shared libraries          |   <- di sini fungsi printf berada
        +---------------------------------+
        |          (ruang kosong)         |
        |              ^   tumbuh naik    |
        +---------------------------------+
        | Run-time heap                   |
        | (dibuat oleh malloc)            |
        +---------------------------------+
        | Read/write data                 |  \
        +---------------------------------+   >  dimuat dari file
        | Read-only code and data         |  /   executable hello
        +---------------------------------+   <- program start
        |                                 |
        +---------------------------------+ 0
                                              alamat rendah

Area-area penting

Dibahas dari alamat terendah naik ke atas.

Program code and data

Code dimulai pada alamat tetap yang sama untuk semua process, diikuti lokasi data yang berkorespondensi dengan variabel global C.

Yang khas dari area ini: isinya diinisialisasi langsung dari isi file executable object — dalam contoh kita, file hello. Jadi area ini bukan dibangun saat runtime, tapi disalin dari file di disk.

Ukurannya tetap begitu process mulai jalan.

Dibahas lebih lanjut di Bab 7 (linking dan loading).

Heap

Langsung menyusul area code dan data. Berbeda dari code dan data yang ukurannya tetap, heap memuai dan menyusut secara dinamis saat run time sebagai akibat pemanggilan rutin pustaka standar C seperti malloc dan free.

Dibahas detail di Bab 9.

Shared libraries

Berada di sekitar tengah ruang alamat. Menampung code dan data untuk shared library seperti pustaka standar C dan pustaka matematika.

Inilah tempat fungsi printf yang dipanggil hello sebenarnya berada — bukan di dalam executable-nya sendiri.

CS:APP sendiri menyebut konsep shared library ini powerful tapi agak sulit. Mekanismenya dibahas di Bab 7 (dynamic linking).

User stack

Berada di puncak ruang alamat user. Dipakai compiler untuk mengimplementasikan pemanggilan fungsi.

Seperti heap, stack juga memuai dan menyusut secara dinamis selama program berjalan:

• tiap kali kita memanggil fungsi → stack tumbuh
• tiap kali kita return dari fungsi → stack menyusut

Cara compiler memakai stack dibahas di Bab 3.

Kernel virtual memory

Region paling atas, disediakan untuk kernel. Aturannya tegas — program aplikasi tidak diizinkan:

• membaca isi area ini
• menulis ke area ini
• memanggil langsung fungsi yang didefinisikan di kode kernel

Sebagai gantinya, aplikasi harus meminta kernel untuk melakukan operasi tersebut, yaitu lewat system call. Ini menyambung langsung ke pembahasan di Processes.

Cara kerjanya

Supaya virtual memory bisa bekerja, dibutuhkan interaksi yang rumit antara hardware dan software operating system, termasuk penerjemahan alamat oleh hardware untuk setiap alamat yang dihasilkan processor.

Perhatikan kata setiap. Ini bukan operasi sesekali — tiap kali instruksi menyentuh memory, ada terjemahan alamat virtual ke alamat fisik yang terjadi di hardware.

Ide dasarnya:

1. Simpan isi virtual memory sebuah process di disk.
2. Gunakan main memory sebagai cache untuk disk itu.

Catatan: Poin kedua ini biasanya yang paling mengejutkan. Kita terbiasa berpikir RAM sebagai tempat penyimpanan utama dan disk sebagai cadangan. Virtual memory membalik posisinya: disk adalah tempat data sebenarnya berada, dan RAM cuma lapisan cache yang cepat di depannya. Sudut pandang ini yang bikin konsep page fault jadi masuk akal.

Penjelasan lengkapnya, dan kenapa ini begitu penting untuk sistem modern, ada di Bab 9.

Catatan untuk kerja systems

• "Code dimulai pada alamat tetap yang sama" sudah tidak sepenuhnya berlaku. Pernyataan itu benar untuk binary non-PIE. Linux modern mengompilasi binary sebagai PIE dan mengaktifkan ASLR, sehingga alamat basis code, heap, stack, dan shared library diacak tiap kali process dijalankan — sebagai pertahanan terhadap eksploitasi. Cek dengan menjalankan cat /proc/self/maps dua kali dan bandingkan hasilnya. Untuk debugging bisa dimatikan sementara dengan setarch -R.
• Peta ini bisa dilihat langsung. /proc/[pid]/maps menampilkan seluruh region beserta permission dan file pendukungnya. Ini cara tercepat memverifikasi bahwa Figure 1.13 memang benar-benar ada, bukan sekadar model.
• Heap besar tidak selalu lewat heap. malloc di glibc memakai brk untuk alokasi kecil, tapi beralih ke mmap untuk alokasi di atas ambang tertentu (M_MMAP_THRESHOLD, default sekitar 128 KB). Jadi alokasi besar sebenarnya mendarat di region memory-mapped, bukan di run-time heap.
• Stack punya batas keras. Stack memang tumbuh otomatis, tapi hanya sampai RLIMIT_STACK (umumnya 8 MB). Di bawahnya ada guard page — menyentuhnya memicu SIGSEGV. Inilah yang terjadi pada rekursi tanpa henti.
• Alokasi tidak sama dengan memory fisik. Linux melakukan overcommit: malloc yang sukses cuma berarti ruang alamat sudah dicadangkan, halaman fisiknya baru diberikan saat benar-benar disentuh (demand paging). Konsekuensinya, program bisa mati kena OOM killer di titik penulisan, bukan di titik alokasi.
• Terjemahan setiap alamat itu mahal, makanya ada TLB. Karena tiap akses memory butuh penerjemahan, hasil terjemahan di-cache di Translation Lookaside Buffer. TLB miss adalah biaya nyata di workload dengan pola akses acak, dan itulah alasan huge pages bisa memberi percepatan besar di aplikasi seperti database dan HPC.

Tip: Kalau ingin melihat semua ini bekerja sekaligus: jalankan perf stat -e dTLB-load-misses,page-faults ./program. Dua angka itu adalah harga langsung dari abstraksi virtual memory.

Istilah kunci

Virtual memory

Abstraksi yang memberi tiap process ilusi penggunaan eksklusif atas main memory.

Virtual address space

Tampilan memory yang seragam yang dilihat tiap process.

Heap

Area yang memuai dan menyusut dinamis saat run time akibat malloc dan free.

User stack

Area di puncak ruang alamat user, dipakai compiler untuk mengimplementasikan pemanggilan fungsi.

Shared library

Code dan data pustaka bersama seperti libc dan libm, dipetakan di sekitar tengah ruang alamat.

Kernel virtual memory

Region teratas yang disediakan untuk kernel; tidak boleh dibaca, ditulis, atau dipanggil langsung oleh aplikasi.

ASLR

Pengacakan alamat basis region saat process dijalankan, sebagai pertahanan keamanan.

Lihat juga

• Process
• Threads
• Files
• OS Manages Hardware
• System Call
• CS:APP