Unofficial Guide to Rust Optimization Techniques

 1// This iterator chain compiles to the same assembly as a hand-written loop
 2let sum: i32 = (0..1_000_000)
 3    .filter(|&x| x % 2 == 0)
 4    .map(|x| x * x)
 5    .sum();
 6
 7// Equivalent optimized assembly:
 8// mov eax, 0
 9// mov ecx, 0
10// loop_start:
11//   test ecx, 1
12//   jne skip
13//   mov edx, ecx
14//   imul edx, ecx
15//   add eax, edx
16// skip:
17//   inc ecx
18//   cmp ecx, 1000000
19//   jl loop_start

 1// Bad: Array of Structs (AoS) - poor cache locality
 2struct Point {
 3    x: f64,
 4    y: f64,
 5    z: f64,
 6}
 7let points: Vec<Point> = vec![/* ... */];
 8
 9// Good: Struct of Arrays (SoA) - better cache locality
10struct Points {
11    x: Vec<f64>,
12    y: Vec<f64>,
13    z: Vec<f64>,
14}
15
16// Even better: Use SIMD-friendly layouts
17#[repr(C, packed)]
18struct Point4 {
19    x: [f64; 4],
20    y: [f64; 4],
21    z: [f64; 4],
22}

 1# Cargo.toml
 2[profile.release]
 3lto = "fat"
 4codegen-units = 1
 5panic = "abort"
 6
 7# Build with PGO
 8cargo rustc --release -- -Cprofile-generate=/tmp/pgo-data
 9# Run your benchmarks/tests
10cargo rustc --release -- -Cprofile-use=/tmp/pgo-data

1// This enables the compiler to inline across crate boundaries
2// and eliminate dead code more aggressively
3#[inline]
4pub fn hot_function(x: i32) -> i32 {
5    x * x + 2 * x + 1
6}

1# Build for native CPU with all available features
2RUSTFLAGS="-C target-cpu=native" cargo build --release
3
4# Or specify exact features
5RUSTFLAGS="-C target-feature=+avx2,+fma" cargo build --release

 1use linked_hash_map::LinkedHashMap;
 2use bumpalo::Bump;
 3
 4// Arena allocator for short-lived objects
 5fn process_batch(data: &[u8]) {
 6    let arena = Bump::new();
 7    let mut cache = LinkedHashMap::new();
 8
 9    // All allocations go to the arena
10    // Freed all at once when arena is dropped
11    for chunk in data.chunks(1024) {
12        let processed = arena.alloc_slice_fill_copy(chunk.len(), 0);
13        // Process chunk...
14        cache.insert(chunk[0], processed);
15    }
16    // Arena automatically freed here
17}
18
19// Pool allocator for fixed-size objects
20use object_pool::Pool;
21
22struct Connection {
23    // Connection data
24}
25
26lazy_static! {
27    static ref CONNECTION_POOL: Pool<Connection> = Pool::new(32, || {
28        Connection::new()
29    });
30}

 1pub struct MemoryPool<T> {
 2    pool: Vec<Box<T>>,
 3    in_use: Vec<bool>,
 4}
 5
 6impl<T: Default> MemoryPool<T> {
 7    pub fn new(capacity: usize) -> Self {
 8        let mut pool = Vec::with_capacity(capacity);
 9        let mut in_use = Vec::with_capacity(capacity);
10
11        for _ in 0..capacity {
12            pool.push(Box::new(T::default()));
13            in_use.push(false);
14        }
15
16        Self { pool, in_use }
17    }
18
19    pub fn acquire(&mut self) -> Option<&mut T> {
20        for (i, available) in self.in_use.iter_mut().enumerate() {
21            if !*available {
22                *available = true;
23                return Some(&mut self.pool[i]);
24            }
25        }
26        None
27    }
28
29    pub fn release(&mut self, ptr: *mut T) {
30        for (i, item) in self.pool.iter().enumerate() {
31            if item.as_ref() as *const T == ptr {
32                self.in_use[i] = false;
33                break;
34            }
35        }
36    }
37}

 1use std::arch::x86_64::*;
 2
 3#[target_feature(enable = "avx2")]
 4unsafe fn add_vectors_simd(a: &[f32], b: &[f32], result: &mut [f32]) {
 5    assert_eq!(a.len(), b.len());
 6    assert_eq!(a.len(), result.len());
 7    assert_eq!(a.len() % 8, 0); // AVX2 processes 8 f32s at once
 8
 9    for i in (0..a.len()).step_by(8) {
10        let va = _mm256_loadu_ps(a.as_ptr().add(i));
11        let vb = _mm256_loadu_ps(b.as_ptr().add(i));
12        let vr = _mm256_add_ps(va, vb);
13        _mm256_storeu_ps(result.as_mut_ptr().add(i), vr);
14    }
15}
16
17// Portable SIMD (experimental)
18#![feature(portable_simd)]
19use std::simd::*;
20
21fn add_vectors_portable(a: &[f32], b: &[f32], result: &mut [f32]) {
22    let (a_chunks, a_remainder) = a.as_chunks::<8>();
23    let (b_chunks, b_remainder) = b.as_chunks::<8>();
24    let (result_chunks, result_remainder) = result.as_chunks_mut::<8>();
25
26    for ((a_chunk, b_chunk), result_chunk) in
27        a_chunks.iter().zip(b_chunks).zip(result_chunks) {
28        let va = f32x8::from_array(*a_chunk);
29        let vb = f32x8::from_array(*b_chunk);
30        *result_chunk = (va + vb).to_array();
31    }
32
33    // Handle remainder
34    for ((a, b), result) in
35        a_remainder.iter().zip(b_remainder).zip(result_remainder) {
36        *result = a + b;
37    }
38}

 1// Use iterators when possible - they vectorize better
 2fn sum_squares(data: &[f64]) -> f64 {
 3    data.iter().map(|&x| x * x).sum()
 4}
 5
 6// Ensure bounds are known at compile time
 7fn process_fixed_size(data: &[u8; 1024]) {
 8    for i in 0..1024 {
 9        // Compiler knows bounds, can vectorize aggressively
10        data[i].wrapping_mul(2);
11    }
12}
13
14// Use slice::chunks_exact for better vectorization
15fn process_chunked(data: &[f32]) {
16    for chunk in data.chunks_exact(4) {
17        // Process 4 elements at a time
18        let sum: f32 = chunk.iter().sum();
19        // Use sum...
20    }
21}

 1// CPU-bound tasks
 2let rt = tokio::runtime::Builder::new_multi_thread()
 3    .worker_threads(num_cpus::get())
 4    .enable_all()
 5    .build()?;
 6
 7// IO-bound tasks
 8let rt = tokio::runtime::Builder::new_multi_thread()
 9    .worker_threads(1)
