No history yet

Memory Layout Optimization

The Art of Memory Layout

A program's performance is not just about algorithmic efficiency; it's also deeply tied to how it interacts with hardware. Memory layout, the arrangement of data in memory, is a critical factor. Efficient layouts reduce wasted space and, more importantly, minimize cache misses by ensuring data that's used together is stored together.

Every type in Rust has two key layout properties: size and alignment. The size is the number of bytes it occupies. The alignment, or align_of, is the byte boundary a value of that type must start on. A u32 has an alignment of 4, meaning its address must be a multiple of 4. This is a hardware requirement; processors are optimized to access data at aligned addresses.

To satisfy alignment requirements for all fields within a struct, the compiler often inserts padding—unused bytes between fields or at the end of the struct. The struct's total alignment is the maximum alignment of any of its fields.

use std::mem::{size_of, align_of};

struct Suboptimal {
    a: u8,    // 1 byte
    // 7 bytes padding
    b: u64,   // 8 bytes
    c: u16,   // 2 bytes
    // 6 bytes padding
}

fn main() {
    // The alignment is max(align_of(u8), align_of(u64), align_of(u16)) = max(1, 8, 2) = 8.
    // The total size must be a multiple of the alignment.
    assert_eq!(size_of::<Suboptimal>(), 24);
    assert_eq!(align_of::<Suboptimal>(), 8);
}

This visualization shows how 13 bytes of padding are added to a struct containing only 11 bytes of data, more than doubling its memory footprint. This is where Rust's default layout strategy becomes invaluable.

Reordering and Representation

By default, Rust uses #[repr(Rust)], which grants the compiler permission to reorder struct fields to minimize padding. The compiler is free to choose any layout it deems optimal, and this layout is not guaranteed to be stable across different compiler versions. It will typically sort fields by their alignment requirements, from largest to smallest, to pack them as tightly as possible.

use std::mem::{size_of, align_of};

// The compiler is free to reorder this to:
// b: u64, c: u16, a: u8, padding: 5 bytes
#[repr(Rust)] // This is the default
struct Optimal {
    a: u8,
    b: u64,
    c: u16,
}

#[repr(C)] // Field reordering is disabled
struct SuboptimalC {
    a: u8,
    b: u64,
    c: u16,
}

fn main() {
    // Optimal layout is 16 bytes (8 for u64, 2 for u16, 1 for u8, 5 padding)
    assert_eq!(size_of::<Optimal>(), 16);

    // C layout is 24 bytes, same as our manual calculation
    assert_eq!(size_of::<SuboptimalC>(), 24);
}

While repr(Rust) is excellent for performance, it's unsuitable for situations requiring a stable memory layout, such as interoperating with C code via FFI. For that, we use #[repr(C)]. This directive disables field reordering and ensures the layout conforms to the C ABI for that target.

Another important directive is #[repr(transparent)]. It's used on structs with a single non- field. It guarantees that the wrapper struct has the exact same memory layout and ABI as the inner field. This is essential for creating zero-cost abstractions, allowing you to build new types with strong guarantees without any runtime overhead.

The Layout API

For cases where you need programmatic access to layout information or need to perform manual memory allocation (for instance, in custom data structures or allocators), Rust provides the std::alloc::Layout API. This allows you to construct a layout description for a type at runtime and use it to interact with allocators safely.

use std::alloc::{Layout, alloc, dealloc};

struct MyData {
    id: u32,
    value: u64,
}

fn main() {
    let layout = Layout::new::<MyData>();

    // The layout for MyData is size 16, align 8.
    assert_eq!(layout.size(), 16);
    assert_eq!(layout.align(), 8);

    unsafe {
        let ptr = alloc(layout);
        if !ptr.is_null() {
            // Write data to the allocated memory
            let data_ptr = ptr as *mut MyData;
            (*data_ptr).id = 42;
            (*data_ptr).value = 100;

            assert_eq!((*data_ptr).id, 42);
            dealloc(ptr, layout);
        }
    }
}

The is the cornerstone of unsafe code that deals with raw memory. It ensures that your requests to the global allocator are correct, preventing undefined behavior that can arise from misaligned pointers or incorrect size calculations. It's a powerful tool for low-level systems programming where every byte and every cycle counts.

Understanding and controlling memory layout is a key skill for writing high-performance Rust. By leveraging Rust's representation attributes and the Layout API, you can write code that is not only safe but also maximally efficient in its use of system resources.

Quiz Questions 1/5

What is the primary benefit of Rust's default struct layout representation, #[repr(Rust)]?

Quiz Questions 2/5

In the context of data types, what does "alignment" refer to?