Lua Academy · Aula

Escrevendo Lua compatível com JIT

Evite saídas do JIT: mantenha os tipos estáveis, minimize redimensionamentos de tabelas e use variáveis locais.

Escrevendo Lua compatível com JIT é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

Por que a compatibilidade com JIT é importante

O compilador JIT funciona melhor com código estável quanto aos tipos e previsível. Tipos e ramificações imprevisíveis causam abortos de rastreamento e retornos ao interpretador.

Mantenha os tipos estáveis

Uma variável deve sempre conter o mesmo tipo. Se uma variável alternar entre número e string, o JIT não poderá especializá-la e terá de inserir verificações de tipo em todos os lugares.

-- 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"

Use variáveis locais

As variáveis locais são armazenadas na pilha do Lua (com alocação em registradores pelo JIT). O acesso a globais e valores externos é mais lento. Armazene globais em variáveis locais no início das funções quentes.

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

Evite redimensionar tabelas em loops

Pré-aloque as tabelas no tamanho esperado. Aumentar uma tabela em um loop (ultrapassando o próximo limite de potência de 2) realoca e copia o vetor, interrompendo os rastreamentos do JIT.

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

Evite misturar vetor e tabela hash

Mantenha as partes de vetor como vetores (chaves inteiras a partir de 1). Misturar chaves inteiras e de string na mesma tabela impede otimizações de vetor.

Evite fechamentos em loops internos quentes

Criar um novo fechamento a cada iteração aloca memória e pode aumentar a pressão sobre o coletor de lixo. Pré-aloque os fechamentos fora do loop.

-- 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

Evite chamadas polimórficas

Chamar objetos de função diferentes pelo mesmo ponto de chamada (funções diferentes a cada iteração) cria um ponto de chamada polimórfico que o JIT não pode incorporar.

Evite recursos NYI (ainda não implementados)

Alguns recursos de Lua não são implementados no JIT do LuaJIT (NYI): string.format com alguns especificadores, pcall dentro de rastreamentos JIT e pairs/next. Verifique a saída de jit.v.

jit.v para detalhamento dos rastreamentos

Ative a saída detalhada do JIT para ver quais rastreamentos são compilados e quais são interrompidos.

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

Use vetores de tamanho fixo

Quando um vetor tem um tamanho fixo conhecido, declará-lo como um vetor C de tamanho constante por meio de FFI pode ser muito mais rápido do que usar uma tabela Lua.

Faça a criação de perfil antes de otimizar

Meça primeiro. A otimização prematura é a raiz de todos os males. Faça a criação de perfil para encontrar o caminho realmente quente antes de investir tempo em reescritas compatíveis com JIT.

Pergunta sobre compatibilidade com JIT

Por que você deve evitar criar fechamentos dentro de loops internos quentes?

Recapitulação: Lua compatível com JIT

Mantenha os tipos estáveis, use variáveis locais, pré-aloque tabelas, evite fechamentos em loops quentes e verifique recursos NYI com jit.v. Faça a criação de perfil primeiro — otimize apenas os gargalos comprovados.

Perguntas Frequentes

A aula “Escrevendo Lua compatível com JIT” é grátis?

Sim — o texto completo de “Escrevendo Lua compatível com JIT” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Escrevendo Lua compatível com JIT”?

Evite saídas do JIT: mantenha os tipos estáveis, minimize redimensionamentos de tabelas e use variáveis locais. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Escrevendo Lua compatível com JIT”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Lua Academy