O Que É Compilação Just-in-Time? Compilar Enquanto Roda
A compilação just-in-time (JIT) traduz código para código de máquina nativo enquanto o programa roda, concentrando o esforço nas partes que executam com mais frequência.
A compilação JIT fica entre interpretar e compilar antecipadamente. O runtime começa interpretando bytecode, observa quais funções rodam repetidamente e então compila esses caminhos quentes em código de máquina otimizado em tempo real. Você ganha startup rápido como um interpretador e, depois de um aquecimento, velocidade rápida em regime permanente como um programa compilado.
Como o JIT decide o que compilar
O runtime perfila a execução conforme o programa roda, contando com que frequência cada método ou laço roda. O código "quente" frequentemente executado é promovido ao compilador; o código "frio" raramente usado continua sendo interpretado, então o runtime gasta esforço só onde compensa.
JIT vs compilação antecipada
A compilação antecipada (AOT) faz todo o trabalho antes de o programa rodar, dando velocidade de pico instantânea mas nenhum conhecimento de runtime. O JIT compila durante a execução, então pode otimizar usando dados reais de runtime, ao custo de um período de aquecimento.
Forças e custos do JIT
- Startup rápido, porque a execução começa interpretando.
- Alto desempenho em regime permanente depois que os caminhos quentes são compilados.
- Otimizações informadas pelo comportamento real de runtime.
- Um custo de aquecimento e memória extra para o compilador e o código compilado.
Onde você vê o JIT
A JVM, o .NET CLR e engines de JavaScript modernas (V8, SpiderMonkey) todas usam JIT. É por isso que um servidor de longa duração fica mais rápido depois do primeiro minuto, e por que um script minúsculo pode nunca se beneficiar, já que termina antes de o aquecimento completar.
Um exemplo rápido
Um servidor Node.js movido a V8 pode rodar um handler de requisição interpretado nas primeiras centenas de chamadas, e então fazer JIT dele quando fica claramente quente, de modo que as requisições posteriores ficam visivelmente mais rápidas.
JIT no CI
Processos de CI de vida curta muitas vezes nunca alcançam regime permanente, então o aquecimento do JIT torna os benchmarks no CI enganosos e adiciona overhead de startup e memória. Se runtimes pesados em JIT elevam a memória durante os testes, os jobs podem ser encerrados por OOM; a Latchkey oferece runners maiores para folga e reexecuta automaticamente falhas transitórias de OOM.
Principais conclusões
- O JIT compila código quente para código de máquina nativo em tempo de execução, depois de perfilar a execução.
- Ele combina startup rápido com alta velocidade em regime permanente, pagando um custo de aquecimento.
- Processos de CI curtos muitas vezes nunca aquecem, o que distorce benchmarks e adiciona overhead.