Performance and Optimization

# Cargo.toml

[profile.release]
# Enable target-specific optimizations
rustflags = ["-C", "target-cpu=native"]

// Inefficient string concatenation
fn concat_strings_inefficient(strings: &[String]) -> String {
    let mut result = String::new();
    for s in strings {
        result += s;  // Creates a new allocation each time
    }
    result
}

// Efficient string concatenation
fn concat_strings_efficient(strings: &[String]) -> String {
    // Pre-allocate the required capacity
    let total_len = strings.iter().map(|s| s.len()).sum();
    let mut result = String::with_capacity(total_len);
    
    // Append without reallocating
    for s in strings {
        result.push_str(s);
    }
    
    result
}

// Using string_cache for frequently used strings
use string_cache::DefaultAtom as Atom;

fn process_strings(strings: &[String]) -> Vec<Atom> {
    // Convert strings to interned atoms (unique, immutable strings)
    strings.iter().map(|s| Atom::from(s.as_str())).collect()
}

# Cargo.toml

[profile.release]
# Optimize for binary size
opt-level = "z"  # Optimize for size
lto = true       # Link-time optimization
codegen-units = 1
panic = "abort"  # Smaller binary by not unwinding on panic
strip = true     # Strip symbols

# Disable debug info
debug = false

# Disable parallel codegen
codegen-units = 1

#[inline(always)]
fn hot_function() {
    // Critical path code that should be inlined
}

#[inline(never)]
fn cold_function() {
    // Rarely executed code that should not be inlined
}

// Using attributes to provide hints to the compiler
#[cold]
fn error_handling() {
    // Error handling code that is rarely executed
}

fn main() {
    // Main execution path
    hot_function();
    
    if cfg!(debug_assertions) {
        cold_function();
    }
    
    if std::env::var("DEBUG").is_ok() {
        error_handling();
    }
}

use std::time::Instant;

fn benchmark<F, R>(name: &str, f: F) -> R
where
    F: FnOnce() -> R,
{
    let start = Instant::now();
    let result = f();
    let duration = start.elapsed();
    println!("{}: {:?}", name, duration);
    result
}

fn main() {
    let data: Vec<i32> = (0..1_000_000).collect();
    
    let sum1 = benchmark("Original", || {
        data.iter().sum::<i32>()
    });
    
    let sum2 = benchmark("Optimized", || {
        data.iter().fold(0, |acc, &x| acc + x)
    });
    
    assert_eq!(sum1, sum2);
}

fn process_data(data: &[i32]) -> i32 {
    let mut result = 0;
    
    // This loop is executed millions of times - optimize it!
    for &value in data {
        result += process_value(value);
    }
    
    result
}

#[inline]
fn process_value(value: i32) -> i32 {
    // This function is called from the hot loop - make it efficient
    value * value
}

use std::collections::{HashMap, BTreeMap, HashSet};
use std::time::Instant;

fn main() {
    // Generate test data
    let n = 1_000_000;
    let data: Vec<i32> = (0..n as i32).collect();
    
    // Measure HashMap (good for random access)
    let start = Instant::now();
    let mut map1 = HashMap::new();
    for (i, &value) in data.iter().enumerate() {
        map1.insert(value, i);
    }
    let duration1 = start.elapsed();
    
    // Measure BTreeMap (good for ordered access)
    let start = Instant::now();
    let mut map2 = BTreeMap::new();
    for (i, &value) in data.iter().enumerate() {
        map2.insert(value, i);
    }
    let duration2 = start.elapsed();
    
    // Measure HashSet (good for membership testing)
    let start = Instant::now();
    let set: HashSet<_> = data.iter().cloned().collect();
    let duration3 = start.elapsed();
    
    println!("HashMap insertion: {:?}", duration1);
    println!("BTreeMap insertion: {:?}", duration2);
    println!("HashSet creation: {:?}", duration3);
}

// Inefficient: Allocates a new vector for each iteration
fn process_strings_inefficient(strings: &[String]) -> Vec<String> {
    strings.iter()
        .map(|s| s.to_uppercase())
        .collect()
}

// Efficient: Preallocates the result vector
fn process_strings_efficient(strings: &[String]) -> Vec<String> {
    let mut result = Vec::with_capacity(strings.len());
    for s in strings {
        result.push(s.to_uppercase());
    }
    result
}

// Even more efficient: Reuses a buffer for string operations
fn process_strings_very_efficient(strings: &[String]) -> Vec<String> {
    let mut result = Vec::with_capacity(strings.len());
    let mut buffer = String::new();
    
    for s in strings {
        buffer.clear();
        buffer.reserve(s.len());
        
        for c in s.chars() {
            if c.is_lowercase() {
                buffer.extend(c.to_uppercase());
            } else {
                buffer.push(c);
            }
        }
        
        result.push(buffer.clone());
    }
    
    result
}