Que fait un compilateur juste à temps (JIT)?

Que fait spécifiquement un compilateur JIT par rapport à un compilateur non JIT? Quelqu'un peut-il donner une description succincte et facile à comprendre?

Un compilateur JIT s'exécute après le démarrage du programme et compile le code (généralement du bytecode ou une sorte d'instructions de machine virtuelle) à la volée (ou juste à temps, comme on l'appelle) dans une forme qui est généralement plus rapide, généralement la native du CPU hôte jeu d'instructions. Un JIT a accès à des informations d'exécution dynamiques alors qu'un compilateur standard ne le fait pas et peut faire de meilleures optimisations telles que les fonctions intégrées qui sont fréquemment utilisées.

Cela contraste avec un compilateur traditionnel qui compile tout le code en langage machine avant la première exécution du programme.

Pour paraphraser, les compilateurs conventionnels construisent l'ensemble du programme en tant que fichier EXE AVANT la première fois que vous l'exécutez. Pour les programmes de style plus récents, un assembly est généré avec un pseudocode (p-code). Ce n'est qu'après avoir exécuté le programme sur le système d'exploitation (par exemple, en double-cliquant sur son icône) que le compilateur (JIT) démarrera et générera le code machine (m-code) que le processeur Intel ou autre comprendra.

Au début, un compilateur était chargé de transformer un langage de haut niveau (défini comme un niveau supérieur à l'assembleur) en code objet (instructions machine), qui serait ensuite lié (par un éditeur de liens) en un exécutable.

À un moment de l'évolution des langages, les compilateurs compileraient un langage de haut niveau en pseudo-code, qui serait ensuite interprété (par un interprète) pour exécuter votre programme. Cela a éliminé le code objet et les exécutables, et a permis à ces langages d'être portables sur plusieurs systèmes d'exploitation et plates-formes matérielles. Pascal (qui a compilé en P-Code) a été l'un des premiers; Java et C # sont des exemples plus récents. Finalement, le terme P-Code a été remplacé par bytecode, car la plupart des pseudo-opérations sont longues d'un octet.

Un compilateur Just-In-Time (JIT) est une fonctionnalité de l'interpréteur d'exécution qui, au lieu d'interpréter le bytecode chaque fois qu'une méthode est invoquée, compilera le bytecode dans les instructions de code machine de la machine en cours d'exécution, puis invoquera ceci code objet à la place. Idéalement, l'efficacité de l'exécution du code objet surmontera l'inefficacité de la recompilation du programme à chaque exécution.

JIT-Juste à temps le mot lui-même dit quand il est nécessaire (sur demande)

Scénario typique:

Le code source est complètement converti en code machine

Scénario JIT:

Le code source sera converti en langage d'assemblage comme une structure [pour ex IL (langage intermédiaire) pour C #, ByteCode pour java].

Le code intermédiaire est converti en langage machine uniquement lorsque l'application a besoin des codes requis sont uniquement convertis en code machine.

Comparaison JIT vs Non-JIT:

• Dans JIT, tout le code n'est pas converti en code machine d'abord, une partie du code nécessaire sera convertie en code machine, puis si une méthode ou une fonctionnalité appelée n'est pas dans la machine, elle sera transformée en code machine ... cela réduit charge sur le CPU.

• Comme le code machine sera généré lors de l'exécution ... le compilateur JIT produira un code machine optimisé pour exécuter l'architecture CPU de la machine.

Exemples JIT:

1. En Java JIT est en JVM (Java Virtual Machine)
2. En C # c'est en CLR (Common Language Runtime)
3. Dans Android, il est en DVM (Dalvik Virtual Machine), ou ART (Android RunTime) dans les versions plus récentes.

Comme d'autres l'ont mentionné

JIT signifie Just-in-Time, ce qui signifie que le code est compilé quand il est nécessaire, pas avant l'exécution.

Juste pour ajouter un point à la discussion ci-dessus, la JVM conserve un décompte du nombre de fois qu'une fonction est exécutée. Si ce nombre dépasse une limite prédéfinie, JIT compile le code en langage machine qui peut être directement exécuté par le processeur (contrairement au cas normal dans lequel javac compile le code en bytecode puis en java - l'interpréteur interprète ce bytecode ligne par ligne le convertit en code machine et s'exécute).

La prochaine fois que cette fonction est calculée, le même code compilé est exécuté à nouveau contrairement à l'interprétation normale dans laquelle le code est à nouveau interprété ligne par ligne. Cela rend l'exécution plus rapide.

Le compilateur JIT compile uniquement le code d'octet en code natif équivalent lors de la première exécution. À chaque exécution successive, la JVM utilise simplement le code natif déjà compilé pour optimiser les performances.

Sans compilateur JIT, l'interpréteur JVM traduit le code octet ligne par ligne pour le faire apparaître comme si une application native était en cours d'exécution.

La source

JIT signifie Just-in-Time, ce qui signifie que le code est compilé quand il est nécessaire, pas avant l'exécution.

Ceci est bénéfique car le compilateur peut générer du code optimisé pour votre machine particulière. Un compilateur statique, comme votre compilateur C moyen, compilera tout le code en code exécutable sur la machine du développeur. Par conséquent, le compilateur effectuera des optimisations basées sur certaines hypothèses. Il peut compiler plus lentement et faire plus d'optimisations car il ne ralentit pas l'exécution du programme pour l'utilisateur.

Une fois que le code d'octet (qui est neutre sur le plan de l'architecture) a été généré par le compilateur Java, l'exécution sera gérée par la JVM (en Java). Le code d'octet sera chargé dans JVM par le chargeur, puis chaque instruction d'octet sera interprétée.

Lorsque nous devons appeler une méthode plusieurs fois, nous devons interpréter le même code plusieurs fois et cela peut prendre plus de temps que nécessaire. Nous avons donc les compilateurs JIT (juste à temps). Lorsque l'octet a été chargé dans JVM (son temps d'exécution), le code entier sera compilé plutôt qu'interprété, ce qui permet de gagner du temps.

