1. rust
  2. /systems
  3. /performance

Performance Optimization

Performance optimization in Rust involves understanding how the compiler works, measuring performance accurately, and applying targeted optimizations. Rust's zero-cost abstractions and fine-grained control over memory make it excellent for high-performance applications.

Performance Measurement and Profiling

Benchmarking with Criterion

First, add to Cargo.toml:

[dev-dependencies] criterion = { version = "0.5", features = ["html_reports"] }  [[bench]] name = "my_benchmark" harness = false

Basic benchmarking:

// benches/my_benchmark.rs use criterion::{black_box, criterion_group, criterion_main, Criterion};  fn fibonacci_recursive(n: u64) -> u64 {  match n {  0 => 1,  1 => 1,  n => fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2),  } }  fn fibonacci_iterative(n: u64) -> u64 {  if n == 0 || n == 1 {  return 1;  }    let mut a = 1;  let mut b = 1;    for _ in 2..=n {  let temp = a + b;  a = b;  b = temp;  }    b }  fn fibonacci_lookup(n: u64) -> u64 {  const FIBONACCI: [u64; 21] = [  1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946  ];    if n < 21 {  FIBONACCI[n as usize]  } else {  fibonacci_iterative(n)  } }  fn criterion_benchmark(c: &mut Criterion) {  let mut group = c.benchmark_group("fibonacci");    for i in [10u64, 15, 20].iter() {  group.bench_with_input(format!("recursive/{}", i), i, |b, i| {  b.iter(|| fibonacci_recursive(black_box(*i)))  });    group.bench_with_input(format!("iterative/{}", i), i, |b, i| {  b.iter(|| fibonacci_iterative(black_box(*i)))  });    group.bench_with_input(format!("lookup/{}", i), i, |b, i| {  b.iter(|| fibonacci_lookup(black_box(*i)))  });  }    group.finish(); }  criterion_group!(benches, criterion_benchmark); criterion_main!(benches);

Run benchmarks:

cargo bench

Built-in Benchmarking (Nightly)

#![feature(test)] extern crate test; use test::Bencher;  #[bench] fn bench_vector_sum_loop(b: &mut Bencher) {  let data: Vec<i32> = (0..1000).collect();  b.iter(|| {  let mut sum = 0;  for &item in &data {  sum += item;  }  sum  }); }  #[bench] fn bench_vector_sum_iterator(b: &mut Bencher) {  let data: Vec<i32> = (0..1000).collect();  b.iter(|| data.iter().sum::<i32>()); }  #[bench] fn bench_vector_sum_fold(b: &mut Bencher) {  let data: Vec<i32> = (0..1000).collect();  b.iter(|| data.iter().fold(0, |acc, &x| acc + x)); }

Profiling with perf and flamegraph

Install dependencies:

cargo install flamegraph # On Linux: install perf

Profile your application:

# Generate flamegraph cargo flamegraph --bin my_app  # Profile with perf perf record --call-graph=dwarf target/release/my_app perf report

Example application to profile:

// src/main.rs use std::collections::HashMap;  fn expensive_computation() -> HashMap<String, u64> {  let mut map = HashMap::new();    for i in 0..1_000_000 {  let key = format!("key_{}", i);  let value = (i as u64).pow(2);  map.insert(key, value);  }    map }  fn process_data(map: &HashMap<String, u64>) -> u64 {  map.values().filter(|&&v| v % 2 == 0).sum() }  fn main() {  let map = expensive_computation();  let result = process_data(&map);  println!("Result: {}", result); }

Compiler Optimizations

Release Profile Configuration

# Cargo.toml [profile.release] opt-level = 3 # Maximum optimization debug = false # No debug info debug-assertions = false overflow-checks = false lto = true # Link-time optimization codegen-units = 1 # Better optimization, slower compile panic = 'abort' # Smaller binary size  [profile.release-lto] inherits = "release" lto = "fat" # More aggressive LTO codegen-units = 1

