0Pricing
Ruby Academy · Lección

Medición del rendimiento

Módulo Benchmark

Medición del rendimiento es una lección gratuita de Ruby Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Ruby Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Ruby Academy incluye 4 lecciones en total.

¿Por qué medir?

Optimizar sin medir es adivinar. El módulo Benchmark de la biblioteca estándar de Ruby mide el código con precisión.

  • Encuentre las partes lentas antes de modificarlas
  • Compare las implementaciones de forma objetiva
  • Evite la optimización 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 devuelve un informe del tiempo de usuario, del sistema y real.

  • El tiempo de usuario es el tiempo de CPU empleado por su código
  • El tiempo real es el tiempo transcurrido del reloj
require 'benchmark'

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

Benchmark.bm

Benchmark.bm ejecuta y etiqueta varios bloques en una tabla.

  • Indique un ancho para las etiquetas para alinearlas
  • Cada x.report es una fila
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 ejecuta primero un ensayo para calentar las cachés y el GC, lo que proporciona resultados más justos.

  • La primera pasada se descarta
  • La segunda pasada es la medición real
require 'benchmark'

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

realtime para mediciones rápidas

Benchmark.realtime devuelve únicamente los segundos transcurridos del reloj como un número de coma flotante.

  • Es la forma más sencilla de medir un bloque
  • Es útil para comprobaciones puntuales
require 'benchmark'

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

Reloj monotónico

Para realizar mediciones precisas que no se vean afectadas por los cambios del reloj del sistema, use Process.clock_gettime con un reloj monotónico.

  • Es inmune a los ajustes de NTP
  • Es la opción integrada más 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"

Comparar dos enfoques

Los benchmarks son especialmente útiles para comparar alternativas. Ejecute ambas con una carga idéntica.

  • Mantenga el tamaño de entrada lo bastante grande para que sea medible
  • Repita las pruebas para reducir el ruido
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 con los microbenchmarks

Los benchmarks diminutos pueden inducir a error.

  • El JIT y las cachés quizá no reflejen las cargas de trabajo reales
  • El GC puede ejecutarse a mitad de la medición
  • Mida tamaños de datos realistas
require 'benchmark'

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

Iteraciones por segundo

A menudo le interesará el throughput: cuántas operaciones se realizan por segundo. La gema benchmark-ips informa de este valor, pero puede calcularlo manualmente de forma aproximada.

  • Cuente las iteraciones durante un intervalo de tiempo fijo
  • Un ips mayor implica una mayor velocidad
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}"

Controlar el GC

El recolector de basura puede distorsionar los resultados. Puede desactivarlo temporalmente para obtener cifras más estables.

  • GC.disable antes y GC.enable después
  • Úselo con precaución para evitar que aumente el consumo de memoria
require 'benchmark'

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

Promediar varias ejecuciones

Ejecute un benchmark varias veces y calcule el promedio para suavizar la variación.

  • Si es necesario, descarte el valor atípico más lento
  • Informe de la mediana para obtener estabilidad
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"

Comprobación rápida

Compruebe sus conocimientos sobre benchmarking.

Resumen

Ha aprendido a medir el rendimiento:

  • El módulo Benchmark mide el código con precisión
  • realtime, measure, bm y bmbm cubren necesidades diferentes
  • Use el reloj monotónico para realizar mediciones precisas
  • Evite los microbenchmarks engañosos y tenga en cuenta el GC
  • Promedie varias ejecuciones para reducir el ruido

A continuación usará herramientas de perfilado especializadas.

Preguntas frecuentes

¿La lección «Medición del rendimiento» es gratis?

Sí — el texto completo de «Medición del rendimiento» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Ruby Academy, actualiza a CoddyKit PRO. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Medición del rendimiento»?

Módulo Benchmark Practicas Ruby Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Ruby Academy?

No se requiere experiencia previa. Ruby Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Medición del rendimiento»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Ruby Academy?

Sí. Cada lección de Ruby Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Medición del rendimiento
  2. Herramientas de perfilado
  3. Optimización de memoria
  4. Cuellos de botella comunes
← Volver a Ruby Academy