Compilation plus rapide de Rust grâce à un frontend parallèle dans la version nightly

Compilation plus rapide avec le frontend parallèle du compilateur Rust

• Le frontend du compilateur Rust peut désormais réduire fortement le temps de compilation en utilisant une exécution parallèle.
• Le frontend parallèle est une fonctionnalité expérimentale, que l’on peut essayer avec le compilateur nightly via l’option -Z threads=8.
• Sa sortie dans le compilateur stable est prévue pour 2024.

Temps de compilation et parallélisme

• Le temps de compilation de Rust reste un sujet d’attention constant, et le groupe de travail sur les performances du compilateur améliore régulièrement ses performances depuis plusieurs années.
• Au cours des 10 premiers mois de 2023, le temps de compilation a diminué en moyenne de 13 %, l’utilisation mémoire de 15 % et la taille des binaires de 7 %.
• Le compilateur étant déjà fortement optimisé, il est devenu plus difficile de trouver de nouvelles améliorations, et le parallélisme reste un levier important mais complexe.

Parallélisme existant entre processus

• Lors de la compilation d’un programme Rust, Cargo exécute plusieurs processus rustc en parallèle pour compiler plusieurs crates.
• Cette exécution parallèle fonctionne bien lorsque les dépendances entre crates sont faibles, mais elle diminue à mesure que ces dépendances augmentent.

Parallélisme existant à l’intérieur d’un processus : le backend

• Le compilateur est divisé en frontend et backend, et le backend est chargé de la génération de code, que LLVM traite en parallèle.
• Le frontend effectue le parsing, le type checking, etc., mais jusqu’à cette semaine, il ne pouvait pas utiliser l’exécution parallèle.

Nouveau parallélisme à l’intérieur d’un processus : le frontend

• Le frontend peut désormais effectuer les tâches de compilation avec un parallélisme fin grâce à Rayon.
• Lorsque le frontend parallèle est activé et configuré pour utiliser 8 threads, on peut constater une nette réduction du temps d’exécution du frontend.

L’assemblage global

• La compilation Rust bénéficie depuis longtemps du parallélisme entre processus via Cargo et du parallélisme dans le backend au sein d’un processus, et elle peut désormais aussi profiter du parallélisme dans le frontend.
• Le compilateur utilise le protocole jobserver pour limiter le nombre de threads créés afin de ne pas dépasser le nombre de cœurs disponibles.

Mode d’emploi

• Le compilateur nightly est publié avec le frontend parallèle activé, mais il s’exécute par défaut en mode mono-thread.
• Les utilisateurs peuvent passer en mode multithread via l’option -Z threads.

Impact sur les performances

• En mode mono-thread, l’exécution du frontend parallèle peut rendre la compilation de 0 % à 2 % plus lente que l’existant.
• En mode multithread, le temps de compilation peut être réduit jusqu’à 50 %, mais l’effet varie selon les caractéristiques du code et la configuration du build.

Exactitude

• En mode mono-thread, la fiabilité devrait être élevée.
• En mode multithread, il peut subsister des bugs connus et des deadlocks, et les binaires produits par le compilateur doivent rester identiques quel que soit le frontend utilisé.

Retours

• En cas de problème avec le frontend parallèle, il est possible de consulter les issues portant le label "WG-compiler-parallel" et d’en soumettre de nouvelles.

Travaux à venir

• Des travaux sont en cours pour améliorer les performances du frontend parallèle et corriger les bugs du mode multithread.
• Il est prévu de stabiliser l’option -Z threads afin que, dans une release stable en 2024, le mode multithread soit utilisé par défaut.

L’avis de GN⁺

Le point le plus important de cet article est que le frontend du compilateur Rust prend désormais en charge l’exécution parallèle, ce qui peut réduire fortement le temps de compilation. Cela apporte aux développeurs Rust un avantage majeur en matière de vitesse de compilation et contribue à un environnement de développement plus efficace. L’introduction du frontend parallèle est une nouvelle enthousiasmante pour la communauté Rust, et peut être vue comme le résultat d’efforts continus d’amélioration des performances.

[GN⁺]

Avis Hacker News

• Attentes positives concernant l’amélioration de la vitesse de compilation de Rust
  • La lenteur de compilation de Rust est souvent pointée comme un inconvénient, en particulier lors du travail sur de grands dépôts, car elle augmente les coûts de CI/CD et ralentit le temps de développement. Le problème est particulièrement sensible lorsqu’il faut vider le cache (ce qui arrive parfois à cause de bugs Docker). Réaction positive face à ces avancées.
• Expérience personnelle sur la vitesse de compilation de Rust
  • Lors d’une ancienne utilisation de Rust, la compilation était lente, mais en l’utilisant à nouveau récemment, le temps de compilation est devenu presque imperceptible. Toutefois, à mesure que le projet grandit, des ralentissements se font parfois sentir, ce qui rend ces améliorations personnellement très bienvenues.
• Question sur le processus de compilation de Rust
  • Question sur le fait de savoir si le frontend de Rust doit terminer la vérification d’emprunt avant que le backend puisse commencer son travail. L’idée est avancée que, si le backend rencontre des erreurs de borrow checking, il pourrait peut-être simplement abandonner un travail spéculatif.
• Observation sur la compilation des binary crates Rust
  • Contrairement aux library crates, les binary crates ont tendance à être volumineuses et monolithiques par défaut, si bien que leur compilation se parallélise mal et que la plus grosse crate finit souvent par être traitée de façon sérielle. Les améliorations sur ce point sont bien accueillies.
• Question sur l’utilisation des cœurs CPU
  • Question sur la possibilité d’utiliser automatiquement tous les cœurs CPU lors de la compilation, ou s’il faut définir une valeur fixe dans un fichier de configuration également utilisé sur d’autres machines.
• Avertissement sur les bugs du mode multithread
  • Il existe des bugs connus et des deadlocks en mode multithread, et si la compilation se bloque, il est possible que l’un de ces problèmes soit en cause. Attitude prudente vis-à-vis de l’option -Z threads.
• Évaluation positive de l’état actuel de la vitesse de compilation de Rust
  • Après ne pas avoir utilisé Rust pendant quelques années, le fait de le reprendre récemment donne l’impression d’une compilation presque instantanée. Grâce à des outils comme ChatGPT, des problèmes Rust auparavant difficiles à résoudre deviennent faciles à traiter, et l’état actuel est jugé très satisfaisant.
• Interrogation sur l’orientation de l’optimisation de la compilation Rust
  • La compilation Rust étant déjà fortement parallélisée au niveau des fichiers, une inquiétude est exprimée sur le fait qu’accélérer la compilation d’un fichier unique puisse détourner des ressources de la parallélisation entre fichiers à un niveau supérieur. Le manque de données concrètes à ce sujet est signalé comme un problème.
• Commentaire saluant l’amélioration de la vitesse de compilation de Rust