Target-Specific Optimizations

# .cargo/config.toml [build] rustflags = [  "-C", "target-cpu=native", # Optimize for current CPU  "-C", "target-feature=+crt-static", # Static linking ]  [target.x86_64-unknown-linux-gnu] rustflags = [  "-C", "link-arg=-fuse-ld=lld", # Use faster linker  "-C", "target-cpu=haswell", # Target specific CPU ]

Profile-Guided Optimization (PGO)

# Step 1: Build instrumented binary RUSTFLAGS="-Cprofile-generate=/tmp/pgo-data" \  cargo build --release --target-dir=/tmp/pgo  # Step 2: Run typical workload /tmp/pgo/release/my_app  # Step 3: Build optimized binary RUSTFLAGS="-Cprofile-use=/tmp/pgo-data" \  cargo build --release

Memory Optimization

Reducing Allocations

// Bad: Many allocations fn process_strings_bad(input: &[&str]) -> Vec<String> {  let mut result = Vec::new();  for s in input {  let processed = s.to_uppercase();  let formatted = format!("Processed: {}", processed);  result.push(formatted);  }  result }  // Good: Pre-allocate and reuse fn process_strings_good(input: &[&str]) -> Vec<String> {  let mut result = Vec::with_capacity(input.len());  let mut buffer = String::new();    for s in input {  buffer.clear();  buffer.push_str("Processed: ");    for ch in s.chars() {  buffer.extend(ch.to_uppercase());  }    result.push(buffer.clone());  }  result }  // Better: Avoid cloning fn process_strings_better(input: &[&str], output: &mut Vec<String>) {  output.clear();  output.reserve(input.len());    for s in input {  let formatted = format!("Processed: {}", s.to_uppercase());  output.push(formatted);  } }  // Best: Use iterators for zero-allocation processing when possible fn process_strings_best(input: &[&str]) -> impl Iterator<Item = String> + '_ {  input.iter().map(|s| format!("Processed: {}", s.to_uppercase())) }

Memory Pool Pattern

