0Pricing
Ruby Academy · Aula

Medindo o desempenho

Módulo Benchmark.

Medindo o desempenho é uma aula grátis de Ruby 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 Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

Por que Medir?

Otimizar sem medir é adivinhar. O módulo Benchmark da biblioteca padrão do Ruby mede o tempo de execução do código com precisão.

  • Encontre as partes lentas antes de alterá-las
  • Compare implementações de forma objetiva
  • Evite a otimização prematura
require 'benchmark'

time = Benchmark.realtime do
  1_000_000.times { |i| i * 2 }
end
puts "Took #{time.round(4)}s"

Benchmark.measure

Benchmark.measure retorna um relatório do tempo de usuário, do sistema e do tempo real.

  • O tempo de usuário é o tempo de CPU do seu código
  • O tempo real é o tempo transcorrido no relógio de parede
require 'benchmark'

result = Benchmark.measure do
  500_000.times { |i| i.to_s }
end
puts result

Benchmark.bm

Benchmark.bm executa e identifica vários blocos em uma tabela.

  • Passe uma largura de rótulo para alinhar os resultados
  • Cada x.report corresponde a uma linha
require 'benchmark'

Benchmark.bm(10) do |x|
  x.report('to_s:') { 100_000.times { |i| i.to_s } }
  x.report('inspect:') { 100_000.times { |i| i.inspect } }
end

Benchmark.bmbm

Benchmark.bmbm executa primeiro um ensaio para aquecer os caches e o GC, fornecendo resultados mais confiáveis.

  • A primeira passagem é descartada
  • A segunda passagem é a medição real
require 'benchmark'

Benchmark.bmbm do |x|
  x.report('sum:') { (1..100_000).sum }
  x.report('reduce:') { (1..100_000).reduce(:+) }
end

realtime para medições rápidas

Benchmark.realtime retorna apenas os segundos do relógio de parede como um número de ponto flutuante.

  • É a maneira mais simples de medir um bloco
  • É útil para verificações pontuais
require 'benchmark'

elapsed = Benchmark.realtime do
  arr = Array.new(100_000) { rand }
  arr.sort
end
puts "Sorted in #{elapsed.round(4)}s"

Relógio Monotônico

Para obter medições precisas que não sejam afetadas por alterações no relógio do sistema, use Process.clock_gettime com um relógio monotônico.

  • Imune a ajustes do NTP
  • A opção integrada mais precisa
start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
200_000.times { |i| i * i }
finish = Process.clock_gettime(Process::CLOCK_MONOTONIC)
puts "Elapsed: #{(finish - start).round(4)}s"

Comparando Duas Abordagens

Os benchmarks são especialmente úteis ao comparar alternativas. Execute ambas sob uma carga idêntica.

  • Mantenha o tamanho da entrada grande o suficiente para ser mensurável
  • Repita a medição para reduzir o ruído
require 'benchmark'

arr = (1..100_000).to_a
Benchmark.bm(8) do |x|
  x.report('map:') { arr.map { |n| n * 2 } }
  x.report('each:') { r = []; arr.each { |n| r << n * 2 } }
end

Cuidado com Microtestes de Desempenho

Microtestes pequenos podem induzir ao erro.

  • O JIT e os caches podem não refletir cargas de trabalho reais
  • O GC pode ser executado durante a medição
  • Meça tamanhos de dados realistas
require 'benchmark'

# Too small to be meaningful
t = Benchmark.realtime { 10.times { |i| i + 1 } }
puts "Misleadingly tiny: #{t}s"

Iterações por Segundo

Muitas vezes, você quer saber a taxa de processamento: quantas operações são realizadas por segundo. A biblioteca benchmark-ips informa esse valor, mas você pode fazer uma aproximação manualmente.

  • Conte as iterações em um intervalo de tempo fixo
  • Um número maior de ips significa maior velocidade
deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 0.2
count = 0
while Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
  count += 1
  'hello'.upcase
end
puts "Iterations in 0.2s: #{count}"

Controlando o GC

O coletor de lixo pode distorcer os resultados. Você pode desativá-lo temporariamente para obter números mais estáveis.

  • GC.disable antes e GC.enable depois
  • Use com cuidado para evitar o crescimento do uso de memória
require 'benchmark'

GC.disable
t = Benchmark.realtime { 100_000.times { |i| i.to_s } }
GC.enable
puts "Without GC: #{t.round(4)}s"

Calculando a Média de Várias Execuções

Execute um benchmark várias vezes e calcule a média para suavizar a variação.

  • Descarte o valor discrepante mais lento, se necessário
  • Informe a mediana para obter estabilidade
require 'benchmark'

times = 3.times.map do
  Benchmark.realtime { (1..50_000).map { |n| n * n } }
end
avg = times.sum / times.size
puts "Average: #{avg.round(4)}s"

Verificação rápida

Teste seus conhecimentos sobre medição de desempenho.

Recapitulação

Você aprendeu a medir o desempenho:

  • O módulo Benchmark mede o tempo do código com precisão
  • realtime, measure, bm e bmbm atendem a necessidades diferentes
  • Use o relógio monotônico para medições precisas
  • Evite microtestes de desempenho enganosos e leve o GC em consideração
  • Calcule a média de várias execuções para reduzir o ruído

A seguir, você usará ferramentas dedicadas de criação de perfis.

Perguntas Frequentes

A aula “Medindo o desempenho” é grátis?

Sim — o texto completo de “Medindo o desempenho” é 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 Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Medindo o desempenho”?

Módulo Benchmark. Você pratica Ruby 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 Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby 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 “Medindo o desempenho”?

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 Ruby Academy?

Sim. Cada aula de Ruby 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. Medindo o desempenho
  2. Ferramentas de criação de perfis
  3. Otimização de memória
  4. Gargalos comuns
← Voltar para Ruby Academy