0Pricing
Go Academy · Aula

Escrevendo benchmarks com testing.B

BenchmarkXxx, laço b.N e flag -bench

Escrevendo benchmarks com testing.B é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Assinatura da função de avaliação de desempenho

As funções de avaliação de desempenho começam com Benchmark e recebem *testing.B. Elas são executadas no arquivo _test.go, junto com os testes comuns.

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

b.N

A estrutura de testes ajusta automaticamente b.N — o número de iterações do laço — até que a avaliação de desempenho seja executada por pelo menos 1 segundo, produzindo uma medida estável de nanossegundos por operação.

Executando avaliações de desempenho

As avaliações de desempenho não são executadas apenas com go test. Utilize -bench para ativá-las:

go test -bench=. -benchmem ./...
// BenchmarkAdd-8  500000000  2.13 ns/op  0 B/op  0 allocs/op

Sinalizador -benchmem

-benchmem acrescenta estatísticas de alocação: bytes por operação e número de alocações por operação. Muitas alocações geralmente indicam problemas de desempenho.

b.ResetTimer

Chame b.ResetTimer() após uma configuração dispendiosa que não deve ser contabilizada na avaliação de desempenho:

func BenchmarkQuery(b *testing.B) {
    db := setupDB() // expensive
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        db.Query("SELECT 1")
    }
}

b.StopTimer / b.StartTimer

Pause e retome o temporizador ao redor da configuração e da finalização que não devem contar para o tempo da avaliação de desempenho.

for i := 0; i < b.N; i++ {
    b.StopTimer()
    data := generateInput()
    b.StartTimer()
    process(data)
}

b.SetBytes

Chame b.SetBytes(n) para informar a taxa de transferência (bytes/s) além do tempo por operação. Isso é útil para avaliar código de serialização ou de rede.

b.SetBytes(int64(len(payload)))
for i := 0; i < b.N; i++ {
    encode(payload)
}

Comparando avaliações de desempenho

Utilize benchstat para comparar duas execuções de avaliação de desempenho e identificar diferenças estatisticamente significativas:

go test -bench=. -count=10 > before.txt
# make change
go test -bench=. -count=10 > after.txt
benchstat before.txt after.txt

Impedindo a eliminação de código morto

Atribua o resultado a uma variável no nível do pacote ou a um coletor para impedir que o compilador otimize o código avaliado:

var result int
func BenchmarkFib(b *testing.B) {
    for i := 0; i < b.N; i++ {
        result = Fib(20)
    }
}

Subavaliações de desempenho

Utilize b.Run para criar subavaliações de desempenho nomeadas, de modo semelhante aos testes orientados por tabela:

for _, size := range []int{10, 100, 1000} {
    b.Run(fmt.Sprintf("size=%d", size), func(b *testing.B) {
        for i := 0; i < b.N; i++ { sort(make([]int, size)) }
    })
}

Avaliação de desempenho versus perfilamento

As avaliações de desempenho quantificam o desempenho. O perfilamento (pprof) mostra onde o tempo é gasto. Utilize avaliações de desempenho para medir e perfilamento para diagnosticar onde otimizar.

Verificação rápida

Por que o corpo do laço da avaliação de desempenho deve utilizar o resultado para impedir a otimização pelo compilador?

Recapitulação: avaliações de desempenho

Pontos principais:

  • BenchmarkXxx(b *testing.B) com for i := 0; i < b.N; i++
  • go test -bench=. -benchmem para obter estatísticas de alocação
  • b.ResetTimer() após uma configuração dispendiosa
  • Utilize benchstat para comparar execuções; atribua os resultados para impedir a eliminação

Perguntas Frequentes

A aula “Escrevendo benchmarks com testing.B” é grátis?

Sim — o texto completo de “Escrevendo benchmarks com testing.B” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Escrevendo benchmarks com testing.B”?

BenchmarkXxx, laço b.N e flag -bench Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Escrevendo benchmarks com testing.B”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Escrevendo benchmarks com testing.B
  2. Criação de perfis de CPU com pprof
  3. Criação de perfis de heap e alocações
  4. Rastreamento de execução
← Voltar para Go Academy