0Pricing
Ruby Academy · Lezione

Misurare le prestazioni

Il modulo Benchmark

Misurare le prestazioni è una lezione Ruby Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Ruby Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Ruby Academy include 4 lezioni in totale.

Perché misurare?

Ottimizzare senza misurare significa procedere per tentativi. Il modulo Benchmark della libreria standard di Ruby misura il tempo di esecuzione del codice con precisione.

  • Individui le parti lente prima di modificarle
  • Confronti obiettivamente le implementazioni
  • Eviti l'ottimizzazione 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 restituisce un rapporto con i tempi utente, di sistema e reale.

  • Il tempo utente è il tempo CPU del suo codice
  • Il tempo reale è il tempo trascorso sull'orologio
require 'benchmark'

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

Benchmark.bm

Benchmark.bm esegue e contrassegna più blocchi in una tabella.

  • Indichi una larghezza per le etichette, così da allinearle
  • Ogni x.report corrisponde a una riga
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 esegue prima una prova per riscaldare le cache e il GC, ottenendo numeri più affidabili.

  • Il primo passaggio viene scartato
  • Il secondo passaggio costituisce la misurazione reale
require 'benchmark'

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

realtime per misurazioni rapide

Benchmark.realtime restituisce solo i secondi di tempo reale come valore float.

  • È il modo più semplice per misurare un singolo blocco
  • È utile per controlli occasionali
require 'benchmark'

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

Orologio monotono

Per misurazioni precise che non risentano delle variazioni dell'orologio di sistema, utilizzi Process.clock_gettime con un orologio monotono.

  • È immune alle regolazioni NTP
  • È l'opzione integrata più accurata
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"

Confronto tra due approcci

I benchmark sono particolarmente utili per confrontare alternative. Esegua entrambe le alternative sotto un carico identico.

  • Mantenga le dimensioni dell'input abbastanza grandi da poter essere misurate
  • Ripeta le misurazioni per ridurre il rumore
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

Attenzione ai microbenchmark

I benchmark molto piccoli possono trarre in inganno.

  • JIT e cache potrebbero non riflettere i carichi di lavoro reali
  • Il GC può avviarsi durante la misurazione
  • Misuri dimensioni di dati realistiche
require 'benchmark'

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

Iterazioni al secondo

Spesso interessa il throughput: quante operazioni vengono eseguite al secondo. La gemma benchmark-ips lo misura, ma è possibile ottenere una stima manuale.

  • Conti le iterazioni in un intervallo di tempo fisso
  • Un valore ips più alto indica una maggiore velocità
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}"

Controllo del GC

Il garbage collector può distorcere i risultati. Può disabilitarlo temporaneamente per ottenere numeri più stabili.

  • GC.disable prima e GC.enable dopo
  • Proceda con cautela per evitare una crescita della memoria
require 'benchmark'

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

Media di più esecuzioni

Esegua un benchmark più volte e calcoli la media per attenuare la variabilità.

  • Se necessario, scarti il valore anomalo più lento
  • Riporti la mediana per una maggiore stabilità
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"

Controllo rapido

Verifichi le sue conoscenze sui benchmark.

Riepilogo

Ha imparato a misurare le prestazioni:

  • Il modulo Benchmark misura accuratamente il tempo di esecuzione del codice
  • realtime, measure, bm e bmbm rispondono a esigenze diverse
  • Utilizzi l'orologio monotono per misurazioni precise
  • Eviti microbenchmark fuorvianti e tenga conto del GC
  • Calcoli la media di più esecuzioni per ridurre il rumore

Ora utilizzerà strumenti di profilazione dedicati.

Domande Frequenti

La lezione «Misurare le prestazioni» è gratuita?

Sì — il testo completo di «Misurare le prestazioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Ruby Academy, passa a CoddyKit PRO. Il corso Ruby Academy include 4 lezioni in totale.

Cosa imparerò in «Misurare le prestazioni»?

Il modulo Benchmark Eserciti Ruby Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Ruby Academy?

Non è richiesta alcuna esperienza precedente. Ruby Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Misurare le prestazioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Ruby Academy?

Sì. Ogni lezione Ruby Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Misurare le prestazioni
  2. Strumenti di profilazione
  3. Ottimizzazione della memoria
  4. Colli di bottiglia comuni
← Torna a Ruby Academy