Buffer Reuse and Memory Locality

In this lesson, you will learn how to boost your program's performance by reusing memory buffers instead of repeatedly allocating new ones.

Why Allocation is Expensive

When you create a new Vec, the computer must ask the operating system for a fresh block of memory. This involves "system calls" and searching for available space, which is relatively slow. Furthermore, if your program constantly creates and destroys buffers, your data becomes scattered across your RAM. This hurts memory locality, meaning your CPU has to jump around to different locations to find your data, leading to "cache misses" that significantly slow down your execution.

The Strategy: Buffer Reuse

Instead of creating a new Vec inside a loop or a frequently called function, you should allocate a single buffer once and reuse it. You can clear the contents of a buffer without deallocating its underlying memory by using the .clear() method.

Consider this inefficient approach:

// Inefficient: Reallocating every time
fn process_data(input: &[i32]) {
    let mut buffer = Vec::new(); // New allocation every call
    for &item in input {
        buffer.push(item * 2);
    }
}

By passing a mutable reference to an existing buffer, we keep the memory "warm" and avoid redundant allocations:

// Efficient: Reusing the same buffer
fn process_data(input: &[i32], buffer: &mut Vec<i32>) {
    buffer.clear(); // Resets length to 0, but keeps capacity intact
    for &item in input {
        buffer.push(item * 2);
    }
}

fn main() {
    let mut my_buffer = Vec::with_capacity(100);
    process_data(&[1, 2, 3], &mut my_buffer);
}

Memory Locality

By keeping the same memory address for your buffer, you ensure that as you write and read data, the memory stays "near" the CPU's cache. Because the Vec keeps its underlying heap allocation across the clear() call, the capacity remains reserved. This prevents the constant "allocate-copy-deallocate" cycle, allowing your CPU to process data much faster because it doesn't have to keep fetching new memory pages from your RAM.

Key Takeaway: Reuse existing buffers by clearing them rather than reallocating, which keeps your memory contiguous and minimizes expensive system calls.