Qu'est-ce que la compilation juste à temps (JIT) ?

La compilation Just-In-Time, ou JIT, est une technique utilisée par les interpréteurs d'exécution pour des langages comme JavaScript, C# et Java pour rapprocher les vitesses d'exécution des performances natives offertes par les langages binaires précompilés comme C+. +.

Compilateurs contre interprètes

Les ordinateurs ne savent pas exécuter des langages de programmation de haut niveau comme C++, du moins pas directement. Afin de traduire un code lisible par l'homme en quelque chose que votre processeur peut exécuter, il doit être converti. Un ordinateur le fait généralement par l'une des deux méthodes suivantes : compilation ou interprétation.

La compilation implique l'exécution d'un compilateur, un programme qui prend le code source et le convertit en code machine binaire, avant d'exécuter l'application. La compilation a lieu sur l'ordinateur du développeur avant d'être emballée et expédiée. La plupart des exécutables que vous téléchargez sont compilés à un certain niveau pour s'exécuter sur votre machine, et le code compilé est généralement assez rapide car le compilateur peut effectuer des optimisations pour votre machine particulière.

Cependant, les compilateurs ont quelques inconvénients. Les programmes doivent être compilés pour des jeux d'instructions CPU spécifiques (tels que x86-64 ou ARM). De plus, les systèmes d'exploitation qui partagent des jeux d'instructions (tels que Windows et Linux, qui fonctionnent tous deux sur des processeurs Intel) doivent également avoir des programmes compilés séparément en raison des nombreuses différences dans leur fonctionnement.

Cela signifie que pour quelque chose comme JavaScript, qui doit être envoyé sur Internet aux clients connectés, il ne peut pas être compilé au préalable, car le client peut exécuter n'importe quelle combinaison de jeu d'instructions et de système d'exploitation.

Les interprètes ont une approche différente. Un interpréteur est essentiellement un robot logiciel qui prend le code source d'un programme tel qu'un script JavaScript ou Python et gère l'exécution au moment de l'exécution. Fondamentalement, cela fonctionne comme un niveau intermédiaire entre le code source et la machine, où un compilateur le traduirait directement.

Ceci a le grand avantage de ne pas exiger que le programme soit construit pour une machine particulière ; Tant que la machine peut exécuter l'interpréteur Python, elle peut exécuter n'importe quel script Python.

Que fait la compilation JIT ?

Malheureusement pour les interprètes, ils sont lents. Un véritable interpréteur doit traduire et gérer chaque instruction, effectuant essentiellement un travail de compilation pour chaque exécution. Il s'agit d'une surcharge, donc la plupart des interpréteurs, tels que le moteur JavaScript V8, la machine virtuelle Java (JVM) et le Common Language Runtime .NET, utilisent la compilation Just-In-Time pour accélérer l'interpréteur.

La compilation juste-à-temps est essentiellement un compilateur qui reporte et compile le code de chaque fonction aussi souvent que nécessaire. Chaque fois que vous appelez une fonction, si le compilateur JIT ne l'a pas encore vue, il compilera cette fonction (en appliquant des optimisations pour la machine sur laquelle elle s'exécute) et l'exécutera. La prochaine fois que vous appelez la fonction, vous avez déjà le code machine à portée de main, il vous suffit donc de le rechercher dans le cache.

Just-In-Time fait référence au fait que l'interpréteur n'a pas à compiler l'intégralité de l'application en une seule fois. C'est certainement possible, mais pour une grande application, cela conduirait à des temps de démarrage très élevés. Il est préférable pour les performances de ne compiler que lorsque cela est nécessaire (c'est-à-dire juste à temps).

Le JIT Compilation est-il un succès en termes de performances ?

JIT est littéralement une amélioration des performances par rapport aux interprètes habituels, donc par rapport à ne pas le faire, c'est beaucoup plus rapide. Cependant, la compilation du code n'est pas particulièrement rapide, il est donc évident que la compilation au moment de l'exécution entraîne une baisse des performances par rapport à la compilation directe en bytecode au préalable.

Cependant, étant donné que la compilation JIT n'a généralement besoin d'être effectuée que la première fois qu'une fonction est appelée, les fonctions couramment utilisées ne verront un impact sur les performances qu'au premier appel. Vous pouvez le tester en C # avec StopWatch - ils détectent le 'bruit de fond' .NET, y compris le temps nécessaire pour compiler la première fois qu'une fonction est exécutée.

Le principal inconvénient des applications compilées JIT est un temps de démarrage à froid élevé, car des milliers de fonctions appelées au démarrage doivent d'abord être compilées. Certaines applications Web ASP.NET peuvent prendre plus d'une minute pour démarrer, en partie à cause du stress élevé du compilateur JIT au début.

Qu'est-ce que tu penses?