Review of Program Memory

Programs allocate memory in two ways:

  • Stack: Kontinuierlicher Speicherbereich für lokale Variablen.

    • Werte haben feste Größen, die zur Kompilierzeit bekannt sind.
    • Extrem schnell: Durch Bewegen eines Stapelzeigers.
    • Einfach zu verwalten: folgt Funktionsaufrufen.
    • Große Speicherlokalität (memory locality).

  • Heap: Speicherung von Werten außerhalb von Funktionsaufrufen.

    • Werte haben dynamische Größen, die zur Laufzeit bestimmt werden.
    • Etwas langsamer als der Stapel: Etwas Buchhaltung ist erforderlich.
    • Keine Garantie für Speicherlokalität.

Beispiel

Creating a String puts fixed-sized metadata on the stack and dynamically sized data, the actual string, on the heap:

fn main() {
    let s1 = String::from("Hello");
}
StackHeaps1capacity5ptrHellolen5
This slide should take about 5 minutes.

  • Mention that a String is backed by a Vec, so it has a capacity and length and can grow if mutable via reallocation on the heap.

  • If students ask about it, you can mention that the underlying memory is heap allocated using the System Allocator and custom allocators can be implemented using the Allocator API

More to Explore

We can inspect the memory layout with unsafe Rust. However, you should point out that this is rightfully unsafe!

fn main() {
    let mut s1 = String::from("Hello");
    s1.push(' ');
    s1.push_str("world");
    // DON'T DO THIS AT HOME! For educational purposes only.
    // String provides no guarantees about its layout, so this could lead to
    // undefined behavior.
    unsafe {
        let (capacity, ptr, len): (usize, usize, usize) = std::mem::transmute(s1);
        println!("capacity = {capacity}, ptr = {ptr:#x}, len = {len}");
    }
}