27 — Profiling & Performance

// Go has a GC, but memory leaks still happen:
//   - Goroutine leaks (blocked goroutines holding references)
//   - Growing maps/slices never freed
//   - Closures capturing large variables

// Detect with pprof heap over time:
// 1. Take a heap snapshot:
curl http://localhost:6060/debug/pprof/heap > heap1.out
// 2. Wait (or send load):
sleep 60
// 3. Take another snapshot:
curl http://localhost:6060/debug/pprof/heap > heap2.out
// 4. Compare:
go tool pprof -base=heap1.out heap2.out
(pprof) top  # shows what grew between snapshots

// ─── Common leak: growing map ───
type Cache struct {
    mu    sync.Mutex
    items map[string]*Item  // never deleted → grows forever
}
// Fix: add TTL-based eviction or a max size with LRU.

💡 Tips & Tricks

• Performance: allocs/op is the key benchmark metric — heap allocations trigger GC. Reducing allocations (pre-allocate, strings.Builder, sync.Pool) often improves performance more than micro-optimizing CPU.
• Idiom: use strings.Builder with Grow(total) for string concatenation — s += w in a loop is O(n²); Builder is O(n). Pre-grow with the estimated total size to avoid reallocations.
• Idiom: pre-allocate slices and maps when you know the size — make([]T, 0, n) and make(map[K]V, n) avoid incremental growth/rehashing.
• Idiom: use sync.Pool for short-lived, allocation-heavy objects (buffers, temp structs) — reset before Put. Don't store long-lived state (pool objects can be reclaimed between GCs).
• Performance: go build -gcflags='-m' shows escape analysis — tells you which variables escape to the heap. In hot paths, eliminating escapes (keeping values on the stack) is the #1 allocation-reduction technique.
• Performance: avoid fmt in hot paths — fmt.Println takes ...any, causing every argument to escape to the heap (interface boxing). Use strconv or direct writes.

⚠️ Edge Cases & Gotchas

• Premature optimization: always profile first. A function at 1% of CPU isn't worth optimizing — the top consumer is. pprof shows you where to focus.
• fmt.Println causes escapes: fmt.Println(x) boxes x into any → heap allocation. In hot paths, use strconv.Itoa or os.Stdout.Write.
• []byte(s) allocates: string ↔ []byte conversion copies the data (strings are immutable). Use strings/bytes package functions that work on the native type.
• Defer prevents inlining: a function with defer may not be inlined (the defer overhead must be set up). In ultra-hot paths, avoid defer.
• runtime.GC() doesn't help in production: manually triggering GC adds pauses. Let the concurrent GC run — tune with GOGC (default 100 = GC when heap doubles).
• GOGC=50 reduces memory but increases CPU: the GC runs more often (when heap grows 50% instead of 100%). Trade memory for CPU. Use GOMEMLIMIT (Go 1.19+) for a hard memory cap instead.
• pprof overhead: profiling adds ~2x overhead. Run it in production briefly (30s), not continuously. Use runtime.SetCPUProfileRate for fine control.
• runtime.SetBlockProfileRate(n): enables blocking profile — records goroutine blocking (channel, mutex, syscall). n=1 samples every blocking event (expensive); n=10000 samples every 10µs.
• Inlining has limits: functions with loops, switches, or too many statements aren't inlined. The threshold is tunable via -gcflags='-l=4' (higher = more aggressive).

🧠 Quick Quiz

func A(b *bytes.Buffer) {
    b.WriteString("hello")
}

func B() string {
    var b bytes.Buffer
    A(&b)
    return b.String()
}