BAB 32: Basic Memory Management
Stack menyimpan nilai berukuran tetap dan heap menyimpan data yang tumbuh, dengan String 24 byte dan isi heap yang dilepas otomatis.
std::mem::size_of::<String>() menghasilkan 24 pada mesin uji ini, sementara isi String::from("halo") hanya 4 byte. Selisih itu bukan kesalahan hitung: variabel teks di stack menyimpan 3 angka pengelola, dan 4 byte huruf halo disimpan terpisah di heap. Buku resmi Rust menjelaskan pembagian ini dengan kalimat "All data stored on the stack must have a known, fixed size. Data with an unknown size at compile time or a size that might change must be stored on the heap instead."
Rust tidak memakai garbage collector dan tidak menuntut pemanggilan free manual. Buku resmi menyebut memori Rust "managed through a system of ownership with a set of rules that the compiler checks", dan bab ini berhenti di lapisan paling dasar dari sistem itu: ke mana nilai disimpan, berapa byte yang dipakai, dan kapan memorinya dilepas.
Setelah bab ini selesai, kamu dapat menjelaskan perbedaan stack dan heap, membaca ukuran tipe dengan size_of, membedakan panjang dan kapasitas pada String, membuktikan bahwa memori dilepas saat blok selesai, memakai Box untuk data besar, dan mengenali 3 kesalahan yang berkaitan dengan perpindahan nilai. Semua contoh dijalankan dengan rustc 1.100.0 pada folder /tmp/latihan-rust/bab32.
2 wilayah memori
Stack dan heap sama-sama memori yang tersedia saat program berjalan, tetapi keduanya diatur dengan cara berbeda. Stack bekerja seperti tumpukan piring: nilai terakhir yang masuk adalah yang pertama keluar. Heap tidak berurutan, dan isinya dicari oleh allocator saat program meminta ruang.
Nilai teks di stack menyimpan penunjuk, sedangkan huruf halo berada di heap.
Buku resmi Rust menulis aturan stack dengan kalimat "The stack stores values in the order it gets them and removes the values in the opposite order", lalu menjelaskan heap sebagai tempat yang "returns a pointer, which is the address of that location". Kalimat kedua itu yang membuat ukuran String tetap 24 byte walaupun isinya 1.000 huruf: yang disimpan di stack adalah penunjuk dan 2 angka pengelola, bukan hurufnya.
Konsekuensi praktisnya ada 2. Nilai bertipe ukuran tetap seperti i32 dan [u8; 4] seluruhnya berada di stack, sehingga tidak butuh alokasi. Nilai yang ukurannya berubah saat program berjalan, seperti String dan Vec, memakai heap untuk isinya dan stack untuk penunjuknya.
Ukuran tetap di stack, ukuran berubah di heap
Fungsi size_of mengembalikan "the size of a type in bytes" menurut dokumentasinya, dan hasilnya di mesin uji ini adalah sebagai berikut.
fn main() {
println!("i32 {}", std::mem::size_of::<i32>());
println!("[i32; 4] {}", std::mem::size_of::<[i32; 4]>());
println!("usize {}", std::mem::size_of::<usize>());
println!("&i32 {}", std::mem::size_of::<&i32>());
println!("&str {}", std::mem::size_of::<&str>());
println!("String {}", std::mem::size_of::<String>());
println!("Vec<i32> {}", std::mem::size_of::<Vec<i32>>());
println!("Box<i32> {}", std::mem::size_of::<Box<i32>>());
}
i32 4
[i32; 4] 16
usize 8
&i32 8
&str 16
String 24
Vec<i32> 24
Box<i32> 8
i32 berukuran 4 byte dan array 4 elemen berukuran 16 byte, sesuai catatan dokumentasi bahwa [T; n] "has a size of n * size_of::usize 8 byte karena mesin uji memakai arsitektur 64 bit.
Angka String 24 byte sama dengan 3 kali usize, dan itu cocok dengan 3 data yang dibutuhkan String untuk mengelola isinya: penunjuk ke heap, panjang, dan kapasitas. &str cukup 16 byte karena hanya menyimpan penunjuk dan panjang. Box<i32> hanya 8 byte karena isinya di heap dan yang tersisa di stack adalah penunjuknya.
String menyimpan penunjuk, bukan isinya
Alamat setiap nilai bisa dicetak dengan format {:p}. Program berikut mencetak ukuran dan alamat variabel di stack, lalu alamat isi String di heap.
fn main() {
let angka = 42;
let teks = String::from("halo");
println!("angka: {} byte di {:p}", std::mem::size_of_val(&angka), &angka);
println!("teks : {} byte di {:p}", std::mem::size_of_val(&teks), &teks);
println!("isi teks ada di {:p}", teks.as_ptr());
}
angka: 4 byte di 0x7ffcea506fc4
teks : 24 byte di 0x7ffcea506fc8
isi teks ada di 0x55617528cd60
2 variabel itu berdampingan di stack, dengan selisih 4 byte sesuai ukuran i32. Alamat isi teks berada jauh di wilayah lain, yaitu 0x55617528cd60, dan di situlah 4 byte huruf halo disimpan. Buku resmi Rust menulis konsekuensinya dengan kalimat "when you want the actual data, you must follow the pointer".
Angka alamat itu berubah setiap kali program dijalankan karena sistem operasi mengacak posisi memori. Yang tetap adalah pola jaraknya: penunjuk 8 byte dan isi heap di wilayah yang berbeda dari stack.
Panjang dan kapasitas
String menyimpan 2 angka yang sering tertukar. Panjang adalah jumlah byte yang terpakai, sedangkan kapasitas adalah jumlah byte yang sudah dipesan dari allocator. Program berikut menambah 1 huruf sekaligus dan mencetak keduanya.
fn main() {
let mut teks = String::new();
println!("awal: panjang {}, kapasitas {}", teks.len(), teks.capacity());
for huruf in "abcdefghij".chars() {
teks.push(huruf);
println!("{} huruf: panjang {}, kapasitas {}", huruf, teks.len(), teks.capacity());
}
}
awal: panjang 0, kapasitas 0
a huruf: panjang 1, kapasitas 8
b huruf: panjang 2, kapasitas 8
c huruf: panjang 3, kapasitas 8
d huruf: panjang 4, kapasitas 8
e huruf: panjang 5, kapasitas 8
f huruf: panjang 6, kapasitas 8
g huruf: panjang 7, kapasitas 8
h huruf: panjang 8, kapasitas 8
i huruf: panjang 9, kapasitas 16
j huruf: panjang 10, kapasitas 16
Pada huruf pertama, String kosong meminta 8 byte ke allocator. Permintaan berikutnya tidak terjadi sampai huruf kesembilan, ketika panjang melewati kapasitas 8 dan kapasitas naik menjadi 16. Artinya push yang tidak memicu pertumbuhan hanya menulis 1 byte di ruang yang sudah dipesan.
Perilaku yang sama terlihat pada Vec, dengan kapasitas awal yang berbeda.
fn main() {
let mut angka = Vec::new();
for n in 1..=5 {
angka.push(n);
println!("{} isi: panjang {}, kapasitas {}", n, angka.len(), angka.capacity());
}
}
1 isi: panjang 1, kapasitas 4
2 isi: panjang 2, kapasitas 4
3 isi: panjang 3, kapasitas 4
4 isi: panjang 4, kapasitas 4
5 isi: panjang 5, kapasitas 8
Vec<i32> meminta ruang untuk 4 elemen pada push pertama, lalu naik ke 8 elemen pada elemen kelima. Kapasitas selalu lebih besar atau sama dengan panjang, dan selisihnya adalah ruang yang sudah dipesan tetapi belum dipakai.
Membebaskan memori saat blok selesai
Rust melepas memori heap tanpa garbage collector dan tanpa free. Waktu pelepasan ditentukan oleh scope, dan itu bisa dibuktikan dengan tipe yang mencetak pesan saat dijatuhkan.
struct Penanda(&'static str);
impl Drop for Penanda {
fn drop(&mut self) {
println!("lepas {}", self.0);
}
}
fn main() {
let luar = Penanda("luar");
{
let dalam = Penanda("dalam");
println!("di dalam blok, {}", dalam.0);
}
println!("setelah blok, {}", luar.0);
}
di dalam blok, dalam
lepas dalam
setelah blok, luar
lepas luar
Baris lepas dalam muncul sebelum setelah blok, luar, karena dalam dijatuhkan tepat saat blok penutupnya selesai. luar baru dilepas di akhir main. Dokumentasi Drop menjelaskan waktunya dengan kalimat "The most common way that a value is no longer needed is when it goes out of scope", dan urutan cetakan di atas adalah buktinya.
Urutan yang sama berlaku untuk String dan Vec, hanya saja pelepasan memorinya tidak mencetak apa pun. Karena itu program Rust yang membuat 1.000 String di dalam loop tidak menumpuk memori selama setiap String dijatuhkan di akhir putaran.
Box untuk memindahkan data besar ke heap
Box memindahkan nilai ke heap dan menyisakan penunjuk di stack. Contoh berikut menaruh array 1.024 byte di dalam Box.
fn main() {
let besar = Box::new([0u8; 1024]);
println!("Box menempati {} byte di stack", std::mem::size_of_val(&besar));
println!("isinya {} byte", besar.len());
}
Box menempati 8 byte di stack
isinya 1024 byte
Variabel besar hanya menempati 8 byte di stack, sedangkan 1.024 byte isinya berada di heap. Dokumentasi Box menyebut hal ini dengan kalimat "Boxes allow you to store data on the heap rather than the stack. What remains on the stack is the pointer to the heap data". Tanpa Box, array [0u8; 1024] akan disalin seluruhnya saat nilainya dipindahkan ke fungsi lain.
3 kesalahan yang berkaitan dengan memori
Kesalahan pertama muncul saat teks literal dipaksa masuk ke tipe String. Kode ini sengaja salah.
fn main() {
let teks: String = "halo";
println!("{}", teks);
}
error[E0308]: mismatched types
--> salah_str_string.rs:2:24
|
2 | let teks: String = "halo";
| ------ ^^^^^^ expected `String`, found `&str`
| |
| expected due to this
|
help: try using a conversion method
|
2 | let teks: String = "halo".to_string();
| ++++++++++++
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0308`.
Literal "halo" bertipe &str dan seluruh isinya sudah ada di biner program, sedangkan String memiliki isi di heap yang bisa tumbuh. Keduanya tidak bisa saling menggantikan tanpa konversi, dan kompilator menyarankan to_string() atau String::from. Perbedaan ini yang membuat parameter fungsi sebaiknya memakai &str, karena &str menerima String lewat deref tanpa memindahkan isinya.
Kesalahan kedua muncul saat nilai dipakai setelah dipindahkan ke variabel lain.
fn main() {
let teks = String::from("halo");
let lain = teks;
println!("{} dan {}", teks, lain);
}
error[E0382]: borrow of moved value: `teks`
--> salah_setelah_pindah.rs:5:27
|
2 | let teks = String::from("halo");
| ---- move occurs because `teks` has type `String`, which does not implement the `Copy` trait
3 | let lain = teks;
| ---- value moved here
4 |
5 | println!("{} dan {}", teks, lain);
| ^^^^ value borrowed here after move
|
help: consider cloning the value if the performance cost is acceptable
|
3 | let lain = teks.clone();
| ++++++++
String tidak mengimplementasikan Copy, sehingga let lain = teks; memindahkan kepemilikan penunjuk heap ke lain, bukan menyalin isinya. Kalau isi heap disalin untuk setiap penugasan, biaya salinnya tidak terlihat saat membaca kode, dan itulah yang dicegah aturan ini. Perbaikannya adalah teks.clone() bila 2 salinan memang dibutuhkan, atau memakai &teks bila cukup meminjam.
Kesalahan ketiga muncul saat String diindeks seperti array.
fn main() {
let teks = String::from("halo");
println!("{}", teks[0]);
}
error[E0277]: the type `str` cannot be indexed by `{integer}`
--> salah_index_string.rs:3:25
|
3 | println!("{}", teks[0]);
| ^ string indices are ranges of `usize`
|
= help: the trait `SliceIndex<str>` is not implemented for `{integer}`
= note: you can use `.chars().nth()` or `.bytes().nth()`
for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0277`.
Indeks pada String harus berupa rentang usize, bukan 1 angka. Alasannya ada di penyimpanan: String menyimpan byte, dan 1 karakter bisa memakai beberapa byte, sehingga indeks per karakter tidak sama dengan indeks per byte. Untuk 1 karakter, .chars().nth(0) adalah cara yang disarankan kompilator.
Kapan memperhatikan alokasi
Sebagian besar program Rust tidak perlu menghitung byte. Alokasi baru menjadi perhatian saat jumlah datanya besar atau saat kode berjalan di dalam loop yang panjang, karena setiap pertumbuhan kapasitas berarti 1 permintaan ke allocator dan 1 penyalinan isi.
Kalau jumlah isinya sudah diketahui, String::with_capacity menghindari pertumbuhan berulang.
fn main() {
let mut teks = String::with_capacity(32);
println!("kapasitas awal {}", teks.capacity());
for huruf in "abcdefghij".chars() {
teks.push(huruf);
}
println!("setelah 10 huruf, kapasitas {}", teks.capacity());
println!("isi {}", teks);
}
kapasitas awal 32
setelah 10 huruf, kapasitas 32
isi abcdefghij
Kapasitas tetap 32 setelah 10 huruf ditambahkan, sehingga tidak ada permintaan tambahan ke allocator di tengah loop. Angka itu juga menunjukkan bahwa kapasitas boleh lebih besar daripada panjang: 22 byte sisanya sudah dipesan dan belum dipakai.
Latihan
- Cetak
size_of::<[u8; 1024]>()dan bandingkan dengansize_of::<Box<[u8; 1024]>>(), lalu jelaskan selisihnya. - Ubah
kapasitas_vec.rssupaya memakaiVec::with_capacity(10), lalu catat kapasitas di setiap putaran. - Tambahkan 1 blok bersarang 2 tingkat pada
drop_otomatis.rsdan tebak urutan cetakanlepassebelum menjalankannya. - Perbaiki
salah_setelah_pindah.rsdengan 2 cara: memakaiclone()dan memakai referensi&teks, lalu jelaskan perbedaan biayanya.
Ringkasan
Nilai berukuran tetap disimpan di stack, sedangkan data yang ukurannya baru diketahui saat program berjalan disimpan di heap dengan penunjuk di stack. size_of menunjukkan i32 4 byte, String 24 byte, dan &str 16 byte, sehingga besar variabel tidak sama dengan besar isinya. String memisahkan panjang dan kapasitas, dan kapasitas naik hanya saat panjang melewatinya. Memori dilepas otomatis saat blok selesai, sesuai urutan Drop, dan Box memindahkan data besar ke heap dengan menyisakan 8 byte penunjuk. 3 kesalahan yang sering muncul adalah E0308 saat &str dipaksa menjadi String, E0382 saat nilai dipakai setelah dipindah, dan E0277 saat String diindeks dengan 1 angka.
Referensi
- The Rust Programming Language. What is Ownership?.
- The Rust Programming Language. Using Box
to Point to Data on the Heap . - Rust Standard Library. size_of.
- Rust Standard Library. Drop.