Écrire du Lua adapté au JIT
Évitez les abandons du JIT : gardez des types stables, limitez le redimensionnement des tables et utilisez des variables locales.
Écrire du Lua adapté au JIT est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.
Pourquoi la compatibilité avec le JIT est importante
Le compilateur JIT fonctionne au mieux avec du code stable en matière de types et prévisible. Les types et les branchements imprévisibles provoquent l'abandon des traces et des retours à l'interpréteur.
Conserver des types stables
Une variable doit toujours contenir le même type. Si une variable alterne entre un nombre et une chaîne, le JIT ne peut pas la spécialiser et doit insérer des vérifications de type partout.
-- 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"Utiliser des variables locales
Les variables locales sont stockées sur la pile Lua (allouées dans des registres par le JIT). L'accès aux variables globales et aux valeurs externes est plus lent. Mettez les variables globales en cache dans des variables locales au début des fonctions très utilisées.
local sin = math.sin -- cache as local
for i = 1, 1e6 do
result = sin(i) -- fast local access
endÉviter le redimensionnement des tables dans les boucles
Préallouez les tables à leur taille attendue. Agrandir une table dans une boucle (en franchissant la prochaine puissance de 2) réalloue et recopie le tableau, ce qui interrompt les traces du JIT.
local t = table.new(1000, 0) -- LuaJIT extension
for i = 1, 1000 do t[i] = i endÉviter de mélanger tableau et table de hachage
Conservez les parties de type tableau sous forme de tableaux (clés entières à partir de 1). Mélanger des clés entières et textuelles dans une même table empêche les optimisations des tableaux.
Éviter les fermetures dans les boucles internes très utilisées
Créer une nouvelle fermeture à chaque itération alloue de la mémoire et peut accroître la pression sur le ramasse-miettes. Préallouez les fermetures en dehors de la boucle.
-- 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Éviter les appels polymorphes
Appeler différents objets fonction via le même point d'appel (des fonctions différentes à chaque itération) crée un point d'appel polymorphe que le JIT ne peut pas intégrer.
Éviter les fonctionnalités NYI (pas encore implémentées)
Certaines fonctionnalités Lua ne sont pas implémentées dans le JIT de LuaJIT (NYI) : string.format avec certains spécificateurs, pcall à l'intérieur des traces JIT, pairs/next. Consultez la sortie de jit.v.
jit.v pour la verbosité des traces
Activez la sortie JIT détaillée pour voir quelles traces sont compilées et lesquelles sont abandonnées.
-- Run script with: luajit -jv script.lua
-- Or in code:
jit.attach(function(event, ...)
if event == "abort" then print("ABORT:", ...) end
end, "all")Utiliser des tableaux de taille fixe
Lorsqu'un tableau possède une taille fixe connue, le déclarer comme tableau C de taille constante via FFI peut être nettement plus rapide qu'une table Lua.
Analyser avant d'optimiser
Mesurez d'abord. L'optimisation prématurée est la source de tous les maux. Faites une analyse des performances pour trouver le véritable chemin critique avant de consacrer du temps à réécrire le code pour le JIT.
Question sur la compatibilité avec le JIT
Pourquoi devez-vous éviter de créer des fermetures dans les boucles internes très utilisées ?
Récapitulatif : Lua compatible avec le JIT
Conservez des types stables, utilisez des variables locales, préallouez les tables, évitez les fermetures dans les boucles très utilisées et recherchez les fonctionnalités NYI avec jit.v. Analysez d'abord les performances : n'optimisez que les goulots d'étranglement avérés.
Questions Fréquemment Posées
La leçon « Écrire du Lua adapté au JIT » est-elle gratuite ?
Oui — le texte complet de « Écrire du Lua adapté au JIT » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Écrire du Lua adapté au JIT » ?
Évitez les abandons du JIT : gardez des types stables, limitez le redimensionnement des tables et utilisez des variables locales. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Lua Academy ?
Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Écrire du Lua adapté au JIT » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?
Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Vue d’ensemble de l’architecture de LuaJIT
- Écrire du Lua adapté au JIT
- Profilage avec jit.p et perf
- Modèles d’évaluation des performances