Introduction de la génération de code Cranelift dans Rust

• Cranelift est un backend de génération de code sous licence Apache-2.0, développé dans le cadre du runtime Wasmtime pour WebAssembly
• En octobre 2023, le projet Rust a commencé à proposer Cranelift comme composant optionnel de la toolchain nightly
• Les utilisateurs peuvent désormais utiliser Cranelift comme backend de génération de code pour les builds de débogage de projets écrits en Rust
• Cranelift concurrence les compilateurs existants et génère du code plus rapidement grâce à une conception simplifiée qui ne privilégie que les optimisations importantes

Importance du temps de compilation

• Les utilisateurs de langages de programmation veulent des temps de compilation rapides
• Rust, comme d'autres langages utilisant LLVM, a suscité des plaintes concernant les temps de compilation
• Un compilateur qui génère du code suffisamment vite peut être avantageux par rapport à l'utilisation d'un interpréteur
• Un compilateur axé sur la vitesse de compilation peut avoir une vraie valeur

Optimisations de Cranelift

• Cranelift effectue des optimisations de plusieurs façons lors de la génération de code
• Le pipeline d'optimisation repose sur les E-graphs, une structure de données représentant efficacement des ensembles de représentations intermédiaires
• Dans les compilateurs traditionnels, l'ordre des optimisations a un impact majeur sur la qualité du code généré
• Cranelift utilise les E-graphs pour que l'ordre des optimisations n'influe pas sur le résultat
• Extraire la représentation finale d'un E-graph est un problème NP-complet, mais Cranelift utilise des heuristiques pour extraire rapidement une représentation suffisamment bonne

Cranelift pour Rust

• Le travail nécessaire pour utiliser Cranelift comme backend Rust a été considérable
• Le compilateur Rust utilise un IR de niveau intermédiaire pour représenter les programmes après vérification des types
• Pour utiliser Cranelift, il a fallu une bibliothèque capable de convertir cet IR intermédiaire en CLIF
• Cette bibliothèque a été principalement écrite par bjorn3, membre de l'équipe du compilateur Rust
• Les utilisateurs peuvent tester le backend Cranelift avec rustup et cargo

Avis de GN⁺

• L'introduction de Cranelift peut être vue comme une réponse à la demande persistante, dans la communauté Rust, de réduire les temps de compilation. Cela peut contribuer à améliorer la productivité des développeurs.
• L'approche de Cranelift, qui utilise des E-graphs pour résoudre le problème de l'ordre des optimisations, propose un nouveau paradigme dans la conception des compilateurs. Cela peut ouvrir de nouvelles directions pour la recherche et le développement dans ce domaine.
• D'un point de vue critique, il reste à vérifier, à travers davantage de cas d'usage réels, à quel point Cranelift est stable et efficace par rapport à LLVM.
• Parmi les autres backends de compilateur offrant des fonctions similaires à Cranelift, on peut citer notamment libgccjit de GCC ; la comparaison avec ces alternatives permettrait de mieux cerner les forces et les faiblesses de Cranelift.
• Les développeurs qui adoptent Cranelift doivent prendre en compte la compatibilité avec l'infrastructure existante basée sur LLVM ainsi que le coût de transition, et évaluer attentivement ses performances et sa stabilité.

[GN⁺]

Avis Hacker News

• Le backend et les optimisations peuvent être utilisés différemment selon les crates. Pour les dépendances, il est souvent pertinent d’utiliser une build LLVM optimisée, et pour son propre code, une LLVM de debug ou Cranelift.
• Un article qui offre un excellent aperçu du compromis entre vitesse d’optimisation et qualité d’optimisation. En particulier, la compilation copy-and-patch utilisant du code précompilé reste la plus rapide, mais laisse moins de marge pour l’optimisation. Cranelift permet davantage d’optimisations que l’approche copy-and-patch en utilisant des e-graphs pour représenter les équivalences dans l’IR. Le résultat le plus optimisé viendra sans doute d’outils de compilation traditionnels comme LLVM ou GCC, mais pour les utilisateurs qui veulent obtenir le plus vite possible un résultat « suffisamment rapide », les nouvelles techniques de compilation offrent une alternative prometteuse.
• Il y a beaucoup de commentaires sur les builds de debug complètes, mais je pense que la différence la plus importante concerne le temps des builds incrémentales après de petits changements. C’est cela qui accélère les itérations de développement. En comparant les temps de build après une petite modification sur les projets rust-analyzer et gleam, l’ajout de Cranelift et de mold montre une amélioration bien plus rapide. Même comparé à Terraform, construit en Go, cela met en évidence les gros progrès de Rust.
• Il n’y a actuellement pas de prise en charge des Mac M1 à M3, et il semble aussi ne pas y avoir de support Windows. La dernière mise à jour du contributeur le plus actif reste ambiguë dans sa conclusion. Le support Windows est actuellement omis, et sur macOS, seul x86_64 est pris en charge pour l’instant. Si vous utilisez un processeur M1, vous pouvez essayer d’installer la version x86_64 de rustc et d’utiliser Rosetta 2, mais Rosetta 2 peut affecter les performances, donc il faut comparer avec le backend LLVM.
• J’ai essayé les instructions de l’article sur le projet Bevy et comparé avec une build « normale ». La build release semble plus rapide que la build Cranelift+debug, mais c’est parce que j’utilise la mise en cache avec sccache et un NAS local. En refaisant le test uniquement avec une build de debug, sans cache, le temps de compilation a été réduit de presque moitié.
• Le lien vers Equality Graphs m’a fait découvrir ESC/Java. Je me demande si quelqu’un l’a vraiment essayé ou l’a utilisé avec succès. Ce serait intéressant de comparer avec Spot bugs (anciennement connu sous le nom de Findbugs).
• Je suis très enthousiaste à l’idée que les builds de debug avec Cranelift accélèrent la vitesse d’itération en développement. C’est particulièrement important pour Rust côté WASM/frontend, où la vitesse d’itération compte beaucoup, et où la nouvelle génération d’outils Rust offre parfois des builds en moins d’une seconde. ARM macOS n’est toutefois pas encore pris en charge, donc les utilisateurs de M1 à M3 devront encore attendre un peu.
• Je me demande s’il existe des benchmarks de runtime (pas de temps de compilation) avec Cranelift. L’article mentionne « deux fois plus lent », mais ces données datent de 2020. Je me demande si cela s’est nettement amélioré depuis.
• Je me demande si quelqu’un peut expliquer pourquoi on s’attend à ce que Cranelift soit plus rapide que LLVM, et pourquoi ces améliorations ne pourraient pas aussi être appliquées à LLVM.