Chapter 5: Performance & Memory

Understanding memory layout and optimization techniques is crucial for writing high-performance Rust code. This chapter explores how Rust manages memory and how to optimize your programs.

5.1 Memory Layout Fundamentals

Stack vs Heap

fn memory_demo() {
    // Stack allocation: fast, fixed size, automatic cleanup
    let x = 42;                    // i32: 4 bytes on stack
    let arr = [1, 2, 3, 4, 5];     // [i32; 5]: 20 bytes on stack

    // Heap allocation: slower, dynamic size, manual management
    let v = vec![1, 2, 3, 4, 5];   // Vec header on stack, data on heap
    let s = String::from("hello"); // String header on stack, data on heap
    let b = Box::new(100);         // Box pointer on stack, value on heap

    println!("Stack value: {}", x);
    println!("Heap value: {}", *b);
}

Type Sizes and Alignment

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

#[derive(Debug)]
struct Point {
    x: f64,  // 8 bytes
    y: f64,  // 8 bytes
}

#[derive(Debug)]
struct Data {
    flag: bool,  // 1 byte
    value: u64,  // 8 bytes
    count: u32,  // 4 bytes
}

fn main() {
    println!("Point: {} bytes, align {}", size_of::<Point>(), align_of::<Point>());
    // Point: 16 bytes, align 8

    println!("Data: {} bytes, align {}", size_of::<Data>(), align_of::<Data>());
    // Data: 24 bytes, align 8 (padding added!)

    // Optimized version
    #[derive(Debug)]
    struct OptimizedData {
        value: u64,  // 8 bytes
        count: u32,  // 4 bytes
        flag: bool,  // 1 byte
    }
    println!("OptimizedData: {} bytes", size_of::<OptimizedData>());
    // OptimizedData: 16 bytes (less padding)
}

Understanding repr

// Default Rust layout (can be reordered)
#[derive(Debug)]
struct Default {
    a: u8,
    b: u32,
    c: u8,
}

// C-compatible layout (no reordering)
#[repr(C)]
struct CCompat {
    a: u8,
    b: u32,
    c: u8,
}

// Packed (no padding - careful with alignment!)
#[repr(packed)]
struct Packed {
    a: u8,
    b: u32,
    c: u8,
}

fn main() {
    println!("Default: {}", std::mem::size_of::<Default>());
    println!("C-compat: {}", std::mem::size_of::<CCompat>());
    println!("Packed: {}", std::mem::size_of::<Packed>());
}

5.2 Smart Pointer Internals

Box, Rc, and Arc Memory Layout

use std::rc::Rc;
use std::sync::Arc;

fn pointer_sizes() {
    println!("Box<i32>: {} bytes", size_of::<Box<i32>>());
    // 8 bytes (just a pointer)

    println!("Rc<i32>: {} bytes", size_of::<Rc<i32>>());
    // 8 bytes (pointer to heap with refcount)

    println!("Arc<i32>: {} bytes", size_of::<Arc<i32>>());
    // 8 bytes (pointer to heap with atomic refcount)

    // Actual heap allocation
    let rc = Rc::new(42);
    // Heap: [strong_count, weak_count, value]
    //       [    4 bytes,     4 bytes, 4 bytes] + padding

    println!("Rc strong count: {}", Rc::strong_count(&rc));
}

Cow (Clone on Write)

use std::borrow::Cow;

fn process_text(input: &str) -> Cow<str> {
    if input.contains("ERROR") {
        // Need to modify: allocate
        Cow::Owned(input.replace("ERROR", "WARNING"))
    } else {
        // No modification: borrow
        Cow::Borrowed(input)
    }
}

fn main() {
    let text1 = "Everything is fine";
    let result1 = process_text(text1);
    // No allocation!

    let text2 = "ERROR occurred";
    let result2 = process_text(text2);
    // Allocated new string

    println!("{}", result1);
    println!("{}", result2);
}

5.3 Performance Profiling

Using Criterion for Benchmarking

// In Cargo.toml:
// [dev-dependencies]
// criterion = "0.5"
//
// [[bench]]
// name = "my_benchmark"
// harness = false

use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 1,
        1 => 1,
        n => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

fn fibonacci_bench(c: &mut Criterion) {
    c.bench_function("fib 20", |b| {
        b.iter(|| fibonacci(black_box(20)))
    });
}

criterion_group!(benches, fibonacci_bench);
criterion_main!(benches);

Using perf and flamegraph

// Install tools:
// cargo install flamegraph

// Run with profiling:
// cargo flamegraph --bin myapp

// Example code to profile
fn hot_path() {
    let mut sum = 0u64;
    for i in 0..1_000_000 {
        sum = sum.wrapping_add(expensive_calculation(i));
    }
    println!("Sum: {}", sum);
}

fn expensive_calculation(n: u64) -> u64 {
    (0..n).sum()
}

5.4 Optimization Techniques

Avoiding Allocations

// Bad: allocates every iteration
fn process_bad(items: &[&str]) {
    for item in items {
        let uppercase = item.to_uppercase();  // Allocation!
        println!("{}", uppercase);
    }
}

// Better: reuse buffer
fn process_better(items: &[&str]) {
    let mut buffer = String::new();
    for item in items {
        buffer.clear();
        buffer.push_str(item);
        buffer.make_ascii_uppercase();
        println!("{}", buffer);
    }
}

// Best: avoid allocation entirely if possible
fn process_best(items: &[&str]) {
    for item in items {
        print!("{}", item.to_uppercase());
    }
}

Using SmallVec

