performance-optimizer

When to Use

Apply when a system is slow, costs too much, or fails under load. Always measure before optimizing — guessing wastes time.

Core Rules

• Measure first, always. Never optimize without a profiler or benchmark showing the bottleneck
• Fix the biggest bottleneck first — fixing #2 before #1 gives partial gains at best
• Define a target before optimizing: "p99 < 200ms" not "faster"
• After every optimization, re-measure — sometimes fixes have side effects

The Loop

1. Measure    → profiler, APM, benchmark (establish baseline)
2. Identify   → find the hot path (usually 1-3 functions cause 80%+ of time)
3. Hypothesize → why is this slow? (N+1 query, GIL contention, memory copy, etc.)
4. Fix        → smallest change that addresses root cause
5. Verify     → re-run benchmark — is it faster? Regressions elsewhere?
6. Repeat     → next bottleneck

Python Profiling

# cProfile — CPU profiling
import cProfile, pstats, io
pr = cProfile.Profile()
pr.enable()
# ... code to profile ...
pr.disable()
s = io.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
ps.print_stats(20)
print(s.getvalue())

# line_profiler — line-by-line (use @profile decorator)
# pip install line_profiler
# kernprof -l -v script.py

# memory_profiler — memory usage line-by-line
# pip install memory_profiler
# @profile decorator, then: python -m memory_profiler script.py

# py-spy — sampling profiler, zero-code-change, attach to running process
# pip install py-spy
# py-spy top --pid 12345
# py-spy record -o profile.svg --pid 12345

Common Python Bottlenecks

# ❌ String concatenation in loop — O(n²) allocations
result = ""
for item in items:
    result += str(item)  # new string object each time

# ✓ join — one allocation
result = "".join(str(item) for item in items)

# ❌ Repeated dict/set lookup in hot loop
for item in items:
    if item in some_list:  # O(n) each time if it's a list
        ...

# ✓ Convert to set once
lookup = set(some_list)  # O(1) lookup
for item in items:
    if item in lookup:
        ...

# ❌ Unnecessary object creation in loop
for i in range(1_000_000):
    temp = MyClass(i)  # constructor overhead × 1M

# ✓ Reuse or use slots
class MyClass:
    __slots__ = ['value']  # ~40% less memory, faster attribute access

# ❌ GIL-bound CPU work in threads
from threading import Thread  # threads share GIL — no real parallelism for CPU

# ✓ Use ProcessPoolExecutor for CPU-bound work
from concurrent.futures import ProcessPoolExecutor
with ProcessPoolExecutor() as pool:
    results = list(pool.map(cpu_intensive_fn, items))