O que faz um just-in-time (JIT) fazer?

https://stackoverflow.com/questions/95635

01-07-2019
|

Pergunta

O que um compilador JIT fazer especificamente em oposição a um compilador JIT não? Alguém pode dar uma sucinta e fácil de entender?

Solução

A JIT é executado compilador depois o início do programa e compila o código (normalmente bytecode ou algum tipo de instruções VM) na mosca (ou just-in-time, como é chamado) em um forma que é geralmente mais rápido, normalmente conjunto de instruções nativa do CPU host. A JIT tem acesso a informações de tempo de execução dinâmica enquanto que um compilador padrão não e pode fazer melhores otimizações como inlining funções que são usadas com freqüência.

Este é em contraste com um compilador tradicional que compila todas o código em linguagem de máquina antes o programa é executado pela primeira vez.

Para paráfrase, compiladores convencionais construir todo o programa como um arquivo EXE antes da primeira vez que você executá-lo. Para os programas de estilo mais recentes, uma montagem é gerado com pseudocódigo (p-código). Só depois de executar o programa no sistema operacional (por exemplo, clicando duas vezes em seu ícone) será o (JIT) chutar e gerar código de máquina (m-code) que o processador baseado em Intel ou o que vai entender.

Outras dicas

No início, um compilador foi responsável por transformar uma linguagem de alto nível (definida como o nível mais alto do que montador) em código objecto (instruções de máquina), o que, em seguida, ser ligado (atrav de um ligante) em um executável.

Em um ponto na evolução das linguagens, compiladores seria compilar uma linguagem de alto nível em pseudo-código, que passaria então a ser interpretado (por um intérprete) para executar o programa. Isso eliminou o código objeto e executáveis, e permitiu línguas para ser portátil para vários sistemas operacionais e plataformas de hardware. Pascal (que compilado para P-Code) foi um dos primeiros; Java e C # são exemplos mais recentes. Eventualmente, o termo P-Code foi substituído por bytecode, já que a maioria dos pseudo-operações são um byte.

A Just-In-Time (JIT) é uma característica do intérprete de tempo de execução, que, em vez de interpretar bytecode cada vez que um método é invocado, irá compilar o bytecode para as instruções de código de máquina da máquina de execução, e em seguida, chamar este código objeto em seu lugar. Idealmente a eficiência de execução de código objeto irá superar a ineficiência de recompilar o programa cada vez que ele é executado.

JIT-Just in time a própria palavra diz quando é necessário (on demand)

cenário típico:

O código fonte é completamente convertido em código de máquina

cenário JIT:

