Lua Academy · Lezione

Pattern di benchmarking

Scriva microbenchmark affidabili usando os.clock ed eviti gli errori più comuni.

Pattern di benchmarking è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 4 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 Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Perché eseguire benchmark?

I micro-benchmark misurano le prestazioni di uno specifico frammento di codice in isolamento. Aiutano a verificare che un'ottimizzazione migliori davvero la velocità, senza basarsi sull'intuizione.

Modello di benchmark di base

Inserisca il codice in un ciclo, misuri il tempo reale trascorso con os.clock() e divida il risultato per il numero di iterazioni.

local N = 1e6
local t0 = os.clock()
for i = 1, N do
  -- code to benchmark
end
local elapsed = os.clock() - t0
print(("%.2f ns/op"):format(elapsed / N * 1e9))

Passaggio di riscaldamento

Esegua un passaggio di riscaldamento prima della misurazione, per consentire a LuaJIT di compilare le tracce. Senza il riscaldamento, la prima esecuzione misurata include il sovraccarico della compilazione JIT.

for i = 1, 1000 do hotFunction(i) end  -- warm up
local t0 = os.clock()
for i = 1, N do hotFunction(i) end
local elapsed = os.clock() - t0

Prevenire l'eliminazione del codice morto

Il JIT potrebbe ottimizzare eliminando i calcoli i cui risultati non vengono utilizzati. Accumuli i risultati in una variabile per mantenere il benchmark affidabile.

local sum = 0
for i = 1, N do sum = sum + math.sin(i) end
print(sum)  -- prevent elimination

Confrontare due approcci

Esegua il benchmark delle implementazioni alternative in condizioni identiche. Le esegua in modo intercalato o più volte per ridurre al minimo il rumore dovuto alla pianificazione del sistema operativo.

local function approach1() -- ...
end
local function approach2() -- ...
end
local function bench(fn, n)
  local t = os.clock()
  for _ = 1, n do fn() end
  return os.clock() - t
end
print("A:", bench(approach1, 1e5))
print("B:", bench(approach2, 1e5))

Analisi statistica

Esegua il benchmark più volte e calcoli minimo, massimo e mediana. Gli outlier dovuti alle pause del GC o alla pianificazione del sistema operativo devono essere scartati.

Benchmark della memoria

Misuri le allocazioni di memoria insieme ai tempi.

collectgarbage("collect")
local mem0 = collectgarbage("count")
-- ... run operation ...
collectgarbage("collect")
local mem1 = collectgarbage("count")
print(("Memory delta: %.1f KB"):format(mem1 - mem0))

Evitare le interferenze del GC

Arresti il GC prima della misurazione per rilevare il puro tempo di calcolo. Lo riattivi al termine.

collectgarbage("stop")
local t0 = os.clock()
for i = 1, N do -- ... end
print(os.clock() - t0)
collectgarbage("restart")

Micro-benchmark e benchmark realistici

I micro-benchmark ottimizzano piccoli frammenti di codice, ma potrebbero non riflettere le prestazioni nel mondo reale. Convalidi sempre i miglioramenti rispetto al profiling dell'applicazione completa.

Utilità per i benchmark

Costruisca un'utilità riutilizzabile benchmark(name, fn, iters) che stampi risultati coerenti e formattati per tutti i benchmark.

local function benchmark(name, fn, iters)
  iters = iters or 1e5
  for _ = 1, iters // 10 do fn() end  -- warm up
  local t = os.clock()
  for _ = 1, iters do fn() end
  local ns = (os.clock() - t) / iters * 1e9
  print(("%-30s %8.1f ns/op"):format(name, ns))
end

Benchmark in CI

Esegua i benchmark in CI per rilevare regressioni delle prestazioni. Generi un avviso se un benchmark peggiora oltre una soglia definita, ad esempio il 10%.

Domanda sui benchmark

Perché un passaggio di riscaldamento è importante quando si esegue il benchmark di codice LuaJIT?

Riepilogo: schemi di benchmarking

Utilizzi un passaggio di riscaldamento, prevenga l'eliminazione del codice morto usando i risultati, misuri con os.clock(), controlli il GC ed esegua più prove per ottenere misurazioni stabili. Costruisca un'utilità di benchmark riutilizzabile per garantire la coerenza.

Domande Frequenti

La lezione «Pattern di benchmarking» è gratuita?

Sì — il testo completo di «Pattern di benchmarking» è 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 Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Pattern di benchmarking»?

Scriva microbenchmark affidabili usando os.clock ed eviti gli errori più comuni. Eserciti Lua 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 Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua 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 4 di 4.

Quanto tempo richiede la lezione «Pattern di benchmarking»?

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

Sì. Ogni lezione Lua 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

← Torna a Lua Academy