Que fait un compilateur juste à temps (JIT)?

Au début, un compilateur était responsable 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 compilaient un langage de haut niveau en pseudo-code, qui serait ensuite interprété (par un interpréteur) pour exécuter votre programme. Cela a éliminé le code objet et les exécutables, et a permis ces langages pour être portable 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 du machine en cours d'exécution, puis invoquez ce code objet à la place. Idéalement, l'efficacité de l'exécution du code objet surmontera l'inefficacité de recompiler le programme chaque fois qu'il s'exécute.

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

Scénario Typique:

Le code source est entièrement converti en code machine

Scénario JIT:

Le code source sera converti en langage assembleur comme structure [pour ex IL (intermediate language) pour C#, ByteCode pour java].

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

Comparaison JIT vs Non-JIT:

• En JIT tout le code n'est pas converti en code machine d'abord une partie du code qui est nécessaire sera converti en code machine alors si une méthode ou une fonctionnalité appelé n'est pas dans la machine alors que sera transformé en code machine... il réduit la charge sur le CPU.

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

Exemples JIT:

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

, Comme d'autres l'ont mentionné

JIT signifie Juste à temps, 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, JVM maintient un 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 java - le l'interpréteur interprète ce bytecode ligne par ligne le convertit en code machine et l'exécute).

Aussi 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.

JIT signifie Juste à temps, 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 ce n'est pas le cas le ralentissement de l'exécution du programme pour l'utilisateur.

Une fois que le code octet (qui est neutre pour 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 la JVM 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 et cela peut prendre plus de temps que nécessaire. Nous avons donc les compilateurs JIT (just-in-time). Lorsque l'octet a été chargé dans la JVM (son exécution temps), le code entier sera compilé plutôt qu'interprété, économisant ainsi du temps.

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

Le compilateur JIT compile uniquement le code octet en code natif équivalent à 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.

Source

Compilateur Juste à Temps (JIT) :
Il compile les bytecodes java dans les instructions machine de ce processeur spécifique.

Par exemple, si nous avons une instruction loop 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 pour 10 fois encore et encore car la même instruction va s'exécuter pour 10 fois. Dans ce cas, il est nécessaire de compiler ce code une seule fois et le la valeur peut être modifiée pour le nombre requis de fois. Ainsi, le compilateur Just In Time (JIT) garde une trace de ces instructions et méthodes (comme indiqué ci-dessus) et compile de tels morceaux de code octet en code machine pour de meilleures performances.

Un autre exemple similaire , est qu'une recherche d'un modèle en 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 à l'exécution temps.

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

Vous avez du code qui est complété 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 thread, 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 apporter ces modifications à la volée - pendant l'exécution. Google JIT optimization (javaworld a un joli bon article à ce sujet.)

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

En utilisant le compilateur java just in time (vraiment un deuxième compilateur) sur la plate-forme système particulière,le bytecode est conforme au code système particulier ,une fois que le code a été re-compilé par le jit complier, il s'exécutera généralement plus rapidement dans l'ordinateur.

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

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 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 utilisé par Java permet à un seul binaire de s'exécuter sur une multitude de plates-formes sans modification.

Les exemples de code suivants montrent comment le JIT optimise le code Java.

Code Avant Optimisation

    class A {
      B b;
      public void newMethod() {
        y = b.get();
        ...do stuff...
        z = b.get();
        sum = y + z;
      }
    }

class B {
   int value;
   final int get() {
      return value;
   }
}

Code Après Optimisation

class A {
B b;
public void newMethod() {
   y = b.value;
   ...do stuff...
   sum = y + y;
}
}
class B {
   int value;
   final int get() {
      return value;
   }
}

À l'origine, le code contenait deux appels à la méthode b. get (). Après optimisation, les deux appels de méthode sont optimisés en une seule opération de copie de variable; c'est-à-dire que le code optimisé n'a pas besoin d'effectuer un appel de méthode pour acquérir la valeur de champ de classe B.

Just-in-time (JIT) compilation, (également traduction dynamique ou compilation d'exécution), est unmoyen d'exécuter du code informatique quiimplique la compilation pendant l'exécution d'un programme-au moment de l'exécution – plutôt qu'avant l'exécution .

IT compilation est une combinaison de les deux approches traditionnelles de la traduction en code machine-compilation anticipée (AOT), et interprétation{[2] – - et combine certains avantages et inconvénients de deux. La compilation JIT combine la vitesse du code compilé avec la flexibilité de l'interprétation .

Considérons JIT utilisé dans JVM,

Par exemple, les compilateurs JIT JVM HotSpot 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 de machine natives très performantes ciblées pour l'architecture système sous-jacente.

Quand une méthode est choisie pour la compilation, la JVM alimente son bytecode au compilateur juste à temps (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, son bytecode est d'abord reformulé dans une représentation interne appelée trace trees, qui ressemble plus au code machine qu'au bytecode. Des analyses et optimisations sont ensuite effectuées sur les arborescences de la méthode. À la fin, les arbres sont traduits en natif code.

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 le code en cours d'exécution pendant les points chauds et le compile. Voir ce .

Se référer à:

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

20% du code octet est utilisé 80% du temps. Le compilateur JIT obtient ces statistiques et optimise ce 20% du code octet 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 de 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, celui qui est plus rapide mais nécessite plus de mémoire,est un compilateur juste à temps. Dans ce schéma, le bytecode 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, de sorte qu'il peut être réutilisé la prochaine fois que cette même méthode est appelée.

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 compilation dite statique du code source Java au bytecode. Ensuite, ce bytecode est passé à la JVM pour exécution. Mais l'exécution du bytecode est lente, donc la JVM mesure à quelle fréquence le bytecode est exécuté et lorsqu'elle détecte un" hotspot " de code exécuté très fréquemment, elle effectue une compilation dynamique du bytecode vers machinecode du code "hotspot" (hotspot profiler). Aujourd'hui, les programmes Java sont exécutés par exécution de code machine.

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érence, interpréteur 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 utilisation:

1. Compilateur: Prend le code source et renvoie un exécutable
2. Interprète: Exécute le programme instruction 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 un combinaison d'un complicateur et d'un interprète. Le JIT transforme d'abord les données intermédiaires (par exemple le bytecode Java) qu'il reçoit en langage machine par interprétation. Un JIT peut souvent détecter quand une certaine partie du code est exécutée souvent et le compilera cette partie pour une exécution plus rapide.