O código fonte será convertida em linguagem assembly como estrutura [por ex IL (linguagem intermediária) para C #, ByteCode para java].

O código intermediário é convertido em linguagem de máquina somente quando as necessidades de aplicação que é exigido códigos só são convertidos em código de máquina.

JIT vs comparação não-JIT:

Em JIT não todo o código é convertido em código de máquina primeira parte do código que é necessário será convertido em código de máquina em seguida, se um método ou chamada funcionalidade não está na máquina, em seguida, que será transformado em código de máquina ... que reduz a carga sobre a CPU.
Como o código de máquina serão gerados em tempo de execução .... o JIT compilador irá produzir o código de máquina, que está optimizada para executar arquitetura de CPU da máquina.

Exemplos JIT:

Em Java JIT está na JVM (Java Virtual Machine)
Em C # é no CLR (Common Language Runtime)
Em Android é no DVM (Dalvik Virtual Machine), ou ART (RunTime Android) em versões mais recentes.

Como outros já mencionado

JIT significa Just-in-Time o que significa que o código é compilado quando é necessário, não antes de tempo de execução.

Só para acrescentar um ponto à discussão acima JVM mantém uma contagem a partir de quanto tempo a função é executada. Se esta contagem excede um JIT limite pré-definido compila o código em linguagem de máquina que pode ser diretamente executado pelo processador (ao contrário do caso normal em que javac compilar o código em bytecode e depois java - interpreta o intérprete esta linha bytecode pelos convertidos alinhá-lo em código de máquina e executa).

Também próxima vez que esta função é calculada mesmo código compilado é executado novamente ao contrário de interpretação normal em que o código é interpretado novamente linha por linha. Isso torna a execução mais rápida.

compilador JIT única compila o código-byte para código nativo equivalente à primeira execução. Após a cada execução sucessiva, a JVM apenas utiliza o código nativo já compilados para otimizar o desempenho.

Sem compilador JIT, o intérprete JVM traduz o código-byte linha-a-linha para fazê-la parecer como se um aplicativo nativo está sendo executado.

Fonte

JIT significa Just-in-Time, o que significa que o código é compilado quando é necessário, não antes de tempo de execução.

Isso é benéfico porque o compilador pode gerar o código que é otimizado para sua máquina particular. Um compilador estático, como seu compilador C média, irá compilar todo o código para o código executável na máquina do desenvolvedor. Daí o compilador irá realizar otimizações com base em alguns pressupostos. Ele pode compilar mais lentamente e fazer mais otimizações porque não está a abrandar a execução do programa para o usuário.

Depois do código de byte (que é a arquitetura neutra) foi gerado pelo compilador Java, a execução será tratada pela JVM (em Java). O código de bites serão carregados no JVM pelo carregador e, em seguida, cada instrução byte é interpretado.

Quando precisamos chamar um método várias vezes, precisamos interpretar o mesmo código muitas vezes e isso pode levar mais tempo do que o necessário. Portanto, temos a JIT compiladores (just-in-time). Quando o byte foi carregado no JVM (o seu tempo de execução), todo o código será compilado em vez de interpretado, poupando assim tempo.

compiladores JIT funciona apenas durante o tempo de execução, por isso não temos qualquer saída binário.

Just In Time Compiler (JIT):
Ele compila os bytecode java em instruções de máquina desse CPU específica.

Por exemplo, se temos uma declaração de loop em nosso código java:

while(i<10){
    // ...
    a=a+i;
    // ...
 }

Os loop acima código é executado para 10 vezes se o valor de i é 0.

Não é necessário para compilar o bytecode por 10 vezes de novo e de novo como a mesma instrução está indo para executar por 10 vezes. Nesse caso, é necessário compilar esse código apenas uma vez e o valor pode ser alterado para o número de vezes necessário. Então, Just In Time (JIT) mantém o controle de tais declarações e métodos (como disse acima antes) e compila esses pedaços de código byte em código de máquina para um melhor desempenho.

Outro exemplo semelhante, é que uma busca por um padrão usando "Expressão Regular" em uma lista de strings / frases.

compilador JIT não compila todo o código para código de máquina. Ele compila código que têm um padrão semelhante em tempo de execução.

Veja este Oracle em Compreender JIT para ler mais.

Você tem código que é compliled em algum IL (linguagem intermediária). Quando você executar o programa, o computador não entender este código. Ele só entende código nativo. Portanto, o compilador JIT compila o IL em código nativo na mosca. Ele faz isso no nível do método.

Eu sei que esta é uma discussão antiga, mas otimização de tempo de execução é outra parte importante da compilação JIT que não parecia ser discutido aqui. Basicamente, o compilador JIT pode monitorar o programa como ele é executado para determinar formas de melhorar a execução. Então, ele pode fazer essas mudanças em tempo real - durante a execução. otimização Google JIT (JavaWorld tem uma bonita bom artigo sobre isso. )

Jit significa apenas no compilador tempo jit é um programa que voltas código Java byte em instrução que podem ser enviados diretamente para o processador.

Usando o java apenas no compilador tempo (realmente um segundo compilador) na plataforma de sistema particular cumpre o bytecode em particular, código do sistema, uma vez que o código foi re-compilado pelo compilador JIT, que normalmente será executado mais rapidamente no computador.

O compilador just-in-time vem com a máquina virtual e é usado opcionalmente. Ele compila o bytecode em código executável específico da plataforma que é executada imediatamente.

A apenas no compilador tempo (JIT) é uma peça de software que leva recebe uma entrada não executável e retorna o código de máquina apropriada para ser executado. Por exemplo:

Intermediate representation    JIT    Native machine code for the current CPU architecture

     Java bytecode            --->        machine code
     Javascript (run with V8) --->        machine code

A consequência disto é que, para uma determinada arquitetura de CPU o compilador JIT apropriado deve ser instalado.

compilador Diferença, intérprete, e JIT

Embora possa haver exceções, em geral, quando queremos transformar código fonte em código de máquina, podemos usar:

Compiler : Toma código fonte e retorna um executável
Interpreter : Executa a instrução de programa pela instrução. Leva um segmento executável do código-fonte e transforma esse segmento em instruções de máquina. Este processo é repetido até que todo o código fonte é transformado em instruções de máquina e executado.
JIT : Muitas implementações diferentes de um JIT são possíveis, no entanto, um JIT é geralmente uma combinação de um compliler e um intérprete. O JIT primeiro transformar dados intermediário (por exemplo código de bytes de Java) que recebe em linguagem de máquina através de interpretação. A JIT muitas vezes pode sentir quando uma determinada parte do código é executado frequentemente ea irá compilar esta parte para uma execução mais rápida.

Um compilador JIT não tem código fonte ea transforma em código byte máquina específica em tempo de compilação. Um compilador JIT leva máquina de código de bites agnóstico que foi gerado em tempo de compilação e a transforma em código de bites máquina específica em tempo de execução. O compilador JIT que Java usa é o que permite que um único binário para rodar em uma infinidade de plataformas sem modificação.

just-in-time (JIT) compilação, (também dinâmica de tradução ou compilação em tempo de execução), é um maneira de executar código de computador que envolve compilação durante a execução de um programa - em tempo de execução -. em vez de antes da execução

compilação de TI é um combinação de as duas abordagens tradicionais de tradução para código de máquina - antes-do-tempo de compilação (AOT) e interpretação - e combina algumas vantagens e desvantagens de ambos. compilação JIT combina a velocidade de código compilado com a flexibilidade de interpretação .

Vamos considerar JIT usado na JVM,

Por exemplo, os compiladores HotSpot JVM JIT gerar otimizações dinâmicas. Em outras palavras, tomam decisões de otimização enquanto o aplicativo Java está sendo executado e gerar alto desempenho instruções de máquina nativas direcionados para a arquitetura subjacente do sistema.

Quando um método é escolhido para a compilação, o JVM alimenta seu bytecode para o compilador Just-In-Time (JIT). O JIT precisa entender a semântica e sintaxe do bytecode antes que possa compilar o método corretamente. Para ajudar o compilador JIT analisar o método, a sua bytecode são primeiro reformulado em uma representação interna chamada árvores traço, que se assemelha código de máquina mais perto do que bytecode. Análise e otimizações são então realizadas nas árvores do método. No final, as árvores são traduzidos em código nativo.

Uma árvore de rastreio é uma estrutura de dados que é usado na compilação de tempo de execução de código de programação. árvores de rastreamento são usados ??em um tipo de 'apenas no compilador tempo' que o código traços execução durante hotspots e compila-lo. Consulte este .

Consulte:

20% do código byte é utilizado 80% do tempo. O compilador JIT recebe estas estatísticas e de optimizar esta 20% do código de bites para funcionar mais rapidamente por adição de métodos in-line, a remoção de bloqueios não utilizados, etc, e também a criação do código de bytes específico para essa máquina. Estou citando a partir deste artigo, eu achei que era útil. http://java.dzone.com/articles/just-time-compiler -jit-hotspot

JIT refere-se ao mecanismo de execução em algumas das implementações de JVM, que é mais rápido, mas requer mais memória, é um compilador just-in-time. Neste esquema, os bytecodes de um método são compilados para o código de máquina nativo a primeira vez que o método é chamado. O código de máquina nativo para o método é então armazenada em cache, para que ele possa ser re-utilizado da próxima vez que mesmo método é invocado.

JVM realmente executa os passos de compilação durante a execução por motivos de desempenho. Isto significa que Java não tem uma separação de compilação-execução limpa. Ele primeiro faz uma compilação estática chamado a partir do código-fonte Java para bytecode. Então este bytecode é passado para o JVM para execução. Mas executar bytecode é lento para que as medidas de JVM quantas vezes o bytecode é executado e quando detecta um "hotspot" de código que é executado com muita freqüência ele executa compilação dinâmica de bytecode para machinecode do código "hotspot" (hotspot profiler). Então, efetivamente programas hoje Java são executados pela execução machinecode.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow