Che cosa fa un just-in-time (JIT) compilatore?

Question

Che cosa fa un compilatore JIT espressamente rispetto a un non-compilatore JIT?Qualcuno può dare una succinta e facile da capire descrizione?

Answer 1

Un compilatore JIT corre dopo il programma è iniziato, compila il codice (di solito bytecode o un qualche tipo di VM istruzioni) al volo (o just-in-time, come si chiama) in una forma che di solito è più veloce, in genere la CPU host nativo del set di istruzioni.Un JIT ha accesso a runtime dinamica d'informazioni, mentre una standard del compilatore non e in grado di fare meglio ottimizzazioni come l'inline di funzioni che vengono utilizzati di frequente.

Questo è in contrasto con la tradizionale compilatore che compila tutti il codice in linguaggio macchina prima il programma viene eseguito prima.

Per parafrasare, convenzionale compilatori costruire l'intero programma come un file EXE, prima che la PRIMA volta che lo si esegue.Per il più nuovo stile programmi, viene generato un assembly con pseudocodice (p-code).Solo DOPO aver eseguito il programma sul sistema operativo (ad esempio, facendo doppio clic sulla sua icona) il compilatore JIT (calcio e generare codice macchina (codice m) che il processore Intel o qualunque sia la volontà di capire.

Answer 2

All'inizio, un compilatore è stato responsabile per la tornitura di un linguaggio di alto livello (definito come il livello più alto di assembler) in codice oggetto (istruzioni macchina), che sarebbe poi essere collegati (da un linker) in un file eseguibile.

A un certo punto l'evoluzione dei linguaggi, compilatori potrebbe compilare un linguaggio di alto livello in pseudo-codice, che dovrebbe quindi essere interpretato (interprete) per eseguire il programma.Questo ha eliminato il codice oggetto e file eseguibili, e ha consentito a queste lingue, per essere portatile, per di più sistemi operativi e piattaforme hardware.Pascal (che, compilati in P-Code) è stato uno dei primi;Java e C# sono esempi più recenti.Alla fine il termine P-Code è stato sostituito con il bytecode, poiché la maggior parte di pseudo-le operazioni sono un byte di lunghezza.

Just-In-Time (JIT) compilatore è una funzione del tempo di un interprete, che invece di interpretare il bytecode ogni volta che viene richiamato un metodo, verrà compilato in bytecode in codice macchina istruzioni della macchina in funzione, e quindi richiamare questo codice oggetto, invece.Idealmente, l'efficienza di esecuzione di codice oggetto superare l'inefficienza di ricompilare il programma ogni volta che viene eseguito.

Answer 3

JIT-Just in time dice la parola stessa, quando è necessario (su richiesta)

Scenario tipico:

Il codice sorgente è completamente convertita in codice macchina

JIT scenario:

Il codice sorgente sarà convertito in linguaggio assembly come struttura [per ex IL (intermediate language) per C#, il ByteCode di java].

Il codice intermedio è convertito in linguaggio macchina solo quando le esigenze di applicazione, è necessario di codici sono solo convertito in codice macchina.

JIT vs Non-JIT confronto:

• JIT non tutto il codice viene convertito in codice macchina prima parte il codice che è necessario, saranno convertiti in codice macchina quindi se un metodo o la funzionalità di chiamata non è in macchina che sarà trasformato in codice macchina...si riduce il carico di lavoro sulla CPU.

• Il codice macchina generato in fase di esecuzione....il JIT compilatore produrre codice macchina che è ottimizzato per l'esecuzione di macchina architettura della CPU.

JIT Esempi:

1. In Java JIT è in JVM (Java Virtual Machine)
2. In C# è in CLR (Common Language Runtime)
3. In Android è in DVM (Dalvik Virtual Machine), o ART (Android RunTime) nelle versioni più recenti.

Answer 4

Come altri hanno detto

JIT è l'acronimo di Just-in-Time, il che significa che il codice viene compilato quando è necessario, non prima di runtime.

Solo per aggiungere un punto alla discussione di cui sopra JVM mantiene un conteggio di quante volte una funzione viene eseguita.Se questo valore supera un determinato limite JIT compila il codice in linguaggio macchina, che può essere direttamente eseguito dal processore (a differenza di un normale caso in cui il javac compilare il codice in bytecode e poi java, l'interprete interpreta il bytecode, riga per riga, la converte in codice macchina ed esegue).

Anche la prossima volta che questa funzione è calcolato stesso compilato il codice viene eseguito di nuovo a differenza dei normali interpretazione, in cui il codice viene interpretato di nuovo, linea per linea.Questo rende più veloce l'esecuzione.

Answer 5

Compilatore JIT compila solo il byte-code a codice nativo equivalente alla prima esecuzione.Su ogni successiva esecuzione, la JVM utilizza semplicemente il già compilato in codice nativo per ottimizzare le prestazioni.

Senza compilatore JIT, la JVM interprete traduce il byte-code, linea per linea, per farlo apparire come se una applicazione nativa viene eseguito.

Fonte

Answer 6

JIT è l'acronimo di Just-in-Time, il che significa che il codice viene compilato quando è necessario, non prima di runtime.

Questo è positivo, perché il compilatore è in grado di generare il codice è ottimizzato per la vostra macchina.Un compilatore statico, come la maggior compilatore C, consente di compilare tutti del codice in materia di codice eseguibile per lo sviluppo della macchina.Quindi il compilatore di eseguire ottimizzazioni sulla base di alcune ipotesi.E ' possibile compilare più lentamente e fare di più ottimizzazioni perché non rallentare l'esecuzione del programma per l'utente.

Answer 7

Dopo il byte di codice (che è l'architettura che è neutro) è stato generato dal compilatore Java, l'esecuzione verrà gestito dalla JVM (Java).Il byte di codice verrà caricato in JVM dal caricatore e quindi ogni byte istruzione viene interpretata.

Quando abbiamo bisogno di chiamare un metodo più volte, abbiamo bisogno di interpretare il codice stesso molte volte e questo può richiedere più tempo di quanto sia necessario.Così abbiamo il JIT (just-in-time) compilatori.Quando il byte è stato caricato in JVM (a suo tempo), tutto il codice viene compilato, anziché interpretato, con conseguente risparmio di tempo.

Compilatori JIT funziona solo durante la fase di esecuzione, in modo da non avere alcun output binario.

Answer 8

Just In Time Compiler (JIT) :
Compila il bytecode java in istruzioni macchina della CPU.

Per esempio, se abbiamo un ciclo di istruzione nel nostro codice java :

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

Il loop di cui sopra di codice viene eseguito per 10 volte, se il valore di i è 0.

Non è necessario compilare il bytecode per 10 volte di nuovo e di nuovo, come la stessa sentenza sta per eseguire per 10 volte.In questo caso, è necessario compilare il codice solo una volta e il valore può essere modificato per il numero necessario di volte.Così, Just In Time (JIT) Compilatore tiene traccia di tali dichiarazioni e metodi (come detto prima) e compila questi pezzi di byte di codice in codice macchina per migliorare le prestazioni.

Un altro esempio simile , è che la ricerca di un modello di "Espressione Regolare" in una lista di stringhe/frasi.

Compilatore JIT non compilare tutto il codice in codice macchina.Compila il codice che hanno un modello simile, in fase di esecuzione.

Vedere questo La documentazione di Oracle a Capire JIT per saperne di più.

Answer 9

È necessario che il codice compliled in alcuni IL (intermediate language).Quando si esegue il programma, il computer non capisce questo codice.Si capisce solo in codice nativo.In modo che il compilatore JIT compila IL in codice nativo al volo.Lo fa a livello di metodo.

Answer 10

So che questo è un vecchio thread, ma runtime optimization è un'altra parte importante di compilazione JIT, che non sembrava essere discusso qui.Fondamentalmente, il compilatore JIT in grado di monitorare l'esecuzione del programma per determinare i modi per migliorare l'esecuzione.Quindi, è possibile apportare le modifiche al volo - durante il runtime.Google ottimizzazione JIT (javaworld ha una bella buon articolo su di esso.)

Answer 11

Jit è l'acronimo di just in time compiler jit è un programma che trasforma il java byte code in istruzioni che possono essere inviati direttamente al processore.

Utilizzando il java just in time compiler (davvero un compilatore secondo) al particolare sistema di piattaforma conforme il bytecode in particolare il codice del sistema,una volta che il codice è stato ri-compilato dal compilatore jit ,di solito eseguire più velocemente nel computer.

Il just-in-time compiler viene fornito con la macchina virtuale ed è utilizzato facoltativamente.Compila il bytecode in specifico per la piattaforma di codice eseguibile che viene immediatamente eseguita.

Answer 12

Just in time compiler (JIT) è un pezzo di software che si riceve non è eseguibile in ingresso e restituisce la macchina appropriata esecuzione di codice.Per esempio:

Intermediate representation    JIT    Native machine code for the current CPU architecture

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

La conseguenza di ciò è che, per un certo architettura della CPU appropriato compilatore JIT deve essere installato.

Differenza compilatore, interprete e JIT

Anche se ci possono essere eccezioni, in generale, quando si vuole trasformare il codice sorgente in codice macchina si può utilizzare:

1. Compilatore:Prende il codice sorgente e restituisce un file eseguibile
2. Interprete:Esegue il programma istruzione per istruzione.Ci vuole un eseguibile, un segmento di codice sorgente e si trasforma in quel segmento in istruzioni macchina.Questo processo viene ripetuto fino a quando tutto il codice sorgente è trasformato in istruzioni macchina ed eseguito.
3. JIT:Le differenti implementazioni di un JIT sono possibili, tuttavia un JIT è di solito una combinazione di un compliler e di un interprete.Il JIT primo turno di dati intermedi (ad es.Java bytecode) che riceve in linguaggio macchina tramite l'interpretazione.Un JIT può spesso senso quando una certa parte di codice viene eseguito spesso e la volontà di compilare questa parte per una esecuzione più veloce.

Answer 13

Non compilatore JIT prende il codice sorgente e le trasforma in una macchina specifica byte di codice in fase di compilazione.Un compilatore JIT prende la macchina agnostico byte di codice che è stato generato in fase di compilazione e le trasforma in una macchina specifica byte di codice in fase di esecuzione.Il compilatore JIT che Java utilizza è quello che permette ad un solo binario per eseguire su una moltitudine di piattaforme, senza modifiche.

Answer 14

just-in-time (JIT) compilazione, (anche la traduzione dinamica o in fase di esecuzione per la compilazione), è un modo di esecuzione di codice per computer che comporta la compilazione durante l'esecuzione di un programma in fase di esecuzione; piuttosto che prima dell'esecuzione.

È la compilazione di un combinazione di i due approcci tradizionali per la traduzione in codice macchina – ahead-of-time compilazione (AOT), e interpretazione – e combina alcuni vantaggi e svantaggi di entrambi. Compilazione JIT unisce la velocità di codice compilato con la flessibilità di interpretazione.

Prendiamo in considerazione il JIT utilizzato nella JVM,

Per esempio, l'HotSpot JVM compilatori JIT generare dinamiche di ottimizzazione.In altre parole, fanno decisioni di ottimizzazione, mentre l'applicazione Java è in esecuzione e generare alte prestazioni native istruzioni macchina mirati per il sistema sottostante architettura.

Quando un metodo viene scelto per la compilazione, la JVM alimenta il suo bytecode per la Just-In-Time compiler (JIT).Il JIT deve comprendere la semantica e la sintassi del bytecode prima di poter compilare il metodo correttamente.Per aiutare il compilatore JIT analizzare il metodo, il suo bytecode sono prima riformulato in una rappresentazione interna chiamata traccia alberi, che ricorda il codice macchina più stretto rispetto a bytecode.Analisi e ottimizzazioni sono eseguiti sugli alberi del metodo.Alla fine, gli alberi sono tradotti in codice nativo.

Una traccia albero è una struttura di dati che viene utilizzato nella compilazione runtime di codice di programmazione.Traccia alberi sono utilizzati in una sorta di "just in time compiler' che ripercorre il codice in esecuzione durante l'hotspot e lo compila.Riferimento questo.

Riferimento :

• http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
• https://en.wikipedia.org/wiki/Just-in-time_compilation

Answer 15

20% del byte di codice viene utilizzato l ' 80% del tempo.Il compilatore JIT ottiene queste statistiche e ottimizzare il 20% del byte di codice per eseguire più velocemente aggiungendo metodi inline, la rimozione di blocchi inutilizzati ecc e anche la creazione di bytecode specifico per quella macchina.Sto citando da questo articolo, l'ho trovato a portata di mano. http://java.dzone.com/articles/just-time-compiler-jit-hotspot

Answer 16

JIT si riferisce al motore di esecuzione in alcune delle implementazioni della JVM, uno che è più veloce, ma richiede più memoria,è un just-in-time compiler.In questo schema, il bytecode di un metodo sono compilati in codice macchina nativo, la prima volta che viene richiamato il metodo.Il codice macchina nativo per il metodo viene quindi memorizzato nella cache, in modo da può essere ri-utilizzato, la prossima volta che stesso metodo viene richiamato.

Answer 17

JVM esegue effettivamente la compilazione passaggi durante la fase di esecuzione per motivi di prestazioni.Questo significa che Java non ha una compilazione parziale esecuzione di separazione.Si fa prima un cosiddetto statico compilazione di codice sorgente Java in bytecode.Quindi, questo bytecode è passato alla JVM per l'esecuzione.Ma l'esecuzione del bytecode è lenta in modo che la JVM misure come spesso il bytecode viene eseguito e quando rileva un "hotspot" di codice che esegue molto spesso si esegue la compilazione dinamica da bytecode codice macchina di un "hotspot" codice (hotspot profiler).Così effettivamente oggi i programmi Java sono gestiti da codice macchina di esecuzione.