10    .max_blocking_threads(512)
11    .enable_all()
12    .build()?;

 1use crossbeam::queue::SegQueue;
 2use std::sync::Arc;
 3
 4// Lock-free queue
 5let queue: Arc<SegQueue<Task>> = Arc::new(SegQueue::new());
 6
 7// Multiple producers
 8for i in 0..num_cpus::get() {
 9    let queue = queue.clone();
10    std::thread::spawn(move || {
11        for j in 0..1000 {
12            queue.push(Task::new(i, j));
13        }
14    });
15}
16
17// Single consumer
18while let Some(task) = queue.pop() {
19    task.process();
20}

 1// High-throughput, bounded
 2use crossbeam::channel;
 3let (tx, rx) = channel::bounded(1024);
 4
 5// Low-latency, unbounded
 6let (tx, rx) = channel::unbounded();
 7
 8// Single producer, single consumer
 9use crossbeam::channel::spsc;
10let (tx, rx) = spsc::bounded(1024);
11
12// Multiple producer, single consumer
13use flume;
14let (tx, rx) = flume::unbounded();

 1// Use likely/unlikely hints
 2#[cold]
 3fn handle_error() -> ! {
 4    panic!("This should rarely happen");
 5}
 6
 7fn process_data(data: &[u8]) -> Result<(), Error> {
 8    for &byte in data {
 9        if likely(byte != 0xFF) {
10            // Hot path - common case
11            process_normal_byte(byte);
12        } else {
13            // Cold path - rare case
14            return Err(Error::SpecialByte);
15        }
16    }
17    Ok(())
18}
19
20// Avoid unpredictable branches in hot loops
21fn sum_positive(data: &[i32]) -> i32 {
22    // Bad: unpredictable branch
23    data.iter().filter(|&&x| x > 0).sum()
24
25    // Better: branchless
26    data.iter().map(|&x| if x > 0 { x } else { 0 }).sum()
27
28    // Even better: SIMD
29    data.iter().map(|&x| x.max(0)).sum()
30}

 1// Force inlining for small, hot functions
 2#[inline(always)]
 3fn fast_path(x: u32) -> u32 {
 4    x.wrapping_mul(0x9e3779b9)
 5}
 6
 7// Prevent inlining for large functions
 8#[inline(never)]
 9fn slow_path() {
10    // Large function body
11}
12
13// Let compiler decide (default)
14#[inline]
15fn normal_function() {
16    // Medium-sized function
17}

 1use criterion::{criterion_group, criterion_main, Criterion, BenchmarkId};
 2
 3fn bench_algorithms(c: &mut Criterion) {
 4    let mut group = c.benchmark_group("sorting");
 5
 6    for size in [100, 1000, 10000].iter() {
 7        let data: Vec<i32> = (0..*size).rev().collect();
 8
 9        group.bench_with_input(
10            BenchmarkId::new("std_sort", size),
11            size,
12            |b, _| b.iter(|| {
13                let mut data = data.clone();
14                data.sort();
15            })
16        );
17
18        group.bench_with_input(
19            BenchmarkId::new("unstable_sort", size),
20            size,
21            |b, _| b.iter(|| {
22                let mut data = data.clone();
23                data.sort_unstable();
24            })
25        );
26    }
27
28    group.finish();
29}
30
31criterion_group!(benches, bench_algorithms);
32criterion_main!(benches);

 1# CPU profiling with perf
 2perf record --call-graph=dwarf ./target/release/my_app
 3perf report
 4
 5# Heap profiling with valgrind
 6valgrind --tool=massif ./target/release/my_app
 7
 8# Rust-specific profiling
 9cargo install cargo-flamegraph