use std::collections::VecDeque;  struct ObjectPool<T> {  objects: VecDeque<T>,  factory: fn() -> T, }  impl<T> ObjectPool<T> {  fn new(factory: fn() -> T) -> Self {  ObjectPool {  objects: VecDeque::new(),  factory,  }  }    fn get(&mut self) -> T {  self.objects.pop_front().unwrap_or_else(self.factory)  }    fn return_object(&mut self, obj: T) {  if self.objects.len() < 100 { // Limit pool size  self.objects.push_back(obj);  }  } }  // Usage example fn with_pool_optimization() {  let mut string_pool = ObjectPool::new(String::new);    for i in 0..1000 {  let mut s = string_pool.get();  s.clear();  s.push_str(&format!("Item {}", i));    // Process string...  println!("Processing: {}", s);    string_pool.return_object(s);  } }

Stack vs Heap Allocation

// Stack allocation (faster) fn stack_allocation() -> [i32; 1000] {  [0; 1000] // Allocated on stack }  // Heap allocation (more flexible but slower) fn heap_allocation() -> Vec<i32> {  vec![0; 1000] // Allocated on heap }  // Hybrid approach: stack for small, heap for large fn adaptive_allocation(size: usize) -> Box<[i32]> {  if size <= 1000 {  // Use stack-allocated array and move to heap  let mut vec = Vec::with_capacity(size);  vec.resize(size, 0);  vec.into_boxed_slice()  } else {  // Direct heap allocation  vec![0; size].into_boxed_slice()  } }  // SmallVec for stack optimization use smallvec::{SmallVec, smallvec};  fn using_smallvec() {  // Store up to 8 elements on stack, then heap  let mut vec: SmallVec<[i32; 8]> = smallvec![1, 2, 3, 4];  vec.push(5);    println!("SmallVec: {:?}", vec); }

Data Structure Optimization

Choose Efficient Data Structures

use std::collections::{HashMap, BTreeMap, HashSet}; use indexmap::IndexMap;  // Different data structures for different use cases fn data_structure_comparison() {  // HashMap: O(1) average access, no ordering  let mut hash_map = HashMap::new();  hash_map.insert("key1", "value1");    // BTreeMap: O(log n) access, sorted order  let mut btree_map = BTreeMap::new();  btree_map.insert("key1", "value1");    // IndexMap: O(1) access, insertion order preserved  let mut index_map = IndexMap::new();  index_map.insert("key1", "value1");    // Vector: O(1) indexed access, O(n) search  let mut vec = Vec::new();  vec.push(("key1", "value1")); }  // Custom data structure for specific use case struct CompactStringSet {  data: Vec<u8>,  offsets: Vec<usize>, }  impl CompactStringSet {  fn new() -> Self {  CompactStringSet {  data: Vec::new(),  offsets: Vec::new(),  }  }    fn insert(&mut self, s: &str) {  self.offsets.push(self.data.len());  self.data.extend_from_slice(s.as_bytes());  self.data.push(0); // Null terminator  }    fn get(&self, index: usize) -> Option<&str> {  if index >= self.offsets.len() {  return None;  }    let start = self.offsets[index];  let end = if index + 1 < self.offsets.len() {  self.offsets[index + 1] - 1 // -1 for null terminator  } else {  self.data.len() - 1  };    std::str::from_utf8(&self.data[start..end]).ok()  }    fn len(&self) -> usize {  self.offsets.len()  } }

Bit Manipulation Optimizations

// Bit-packed boolean array struct BitSet {  data: Vec<u64>,  len: usize, }  impl BitSet {  fn new(len: usize) -> Self {  let words = (len + 63) / 64; // Round up  BitSet {  data: vec![0; words],  len,  }  }    fn set(&mut self, index: usize, value: bool) {  if index >= self.len {  return;  }    let word_index = index / 64;  let bit_index = index % 64;    if value {  self.data[word_index] |= 1u64 << bit_index;  } else {  self.data[word_index] &= !(1u64 << bit_index);  }  }    fn get(&self, index: usize) -> bool {  if index >= self.len {  return false;  }    let word_index = index / 64;  let bit_index = index % 64;    (self.data[word_index] & (1u64 << bit_index)) != 0  }    fn count_ones(&self) -> u32 {  self.data.iter().map(|word| word.count_ones()).sum()  } }  // Bit manipulation tricks fn bit_tricks() {  let mut x = 42u32;    // Check if power of 2  let is_power_of_2 = x != 0 && (x & (x - 1)) == 0;    // Next power of 2  x -= 1;  x |= x >> 1;  x |= x >> 2;  x |= x >> 4;  x |= x >> 8;  x |= x >> 16;  x += 1;    // Count trailing zeros (fast)  let trailing_zeros = 42u32.trailing_zeros();    // Population count (number of 1 bits)  let pop_count = 42u32.count_ones();    println!("Bit tricks: power_of_2={}, next_pow2={}, trailing_zeros={}, pop_count={}",   is_power_of_2, x, trailing_zeros, pop_count); }

Algorithm Optimization

Cache-Friendly Algorithms

// Cache-unfriendly: row-major access of column-major data fn matrix_multiply_bad(a: &[Vec<f64>], b: &[Vec<f64>]) -> Vec<Vec<f64>> {  let n = a.len();  let m = b[0].len();  let p = b.len();  let mut result = vec![vec![0.0; m]; n];    for i in 0..n {  for j in 0..m {  for k in 0..p {  result[i][j] += a[i][k] * b[k][j]; // Poor cache locality  }  }  }    result }  // Cache-friendly: blocked/tiled multiplication fn matrix_multiply_good(a: &[Vec<f64>], b: &[Vec<f64>]) -> Vec<Vec<f64>> {  let n = a.len();  let m = b[0].len();  let p = b.len();  let mut result = vec![vec![0.0; m]; n];  let block_size = 64; // Optimize for cache line size    for ii in (0..n).step_by(block_size) {  for jj in (0..m).step_by(block_size) {  for kk in (0..p).step_by(block_size) {  let i_end = (ii + block_size).min(n);  let j_end = (jj + block_size).min(m);  let k_end = (kk + block_size).min(p);    for i in ii..i_end {  for j in jj..j_end {  for k in kk..k_end {  result[i][j] += a[i][k] * b[k][j];  }  }  }  }  }  }    result }  // SIMD-optimized operations fn simd_sum(data: &[f32]) -> f32 {  // Manual SIMD (requires nightly and target features)  #[cfg(target_arch = "x86_64")]  {  use std::arch::x86_64::*;    unsafe {  let mut sum_vec = _mm256_setzero_ps();  let chunks = data.chunks_exact(8);    for chunk in chunks {  let chunk_vec = _mm256_loadu_ps(chunk.as_ptr());  sum_vec = _mm256_add_ps(sum_vec, chunk_vec);  }    // Horizontal sum  let high = _mm256_extractf128_ps(sum_vec, 1);  let low = _mm256_extractf128_ps(sum_vec, 0);  let sum128 = _mm_add_ps(high, low);    let sum64 = _mm_add_ps(sum128, _mm_movehl_ps(sum128, sum128));  let sum32 = _mm_add_ss(sum64, _mm_shuffle_ps(sum64, sum64, 1));    let mut result = _mm_cvtss_f32(sum32);    // Handle remainder  let remainder = data.chunks_exact(8).remainder();  result += remainder.iter().sum::<f32>();    result  }  }    #[cfg(not(target_arch = "x86_64"))]  {  data.iter().sum()  } }

Parallel Processing

use rayon::prelude::*;  // Sequential processing fn process_sequential(data: &[i32]) -> Vec<i32> {  data.iter().map(|&x| x * x + 1).collect() }  // Parallel processing fn process_parallel(data: &[i32]) -> Vec<i32> {  data.par_iter().map(|&x| x * x + 1).collect() }  // Parallel reduction fn parallel_sum(data: &[i32]) -> i64 {  data.par_iter().map(|&x| x as i64).sum() }  // Custom parallel algorithm fn parallel_quicksort<T: Ord + Send>(mut data: Vec<T>) -> Vec<T> {  if data.len() <= 1 {  return data;  }    let pivot_index = data.len() / 2;  let pivot = data.remove(pivot_index);    let (left, right): (Vec<_>, Vec<_>) = data.into_par_iter()  .partition(|item| item < &pivot);    if left.len() > 1000 && right.len() > 1000 {  // Parallel recursive calls for large partitions  let (mut sorted_left, mut sorted_right) = rayon::join(  || parallel_quicksort(left),  || parallel_quicksort(right),  );    sorted_left.push(pivot);  sorted_left.extend(sorted_right);  sorted_left  } else {  // Sequential for small partitions  let mut result = parallel_quicksort(left);  result.push(pivot);  result.extend(parallel_quicksort(right));  result  } }

String and Text Optimization

Efficient String Processing

// Avoiding allocations in string processing fn count_words_efficient(text: &str) -> usize {  text.split_whitespace().count() // No allocations }  fn extract_numbers_efficient(text: &str) -> Vec<i32> {  text.split_whitespace()  .filter_map(|s| s.parse().ok())  .collect() }  // String interning for repeated strings use std::collections::HashMap;  struct StringInterner {  strings: Vec<String>,  map: HashMap<String, usize>, }  impl StringInterner {  fn new() -> Self {  StringInterner {  strings: Vec::new(),  map: HashMap::new(),  }  }    fn intern(&mut self, s: &str) -> usize {  if let Some(&id) = self.map.get(s) {  id  } else {  let id = self.strings.len();  self.strings.push(s.to_string());  self.map.insert(s.to_string(), id);  id  }  }    fn get(&self, id: usize) -> Option<&str> {  self.strings.get(id).map(|s| s.as_str())  } }  // Byte string processing (faster than UTF-8) fn process_ascii_bytes(data: &[u8]) -> usize {  data.iter().filter(|&&b| b.is_ascii_alphabetic()).count() }  // SIMD string search fn find_byte_simd(haystack: &[u8], needle: u8) -> Option<usize> {  // Use memchr crate for production code  haystack.iter().position(|&b| b == needle) }

I/O Optimization

Buffered I/O and Batch Processing

use std::io::{BufRead, BufReader, BufWriter, Write}; use std::fs::File;  // Efficient file reading fn read_lines_efficient(filename: &str) -> Result<Vec<String>, std::io::Error> {  let file = File::open(filename)?;  let reader = BufReader::new(file);  reader.lines().collect() }  // Efficient file writing fn write_lines_efficient(filename: &str, lines: &[String]) -> Result<(), std::io::Error> {  let file = File::create(filename)?;  let mut writer = BufWriter::new(file);    for line in lines {  writeln!(writer, "{}", line)?;  }    writer.flush()?;  Ok(()) }  // Memory-mapped files for large data use memmap2::MmapOptions;  fn process_large_file_mmap(filename: &str) -> Result<usize, Box<dyn std::error::Error>> {  let file = File::open(filename)?;  let mmap = unsafe { MmapOptions::new().map(&file)? };    // Process memory-mapped data directly  let line_count = mmap.split(|&b| b == b'\n').count();  Ok(line_count) }  // Async I/O for high concurrency async fn async_file_processing(filenames: Vec<&str>) -> Result<Vec<String>, tokio::io::Error> {  use tokio::fs;  use futures::future::try_join_all;    let tasks: Vec<_> = filenames.into_iter()  .map(|filename| async move {  fs::read_to_string(filename).await  })  .collect();    try_join_all(tasks).await }

Compilation and Build Optimization

Cargo Configuration

# .cargo/config.toml [build] rustflags = ["-C", "target-cpu=native"]  [profile.release] debug = true # Keep symbols for profiling debug-assertions = false overflow-checks = false lto = "thin" # Balance between compile time and performance codegen-units = 16 # Parallel compilation incremental = false # Disable for release builds panic = "abort" # Smaller binaries  # Custom profile for maximum performance [profile.max-perf] inherits = "release" opt-level = 3 lto = "fat" codegen-units = 1 panic = "abort" 
# Enable LTO export RUSTFLAGS="-C link-args=-fuse-ld=lld" cargo build --release

Cross-compilation optimization

# Target-specific optimizations cargo build --release --target x86_64-unknown-linux-musl cargo build --release --target x86_64-pc-windows-gnu  # CPU-specific targeting export RUSTFLAGS="-C target-cpu=skylake" cargo build --release

Advanced Optimization Techniques

Const Evaluation and Compile-Time Computation

// Compile-time computation const fn factorial(n: u64) -> u64 {  if n == 0 { 1 } else { n * factorial(n - 1) } }  const FACTORIAL_10: u64 = factorial(10); // Computed at compile time  // Const generics for optimization struct Matrix<const N: usize, const M: usize> {  data: [[f64; M]; N], }  impl<const N: usize, const M: usize> Matrix<N, M> {  const fn zeros() -> Self {  Matrix { data: [[0.0; M]; N] }  }    // Optimized matrix multiplication for known sizes  fn multiply<const P: usize>(&self, other: &Matrix<M, P>) -> Matrix<N, P> {  let mut result = Matrix::<N, P>::zeros();    for i in 0..N {  for j in 0..P {  for k in 0..M {  result.data[i][j] += self.data[i][k] * other.data[k][j];  }  }  }    result  } }  // Lookup tables const SINE_TABLE: [f32; 360] = {  let mut table = [0.0; 360];  let mut i = 0;  while i < 360 {  table[i] = (i as f32 * std::f32::consts::PI / 180.0).sin();  i += 1;  }  table };  fn fast_sine(degrees: usize) -> f32 {  SINE_TABLE[degrees % 360] }

Branch Prediction Optimization

// Help branch predictor with likely/unlikely fn process_with_hints(data: &[i32]) -> i32 {  let mut sum = 0;    for &value in data {  if likely(value > 0) {  sum += value;  } else {  sum -= value;  }  }    sum }  // Branchless programming fn branchless_max(a: i32, b: i32) -> i32 {  let diff = a - b;  a - (diff & (diff >> 31)) }  fn branchless_abs(x: i32) -> i32 {  let mask = x >> 31;  (x + mask) ^ mask }  // Jump table instead of long if-else chain fn dispatch_operation(op: u8, a: i32, b: i32) -> i32 {  const OPERATIONS: [fn(i32, i32) -> i32; 4] = [  |a, b| a + b, // 0: add  |a, b| a - b, // 1: subtract  |a, b| a * b, // 2: multiply  |a, b| a / b, // 3: divide  ];    if (op as usize) < OPERATIONS.len() {  OPERATIONS[op as usize](a, b)  } else {  0  } }  // Compiler hints (requires nightly) #[inline(always)] fn likely(b: bool) -> bool {  #[cfg(target_arch = "x86_64")]  unsafe {  std::intrinsics::likely(b)  }  #[cfg(not(target_arch = "x86_64"))]  b }

Performance Testing and Validation

Comprehensive Benchmarking Suite

// benches/comprehensive.rs use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};  fn bench_algorithms(c: &mut Criterion) {  let mut group = c.benchmark_group("sorting");    for size in [100, 1000, 10000].iter() {  let data: Vec<i32> = (0..*size).rev().collect();    group.throughput(Throughput::Elements(*size as u64));    group.bench_with_input(  BenchmarkId::new("std_sort", size),  size,  |b, _size| {  b.iter_batched(  || data.clone(),  |mut data| data.sort(),  criterion::BatchSize::SmallInput,  )  },  );    group.bench_with_input(  BenchmarkId::new("custom_sort", size),  size,  |b, _size| {  b.iter_batched(  || data.clone(),  |data| parallel_quicksort(data),  criterion::BatchSize::SmallInput,  )  },  );  }    group.finish(); }  criterion_group!(benches, bench_algorithms); criterion_main!(benches);

Memory Usage Profiling

// Memory allocation tracking #[global_allocator] static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;  fn track_memory_usage() {  use jemalloc_ctl::{stats, epoch};    epoch::advance().unwrap();  let allocated = stats::allocated::read().unwrap();  println!("Allocated: {} bytes", allocated);    // Your code here  let _data: Vec<i32> = (0..1000000).collect();    epoch::advance().unwrap();  let allocated_after = stats::allocated::read().unwrap();  println!("Allocated after: {} bytes", allocated_after);  println!("Difference: {} bytes", allocated_after - allocated); }

Best Practices Summary

  1. Measure First: Always profile before optimizing
  2. Target Bottlenecks: Focus on the critical path
  3. Cache-Friendly Code: Consider memory access patterns
  4. Minimize Allocations: Reuse memory when possible
  5. Choose Right Data Structures: Match structure to access pattern
  6. Leverage Parallelism: Use rayon for CPU-bound tasks
  7. Optimize Compilation: Use appropriate release flags
  8. SIMD When Applicable: For data-parallel operations
  9. Avoid Premature Optimization: Keep code readable
  10. Validate Optimizations: Ensure correctness is maintained

Performance optimization in Rust is about understanding the system, measuring carefully, and applying targeted improvements. The language's zero-cost abstractions and control over memory layout provide excellent opportunities for optimization while maintaining safety.