Analyze Rust Optimizations

# Check for benchmarks
ls benches/ 2>/dev/null || ls **/bench*.rs 2>/dev/null

# Run benchmarks if available
cargo bench

# Generate flamegraph (if installed)
cargo flamegraph --bench <benchmark_name>

# Check binary/dependency bloat
cargo bloat --release
cargo bloat --release --crates

If tools missing, see <tools_setup> for installation.

1. Check available tools:

   command -v flamegraph && echo "flamegraph: installed"
   cargo bloat --version 2>/dev/null && echo "cargo-bloat: installed"
   command -v samply && echo "samply: installed"
   command -v heaptrack && echo "heaptrack: installed"
   

2. Run benchmarks (if benches/ or #[bench] exists):

   cargo bench -- --save-baseline before
   

3. CPU profiling (pick available tool):

   • cargo flamegraph - generates SVG flamegraph
   • samply record cargo run --release - sampling profiler
   • perf record cargo run --release && perf report - Linux perf

4. Memory profiling:

   • heaptrack cargo run --release - heap allocations
   • valgrind --tool=massif - memory over time
   • DHAT via #[global_allocator] instrumentation

Phase 2: Static Code Analysis

Scan the codebase for these patterns (priority order):

1. Hot path allocations: .clone(), .to_string(), .to_vec() in loops
2. Unnecessary allocations: String where &str suffices, Vec where slice works
3. Missing #[inline]: Small functions called across crate boundaries
4. Inefficient iterators: .collect() followed by iteration, multiple .iter() passes
5. Box/Arc overuse: Heap allocation where stack would work
6. HashMap/BTreeMap inefficiency: Missing with_capacity(), poor hash functions
7. String formatting in hot paths: format!() allocates, prefer write!()
8. Bounds checking: Array indexing vs .get_unchecked() in verified-safe paths
9. Memory layout: Large structs, poor field ordering, excessive padding

Phase 3: Generate Report

Produce two outputs:

1. Prioritized findings list - ranked by estimated impact
2. Detailed report - comprehensive markdown with sections

Memory Usage (Priority 2)

# Flamegraph (CPU profiling visualization)
cargo install flamegraph
# Linux: sudo apt install linux-perf
# macOS: works via dtrace

# cargo-bloat (binary size analysis)
cargo install cargo-bloat

# samply (sampling profiler)
cargo install samply

# heaptrack (memory profiling) - Linux only
sudo apt install heaptrack heaptrack-gui

# criterion (micro-benchmarking)
# Add to Cargo.toml: criterion = "0.5"

For accurate profiling:

# Cargo.toml - add release profile with debug info
[profile.release]
debug = true

## Optimization Findings (Prioritized)

### Critical (High Impact)
1. **[PERF]** `src/parser.rs:142` - `.clone()` inside hot loop, ~500k calls/sec
2. **[MEM]** `src/cache.rs:89` - HashMap without capacity, grows 12 times

### Important (Medium Impact)
3. **[PERF]** `src/lib.rs:34` - Missing `#[inline]` on public API hot path
4. **[MEM]** `src/types.rs:15-28` - Struct padding wastes 24 bytes per instance

### Minor (Low Impact)
5. **[PERF]** `src/utils.rs:67` - `format!()` could use `write!()`

2. Detailed Report Structure

# Rust Optimization Analysis Report

## Executive Summary
- Total findings: X
- Critical: Y | Important: Z | Minor: W
- Estimated performance gain: ...

## Profiling Results
### CPU Profile
[Flamegraph or hotspot analysis]

### Memory Profile
[Allocation patterns, peak usage]

## Findings by Category

### Runtime Performance
[Detailed findings with code snippets and fixes]

### Memory Usage
[Detailed findings with before/after layouts]

## Recommended Changes
[Prioritized action items with effort estimates]

## Appendix
- Tool versions used
- Benchmark results
- Profiling methodology

# Find .clone() in potential hot paths
rg '\.clone\(\)' --type rust -n

# Find allocating methods in loops
rg 'for .* in|while|loop' -A 10 --type rust | rg '\.to_string\(\)|\.to_vec\(\)|\.clone\(\)'

# Find HashMap/Vec without capacity hints
rg 'HashMap::new\(\)|Vec::new\(\)' --type rust -n

# Find format! macro usage
rg 'format!\(' --type rust -n

# Find missing inline attributes on pub functions
rg '^pub fn \w+' --type rust -n

# Find large enums (check for Box opportunities)
rg '^pub enum|^enum' -A 20 --type rust

# Find dyn Trait usage
rg 'dyn \w+' --type rust -n

• Available profiling tools identified (or install instructions provided)
• Dynamic profiling run (benchmarks, flamegraph, memory profiler)
• Static analysis completed for all optimization patterns
• Findings prioritized by impact (Critical/Important/Minor)
• Each finding includes file:line reference
• Each finding includes specific fix recommendation
• Prioritized findings list generated
• Detailed markdown report generated
• Report includes methodology and tool versions