Comparer les temps de compilation de Rust et de C++

Je suis tombé sur un article intéressant ailleurs et je vous le partage.

Rust et C++ sont souvent comparés sur de nombreux aspects. Cependant, il était difficile de comparer directement leurs temps de compilation, car il est rare qu’un même projet soit écrit dans les deux langages. Le projet quick-lint-js, écrit en C++, a réécrit une partie du code en Rust afin de comparer les temps de compilation. À noter toutefois que Windows a été exclu de l’environnement de compilation.

Critères du portage

• Hors bibliothèques tierces
• Travail effectué sur Linux et macOS
• Suite de tests très étendue
• FFI, pointeurs, conteneurs standard et maison, classes et fonctions utilitaires, E/S, concurrence, génériques, macros, SIMD, héritage, ...

Conclusion

• Le temps de compilation de Rust est comparable à celui de C++, ou plus lent (du moins sur ce projet)
• Rust demande d’écrire davantage de code que C++
• Sur un build complet (Full), C++ est comparable ou plus rapide
• Sur les builds incrémentaux (Incremental), cela peut être parfois plus court, parfois plus long (et dans certains cas beaucoup plus long)
• Il a été décidé de ne pas porter le reste de quick-lint-js vers Rust (à moins qu’un gain sur le temps de build ne change la donne ?)

[freedomzero]

Il y a visiblement pas mal de gens qui utilisent Rust aussi en Corée. Je me demande dans quels secteurs vous travaillez tous.

[cr543l]

Après la première compilation, en C++, si l’on modifie des fichiers .cpp isolés plutôt que des .h avec beaucoup de dépendances, la compilation est très rapide ; je me demande comment cela se passe avec Rust.

[ssssss]

Il semble que le sujet soit expliqué en détail dans la FAQ de la documentation Rust, alors je le partage ici.

====================================
La compilation de Rust semble lente. Pourquoi ?

Parce qu’il traduit le code en langage machine et effectue des optimisations. Rust fournit des abstractions de haut niveau qui se compilent en code machine efficace, et ce processus de traduction prend naturellement du temps, surtout lorsqu’on active les optimisations.

Cela dit, les temps de compilation de Rust ne sont pas aussi mauvais qu’on pourrait le penser, et il y a de bonnes raisons de croire qu’ils continueront à s’améliorer. Si l’on compare des projets de taille similaire en C++ et en Rust, le temps nécessaire pour compiler l’ensemble du projet est généralement comparable. La principale raison pour laquelle la compilation de Rust paraît lente est que C++ et Rust ont des modèles de compilation différents : en C++, l’unité de compilation est un fichier, tandis qu’en Rust il s’agit d’une crate composée de plusieurs fichiers. Par conséquent, si l’on modifie un seul fichier C++ pendant le développement, le temps de recompilation peut être bien plus court qu’en Rust. Un important travail de refactorisation du compilateur Rust est actuellement en cours afin de permettre la compilation incrémentale ; une fois ce chantier terminé, les temps de compilation de Rust devraient s’améliorer eux aussi, à l’image du modèle de C++.

Indépendamment du modèle de compilation, la conception du langage Rust comporte plusieurs éléments qui influencent les temps de compilation.

D’abord, Rust possède un système de types relativement complexe, et il faut consacrer un temps de compilation non négligeable à faire respecter les contraintes qui garantissent sa sûreté à l’exécution.

Ensuite, le compilateur Rust traîne une dette technique ancienne, en particulier parce que la qualité de l’LLVM IR généré n’est pas très bonne, ce qui oblige LLVM à passer du temps à le « corriger ». À l’avenir, les phases d’optimisation et de traduction basées sur MIR pourraient réduire la charge que le compilateur Rust fait peser sur LLVM.

Troisièmement, le fait que Rust utilise LLVM pour la génération de code est une arme à double tranchant. Grâce à LLVM, Rust affiche des performances d’exécution de tout premier plan, mais LLVM est un framework massif qui n’a pas été conçu en priorité pour les temps de compilation, et il est particulièrement vulnérable à des entrées de mauvaise qualité.

Enfin, la stratégie de Rust consistant à monomorphiser les types génériques, de façon similaire à C++, produit du code rapide, mais a pour inconvénient de devoir générer beaucoup plus de code que d’autres stratégies de traduction. Cette inflation du code peut être échangée contre les avantages et inconvénients du dynamic dispatch en utilisant des objets de trait.

[bus710]

Ce qui est sûr, c'est que les projets Rust consomment énormément d'espace disque pendant le build. Je me souviens avoir été surpris de voir qu'un projet utilisant une bonne centaine de bibliothèques occupait déjà environ 2 Go...