Les compilateurs JIT ne fonctionnent que pendant l'exécution, nous n'avons donc pas de sortie binaire.

Compilateur Just In Time (JIT):
il compile les bytecodes java en instructions machine de ce CPU spécifique.

Par exemple, si nous avons une instruction de boucle dans notre code java:

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

Le code de boucle ci-dessus s'exécute 10 fois si la valeur de i est 0.

Il n'est pas nécessaire de compiler le bytecode 10 fois encore et encore car la même instruction va s'exécuter 10 fois. Dans ce cas, il est nécessaire de compiler ce code une seule fois et la valeur peut être modifiée le nombre de fois requis. Ainsi, le compilateur Just In Time (JIT) assure le suivi de ces instructions et méthodes (comme indiqué ci-dessus) et compile ces morceaux de code octet en code machine pour de meilleures performances.

Un autre exemple similaire est celui de la recherche d'un modèle utilisant "Expression régulière" dans une liste de chaînes / phrases.

Le compilateur JIT ne compile pas tout le code en code machine. Il compile du code qui a un modèle similaire au moment de l'exécution.

Consultez cette documentation Oracle sur Comprendre JIT pour en savoir plus.

Vous avez du code qui est compilé dans un IL (langage intermédiaire). Lorsque vous exécutez votre programme, l'ordinateur ne comprend pas ce code. Il ne comprend que le code natif. Ainsi, le compilateur JIT compile votre IL en code natif à la volée. Il le fait au niveau de la méthode.

Je sais que c'est un vieux fil, mais l'optimisation de l'exécution est une autre partie importante de la compilation JIT qui ne semble pas être discutée ici. Fondamentalement, le compilateur JIT peut surveiller le programme pendant son exécution pour déterminer les moyens d'améliorer l'exécution. Ensuite, il peut effectuer ces modifications à la volée - pendant l'exécution. Optimisation de Google JIT (javaworld a un très bon article à ce sujet. )

Un compilateur juste à temps (JIT) est un logiciel qui prend reçoit une entrée non exécutable et renvoie le code machine approprié à exécuter. Par exemple:

Intermediate representation    JIT    Native machine code for the current CPU architecture

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

La conséquence de ceci est que pour une certaine architecture CPU, le compilateur JIT approprié doit être installé.

Compilateur de différences, interprète et JIT

Bien qu'il puisse y avoir des exceptions en général lorsque nous voulons transformer le code source en code machine, nous pouvons utiliser:

1. Compilateur : prend le code source et retourne un exécutable
2. Interprète : exécute l'instruction du programme par instruction. Il prend un segment exécutable du code source et transforme ce segment en instructions machine. Ce processus est répété jusqu'à ce que tout le code source soit transformé en instructions machine et exécuté.
3. JIT : De nombreuses implémentations différentes d'un JIT sont possibles, mais un JIT est généralement une combinaison d'un compilateur et d'un interpréteur. Le JIT transforme d'abord les données intermédiaires (par exemple le bytecode Java) qu'il reçoit en langage machine via l'interprétation. Un JIT peut souvent détecter quand une certaine partie du code est exécutée souvent et le compilera pour une exécution plus rapide.

