Nel calcolo, l’esecuzione di programmi scritti in linguaggi di alto livello richiede che il codice sorgente sia compilato su una lingua di basso livello o madre. Questa compilation viene definita Avanti delle cose (AOT) ed è in genere fatto durante il tempo di costruzione. Ridurre efficacemente il lavoro da svolgere durante il runtime.
In caso di Java, l’AOT produce un binario intermedio, vale a dire. bytecode, che viene quindi tradotto in codice macchina nativo durante l’esecuzione da Java Digital Machine (JVM). Questo è in linea con la filosofia di Java Write-on-Run-Anyplace (Wora), o semplicemente, indipendenza dalla piattaforma.
Durante l’esecuzione del programma, JVM identifica il codice di funzionamento frequenteindicato come Hotspot, che potrebbe essere ottimizzato. Questa ottimizzazione viene eseguita dal compilatore Simply-in-Time (JIT) durante il runtime. Fatto divertente: ecco come Hotspot VM prende il suo nome.
JIT viene utilizzato attraverso linguaggi di programmazione come .NET, JavaScript V8 e in alcuni contesti all’interno di Python e PHP. In questo articolo, ci concentreremo su Simply-in-Time (JIT) solo in Java.
Jit in jvm
In fase di esecuzione, JVM carica il codice compilato, vale a dire, bytecode e determina la semantica di ciascun bytecode per il calcolo appropriato. L’interpretazione bytecode in fase di esecuzione richiede risorse di elaborazione, come processore e memoria, con conseguente esecuzione più lenta rispetto a un’applicazione nativa. JIT aiuta a ottimizzare le prestazioni del programma Java compilando bytecode al codice nativo in fase di esecuzione. Il codice compilato nativamente risultante viene memorizzato nella cache per un uso successivo (ri).
Durante l’avvio di JVM, viene chiamato un gran numero di metodi. Se tutti questi metodi vengono compilati immediatamente, influenzerebbe significativamente il tempo di avvio. Pertanto, come compromesso tra tempi di avvio e prestazioni a lungo termine, solo quei metodi che vengono spesso chiamati vengono compilati non appena inizia il JVM. I metodi meno utilizzati vengono compilati in seguito o per niente, a seconda dell’uso.
Per determinare la soglia in cui il metodo deve essere compilato viene mantenuto internamente dal JVM come conteggio di invocazione del metodo. Per ogni invocazione, il contatore viene decrementato. Una volta che il contatore raggiunge lo zero, il JIT entra e compila il metodo.
Un altro contatore mantenuto da JVM è per il back-bordo del ciclo. Per ogni ciclo eseguito, il contatore viene controllato contro la soglia, oltre la quale è troppo accompagnato da JIT per l’ottimizzazione.
Compilatori JIT
I componenti JIT sono al di sotto di due gusti:
- C1: compilatore consumer → Il compilatore C1 ha una soglia bassa per la compilazione e quindi è ottimizzato per l’avvio rapido dell’applicazione.
- C2: compilatore server → Il compilatore C2 ha una soglia più alta per la compilation. Per questo motivo, le informazioni di profilazione disponibili prima della compilation sono molto più ricche. Pertanto, il codice compilato C2 è altamente ottimizzato per le prestazioni. Inoltre, i metodi che sono determinati per essere nel percorso di esecuzione critico dell’applicazione possono essere identificati accuratamente da C2.
Compilazione a più livelli
JIT può compilare il codice a vari livelli di ottimizzazione a seconda del suo utilizzo e complessità. Per un livello più elevato di ottimizzazione, sebbene il programma funzioni meglio, la compilation è costosa in termini di utilizzo delle risorse, vale a dire. CPU e memoria.
Per ottenere il meglio da C1 e C2, non solo sono raggruppati insieme, ma Compilazione a più livelli su più livelli viene eseguito come descritto di seguito.
Livelli di compilazione a più livelli
- Livello 0: codice interpretato → Durante l’avvio, tutto il bytecode viene tradotto in codice nativo. A questo livello, non c’è ottimizzazione. Tuttavia, il codice frequentemente eseguito viene determinato e profilato. Queste informazioni sono utilizzate nei livelli successivi per l’ottimizzazione.
- Livello 1: semplice codice compilato C1 → A questo livello, i metodi a bassa complessità sono ottimizzati, che il JVM considera come banale. Né la profilazione viene eseguita su questi metodi, né sono ulteriormente ottimizzati.
- Livello 2: codice compilato C1 limitato → A questo livello, solo alcuni dei metodi caldi sono compilati con qualsiasi informazione di profilazione sia disponibile. Questi metodi sono compilati per eventuali ottimizzazioni precoci senza aspettare C2. Si noti che questi metodi potrebbero successivamente essere (ri) compilati a livelli più alti, vale a dire. Vengono catturati 3 o 4 profili aggiuntivi.
- Livello 3: codice compilato C1 completo → A questo livello, tutto il non banale I metodi caldi sono compilati con informazioni sulla profilazione completa disponibili. Nella maggior parte dei casi il JIT salta direttamente dal codice interpretato di livello 0 a 3, a meno che le code del compilatore non siano piene.
- Livello 4: Codice compilato C2 → A questo livello JIT compila il codice con la massima ottimizzazione con tutte le informazioni di profilazione ricche disponibili. Per l’esecuzione a lungo termine, questi codici compilati sono più adatti. Poiché questo è il picco dell’ottimizzazione, non ci sono ulteriori informazioni di profilazione acquisite.
È interessante notare che un codice potrebbe essere (ri) compilato più volte per l’ottimizzazione di livello superiore, come ritenuto appropriato dal JIT.
Deoptimizzazione
Mentre JIT si sforza continuamente di migliorare o ottimizzare le prestazioni, potrebbero esserci casi che i metodi ottimizzati sono ora irrilevanti. Inoltre, le ipotesi del compilatore sull’ottimizzazione potrebbero variare con il comportamento del metodo. Per tali casi, JIT ritorna temporaneamente il livello di ottimizzazione al precedente o direttamente al livello 0.
Si noti che questi metodi possono essere nuovamente ottimizzati con nuove informazioni sul profilo. Tuttavia, si consiglia di monitorare story commutazione e consigliato di adattare di conseguenza il codice sorgente per contrastare il costo della commutazione frequente.
Configurazioni
La compilazione JIT e a più livelli sono abilitate per impostazione predefinita. Potrebbero ancora essere disabili per forti ragioni, advert esempio per diagnosticare eventuali errori indotti da JIT (che è abbastanza raro in natura) Pertanto dovrebbe essere evitato.
Per disabilitare jit o specificare -Djava.compiler=NONE O -Xint come argomenti durante l’avvio JVM.
Per disabilitare la compilazione a più livelli, specificare completamente -XX:-TieredCompilation.
Per il controllo granulare, cioè utilizzare solo il compilatore C1, specificare -XX:TieredStopAtLevel=1.
Per controllare le rispettive soglie di vari livelli da 2 a 4, fare riferimento di seguito (usali sostituendo Y con il numero per il livello)
-XX:TierYCompileThreshold=0-XX:TierYInvocationThreshold=100-XX:TierYMinInvocationThreshold=50-XX:TierYBackEdgeThreshold=1500
Si noti che la modifica di una di queste configurazioni avrà effetti sulle prestazioni del programma. Pertanto, si consiglia di modificare solo dopo un benchmarking completo.
Conclusione
Compilation JIT Migliora le prestazioni del programma Java convertendo bytecode in codice nativo in fase di esecuzione, ottimizzando metodi usati frequentemente bilanciando la velocità di avvio. La compilazione a più livelli perfeziona ulteriormente questo processo ottimizzando progressivamente il codice in base ai dati di profilazione. Mentre le impostazioni JIT predefinite funzionano bene, le configurazioni di messa a punto richiedono un benchmarking attento per prevenire gli svantaggi delle prestazioni.
Per la maggior parte delle applicazioni, queste ottimizzazioni si verificano perfettamente, senza richiedere l’intervento degli sviluppatori. Tuttavia, la comprensione della compilation just-in-time (JIT) è fondamentale per applicazioni advert alte prestazioni, in cui le impostazioni di compilation di messa a punto possono influire significativamente sull’efficienza di esecuzione.
Hotspot JDK contro Graalvm JIT
Graalvm JIT è un’altra implementazione le cui differenze fondamentali con HOTSPOT JDK JIT sono descritte di seguito:
- Hotspot JDK → L’hotspot normal JVM utilizza un approccio JIT a livelli, con il compilatore C1 più semplice per ottimizzazioni rapide e il compilatore C2 (server) più aggressivo per ottimizzazioni più profonde. Questi compilatori sono prevalentemente scritti in C/C ++ e sono stati affinati per molti anni per offrire prestazioni stabili e affidabili per i carichi di lavoro Generale Java.
- Graalvm jit → Graalvm si basa sulla fondazione hotspot sostituendo il tradizionale compilatore C2 con il compilatore Graal. Scritto in Java, il compilatore Graal introduce ottimizzazioni avanzate come un miglioramento dell’analisi di fuga, una parziale analisi di fuga e delle ottimizzazioni speculative. Inoltre, Graalvm si estende oltre i semplici miglioramenti di JIT; Supporta i punti di corsa in poliglotta, abilitando linguaggi come JavaScript e Python e offre una compilation in anticipo dei tempi (AOT) per migliorare i tempi di avvio e ridurre le spese generali di memoria in scenari adeguati.
In sostanza, mentre Hotspot rimane una piattaforma testata e stabile per la gestione di applicazioni Java, Graalvm spinge i confini delle prestazioni e della flessibilità con il suo moderno compilatore JIT e ulteriori funzionalità di runtime. La scelta tra di loro di solito dipende dal carico di lavoro specifico e dai requisiti di prestazioni o interoperabilità dell’applicazione.
