Rust Memory Management

Why Memory Management Matters

Memory management is essential because:

1. Efficient Resource Use: Ensures memory is allocated and freed properly to avoid waste.
2. Avoids Errors: Prevents issues like memory leaks, dangling pointers, or invalid memory access.
3. Improves Performance: Reduces overhead caused by garbage collectors or inefficient memory handling.

How Rust Handles Memory Management

Rust’s memory management is built on three key concepts:

1. Ownership
2. Borrowing
3. Lifetimes

These concepts eliminate the need for a garbage collector or manual memory management.

1. Ownership

Ownership is Rust’s central concept for memory management. It defines how memory is allocated, used, and deallocated. Every value in Rust has an owner, and there can only be one owner at a time.

Rules of Ownership

1. Each value has a single owner.
2. When the owner goes out of scope, the value is dropped, and memory is freed.
3. Ownership can be transferred (moved) to another variable.

Example: Ownership

fn main() {
    let s1 = String::from("Hello");
    let s2 = s1; // Ownership is moved from s1 to s2
    // println!("{}", s1); // Error: s1 is no longer valid
    println!("{}", s2);
}

Explanation:

• When s1 is assigned to s2, the ownership of the String is moved.
• s1 becomes invalid, and only s2 can access the value.

2. Borrowing

Borrowing allows you to access a value without transferring ownership. This is done using references. Rust ensures memory safety by enforcing borrowing rules.

Rules of Borrowing

1. You can have either one mutable reference or multiple immutable references at a time.
2. References must always be valid.

Example: Borrowing

fn main() {
    let s1 = String::from("Hello");
    let len = calculate_length(&s1); // Borrowing s1 as an immutable reference
    println!("The length of '{}' is {}", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len() // Accessing the borrowed value
}

Explanation:

• The &s1 reference is passed to the calculate_length function.
• Ownership is not transferred, so s1 remains valid in main.

Example: Mutable Borrowing

fn main() {
    let mut s = String::from("Hello");
    change(&mut s); // Mutable borrow
    println!("{}", s);
}

fn change(s: &mut String) {
    s.push_str(", world!");
}

Explanation:

• The &mut s mutable reference allows modifying the value.
• Rust prevents multiple mutable references to avoid data races.

3. Lifetimes

Lifetimes ensure references remain valid while they are being used. Rust uses lifetimes to prevent dangling references.

Example: Lifetimes

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let s1 = String::from("short");
    let s2 = String::from("longer");
    let result = longest(&s1, &s2);
    println!("The longest string is '{}'", result);
}

Explanation:

• The ‘a lifetime ensures the returned reference is valid as long as both input references are valid.

Heap vs. Stack in Rust

Rust uses the stack and heap for memory allocation:

1. Stack: Stores fixed-size data like integers and references. Faster but limited in size.
2. Heap: Stores dynamically sized data like String or Vec. Allocating and accessing data on the heap is slower.

Rust automatically decides where to allocate memory based on the data type.

Example

fn main() {
    let x = 5; // Stored on the stack
    let y = String::from("Hello"); // Stored on the heap
    println!("x = {}, y = {}", x, y);
}

Memory Safety in Rust

Rust prevents common memory errors like:

1. Dangling Pointers: References pointing to invalid memory.
2. Double Free Errors: Freeing the same memory twice.
3. Data Races: Simultaneous access to memory by multiple threads.

Rust enforces strict compile-time checks to ensure memory safety.

Example: Dangling Pointer Prevention

fn main() {
    let r;
    {
        let x = 5;
        r = &x; // Error: `x` does not live long enough
    }
    println!("{}", r);
}

Fix: Ensure the referenced value lives long enough.

Smart Pointers

Rust provides smart pointers like Box, Rc and RefCell to handle advanced memory management scenarios.

Example: Using Box

fn main() {
    let b = Box::new(10); // Allocate value on the heap
    println!("b = {}", b);
}

Advantages of Rust’s Memory Management

1. No Garbage Collector: High performance without runtime overhead.
2. Memory Safety: Prevents common bugs like null pointer dereferences.
3. Ease of Use: Memory management is automated through ownership and borrowing.