Jit signifie juste à temps compilateur jit est un programme qui transforme le code d'octet java en instruction qui peut être envoyée directement au processeur.

L'utilisation du compilateur java juste à temps (en fait un deuxième compilateur) sur la plate-forme système particulière conforme le bytecode dans un code système particulier, une fois que le code a été recompilé par le compilateur jit, il s'exécutera généralement plus rapidement sur l'ordinateur.

Le compilateur juste à temps est fourni avec la machine virtuelle et est utilisé en option. Il compile le bytecode en code exécutable spécifique à la plate-forme qui est immédiatement exécuté.

La compilation juste à temps (JIT), (également traduction dynamique ou compilation au moment de l'exécution ), est un moyen d'exécuter du code informatique qui implique la compilation pendant l'exécution d'un programme - au moment de l'exécution - plutôt qu'avant l'exécution .

La compilation informatique est une combinaison des deux approches traditionnelles de la traduction en code machine - la compilation anticipée (AOT) et l' interprétation - et combine certains avantages et inconvénients des deux. La compilation JIT combine la vitesse du code compilé avec la flexibilité d'interprétation .

Considérons JIT utilisé dans JVM,

Par exemple, les compilateurs HotSpot JVM JIT génèrent des optimisations dynamiques. En d'autres termes, ils prennent des décisions d'optimisation pendant que l'application Java est en cours d'exécution et génèrent des instructions de machine native hautes performances ciblées pour l'architecture système sous-jacente.

Lorsqu'une méthode est choisie pour la compilation, la JVM transmet son bytecode au compilateur Just-In-Time (JIT). Le JIT doit comprendre la sémantique et la syntaxe du bytecode avant de pouvoir compiler correctement la méthode. Pour aider le compilateur JIT à analyser la méthode, son bytecode est d'abord reformulé dans une représentation interne appelée arbres de trace, qui ressemble plus au code machine que le bytecode. L'analyse et les optimisations sont ensuite effectuées sur les arbres de la méthode. À la fin, les arbres sont traduits en code natif.

Un arbre de trace est une structure de données utilisée dans la compilation d'exécution du code de programmation. Les arbres de trace sont utilisés dans un type de «compilateur juste à temps» qui trace l'exécution du code pendant les points chauds et le compile. Référez ceci .

Référer :

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

Un compilateur non JIT prend le code source et le transforme en code octet spécifique à la machine au moment de la compilation. Un compilateur JIT prend le code d'octet indépendant de la machine qui a été généré au moment de la compilation et le transforme en code d'octet spécifique à la machine au moment de l'exécution. Le compilateur JIT que Java utilise est ce qui permet à un seul binaire de s'exécuter sur une multitude de plateformes sans modification.

20% du code d'octet est utilisé 80% du temps. Le compilateur JIT obtient ces statistiques et optimise ces 20% du code d'octets pour s'exécuter plus rapidement en ajoutant des méthodes en ligne, en supprimant les verrous inutilisés, etc. et en créant également le bytecode spécifique à cette machine. Je cite cet article, j'ai trouvé que c'était pratique. http://java.dzone.com/articles/just-time-compiler-jit-hotspot

JIT fait référence au moteur d'exécution dans quelques implémentations JVM, qui est plus rapide mais nécessite plus de mémoire, est un compilateur juste à temps. Dans ce schéma, les bytecodes d'une méthode sont compilés en code machine natif la première fois que la méthode est invoquée. Le code machine natif de la méthode est ensuite mis en cache, il peut donc être réutilisé la prochaine fois que la même méthode est invoquée.

La JVM effectue en fait des étapes de compilation pendant l'exécution pour des raisons de performances. Cela signifie que Java n'a pas de séparation de compilation-exécution propre. Il fait d'abord une soi-disant compilation statique du code source Java au bytecode. Ensuite, ce bytecode est transmis à la JVM pour exécution. Mais l'exécution du bytecode est lente, donc la JVM mesure la fréquence d'exécution du bytecode et lorsqu'elle détecte un "hotspot" de code qui est exécuté très fréquemment, elle effectue une compilation dynamique du bytecode au machinecode du code "hotspot" (hotspot profiler). Si efficacement aujourd'hui, les programmes Java sont exécutés par l'exécution de code machine.

Le compilateur Just In Time, également appelé compilateur JIT, est utilisé pour améliorer les performances en Java. Il est activé par défaut. Il s'agit d'une compilation effectuée au moment de l'exécution plutôt plus tôt. Java a popularisé l'utilisation du compilateur JIT en l'incluant dans JVM.