Pernah nggak sih kalian ngebayangin komputer itu kayak kantor yang super sibuk? Aku baru aja belajar tentang manajemen memori di Rust, dan ternyata konsepnya mirip banget sama dinamika kantor.

Ada Bos (Operation System), ada meja kerja fisik (RAM), dan ada kita (Program). Seringkali kita koding tanpa mikirin apa yang terjadi di belakang layar, tapi di Rust, pemahaman ini penting banget. Yuk, kita bedah bareng-bareng apa itu Virtual Memory, Paging, dan gimana Rust ngatur 'barang-barangnya' lewat Stack dan Heap.

Virtual Memory (Sang Ilusi Ruang)

Virtual memory adalah teknik abstraksi memori. Saat kita mencetak alamat memori di Rust (misalnya 0x7ff...), itu bukanlah alamat fisik di kepingan RAM (DRAM), melainkan alamat virtual. OS memberikan setiap program ruang alamat privatnya sendiri yang terisolasi dari program lain.

Bayangkan kantor tadi memiliki satu meja panjang (RAM Fisik) yang dipakai rame-rame sama karyawan lain (Sporify, Browser, VS Code). Kalau semua berebut meja yang sama, pasti rusuh. Program A bisa nggak sengaja nyoret kertas kerja Program B.

Solusinya? Kacamata VR (Virtual Reality).

Saat program Rust kita jalan, OS memberikan Kacamata VR. Dengan kacamata ini, program kita merasa sendirian di ruangan. Dia melihat meja kosong yang sangaaat panjang dari ujung ke ujung.

• Realitanya dia cuman dikasih sepetak kecil di pojok meja fisik.
• Keuntungannya program kita nggak perlu pusing mikirin di mana program lain duduk. Aman, privat, dan nggak bakalan bikin crash program lain.

Paging

Karena program melihat memori virtual yang luas, OS butuh cara untuk memetakan (mapping) alamat virtual tersebut ke RAM fisik yang sebenarnya. OS membagi memori menjadi potongan-potongan kecil berukuran tetap (biasanya 4KB) yang disebut Page.

• Virtual Page: Potongan di sisi pandangan program.
• Physical Frame: Potongan di sisi RAM fisik.
• Page Table: Buku catatan milik OS yang memetakan "Halaman Virtual X ada di Frame Fisik Y".

Program kita melihat meja virtual yang luas, tapi Bos (OS) nggak mungkin memetakan meja itu cm demi cm, itu ribet. Bos membaginya per lembar kertas HVS (Page).

Gimana kalau meja fisik penuh? Di sinilah serunya. Jika program kita butuh kertas baru tapi meja fisik penuh, Bos akan melakukan Swapping. Dia akan mengambil kertas milik program lain yang lagi nganggur, menyimpannya di Gudang (Hard Disk/SSD), dan memberikan tempat kosong itu ke kita.

Inilah kenapa kalau kita buka terlalu banyak tab Chrome sampai RAM habis, komputer jadi lemot. Itu karena si Bos (OS) sibuk lari bolak-balik dari meja (RAM) ke Gudang (SSD) buat nuker-nuker kertas (Page Fault).

Memory Layout di Rust (Tata Ruang Kantor)

Sekarang kita masuk ke internal Rust. Di dalam ruang virtual yang luas tadi, Rust adalah karyawan yang sangat rapi. Dia nggak sembarangan taruh barang. Dia membagi mejanya menjadi segmen-segmen standar.

Berikut diagram layout memorinya:

High Address
+---------------------------+
|          Stack            | <- Tumbuh ke bawah (Low Address)
|    [frames added here]    |
+---------------------------+
|     Unallocated Space     |
+---------------------------+
|          Heap             | <- Tumbuh ke atas (High Address)
|  [Box::new, vec![], etc.] |
+---------------------------+
|    Text / Code Segment    | <- Binary program (read-only)
+---------------------------+
Low Address

Rust membagi area kerjanya menjadi 3 zona utama:

A. Stack

Area memori LIFO (Last In, First Out) untuk data yang ukurannya sudah diketahui saat kompilasi (compile-time), seperti Sticky Notes. Kita butuh simpan angka `integer`? Tulis di sticky note, tempel di paling atas. Selesai pakai? Cabut dan buang. Sangat cepat karena nggak perlu cari tempat kosong, tinggal tempel di atas tumpukan.

B. Heap

Area memori dinamis untuk data yang ukurannya bisa berubah atau besar. Pengelolaannya lebih kompleks karena butuh alokator untuk mencari ruang kosong, seperti Lantai/Gudang. Kita mau simpan `String` panjang atau `Vector` yang isinya nambah terus? Nggak muat di sticky note. Kita taruh barangnya di lantai (Heap), lalu kita catat lokasinya di sticky note (Stack).

C. Code Segment

Berisi instruksi mesin program yang read-only seperti buku manual SOP. Program baca buku ini untuk tau langkah apa yang harus dilakukan. Nggak boleh dicoret-coret.

Biar makin sreg, mari kita lihat apa yang terjadi saat kode sederhana ini dijalankan:

fn main() {
  let angka = 42;           // Stack
  let data = Box::new(100); // Heap
}

Inilah journey yang terjadi:

1. Setup (Virtual Memory): Saat kita menjalankan `cargo run`, OS membuat proses baru. Program Rust merasa punya meja virtual sendiri.
2. Loading (Memory Layout): Instruksi program dimuat ke segmen text.
3. Eksekusi `angka` (Stack): Rust mengambil satu sticky note di Stack, menulis angka `42`.
4. Eksekusi `data` (Heap): Rust melihat `Box::new` sebagai Heap. Rust minta tempat ke OS. Jika RAM fisik belum dipetakan, OS melakukan Paging (mencari laci kosong di RAM fisik dan menyambungkannya ke alamat virtual Heap). Angka `100` ditaruh ke Heap. Alamat/Lokasi Heap tersebut dicatat di sticky note baru di Stack bernama `data`.

Key Takeways (TL;DR)

Kenapa kita peduli soal ini? Karena Rust sangat peduli di mana data kita tinggal.

• Virtual Memory bikin program kita aman.
• Paging bikin kita bisa jalanin program besar meski RAM terbatas.
• Stack & Heap adalah kanvas kita sebagai developer Rust untuk mengatur performa.