10cargo flamegraph --bin my_app
11
12# Memory debugging
13cargo install cargo-valgrind
14cargo valgrind run --bin my_app

 1// Const evaluation
 2const fn fibonacci(n: usize) -> usize {
 3    match n {
 4        0 => 0,
 5        1 => 1,
 6        _ => fibonacci(n - 1) + fibonacci(n - 2),
 7    }
 8}
 9
10// Pre-computed at compile time
11const FIB_10: usize = fibonacci(10);
12
13// Procedural macros for code generation
14use proc_macro::TokenStream;
15
16#[proc_macro]
17pub fn generate_lookup_table(_input: TokenStream) -> TokenStream {
18    let mut table = String::new();
19    table.push_str("const LOOKUP: [u8; 256] = [");
20
21    for i in 0..256 {
22        table.push_str(&format!("{}, ", expensive_function(i)));
23    }
24
25    table.push_str("];");
26    table.parse().unwrap()
27}

 1use std::arch::asm;
 2
 3#[cfg(target_arch = "x86_64")]
 4unsafe fn fast_strlen(s: *const u8) -> usize {
 5    let len: usize;
 6    asm!(
 7        "xor {len}, {len}",
 8        "2:",
 9        "cmp byte ptr [{s} + {len}], 0",
10        "je 3f",
11        "inc {len}",
12        "jmp 2b",
13        "3:",
14        s = in(reg) s,
15        len = out(reg) len,
16        options(nostack, preserves_flags)
17    );
18    len
19}

 1// Use #[inline(never)] to ensure functions show up in profiles
 2#[inline(never)]
 3fn potentially_slow_function() {
 4    // Implementation
 5}
 6
 7// Add timing instrumentation
 8fn timed_operation() {
 9    let start = std::time::Instant::now();
10    do_work();
11    println!("Operation took: {:?}", start.elapsed());
12}

 1// O(n²) → O(n log n) is better than micro-optimizations
 2// Bad: O(n²)
 3fn find_duplicates_slow(data: &[i32]) -> Vec<i32> {
 4    let mut duplicates = Vec::new();
 5    for (i, &x) in data.iter().enumerate() {
 6        for &y in &data[i+1..] {
 7            if x == y {
 8                duplicates.push(x);
 9                break;
10            }
11        }
12    }
13    duplicates
14}
15
16// Good: O(n log n)
17use std::collections::HashSet;
18fn find_duplicates_fast(data: &[i32]) -> Vec<i32> {
19    let mut seen = HashSet::new();
20    let mut duplicates = Vec::new();
21
22    for &x in data {
23        if !seen.insert(x) {
24            duplicates.push(x);
25        }
26    }
27    duplicates
28}