Que fait un compilateur juste à temps (JIT)?

Question

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

Answer 1

Un compilateur JIT exécute après que le programme a démarré et compile le code (généralement du bytecode ou une sorte d’instruction de machine virtuelle) à la volée (ou juste à temps, comme on l’appelle) en un forme qui est généralement plus rapide, généralement le jeu d’instructions natif du processeur hôte. Un JIT a accès aux informations d’exécution dynamiques, alors qu’un compilateur standard ne le peut pas et peut effectuer de meilleures optimisations, telles que l’ajout de fonctions en ligne fréquemment utilisées.

Cela contraste avec un compilateur traditionnel qui compile tout le code dans le langage machine avant que le programme ne soit exécuté pour la première fois.

Pour paraphraser les compilateurs classiques, le programme entier est créé sous forme de fichier EXE AVANT la première exécution. Pour les programmes de style plus récent, un assemblage est généré avec un pseudocode (p-code). Seulement après avoir exécuté le programme sur le système d'exploitation (par exemple, en double-cliquant sur son icône), le compilateur (JIT) démarrera et générera un code machine (m-code) que le processeur à base Intel ou tout autre personne comprendra.

Answer 2

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

À un moment de l'évolution des langages, les compilateurs compilaient un langage de haut niveau en pseudo-code, qui serait ensuite interprété (par un interprète) pour exécuter votre programme. Cela éliminait le code objet et les exécutables et permettait à ces langages d'être portables sur plusieurs systèmes d'exploitation et plates-formes matérielles. Pascal (qui a compilé 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 du bytecode, car la plupart des pseudo-opérations ont une longueur en octets.

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

Answer 3

