Quelles sont les différences entre un compilateur Just-in-Time et un interprète?
Quelles sont les différences entre un compilateur Just-in-Time et un interprète, et existe-t-il des différences entre les compilateurs .NET et Java JIT?
Compilation juste-à-temps correspond à la conversion de code non natif, par exemple un bytecode, en code natif juste avant son exécution.
De Wikipedia:
JIT s'appuie sur deux idées antérieures dans les environnements d'exécution: la compilation par code intermédiaire et la compilation dynamique. Il convertit le code au moment de l'exécution avant de l'exécuter en mode natif, par exemple le bytecode en code machine natif.
Un interprète exécute un programme. Il peut ou non avoir une gigue.
Encore une fois, de Wikipedia:
Un interprète peut être un programme qui Soit
- exécute directement le code source
- traduit le code source en une représentation intermédiaire efficace (code) et l'exécute immédiatement
- exécute explicitement le code précompilé stocké créé par un compilateur qui fait partie du système d'interpréteur
Les distributions standard Java et .NET ont toutes deux une compilation JIT, mais les normes ne l’imposent pas. Les compilateurs JIT dans .NET et C # sont bien sûr différents car le bytecode intermédiaire est différent. Le principe est le même si.
J'ai toujours trouvé qu'une explication plus abstraite pouvait parfois aider. Disons que vous essayez de demander à tout le monde au Mexique: "Bonjour. Comment allez-vous?" (votre langue source ) Bien sûr, vous devrez d’abord le traduire en espagnol (la langue maternelle du pays). Cette traduction serait "Hola. Como estas?"
Si vous connaissez l’espagnol, vous n’auriez pas besoin de traduire ( code natif/assembleur ). Vous venez de demander "Hola. Como estas?"
Si vous ne connaissez pas l'espagnol, il existe 3 façons de le gérer.
La première consiste à obtenir un dictionnaire espagnol (a compiler ) et à rechercher les mots espagnols avant de partir. Peut-être que vous réalisez que "Hola. Que tal?" est une syllabe plus courte ( optimisation du compilateur ) et l’utilise à la place. Ceci est compilation de langue ; vous convertissez au préalable les informations dans la langue maternelle.
La seconde est l'endroit où vous recherchez les mots dans le dictionnaire espagnol alors que vous vous tenez devant la première personne, puis stockez le résultat (recherchez les mots juste à temps ). L'avantage ici est que vous pouvez obtenir un dictionnaire mandarin puis faire la même expérience en Chine sans devoir conserver dix notes autocollantes ( binaires pour différentes plateformes ) de phrases traduites.
La troisième est l'endroit où vous recherchez les mots lorsque vous vous tenez devant chaque personne. En substance, vous interprétez les mots pour chaque personne séparément (vous agissez en tant que interprète ). L'avantage ici est que tous les changements sont immédiatement répercutés sur la personne suivante (vous pouvez demander à "Bonjour. De quelle couleur est votre chien?" Sans avoir à retourner chez vous et à redémarrer - vous n'avez pas besoin de recompiler the phrases).
- Traduire à l'avance signifie que vous pouvez demander aux gens plus rapidement ( pré-compilation ); vous n'avez même pas besoin d'apporter le dictionnaire.
- Traduire quand vous voyez la première personne de chaque pays est presque aussi rapide qu’une traduction à l’avance, mais vous permet quand même de voyager dans plusieurs pays sans avoir à rentrer chez vous pour obtenir un dictionnaire, mais cela signifie que vous devez apporter plusieurs dictionnaires avec vous ( a exécution indépendante de la plate-forme ).
- Traduire à la demande est beaucoup plus lent, mais vous permet de changer les mots sans vous déplacer ( source distribuée ).
Un interprète génère et exécute des instructions de code machine à la volée pour chaque instruction, qu’elle ait été exécutée ou non.
Un JIT met en cache les instructions précédemment interprétées dans le code machine et les réutilise, en économisant ainsi du temps et des ressources sans avoir à réinterpréter les instructions déjà interprétées.
La question de savoir si un moteur d'exécution est un compilateur ou un interprète peut être résolue très simplement en considérant ce qui se passe si une routine est exécutée 1 000 fois. Si le code du moteur d’exécution doit examiner une représentation particulière du code 1 000 fois, le moteur d’exécution est un interpréteur de cette représentation. Si le code au sein de l'exécution, le moteur d'exécution devra uniquement examiner cette représentation particulière un nombre de fois plus petit (généralement, mais pas nécessairement une fois), il s'agit d'un compilateur ou d'un traducteur de cette représentation. Notez qu'il est très courant qu'un moteur d'exécution prenne le code d'entrée et le convertisse en un autre formulaire pouvant être examiné plus facilement. Un tel moteur d’exécution combinerait un compilateur ou un traducteur de la première forme avec un interprète de la dernière.
Notez que les interprètes produisent très rarement une forme de code machine. Le seul moment où un interprète produira du code machine est le moment où une instruction est supposée effectuer une opération qui ne peut en réalité être effectuée autrement. Par exemple, si un interprète BASIC s'exécutant sur le 8080 rencontre l'instruction "OUT 100,5", il effectuera généralement cette opération en stockant D3 64 C9 (OUT 64h/RET) dans trois octets consécutifs à une adresse fixe, le chargement de A avec 5, et en appelant cette adresse. Techniquement, l’interprète génère peut-être un code machine, mais si vous exécutez la même instruction OUT 500 fois, il devra générer à nouveau le code machine à chaque fois.
tl; dr
Interpreter : ne prend qu'une instruction à la fois pour son exécution
Just-in-time : prend un bloc de code à la fois et le compile avant de l'exécuter. donc a beaucoup de place pour l'optimisation
Le compilateur JIT produit des codes machine binaires traduisant le code source du bloc. L'interprète traduit ligne par ligne.
Lorsque la classe est référencée pour la première fois, JIT Execution Engine recompile les fichiers .class (fichiers binaires primaires) générés par le compilateur Java contenant le jeu d’instructions JVM en fichiers binaires contenant le jeu d’instructions du système hôte. JIT stocke et réutilise les fichiers binaires recompilés de Memory à l'avenir, en réduisant le temps d'interprétation et les avantages de l'exécution de code natif.
D'autre part, un ancien interpréteur Java simple interprète une instruction JVM à partir d'un fichier de classe à la fois et appelle une procédure.
Trouvez une comparaison de détail ici http://bitshub.blogspot.com/2010/01/Flavors-of-JVM.html
Lorsque vous compilez un langage Microsoft.NET, le fournisseur génère un code écrit en langage MSIL (Microsoft Intermediate Language). MSIL est un ensemble d'instructions pouvant être rapidement traduit en code natif.
Une application Microsoft.NET ne peut être exécutée qu'une fois le code MSIL traduit en code machine natif. Dans .NET Framework, le langage intermédiaire est mis en conformité "juste à temps" (JIT) en code natif lorsque l'application ou le composant est exécuté au lieu de compiler l'application au moment du développement.