Pour Python, un compilateur JIT a été proposé, utilisant la technique du copy-and-patch.

Brandt Bucher de Microsoft, membre de l'équipe des développeurs principaux de CPython et travaillant sur l'augmentation des performances de l'interpréteur CPython, a publié une implémentation d'un compilateur JIT pour Python, utilisant la technique Copy-and-Patch. La publication du JIT coïncide avec Noël et l'annonce est écrite en vers.

Le JIT proposé se distingue par sa rapidité de génération de code, sa facilité de maintenance et son intégration complète avec l'interpréteur. La méthode proposée permet de transformer automatiquement un interpréteur écrit en C en compilateur JIT, sans avoir à élaborer une logique de génération de code distincte et sans créer manuellement des représentations assembleur. Avec cette approche, la correction d'un bug dans l'interpréteur entraînera également la résolution du même problème dans le JIT, car un générateur de code commun est utilisé.

Le fonctionnement de la méthode Copy-and-Patch repose sur le fait que la relocation de code en mémoire lors du chargement par le linkeur d'objets et le remplacement des instructions machine au lieu du bytecode dans le JIT représentent des tâches similaires. Lors de l'exécution du JIT, le processus parcourt les instructions bytecode créées par l'interpréteur et copie, pour chaque instruction, un code machine préalablement compilé dans une zone mémoire avec du code exécutable, tout en modifiant à la volée les instructions pour substituer les données traitées (le JIT copie des modèles de fonctions déjà compilées et les remplace par les valeurs nécessaires telles que les arguments et les constantes). Lors du chargement des fichiers objets, le code machine est également copié en mémoire et des symboles externes sont substitués.

Dans Copy-and-Patch JIT, un fichier objet au format ELF est généré à l'aide de LLVM, contenant des données sur les instructions de bytecode et des informations nécessaires pour remplacer des données. JIT remplace les instructions de bytecode générées pendant l'interprétation du programme par des représentations en code machine, tout en substituant les données nécessaires aux calculs. La mise en œuvre de JIT nécessite LLVM comme dépendance au moment de la compilation, mais les composants au moment de l'exécution ne dépendent pas d'externalités et se composent d'environ 300 lignes de code en C écrites manuellement et de 3000 lignes de code en C générées.

Comparé à l'outillage JIT traditionnel (LLVM -O0), le JIT proposé assure une génération de code 100 fois plus rapide et un code résultant 15% plus rapide. Par rapport à la compilation en WebAssembly (Liftoff), le nouveau JIT génère du code 5 fois plus rapidement, et le code résultant fonctionne 50% plus rapidement. En comparaison avec le JIT optimisant (LuaJIT) utilisant du code assembleur écrit manuellement, la nouvelle version s'est révélée plus rapide dans 13 des 44 tests, avec un retard de performance moyen de 35%, tout en simplifiant beaucoup la maintenance et en réduisant le niveau de complexité de mise en œuvre.

Source : opennet.ru