Noções Básicas de Desempenho

9 exemplos para você começar com Desempenho - 7 básicos e 2 intermediários.

Pré-requisitos

• Instale o Go 1.26.x ou posterior em go.dev/dl.
• Crie um módulo: mkdir perflab && cd perflab && go mod init example.com/perflab.
• Adicione um arquivo de teste por exemplo ou um pacote perflab_test.go.
• Opcional: go install golang.org/x/perf/cmd/benchstat@latest para comparar execuções de benchmark.

Exemplos Básicos

1. Benchmark Mínimo

Meça quanto tempo uma função leva por iteração com testing.B.

package perflab
 
import "testing"
 
func Sum(n int) int {
    s := 0
    for i := 0; i < n; i++ {
        s += i
    }
    return s
}
 
func BenchmarkSum(b *testing.B) {
    for b.Loop() {
        Sum(1000)
    }
}

go test -bench=BenchmarkSum ./...

• Funções BenchmarkXxx ficam em arquivos *_test.go.
• b.Loop() (Go 1.24+) substitui loops manuais b.N e redefine os temporizadores corretamente.
• A saída mostra ns/op - nanossegundos por iteração do loop.

Relacionado: Benchmarks com testing.B & B.Loop - profundidade de benchmark

2. Estatísticas de Alocação com -benchmem

Relate bytes e alocações por operação ao lado da temporização.

import "strings"
 
func BenchmarkJoin(b *testing.B) {
    parts := []string{"a", "b", "c", "d"}
    b.ReportAllocs()
    for b.Loop() {
        _ = strings.Join(parts, ",")
    }
}

go test -bench=BenchmarkJoin -benchmem ./...

• -benchmem adiciona colunas B/op (bytes por op) e allocs/op.
• b.ReportAllocs() garante que as contagens de alocação apareçam mesmo sem -benchmem.
• allocs/op alto em caminhos quentes geralmente importa mais do que alguns nanossegundos.

Relacionado: Pré-alocação de Slice, strings.Builder & Pré-dimensionamento de map - reduzindo alocações

3. Perfil de CPU de um Benchmark

Escreva um arquivo de perfil de CPU enquanto os benchmarks são executados.

go test -cpuprofile=cpu.prof -bench=BenchmarkJoin ./...
go tool pprof -top cpu.prof

• -cpuprofile amostra o processo durante o benchmark apenas.
• go tool pprof -top imprime as funções mais quentes por tempo de CPU plano.
• Use isso antes de otimizar - confirme se a função que você planeja alterar está realmente quente.

Relacionado: Perfil de CPU e Heap com pprof - fluxo completo de pprof

4. Perfil de Heap de Testes

Capture locais de alocação de heap durante um teste ou benchmark.

go test -memprofile=heap.prof -bench=BenchmarkJoin ./...
go tool pprof -top -alloc_space heap.prof

• -memprofile registra amostras de alocação.
• -alloc_space ordena por bytes totais alocados; -inuse_space mostra o heap em uso.
• Combine com -benchmem para conectar números de micro-otimização a locais de chamada.

Relacionado: Perfil de CPU e Heap com pprof - leitura de gráficos de heap

5. Endpoint net/http/pprof

Exponha perfis em um servidor HTTP em execução para coleta de teste de carga.

package main
 
import (
    _ "net/http/pprof"
    "net/http"
)
 
func main() {
    go func() {
        http.ListenAndServe("localhost:6060", nil)
    }()
    // ... seu serviço em outra porta
}

go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

• Importar _ "net/http/pprof" registra /debug/pprof/* no DefaultServeMux.
• Vincule 6060 em localhost ou proteja com autenticação em produção.
• Colete perfis enquanto os geradores de carga estão em execução, não em um servidor ocioso.

Relacionado: Desempenho em Go: Meça, Perfilar, Depois Otimize - cultura de medição

6. Interface Web Interativa do pprof

Explore gráficos de chama no navegador.

go tool pprof -http=:8081 cpu.prof

• Abre uma interface web local com gráficos de chama, visualizações de top, peek e código-fonte.
• Use Focus e Ignore para reduzir frames barulhentos da biblioteca padrão.
• Compartilhe o arquivo de perfil em PRs como evidência para alegações de otimização.

Relacionado: Perfil de CPU e Heap com pprof - leitura de gráficos de chama

7. Rastreamento de GC com GODEBUG

Imprima a temporização do coletor de lixo e o tamanho do heap no stderr.

GODEBUG=gctrace=1 go run .

• Cada linha registra o ciclo de GC, pausa e meta do heap.
• Útil quando picos de latência de cauda se correlacionam com o GC, não com hotspots de CPU.
• Reduza a taxa de alocação antes de ajustar GOGC ou GOMEMLIMIT.

Relacionado: Ajuste de GC para Serviços Sensíveis à Latência - experimentos de GC

Exemplos Intermediários

8. Compare Execuções com benchstat

Grave a saída de benchmark de linha de base e candidata, depois compare estatisticamente.

go test -bench=BenchmarkJoin -count=10 ./... > old.txt
# mude o código
go test -bench=BenchmarkJoin -count=10 ./... > new.txt
benchstat old.txt new.txt

• -count=10 reduz o ruído da escala de frequência da CPU e do estado do cache.
• benchstat relata se as diferenças são significativas, não apenas mais rápidas em uma execução.
• Documente o ambiente (modelo de CPU, GOMAXPROCS) ao publicar números.

Relacionado: Benchmarks com testing.B & B.Loop - higiene de benchmark

9. Servidor pprof Dedicado em Formato de Produção

Monte o pprof em um mux personalizado com timeouts e vinculação a localhost.

package main
 
import (
    "net/http"
    _ "net/http/pprof"
    "time"
)
 
func main() {
    admin := http.NewServeMux()
    admin.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("ok"))
    })
    // rotas pprof registradas no DefaultServeMux; monte-as:
    admin.Handle("/debug/", http.DefaultServeMux)
 
    srv := &http.Server{
        Addr:              "127.0.0.1:6060",
        Handler:           admin,
        ReadHeaderTimeout: 5 * time.Second,
    }
    _ = srv.ListenAndServe()
}

• O listener de administração separado mantém os endpoints de depuração fora da porta da API pública.
• ReadHeaderTimeout bloqueia ataques slowloris na porta de administração também.
• No Kubernetes, use port-forward 6060 durante incidentes em vez de expô-lo publicamente.

Relacionado: Noções Básicas de net/http - padrões de servidor

Links Externos Relacionados

• A Tour of Go - Introdução interativa oficial ao Go.
• Documentação da Biblioteca Padrão Go - Referência completa para a biblioteca padrão.
• Go Playground - Editor e executor online oficial.
• Get Programming with Go (Manning) - Nathan Youngman & Roger Peppé.
• The Go Programming Language (ebook) - Donovan & Kernighan.

Versões de Stack: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, go fix modernizers - verifique o patch na compilação), chi (mais recente - verifique na compilação), gin (mais recente - verifique na compilação), echo (mais recente - verifique na compilação), google.golang.org/grpc (mais recente - verifique na compilação), sigs.k8s.io/controller-runtime (mais recente - verifique na compilação), kubebuilder (mais recente - verifique na compilação), tinygo (mais recente - verifique os alvos de placa na compilação), wazero (mais recente - verifique na compilação) e golangci-lint (mais recente - verifique o conjunto de linters na compilação).