JIT-Juste à temps le mot lui-même dit quand on en a besoin (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 assembleur tel que la structure [pour ex IL (langage intermédiaire) pour C #, ByteCode pour java].

Le code intermédiaire est converti en langage machine uniquement lorsque les besoins requis par l'application sont convertis uniquement en code machine.

Comparaison entre JIT et non-JIT:

• Dans JIT, tout le code n'est pas d'abord converti en code machine du code nécessaire sera converti en code machine alors si une méthode ou fonctionnalité appelée est pas dans la machine alors que sera transformé en code machine ... cela réduira la charge du processeur.

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

Exemples JIT:

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

Answer 4

Comme d'autres l'ont mentionné

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

Juste pour ajouter un point à la discussion ci-dessus, JVM conserve le 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 pouvant être exécuté directement par le processeur (contrairement au cas normal dans lequel javac compile le code en bytecode puis en java - l'interprète interprète ce bytecode ligne par ligne et le convertit en code machine et 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 interprété à nouveau ligne par ligne. Cela rend l'exécution plus rapide.

Answer 5

Le compilateur JIT compile uniquement le code 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 le compilateur JIT, l'interpréteur JVM convertit ligne par ligne le code octet pour lui donner l'apparence d'une application native en cours d'exécution.

Source

Answer 6

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

Cela est avantageux car le compilateur peut générer un code optimisé pour votre machine. 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.

Answer 7

Après que le code d'octet (indépendant de l'architecture) ait été généré par le compilateur Java, l'exécution sera gérée par la machine virtuelle Java (en Java). Le code d'octet sera chargé dans la machine virtuelle Java par le chargeur, puis chaque instruction d'octet est interprétée.

Lorsque nous devons appeler une méthode plusieurs fois, nous devons interpréter le même code plusieurs fois, ce qui peut prendre plus de temps que nécessaire. Nous avons donc les compilateurs JIT (juste à temps). Une fois l’octet chargé dans la machine virtuelle Java (son temps d’exécution), tout le code sera compilé et non interprété, ce qui fera gagner du temps.

Les compilateurs JIT ne fonctionnent que pendant l’exécution, nous n’avons donc aucune sortie binaire.

Answer 8

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

Par exemple, si nous avons une déclaration de boucle dans notre code Java:

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

Le code de la boucle ci-dessus est lu 10 fois si la valeur de i est 0.

Il n’est pas nécessaire de compiler le code intermédiaire 10 fois de suite, car la même instruction est exécutée 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. Donc, Just In Time (JIT) compilateur garde une trace de ces déclarations et méthodes (comme indiqué précédemment) et compile ces fragments de code octet en code machine pour de meilleures performances.

Un autre exemple similaire est la recherche d'un motif à l'aide de "Expression régulière". dans une liste de chaînes / phrases.

JIT Compiler ne compile pas tout le code en code machine. Il compile du code qui a un motif similaire au moment de l’exécution.

Voir cette documentation Oracle sur Understand JIT pour en savoir plus.

Answer 9

Vous avez un 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. Le compilateur JIT compile donc votre IL en code natif à la volée. Cela se fait au niveau de la méthode.

Answer 10

Je sais que c’est un vieux fil de discussion, mais l’optimisation de l’exécution est un autre élément important de la compilation JIT qui ne semble pas avoir été discuté ici. Fondamentalement, le compilateur JIT peut surveiller le programme pendant son exécution afin de déterminer les moyens d’améliorer l’exécution. Ensuite, il peut effectuer ces modifications à la volée - pendant l'exécution. Optimisation Google JIT (javaworld a un joli bon article à ce sujet. )

Answer 11

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

L'utilisation du compilateur juste-à-temps java (en réalité un deuxième compilateur) sur la plate-forme du système particulier convertit le bytecode en code système particulier. ordinateur.

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

Answer 12

Un compilateur juste-à-temps (JIT) est un logiciel qui 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 en est que, pour une certaine architecture de CPU, le compilateur JIT approprié doit être installé.

Compilateur de différence, 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 : récupère le code source et renvoie un fichier exécutable
2. Interprète : exécute l'instruction par programme. 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. Toutefois, un JIT est généralement une combinaison d'un complicateur et d'un interprète. Le JIT convertit d’abord les données intermédiaires (par exemple, le bytecode Java) qu’il reçoit en langage machine via interprétation. Un JIT peut souvent détecter quand une certaine partie du code est souvent exécutée et le compilera pour une exécution plus rapide.

Answer 13

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 du code octet indépendant de la machine généré lors de la compilation et le transforme en code octet spécifique à la machine lors de l'exécution. Le compilateur JIT utilisé par Java permet à un seul binaire de s’exécuter sur une multitude de plates-formes sans modification.

Answer 14

La

compilation JIT (Just-In-Time), (également traduction dynamique ou compilation au moment de l'exécution), est un moyen d'exécuter du code informatique qui implique une compilation lors de 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 classiques de la conversion en code machine: la compilation anticipée (AOT) et une interprétation - et combine certains avantages et inconvénients des deux. La compilation JIT associe la vitesse du code compilé à la souplesse d’interprétation .

Considérons JIT utilisé dans la 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 l’exécution de l’application Java et génèrent des instructions machine natives très performantes ciblées pour l’architecture système sous-jacente.

Lorsqu'une méthode est choisie pour la compilation, la machine virtuelle Java envoie son bytecode au compilateur Just-In-Time (JIT). Le JIT doit comprendre la sémantique et la syntaxe du bytecode avant de pouvoir compiler la méthode correctement. Pour aider le compilateur JIT à analyser la méthode, ses codes octets sont d’abord reformulés dans une représentation interne appelée arborescences, qui ressemble davantage au code machine au code octet. Des analyses et des optimisations sont ensuite effectuées sur les arbres de la méthode. À la fin, les arbres sont traduits en code natif.

  

Une arborescence de trace est une structure de données utilisée dans la compilation au moment de l'exécution du code de programmation. Les arborescences de trace sont utilisées dans un type de 'compilateur juste à temps' qui trace le code exécuté pendant les hotspots et le compile. Consultez this .

Référez-vous:

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

Answer 15

20% du code octet est utilisé 80% du temps. Le compilateur JIT obtient ces statistiques et optimise l’exécution plus rapide de 20% du code octet en ajoutant des méthodes inline, 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

Answer 16

JIT fait référence au moteur d’exécution dans quelques implémentations de machine virtuelle Java, qui est plus rapide mais nécessite plus de mémoire. Il s’agit d’un compilateur juste à temps. Dans ce schéma, les codes bytec d'une méthode sont compilés en code machine natif lors du premier appel de la méthode. Le code machine natif de la méthode est ensuite mis en cache afin qu’il puisse être réutilisé lors de la prochaine invocation de cette même méthode.

Answer 17

La machine virtuelle Java exécute des étapes de compilation pendant l'exécution pour des raisons de performances. Cela signifie que Java n'a pas de séparation nette entre compilation et exécution. Il effectue d’abord une compilation dite statique du code source Java en bytecode. Ensuite, ce bytecode est transmis à la machine virtuelle Java pour exécution. Mais l’exécution du bytecode étant lente, la machine virtuelle Java mesure la fréquence d’exécution du bytecode et le moment où elle détecte un "hotspot". de code très fréquemment exécuté, il effectue une compilation dynamique du code intermédiaire en code machinecode du "hotspot". code (profileur de hotspot). Donc, efficacement, les programmes Java sont aujourd'hui exécutés par l'exécution de machinecode.