m10-performance

SKILL.md

Performance Optimization

Layer 2: Design Choices

Core Question

What's the bottleneck, and is optimization worth it?

Before optimizing:

Have you measured? (Don't guess)

What's the acceptable performance?

Will optimization add complexity?

Performance Decision → Implementation

Goal
Design Choice
Implementation

Reduce allocations
Pre-allocate, reuse
with_capacity, object pools

Improve cache
Contiguous data
Vec, SmallVec

Parallelize
Data parallelism
rayon, threads

Avoid copies
Zero-copy
References, Cow<T>

Reduce indirection
Inline data
smallvec, arrays

Thinking Prompt

Before optimizing:

Have you measured?

Profile first → flamegraph, perf

Benchmark → criterion, cargo bench

Identify actual hotspots

What's the priority?

Algorithm (10x-1000x improvement)

Data structure (2x-10x)

Allocation (2x-5x)

Cache (1.5x-3x)

What's the trade-off?

Complexity vs speed

Memory vs CPU

Latency vs throughput

Trace Up ↑

To domain constraints (Layer 3):

"How fast does this need to be?"
    ↑ Ask: What's the performance SLA?
    ↑ Check: domain-* (latency requirements)
    ↑ Check: Business requirements (acceptable response time)

Question
Trace To
Ask

Latency requirements
domain-*
What's acceptable response time?

Throughput needs
domain-*
How many requests per second?

Memory constraints
domain-*
What's the memory budget?

Trace Down ↓

To implementation (Layer 1):

"Need to reduce allocations"
    ↓ m01-ownership: Use references, avoid clone
    ↓ m02-resource: Pre-allocate with_capacity

"Need to parallelize"
    ↓ m07-concurrency: Choose rayon or threads
    ↓ m07-concurrency: Consider async for I/O-bound

"Need cache efficiency"
    ↓ Data layout: Prefer Vec over HashMap when possible
    ↓ Access patterns: Sequential over random access

Quick Reference

Tool
Purpose

cargo bench
Micro-benchmarks

criterion
Statistical benchmarks

perf / flamegraph
CPU profiling

heaptrack
Allocation tracking

valgrind / cachegrind
Cache analysis

Optimization Priority

1. Algorithm choice     (10x - 1000x)
2. Data structure       (2x - 10x)
3. Allocation reduction (2x - 5x)
4. Cache optimization   (1.5x - 3x)
5. SIMD/Parallelism     (2x - 8x)

Common Techniques

Technique
When
How

Pre-allocation
Known size
Vec::with_capacity(n)

Avoid cloning
Hot paths
Use references or Cow<T>

Batch operations
Many small ops
Collect then process

SmallVec
Usually small
smallvec::SmallVec<[T; N]>

Inline buffers
Fixed-size data
Arrays over Vec

Common Mistakes

Mistake
Why Wrong
Better

Optimize without profiling
Wrong target
Profile first

Benchmark in debug mode
Meaningless
Always --release

Use LinkedList
Cache unfriendly
Vec or VecDeque

Hidden .clone()
Unnecessary allocs
Use references

Premature optimization
Wasted effort
Make it work first

Anti-Patterns

Anti-Pattern
Why Bad
Better

Clone to avoid lifetimes
Performance cost
Proper ownership

Box everything
Indirection cost
Stack when possible

HashMap for small sets
Overhead
Vec with linear search

String concat in loop
O(n^2)
String::with_capacity or format!

Related Skills

When
See

Reducing clones
m01-ownership

Concurrency options
m07-concurrency

Smart pointer choice
m02-resource

Domain requirements
domain-*