Ownership & Borrowing

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.

Kotak di sisi stack berisi angka i32 4 byte dan teks String 24 byte, panah penunjuk mengarah ke kotak biru di sisi heap berisi isi halo 4 byte

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.

RSRUST
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>>());
}
CodeTEXT
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.

RSRUST
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());
}
CodeTEXT
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.

RSRUST
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());
    }
}
CodeTEXT
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.

RSRUST
fn main() {
    let mut angka = Vec::new();

    for n in 1..=5 {
        angka.push(n);
        println!("{} isi: panjang {}, kapasitas {}", n, angka.len(), angka.capacity());
    }
}
CodeTEXT
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.

RSRUST
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);
}
CodeTEXT
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.

RSRUST
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());
}
CodeTEXT
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.

RSRUST
fn main() {
    let teks: String = "halo";
    println!("{}", teks);
}
CodeTEXT
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.

RSRUST
fn main() {
    let teks = String::from("halo");
    let lain = teks;

    println!("{} dan {}", teks, lain);
}
CodeTEXT
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.

RSRUST
fn main() {
    let teks = String::from("halo");
    println!("{}", teks[0]);
}
CodeTEXT
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.

RSRUST
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);
}
CodeTEXT
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

  1. Cetak size_of::<[u8; 1024]>() dan bandingkan dengan size_of::<Box<[u8; 1024]>>(), lalu jelaskan selisihnya.
  2. Ubah kapasitas_vec.rs supaya memakai Vec::with_capacity(10), lalu catat kapasitas di setiap putaran.
  3. Tambahkan 1 blok bersarang 2 tingkat pada drop_otomatis.rs dan tebak urutan cetakan lepas sebelum menjalankannya.
  4. Perbaiki salah_setelah_pindah.rs dengan 2 cara: memakai clone() 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

  1. The Rust Programming Language. What is Ownership?.
  2. The Rust Programming Language. Using Box to Point to Data on the Heap.
  3. Rust Standard Library. size_of.
  4. Rust Standard Library. Drop.