I’ve spent years optimizing Rust applications for performance, and I’ve found that CPU-bound applications respond well to specific optimization techniques. Here’s what works best in practice.

Performance optimization in Rust requires careful measurement and strategic improvements. Many developers immediately reach for parallelism, but significant gains often come from improving sequential code first.

Profile-guided optimization enables the compiler to optimize based on real usage patterns. To implement PGO, modify your Cargo.toml to generate profile data:

# In Cargo.toml
[profile.release]
lto = true
codegen-units = 1
pgo = "generate"

After running your application with typical workloads, switch the configuration to use the generated profiles:

# In Cargo.toml
[profile.release]
lto = true
codegen-units = 1
pgo = "use"

Memory allocation is often a hidden performance bottleneck. Implementing custom allocators can drastically improve performance for specific workloads:

#[global_allocator]
static GLOBAL: CustomAllocator = CustomAllocator::new();

struct CustomAllocator {
    small_allocations: Mutex<BumpAllocator>,
    large_allocations: Mutex<MmapAllocator>,
}

unsafe impl GlobalAlloc for CustomAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        if layout.size() < 1024 {
            self.small_allocations.lock().unwrap().allocate(layout)
        } else {
            self.large_allocations.lock().unwrap().allocate(layout)
        }
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        // Implementation details
    }
}

For numerical computations, SIMD (Single Instruction Multiple Data) operations can provide dramatic speedups. Rust provides platform-specific intrinsics to leverage these capabilities:

#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;

unsafe fn vector_add(a: &[f32], b: &[f32], c: &mut [f32]) {
    let len = a.len();
    let mut i = 0;
    
    while i + 8 <= len {
        let a_vec = _mm256_loadu_ps(&a[i]);
        let b_vec = _mm256_loadu_ps(&b[i]);
        let sum = _mm256_add_ps(a_vec, b_vec);
        _mm256_storeu_ps(&mut c[i], sum);
        i += 8;
    }
    
    // Handle remaining elements
    for j in i..len {
        c[j] = a[j] + b[j];
    }
}

Loop optimization techniques can significantly improve performance. Loop unrolling reduces branch prediction failures and increases instruction-level parallelism:

fn sum_array(array: &[i32]) -> i32 {
    let mut sum = 0;
    let mut i = 0;
    let len = array.len();
    
    // Process 4 elements at a time
    while i + 4 <= len {
        sum += array[i] + array[i+1] + array[i+2] + array[i+3];
        i += 4;
    }
    
    // Handle remaining elements
    while i < len {
        sum += array[i];
        i += 1;
    }
    
    sum
}

For matrix operations, tiling improves cache locality by operating on small chunks of data that fit in the cache:

fn matrix_multiply(a: &[f32], b: &[f32], c: &mut [f32], n: usize) {
    const TILE_SIZE: usize = 16;
    
    c.fill(0.0);
    
    for i_tile in (0..n).step_by(TILE_SIZE) {
        for j_tile in (0..n).step_by(TILE_SIZE) {
            for k_tile in (0..n).step_by(TILE_SIZE) {
                for i in i_tile..std::cmp::min(i_tile + TILE_SIZE, n) {
                    for j in j_tile..std::cmp::min(j_tile + TILE_SIZE, n) {
                        let mut sum = c[i * n + j];
                        
                        for k in k_tile..std::cmp::min(k_tile + TILE_SIZE, n) {
                            sum += a[i * n + k] * b[k * n + j];
                        }
                        
                        c[i * n + j] = sum;
                    }
                }
            }
        }
    }
}

Memory alignment can significantly affect performance. Modern CPUs prefer data aligned to cache line boundaries (typically 64 bytes):

#[repr(align(64))]
struct AlignedData {
    values: [f32; 1024],
}

impl AlignedData {
    fn process(&mut self) {
        for val in &mut self.values {
            *val = val.sqrt() + 1.0;
        }
    }
}

Bit manipulation offers performance benefits for specific algorithms. These operations execute in a single CPU cycle and can replace more complex logic:

fn count_set_bits(mut x: u64) -> u32 {
    let mut count = 0;
    while x != 0 {
        x &= x - 1; // Clear the least significant set bit
        count += 1;
    }
    count
}

fn is_power_of_two(x: u64) -> bool {
    x != 0 && (x & (x - 1)) == 0
}

fn next_power_of_two(x: u32) -> u32 {
    if x == 0 { return 1; }
    
    let mut n = x - 1;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    n + 1
}

Branch prediction can significantly impact performance. Most CPUs predict that branches fall through, so organizing your code to make the common case follow this pattern improves performance:

fn process_data(data: &[i32]) -> i32 {
    let mut sum = 0;
    
    for &value in data {
        // Put the common case in the if part
        if value >= 0 {
            sum += value;
        } else {
            // Less common case
            sum -= value / 2;
        }
    }
    
    sum
}

Function inlining affects both code size and execution speed. Rust provides attributes to control this behavior:

#[inline(always)]
fn critical_math_operation(x: f64, y: f64) -> f64 {
    (x * x + y * y).sqrt()
}

#[inline(never)]
fn rarely_called_complex_function(data: &[u8]) -> u64 {
    // Complex logic that would bloat code size if inlined
    let mut hash = 0u64;
    for &byte in data {
        hash = hash.wrapping_mul(131).wrapping_add(byte as u64);
    }
    hash
}

Memory prefetching can improve performance by loading data into cache before it’s needed:

use std::intrinsics::prefetch_read_data;

fn process_large_array(data: &[u8]) {
    const PREFETCH_DISTANCE: usize = 64; // Adjusted based on workload
    
    for i in 0..data.len() {
        // Prefetch future data while processing current item
        if i + PREFETCH_DISTANCE < data.len() {
            unsafe {
                prefetch_read_data(
                    &data[i + PREFETCH_DISTANCE] as *const _ as *const libc::c_void, 
                    3  // Temporal locality hint
                );
            }
        }
        
        // Process current data
        process_byte(data[i]);
    }
}

I’ve found that implementing these optimizations requires careful benchmarking. In one project, switching to a custom allocator improved performance by 30% while SIMD instructions provided a 4x speedup for numerical processing.

Profile-driven development is critical. Before optimizing, I use tools like perf, flamegraph, or criterion.rs to identify bottlenecks. Often, the actual performance issue differs from my initial assumptions.

When optimizing an image processing library, I discovered that memory access patterns were more important than computational efficiency. By restructuring data layouts and implementing tiling, I achieved a 2.5x speedup without changing the core algorithms.

Remember that premature optimization can complicate code without meaningful benefits. I focus first on algorithms and data structures, then memory access patterns, and only then on micro-optimizations.

The most effective optimizations often come from understanding how your code interacts with hardware. Cache misses, branch mispredictions, and memory allocation can dwarf algorithmic inefficiencies in many real-world applications.

These techniques should be applied selectively where profiling shows bottlenecks. Rust’s safety guarantees allow aggressive optimization while maintaining correctness, making it ideal for high-performance applications.

By methodically applying these techniques, I’ve consistently achieved substantial performance improvements in CPU-bound applications while maintaining Rust’s safety guarantees. The key is measuring impact, understanding hardware interactions, and focusing efforts where they matter most.