1// This iterator chain compiles to the same assembly as a hand-written loop
 2letsum: 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{ 3x: f64, 4y: f64, 5z: f64, 6} 7letpoints: Vec<Point>=vec![/* ... */]; 8 9// Good: Struct of Arrays (SoA) - better cache locality
10struct Points{11x: Vec<f64>,12y: Vec<f64>,13z: Vec<f64>,14}1516// Even better: Use SIMD-friendly layouts
17#[repr(C, packed)]18struct Point4{19x: [f64;4],20y: [f64;4],21z: [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]4pubfn hot_function(x: i32)-> i32 {5x*x+2*x+16}

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

 1uselinked_hash_map::LinkedHashMap; 2usebumpalo::Bump; 3 4// Arena allocator for short-lived objects
 5fn process_batch(data: &[u8]){ 6letarena=Bump::new(); 7letmutcache=LinkedHashMap::new(); 8 9// All allocations go to the arena
10// Freed all at once when arena is dropped
11forchunkindata.chunks(1024){12letprocessed=arena.alloc_slice_fill_copy(chunk.len(),0);13// Process chunk...
14cache.insert(chunk[0],processed);15}16// Arena automatically freed here
17}1819// Pool allocator for fixed-size objects
20useobject_pool::Pool;2122struct Connection{23// Connection data
24}2526lazy_static!{27staticrefCONNECTION_POOL: Pool<Connection>=Pool::new(32,||{28Connection::new()29});30}

 1pubstruct MemoryPool<T>{ 2pool: Vec<Box<T>>, 3in_use: Vec<bool>, 4} 5 6impl<T: Default>MemoryPool<T>{ 7pubfn new(capacity: usize)-> Self{ 8letmutpool=Vec::with_capacity(capacity); 9letmutin_use=Vec::with_capacity(capacity);1011for_in0..capacity{12pool.push(Box::new(T::default()));13in_use.push(false);14}1516Self{pool,in_use}17}1819pubfn acquire(&mutself)-> Option<&mutT>{20for(i,available)inself.in_use.iter_mut().enumerate(){21if!*available{22*available=true;23returnSome(&mutself.pool[i]);24}25}26None27}2829pubfn release(&mutself,ptr: *mutT){30for(i,item)inself.pool.iter().enumerate(){31ifitem.as_ref()as*constT==ptr{32self.in_use[i]=false;33break;34}35}36}37}

 1usestd::arch::x86_64::*; 2 3#[target_feature(enable = "avx2")] 4unsafefn add_vectors_simd(a: &[f32],b: &[f32],result: &mut[f32]){ 5assert_eq!(a.len(),b.len()); 6assert_eq!(a.len(),result.len()); 7assert_eq!(a.len()%8,0);// AVX2 processes 8 f32s at once
 8 9foriin(0..a.len()).step_by(8){10letva=_mm256_loadu_ps(a.as_ptr().add(i));11letvb=_mm256_loadu_ps(b.as_ptr().add(i));12letvr=_mm256_add_ps(va,vb);13_mm256_storeu_ps(result.as_mut_ptr().add(i),vr);14}15}1617// Portable SIMD (experimental)
18#![feature(portable_simd)]19usestd::simd::*;2021fn add_vectors_portable(a: &[f32],b: &[f32],result: &mut[f32]){22let(a_chunks,a_remainder)=a.as_chunks::<8>();23let(b_chunks,b_remainder)=b.as_chunks::<8>();24let(result_chunks,result_remainder)=result.as_chunks_mut::<8>();2526for((a_chunk,b_chunk),result_chunk)in27a_chunks.iter().zip(b_chunks).zip(result_chunks){28letva=f32x8::from_array(*a_chunk);29letvb=f32x8::from_array(*b_chunk);30*result_chunk=(va+vb).to_array();31}3233// Handle remainder
34for((a,b),result)in35a_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 { 3data.iter().map(|&x|x*x).sum() 4} 5 6// Ensure bounds are known at compile time
 7fn process_fixed_size(data: &[u8;1024]){ 8foriin0..1024{ 9// Compiler knows bounds, can vectorize aggressively
10data[i].wrapping_mul(2);11}12}1314// Use slice::chunks_exact for better vectorization
15fn process_chunked(data: &[f32]){16forchunkindata.chunks_exact(4){17// Process 4 elements at a time
18letsum: f32 =chunk.iter().sum();19// Use sum...
20}21}

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

 1usecrossbeam::queue::SegQueue; 2usestd::sync::Arc; 3 4// Lock-free queue
 5letqueue: Arc<SegQueue<Task>>=Arc::new(SegQueue::new()); 6 7// Multiple producers
 8foriin0..num_cpus::get(){ 9letqueue=queue.clone();10std::thread::spawn(move||{11forjin0..1000{12queue.push(Task::new(i,j));13}14});15}1617// Single consumer
18whileletSome(task)=queue.pop(){19task.process();20}

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

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

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

 1usecriterion::{criterion_group,criterion_main,Criterion,BenchmarkId}; 2 3fn bench_algorithms(c: &mutCriterion){ 4letmutgroup=c.benchmark_group("sorting"); 5 6forsizein[100,1000,10000].iter(){ 7letdata: Vec<i32>=(0..*size).rev().collect(); 8 9group.bench_with_input(10BenchmarkId::new("std_sort",size),11size,12|b,_|b.iter(||{13letmutdata=data.clone();14data.sort();15})16);1718group.bench_with_input(19BenchmarkId::new("unstable_sort",size),20size,21|b,_|b.iter(||{22letmutdata=data.clone();23data.sort_unstable();24})25);26}2728group.finish();29}3031criterion_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
1112# Memory debugging
13cargo install cargo-valgrind
14cargo valgrind run --bin my_app

 1// Const evaluation
 2constfn fibonacci(n: usize)-> usize { 3matchn{ 40=>0, 51=>1, 6_=>fibonacci(n-1)+fibonacci(n-2), 7} 8} 910// Pre-computed at compile time
11constFIB_10: usize =fibonacci(10);1213// Procedural macros for code generation
14useproc_macro::TokenStream;1516#[proc_macro]17pubfn generate_lookup_table(_input: TokenStream)-> TokenStream{18letmuttable=String::new();19table.push_str("const LOOKUP: [u8; 256] = [");2021foriin0..256{22table.push_str(&format!("{}, ",expensive_function(i)));23}2425table.push_str("];");26table.parse().unwrap()27}

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

 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(){ 9letstart=std::time::Instant::now();10do_work();11println!("Operation took: {:?}",start.elapsed());12}

 1// O(n2) → O(n log n) is better than micro-optimizations
 2// Bad: O(n2)
 3fn find_duplicates_slow(data: &[i32])-> Vec<i32>{ 4letmutduplicates=Vec::new(); 5for(i,&x)indata.iter().enumerate(){ 6for&yin&data[i+1..]{ 7ifx==y{ 8duplicates.push(x); 9break;10}11}12}13duplicates14}1516// Good: O(n log n)
17usestd::collections::HashSet;18fn find_duplicates_fast(data: &[i32])-> Vec<i32>{19letmutseen=HashSet::new();20letmutduplicates=Vec::new();2122for&xindata{23if!seen.insert(x){24duplicates.push(x);25}26}27duplicates28}