Como você perfila e otimiza o desempenho do Go?

Question

Accepted Answer

Go possui **excelente profiling integrado** através da ferramenta `pprof`, e o fluxo de trabalho segue a mesma disciplina de sempre: **profile para encontrar o real gargalo, depois otimize-o** — nunca adivinhe. O profiling do Go é uma característica de primeira classe, bem integrada.

## Profiling com pprof

```go
// 1. via benchmarks — generate CPU & memory profiles
// go test -bench=. -cpuprofile=cpu.out -memprofile=mem.out
// go tool pprof cpu.out   → interactive analysis (top, list, web for flame graphs)

// 2. in a running server — expose pprof endpoints
import _ "net/http/pprof"           // registers /debug/pprof/ handlers
go func() { http.ListenAndServe("localhost:6060", nil) }()
// then: go tool pprof http://localhost:6060/debug/pprof/profile  (live CPU profile)
//       go tool pprof http://localhost:6060/debug/pprof/heap     (memory)
//       /debug/pprof/goroutine  (goroutine stacks — find leaks/blocks)
```

`pprof` perfila uso de CPU, alocações de memória, goroutines e bloqueios — e produz flame graphs para identificar hotspots. Os endpoints HTTP ao vivo o tornam utilizável em produção com baixo overhead.

## Benchmarking para medir mudanças

```go
func BenchmarkProcess(b *testing.B) {
    for i := 0; i < b.N; i++ { Process(data) }
}
// go test -bench=. -benchmem → ns/op AND allocations/op (B/op, allocs/op)
// use benchstat to compare before/after statistically
```

Benchmarks (com `-benchmem`) medem tanto velocidade quanto alocações — e `benchstat` compara execuções rigorosamente, então você confirma que uma otimização realmente ajudou.

## Otimizações comuns do Go

```text
✓ Reduce allocations (the biggest GC-driven win):
  - preallocate slices/maps with known capacity: make([]T, 0, n)
  - reuse objects with sync.Pool in hot paths
  - minimize heap escapes (check with: go build -gcflags='-m')
  - use strings.Builder for string concatenation (not += in loops)
✓ Algorithmic improvements — right data structure (map O(1) vs slice scan O(n))
✓ Concurrency — parallelize independent work with goroutines (use all cores)
  - but bound it (worker pools) and beware the overhead for small tasks
✓ Avoid unnecessary interface boxing / reflection in hot paths
✓ I/O — buffer reads/writes (bufio), batch operations, reuse connections
```

## Reduzir alocações é frequentemente a chave

```go
// ❌ allocates a new string each iteration
s := ""
for _, w := range words { s += w }

// ✅ strings.Builder reuses a buffer
var b strings.Builder
for _, w := range words { b.WriteString(w) }
s := b.String()
```

Reduzir alocações em heap diminui a pressão do GC, frequentemente o maior alavanca de desempenho do Go.

## O banco de dados/IO é frequentemente o real gargalo

```text
For server apps, the slow part is usually DB queries (N+1, missing indexes) or
network I/O — NOT Go code. Profile to confirm where the time actually goes.
```

## Por que isso importa

Go é frequentemente escolhido para sistemas sensíveis ao desempenho, e seu **excelente profiling integrado** (`pprof`, benchmarks integrados, o race detector) torna a otimização uma atividade bem suportada e de primeira classe.

A disciplina essencial é a mesma em qualquer lugar: **meça primeiro** com pprof/benchmarks para encontrar o gargalo real, depois otimize-o especificamente — adivinhar desperdiça esforço.

O conhecimento específico do Go importa: **reduzir alocações** é frequentemente a maior vantagem (prealocação, `sync.Pool`, `strings.Builder`, minimizar escapes para heap) porque diminui a pressão do GC; melhorias algorítmicas e concorrência limitada ajudam; e reconhecer que o gargalo é frequentemente o **banco de dados ou I/O**, não código Go, concentra o esforço corretamente.

Saber usar pprof efetivamente, fazer benchmarking rigorosamente (`-benchmem`, benchstat), e aplicar as otimizações certas é uma habilidade fundamental de Go em nível sênior, especialmente considerando que Go é selecionado precisamente para construir serviços rápidos e escaláveis.