• Langue : Anglais
• Discipline : Informatique et applications
• Identifiant : 2025ULILB032
• Type de thèse : Doctorat
• Date de soutenance : 28/11/2025

Résumé en langue originale

Les machines virtuelles (VM) combinent des interprètes et des compilateurs à la volée (JIT) pour obtenir de bonnes performances.Cependant, maintenir plusieurs moteurs d'exécution augmente considérablement les coûts de développement et de maintenance.Alors que des travaux antérieurs se sont intéressés à la génération automatique de compilateurs JIT optimisants, la question de savoir si la métacompilation peut être appliquée efficacement aux compilateurs JIT de base, qui privilégient une compilation rapide et un temps de préchauffage réduit, restait ouverte.Dans cette thèse, nous présentons textbf{Druid, un métacompilateur source-à-source avant d'exécution qui génère un compilateur JIT de base} directement à partir des définitions de l'interpréteur.Les développeurs du langage guident le processus de métacompilation à l'aide d'annotations et d'intrinsèques, pendant que Druid cible une infrastructure JIT existante afin de réutiliser des optimisations et des composants d'exécution éprouvés, offrant ainsi des performances de préchauffage compétitives.Nous avons appliqué Druid à la machine virtuelle Pharo utilisée en production, et évalué les performances du compilateur JIT généré automatiquement.Le JIT de base obtenu est xTimes{1.8} plus rapide que l'interpréteur et atteint {70%} des performances d'un compilateur JIT écrit manuellement et amélioré depuis plus de dix ans.Cela n'a nécessité que 60 modifications ponctuelles dans l'interpréteur, démontrant que Druid réduit considérablement l'effort d'ingénierie requis pour maintenir et faire évoluer les VM de langage.Les compilateurs JIT de base doivent compiler rapidement tout en appliquant des optimisations essentielles.Une stratégie couramment utilisée est l'interprétation abstraite à la compilation, qui réalise en un seul passage l'allocation de registres, la propagation de constantes et l'ordonnancement des instructions.Cependant, il est difficile d'isoler et de quantifier les bénéfices de cette technique en comparant des compilateurs développés indépendamment.Avec Druid, nous avons généré automatiquement plusieurs variantes du compilateur JIT de Pharo afin d'évaluer expérimentalement l'impact de l'interprétation abstraite dans des conditions contrôlées.Nous utilisons la métacompilation pour: (a) réduire l'effort d'expérimentation et (b) produire des variantes de compilateurs comparables, réduisant le bruit lié aux différences implémentations.Nos résultats montrent que l'interprétation abstraite réduit la taille du code machine de {12%} et améliore la vitesse d'exécution de {10%} en moyenne (jusqu'à {30%}), sans augmentation mesurable du temps de compilation JIT par rapport à une approche de traduction directe.

Résumé traduit

Virtual Machines (VMs) combine interpreters and just-in-time (JIT) compilers to achieve good performance.However, maintaining multiple execution engines significantly increases development and maintenance costs.While prior work has explored automatically generating optimizing JIT compilers, the question of whether metacompilation can be applied effectively to baseline JIT compilers, which favor fast compilation and short warmup times, has remained open.In this thesis, we present extbf{Druid, a source-to-source ahead-of-time metacompiler that generates a baseline JIT compiler} directly from interpreter definitions.Language developers guide the meta-compilation process through annotations and intrinsics, while Druid targets an existing JIT backend to reuse mature optimizations and runtime infrastructure, delivering competitive warmup performance.We applied Druid to the production Pharo VM and evaluated the performance of the automatically generated JIT compiler.The resulting JIT frontend runs, on average, 2x faster than the interpreter and achieves 70% of the performance of a handwritten JIT compiler that has been refined for over a decade.This required changes at only 60 call sites in the interpreter, demonstrating that Druid greatly reduces the engineering effort needed to maintain and evolve language VMs.Baseline JIT compilers must compile quickly while still applying essential optimizations.A widely used strategy is compile-time abstract interpretation, which performs register allocation, constant propagation, and instruction scheduling in a single pass.However, isolating and quantifying the benefits of this technique is difficult when comparing different, independently engineered compilers.Using Druid, we automatically generated several variants of the Pharo JIT compiler to experimentally evaluate the impact of compile-time abstract interpretation under controlled conditions.We use metacompilation as a means to (a) reduce the experimentation effort and (b) to produce compiler variants that are comparable, reducing implementation noise.Our results show that abstract interpretation reduces machine code size by 12% and improves execution speed by 10% on average (up to 30%), with no measurable increase in JIT compilation time compared to a direct translation approach.