JIT

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
NoFonti.svg
Este artigo ou se(c)ção cita uma ou mais fontes fiáveis e independentes, mas ela(s) não cobre(m) todo o texto (desde dezembro de 2011).
Por favor, melhore este artigo providenciando mais fontes fiáveis e independentes e inserindo-as em notas de rodapé ou no corpo do texto, conforme o livro de estilo.
Encontre fontes: Googlenotícias, livros, acadêmicoYahoo!Bing. Veja como referenciar e citar as fontes.

Em Ciência da Computação, compilação just-in-time (JIT), também conhecida como tradução dinâmica, é a compilação de um programa em tempo de execução , usando uma abordagem diferente da compilação anterior à execução. Geralmente, consiste em transformar o código em código de máquina, que é então executado diretamente, mas também pode se referir a tradução para outros formatos.[1]

A compilação JIT é uma combinação de duas abordagens tradicionais de tradução para código de máquina: anterior à execução e durante a execução (interpretação), portanto combina algumas vantagens e desvantagens de ambas. A grosso modo, a compilação JIT combina a velocidade do código compilado à flexibilidade da interpretação, com o gargalo do interpretador e da compilação. A compilação dinâmica permite otimizações que não são possíveis em compilações estáticas, levando em alguns casos a códigos mais rápidos.

Visão Geral[editar | editar código-fonte]

Em sistemas computacionais baseados em máquinas virtuais, como Java e .NET, o processo de compilação traduz o código fonte para uma representação intermediária conhecida pelo termo bytecode. Esta representação intermediária não está associada a nenhum código de máquina específico e pode ser transportada para várias arquiteturas de computador distintas. Em cada arquitetura específica, essa representação intermediária é interpretada - ou executada em uma máquina virtual.

Nos ambientes que oferecem o recurso de JIT, a máquina virtual responsável pela execução dos bytecodes resultantes da compilação do programa fonte realiza a tradução desse bytecode para código de máquina nativo enquanto o executa. No caso mais comum, cada trecho de código é traduzido no instante em que está para ser executado pela primeira vez, daí derivando o nome "just-in-time".

A ideia de um sistema que suporta o conceito de JIT é combinar as vantagens da compilação tradicional - que converte o código fonte diretamente para código de máquina - e do conceito de máquinas virtuais, baseadas em bytecode. A custosa tarefa de analisar e verificar o código fonte do programa original é realizada pelo processo de compilação para bytecode, em tempo de desenvolvimento. Também nesta fase, são realizadas todas as possíveis otimizações baseadas na análise do código fonte, obtendo-se um conjunto de bytecodes otimizados e semanticamente equivalente ao programa fonte original. O programa objeto resultante deste processo de compilação é transportável para as várias arquiteturas distintas que suportam a máquina virtual alvo da compilação, isto é, que possuem um interpretador de bytecode. Durante a execução do programa, o compilador JIT realiza apenas a tradução de bytecode para código de máquina, relativo a interpretação. Isso resulta numa tarefa muito mais simples e mais rápida.

Esse mecanismo de execução apresenta um desempenho significativamente superior ao processo clássico de interpretação. Isto porque o código de máquina resultante da compilação JIT é armazenado na memória, garantindo que o trecho de código em questão não será mais recompilado ou reinterpretado sempre que, durante a execução do programa, for novamente acionado. Além disso, muitos compiladores JIT possuem mecanismos para realizar otimizações adicionais nos trechos de código do programa que são executados com maior freqüência.

Entretanto, o mecanismo de execução baseado em compiladores JIT pode causar um pequeno atraso no início da execução de uma aplicação, em função de ter que compilar o bytecode para código de máquina. Naturalmente, quanto mais otimizações o compilador JIT realizar, mais rápida tenderá a ser a execução do programa alvo, porém maior será o atraso no início da execução. Por conta disso, os compiladores JIT mais bem elaborados normalmente realizam um balanceamento criterioso entre o tempo a ser gasto com a compilação e a qualidade de código que ele pretende gerar.

Dois exemplos de plataformas que se utilizam de compiladores JIT são os ambientes.NET e Java. No caso do ambiente Java, o compilador de Java traduz o programa fonte para uma representação intermediária (programa objeto) conhecida pelo termo bytecode. Posteriormente, o programa objeto será interpretado pela máquina virtual Java. No caso do ambiente.NET, a representação intermediária é conhecida pelo termo Microsoft Intermediate Language (MSIL)[2] , que será interpretada pela máquina virtual do ambiente.NET, chamada Common Language Runtime.

Referências

  1. Engel, Joshua. Programming for the Java Virtual Machine (em inglês). Reading, Massachusetts: Addison & Wesley, 1999. 488 pp. p. 355. ISBN 0-201-30972-6
  2. Cough, John. Compiling for the .NET Common Language Runtime (CLR) (em inglês). Upper Saddle River: Prentice Hall, 2002. 391 pp. p. 2-12. ISBN 0-13-062296-6

Ligações externas[editar | editar código-fonte]

  • GNU lightning — Uma biblioteca que gera código de máquina em tempo de execução