use smallvec::{SmallVec, smallvec};

fn smallvec_demo() {
    // Store up to 4 items inline, then spill to heap
    let mut vec: SmallVec<[i32; 4]> = smallvec![1, 2, 3];

    // Still on stack
    vec.push(4);

    // Now spills to heap
    vec.push(5);

    // Great for frequently-small collections
    // Common pattern: SmallVec<[T; 8]>
}

Iterator Optimization

// Slow: intermediate collections
fn sum_squares_slow(nums: &[i32]) -> i32 {
    let filtered: Vec<_> = nums.iter().filter(|&&x| x > 0).collect();
    let mapped: Vec<_> = filtered.iter().map(|&&x| x * x).collect();
    mapped.iter().sum()
}

// Fast: no intermediate allocations
fn sum_squares_fast(nums: &[i32]) -> i32 {
    nums.iter()
        .filter(|&&x| x > 0)
        .map(|&x| x * x)
        .sum()
}

// Even faster: use fold directly
fn sum_squares_fastest(nums: &[i32]) -> i32 {
    nums.iter()
        .filter(|&&x| x > 0)
        .fold(0, |acc, &x| acc + x * x)
}

5.5 SIMD and Vectorization

// Portable SIMD (nightly)
#![feature(portable_simd)]
use std::simd::{f32x4, SimdFloat};

fn simd_sum(values: &[f32]) -> f32 {
    let mut sum = 0.0;

    // Process 4 values at a time
    let chunks = values.chunks_exact(4);
    let remainder = chunks.remainder();

    let mut vec_sum = f32x4::splat(0.0);
    for chunk in chunks {
        let vec = f32x4::from_slice(chunk);
        vec_sum += vec;
    }

    sum += vec_sum.reduce_sum();

    // Handle remainder
    sum += remainder.iter().sum::<f32>();
    sum
}

// Using packed_simd crate (stable)
// [dependencies]
// packed_simd = "0.3"

5.6 Memory Pool Pattern

use std::cell::RefCell;

struct Pool<T> {
    items: RefCell<Vec<T>>,
}

impl<T> Pool<T> {
    fn new() -> Self {
        Pool {
            items: RefCell::new(Vec::new()),
        }
    }

    fn acquire(&self) -> Option<T> {
        self.items.borrow_mut().pop()
    }

    fn release(&self, item: T) {
        self.items.borrow_mut().push(item);
    }
}

// Usage
fn pool_example() {
    let pool = Pool::<Vec<u8>>::new();

    // Get a buffer (or allocate new)
    let mut buf = pool.acquire().unwrap_or_else(Vec::new);

    // Use it
    buf.extend_from_slice(b"hello");

    // Return it for reuse
    buf.clear();
    pool.release(buf);
}

5.7 Cache-Friendly Data Structures

Structure of Arrays (SoA)

// Array of Structures (AoS) - cache unfriendly
struct ParticleAoS {
    x: f32,
    y: f32,
    vx: f32,
    vy: f32,
}

fn update_aos(particles: &mut [ParticleAoS]) {
    for p in particles {
        p.x += p.vx;  // Jumps around in memory
        p.y += p.vy;
    }
}

// Structure of Arrays (SoA) - cache friendly
struct ParticlesSoA {
    x: Vec<f32>,
    y: Vec<f32>,
    vx: Vec<f32>,
    vy: Vec<f32>,
}

fn update_soa(particles: &mut ParticlesSoA) {
    // Better cache locality
    for i in 0..particles.x.len() {
        particles.x[i] += particles.vx[i];
        particles.y[i] += particles.vy[i];
    }
}

5.8 Compile-Time Optimization

Profile-Guided Optimization

# In Cargo.toml
[profile.release]
lto = true              # Link-time optimization
codegen-units = 1       # Better optimization, slower compile
opt-level = 3           # Maximum optimization
strip = true            # Remove debug symbols

# Profile-guided optimization
# 1. Build instrumented binary
# RUSTFLAGS="-Cprofile-generate=/tmp/pgo-data" cargo build --release
#
# 2. Run workload
# ./target/release/myapp
#
# 3. Build optimized binary
# RUSTFLAGS="-Cprofile-use=/tmp/pgo-data" cargo build --release

Const Evaluation

// Compute at compile time
const fn factorial(n: u64) -> u64 {
    match n {
        0 | 1 => 1,
        _ => n * factorial(n - 1),
    }
}

const FACT_10: u64 = factorial(10);  // Computed at compile time!

fn main() {
    println!("10! = {}", FACT_10);  // No runtime cost
}

// Const generic computation
fn create_lookup_table<const N: usize>() -> [u64; N] {
    let mut table = [0; N];
    let mut i = 0;
    while i < N {
        table[i] = factorial(i as u64);
        i += 1;
    }
    table
}

const FACTORIALS: [u64; 20] = create_lookup_table::<20>();

5.9 Unsafe for Performance

// Safe but bounds-checked every access
fn sum_safe(data: &[i32]) -> i32 {
    let mut sum = 0;
    for i in 0..data.len() {
        sum += data[i];  // Bounds check on every access
    }
    sum
}

// Unsafe: skip bounds checks when we know it's safe
fn sum_unsafe(data: &[i32]) -> i32 {
    let mut sum = 0;
    for i in 0..data.len() {
        unsafe {
            sum += *data.get_unchecked(i);  // No bounds check
        }
    }
    sum
}

// Best: use iterators (no bounds checks, same speed as unsafe)
fn sum_iter(data: &[i32]) -> i32 {
    data.iter().sum()
}

5.10 Chapter Summary