Red Hat développe le compilateur MIR JIT

Chez Red Hat en développement nouveau compilateur JIT léger MIR, qui assure l'exécution du code préalablement converti en une représentation intermédiaire MIR (Medium Internal Representation, à ne pas confondre avec une autre représentation intermédiaire MIR (IR de niveau intermédiaire), utilisé dans le compilateur Rust). Le projet vise à fournir un cadre pour la mise en œuvre d'interpréteurs et de JIT rapides et compacts. Le code du projet est écrit en C et distribué par sous licence MIT.

Au stade actuel de développement, les traducteurs vers la représentation intermédiaire de MIR sont préparés pour langage C et le bitcode LLVM (Bitcode), mais à l'avenir, il est prévu d'implémenter la possibilité de générer du MIR pour WebAssembly, du bytecode Java, CIL (Langage intermédiaire commun), Rust et C++. Le projet est développé par l'un des développeurs du moteur JIT MJIT, utilisé dans Ruby. Tout d'abord, il est prévu de mettre en œuvre un JIT basé sur MIR pour CRuby и MRuby. À l'avenir, il sera également possible de porter GCC pour utiliser MIR.

Le code MIR intermédiaire peut être présenté sous forme binaire et texte (lisible). Ce code peut être exécuté dans un interpréteur et du code machine peut être généré sur cette base (x86_64, dans les plans ARM64, PPC64 et MIPS64). Il est également possible d'effectuer la conversion inverse - de MIR en CIL, bytecode Java, WebAssembly et code C.

Parmi les fonctionnalités de MIR, on distingue le typage strict, la prise en charge des modules et des fonctions, la fourniture d'un ensemble d'instructions pour la conversion de type, la comparaison, les opérations arithmétiques et logiques, le branchement, etc. Les modules, qui incluent un ensemble de fonctions converties au format MIR, peuvent être chargés sous forme de bibliothèques, et peuvent également charger du code C externe.

Le principal avantage de l'exécution de code intermédiaire en JIT au lieu de la compilation en fichiers exécutables natifs est la possibilité de générer des fichiers compacts qui peuvent être exécutés sans reconstruction sur différentes architectures matérielles (x86, ARM, PPC, MIPS). Pour les architectures non prises en charge, un mode d'interprétation est disponible, qui dans le cas de MIR est 6 à 10 fois plus lent que JIT.

Inconvénients des compilateurs JIT existants
GCC et LLVM seraient trop volumineux, auraient une faible vitesse de compilation et seraient difficiles à mettre en œuvre des optimisations combinées pour différents langages de programmation. Les développeurs de MIR ont essayé de résoudre ces problèmes
problèmes et fixer des objectifs :

• La compilation dans MIR devrait être au moins 100 fois plus rapide que dans GCC ;
• Le JIT pour l'exécution de MIR doit être très compact et inclure environ 15 XNUMX lignes de code ;
• L'exécution de MIR à l'aide de JIT ne devrait pas être plus lente de 30 % que les performances d'un exécutable compilé à partir du même code C dans GCC (avec les optimisations "-O2") ;
• Les étapes d'initialisation avant le début de l'exécution proprement dite devraient prendre 100 fois moins de temps ;
• La représentation MIR pour JIT doit être 100 fois plus petite que l'exécutable compilé dans GCC.

Dans sa forme actuelle, l'implémentation de MIR est à bien des égards en avance sur les objectifs initialement fixés : des tests ont montré que les performances de compilation dans MIR sont 2 fois plus rapides que « GCC -O178 », les performances d'exécution sont 6 % en retard sur le code natif, la taille du code est 144 fois plus petit, le JIT d'implémentation MIR comprend 16 XNUMX lignes de code.

Source: opennet.ru