Lua Academy · Les

JIT-vriendelijke Lua schrijven

Voorkom JIT-bail-outs: houd types stabiel, beperk het vergroten van tables en gebruik locals

Les 2 van 413 stappen

JIT-vriendelijke Lua schrijven is een gratis Lua Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Waarom JIT-vriendelijkheid belangrijk is

De JIT-compiler werkt het best met typestabiele, voorspelbare code. Onvoorspelbare typen en vertakkingen veroorzaken afgebroken traces en terugvallen naar de interpreter.

Typen stabiel houden

Een variabele moet altijd hetzelfde type bevatten. Als een variabele afwisselend een getal en een tekenreeks bevat, kan de JIT niet specialiseren en moet deze overal typecontroles invoegen.

-- BAD: type unstable
local x = 1
if cond then x = "one" end  -- JIT cannot specialize x

-- GOOD: separate variables
local xNum = 1
local xStr = "one"

Lokale variabelen gebruiken

Lokale variabelen worden op de Lua-stack opgeslagen (door JIT aan registers toegewezen). Toegang tot globale variabelen en upvalues is trager. Cache globale variabelen als lokale variabelen bovenaan hete functies.

local sin = math.sin  -- cache as local
for i = 1, 1e6 do
  result = sin(i)  -- fast local access
end

Tabelgroei in lussen vermijden

Reserveer vooraf ruimte voor tabellen tot hun verwachte grootte. Een tabel laten groeien in een lus (waarbij de volgende macht-van-tweegrens wordt overschreden) zorgt ervoor dat de array opnieuw wordt toegewezen en gekopieerd, waardoor JIT-traces worden verbroken.

local t = table.new(1000, 0)  -- LuaJIT extension
for i = 1, 1000 do t[i] = i end

Gemengde arrays en hashes vermijden

Houd arraygedeelten als arrays (gehele sleutels vanaf 1). Het mengen van gehele en tekenreekssleutels in dezelfde tabel verhindert arrayoptimalisaties.

Closures in hete binnenlussen vermijden

Bij elke iteratie een nieuwe closure maken reserveert geheugen en kan de druk op de garbagecollector verhogen. Reserveer closures vooraf buiten de lus.

-- BAD: closure created every iteration
for i = 1, 1e6 do
  local fn = function() return i end  -- allocation!
end

-- GOOD: use a local function outside
local function work(i) return i end
for i = 1, 1e6 do work(i) end

Polymorfe aanroepen vermijden

Het aanroepen van verschillende functieobjecten via dezelfde aanroepplek (elke iteratie een andere functie) maakt een polymorfe aanroepplek die de JIT niet kan inline-en.

NYI-functies (nog niet geïmplementeerd) vermijden

Sommige Lua-functies zijn niet geïmplementeerd in de JIT van LuaJIT (NYI): string.format met bepaalde specificaties, pcall binnen JIT-traces en pairs/next. Controleer de uitvoer van jit.v.

jit.v voor trace-uitvoer

Schakel uitgebreide JIT-uitvoer in om te zien welke traces worden gecompileerd en welke worden afgebroken.

-- Run script with: luajit -jv script.lua
-- Or in code:
jit.attach(function(event, ...)
  if event == "abort" then print("ABORT:", ...) end
end, "all")

Arrays met vaste grootte gebruiken

Wanneer een array een bekende vaste grootte heeft, kan het declareren ervan als een C-array met constante grootte via FFI aanzienlijk sneller zijn dan een Lua-tabel.

Profilen vóór optimaliseren

Meet eerst. Voortijdige optimalisatie is de wortel van alle kwaad. Profileer om het daadwerkelijke hete codepad te vinden voordat je tijd besteedt aan JIT-vriendelijke herschrijvingen.

Vraag over JIT-vriendelijke code

Waarom moet je voorkomen dat je closures binnen hete binnenlussen maakt?

Beantwoord dit in de interactieve les

Samenvatting: JIT-vriendelijke Lua

Houd typen stabiel, gebruik lokale variabelen, reserveer tabellen vooraf, vermijd closures in hete lussen en controleer met jit.v op NYI-functies. Profileer eerst — optimaliseer alleen bewezen knelpunten.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “JIT-vriendelijke Lua schrijven” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “JIT-vriendelijke Lua schrijven”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “JIT-vriendelijke Lua schrijven”?

Voorkom JIT-bail-outs: houd types stabiel, beperk het vergroten van tables en gebruik locals Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “JIT-vriendelijke Lua schrijven”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Lua Academy