Jeandle JDK ou pourquoi les développeurs greffent LLVM sur la machine virtuelle Java

Plonger dans les entrailles du compilateur C2 du HotSpot JVM n'est pas pour les âmes sensibles. Le code C++ de C2 a été écrit sur des décennies. Il a accumulé une tonne d'optimisations spécifiques, mais le maintenir devient plus difficile chaque année. À un moment donné, l'équipe d'ingénierie d'Oracle a essayé de se faciliter la vie avec le projet Graal, réécrivant le compilateur JIT en Java lui-même. Les développeurs du projet Jeandle ont adopté une approche différente : ils ont décidé de prendre le framework LLVM existant et d'en faire le moteur de compilation pour OpenJDK.

Qu'est-ce que Jeandle et pourquoi a-t-il besoin de LLVM

Jeandle est un compilateur JIT expérimental pour Java construit directement sur OpenJDK. Au lieu de s'appuyer sur les compilateurs intégrés C1 ou C2, il intercepte l'exécution du bytecode chaud et le transmet au générateur de code de LLVM.

Pourquoi introduire LLVM dans la machine virtuelle Java ?

Le principal avantage de LLVM est la vaste collection d'optimisations de bas niveau créées par la communauté mondiale pour C, C++ et Rust. La vectorisation automatique des instructions, l'analyse approfondie des boucles et les optimisations adaptées aux fonctionnalités spécifiques des processeurs sont déjà présentes dans LLVM et reçoivent des mises à jour régulières.

Dans C2 traditionnel, chaque nouvelle optimisation ou support d'une nouvelle architecture de processeur (comme RISC-V) doit être implémenté manuellement. En combinant OpenJDK avec LLVM, les auteurs de Jeandle visent à obtenir un puissant générateur de code machine sans réécrire les optimiseurs from scratch.

Comment ça fonctionne sous le capot

Le traitement du code dans Jeandle est divisé en plusieurs étapes :

1. La machine virtuelle suit les méthodes d'application fréquemment appelées.
2. Quand le bytecode d'une méthode est considéré comme suffisamment chaud, Jeandle le traduit en LLVM IR.
3. Les passes d'optimisation de LLVM sont appliquées au code IR résultant.
4. LLVM compile l'IR en code machine natif pour la plateforme cible (x86_64, AArch64, etc.).
5. La JVM échange la référence de méthode, et l'exécution se poursuit avec le code machine compilé.

Le dépôt du projet contient une documentation approfondie. Le répertoire guides contient des descriptions de l'architecture système, des instructions de construction et un document séparé sur la configuration du débogage.

Les développeurs ont exposé le contrôle du comportement du compilateur via des flags JVM dédiés. Ces flags permettent d'ajuster les niveaux d'optimisation et de demander des dumps de la représentation intermédiaire LLVM IR pendant l'exécution de l'application.

Le principal défi avec un JIT basé sur LLVM

L'idée d'utiliser LLVM dans les compilateurs JIT n'est pas nouvelle. Des tentatives similaires ont été faites précédemment dans le projet Shark pour OpenJDK et le projet Falcon chez Azul. Le principal obstacle sur cette voie est la vitesse de compilation elle-même.

LLVM a été conçu à l'origine pour la compilation ahead-of-time (AOT). Dans les compilateurs statiques comme Clang, le processus peut prendre des minutes — la priorité est que le binaire final s'exécute le plus rapidement possible. En mode JIT, le temps de compilation est critique. Si LLVM commence à passer beaucoup de temps et à optimiser méticuleusement chaque méthode, l'application va simplement se figer pendant la phase de warmup.

De plus, les auteurs de Jeandle font face à une tâche complexe d'intégration avec le runtime Java. Le compilateur doit gérer correctement les safepoints pour le garbage collector, travailler avec les barrières de mémoire et supporter le chargement dynamique de classes.

État actuel et perspectives d'avenir

Actuellement, Jeandle est en phase de prototypage actif. Le dépôt a accumulé environ 460 étoiles et plus de 60 issues ouvertes. Le code n'est pas encore prêt pour une utilisation en production, et les auteurs ne le cachent pas.

Néanmoins, le projet intéressera plusieurs catégories d'ingénieurs :

• Ceux qui étudient les rouages internes du JVM et veulent comprendre comment le JIT fonctionne avec un exemple concret.
• Les développeurs de compilateurs à la recherche de cas d'utilisation pratiques d'intégration de LLVM IR.
• Les chercheurs créant des profils d'optimisation personnalisés pour des architectures de processeurs spécifiques.

Le code source est open source sous licence GPL v2.0. Si vous voulez comprendre comment combiner une machine virtuelle Java avec un compilateur natif, consultez la documentation du projet — elle couvre le processus de construction et les décisions architecturales en détail.