Le langage C ne sera-t-il jamais battu en termes de rapidité d'exécution et de faible consommation d'énergie ?

Voici les résultats d'une étude sur 27 langages de programmation les plus populaires

Programmation : une étude révèle les langages les plus voraces en énergie
Perl, Python et Ruby en tête, C, Rust et C++, les langages les plus verts

Quels sont les langages de programmation qui consomment le moins d'énergie ? C'est à cette question qu'ont voulu répondre six chercheurs de trois universités portugaises dans une étude intitulée « Energy Efficiency Across Programming Languages ». Dans leur recherche, ils étudient le temps d'exécution, l'utilisation de la mémoire, mais surtout la consommation d'énergie de 27 langages de programmation bien connus.

L’objectif principal de leurs travaux était de comprendre l’efficacité énergétique dans divers langages de programmation. Cela peut sembler une tâche simple, mais ce n’est pas aussi trivial que cela puisse paraître. En effet, pour comparer correctement l'efficacité énergétique entre différents langages, il faut obtenir des implémentations comparables de solutions à un ensemble représentatif de problèmes.

D'abord, la méthodologie

Pour obtenir un ensemble de programmes comparables, représentatifs et complets écrits dans la plupart des langages de programmation les plus populaires et les plus largement utilisés, les chercheurs ont exploré le Computer Language Benchmarks Game (CLBG). L'initiative CLBG offre un framework pour exécuter, tester et comparer des solutions cohérentes mises en œuvre pour un ensemble de problèmes de programmation bien connus et divers. Son objectif est en effet permettre à ceux qui le désirent de pouvoir comparer des solutions, au sein d'un même langage ou entre différents langages de programmation. Au moment de leur recherche, le CLBG proposait des solutions pour 13 problèmes de référence (ou benchmarks), de telle sorte que les solutions à chacun de ces problèmes respectent un algorithme donné et des directives de mise en œuvre spécifiques. Les solutions à chaque problème sont exprimées au maximum dans 28 langages de programmation différents.


Parmi les 28 langages pris en compte dans le CLBG, les chercheurs ont exclu Smalltalk, car le compilateur de ce langage est propriétaire. De plus, pour des raisons de comparabilité, ils ont écarté les problèmes qui avaient une couverture de langages inférieure à 80 %. La couverture de langages d'un problème est le pourcentage de langages de programmation (sur les 27) dans lesquels des solutions sont disponibles pour ce problème. La définition de ce critère a permis d'exclure trois problèmes de l'étude.

Pour chacun des 10 problèmes restants, les chercheurs ont ensuite retenu la version de code source la plus efficace (c’est-à-dire la plus rapide), pour les 27 langages de programmation considérés. La documentation du CLBG fournit également des informations sur la version spécifique du compilateur/runner utilisée pour chaque langage, ainsi que sur les options de compilation/exécution considérées. Les chercheurs disent avoir « strictement suivi ces instructions », qu'ils ont installé les versions correctes de compilateur et se sont également assurés que chaque solution était compilée/exécutée avec les mêmes options que celles utilisées dans le CLBG.

Ils ont aussi testé chaque solution retenue pour s'assurer qu'ils pouvaient les exécuter sans erreurs et que le résultat obtenu était celui attendu. L'étape suivante consistait à recueillir des informations sur la consommation d'énergie, le temps d'exécution et l'utilisation maximale de la mémoire pour chacune des solutions compilables et exécutables dans chaque langage.

Il est à noter que le CLBG contient déjà des informations mesurées à la fois sur le temps d'exécution et l'utilisation maximale de la mémoire. Les chercheurs ont mesuré les deux, non seulement pour vérifier la cohérence de leurs résultats par rapport à ceux du CLBG, mais également parce que des spécifications matérielles différentes produiraient des résultats différents.

Pour mesurer la consommation d'énergie, ils ont utilisé l'outil RAPL (Running Average Power Limit) d'Intel, capable de fournir des estimations d'énergie très précises, comme cela a déjà été prouvé dans certaines études. A 10 reprises, chaque solution a été exécutée et les performances associées mesurées « afin de réduire l’impact des démarrages à froid et des effets du cache, d’analyser la cohérence des mesures et d’éviter les valeurs aberrantes ». Et ils rapportent que « les résultats mesurés sont assez cohérents ». Pour plus de cohérence, tous les tests ont été réalisés sur un ordinateur de bureau exécutant Linux Ubuntu Server 16.10, avec 16 Go de RAM et un processeur Intel Core i5-4460 cadencé à 3.20 GHz.

Après toutes ces précautions prises pour avoir des résultats pertinents, que révèlent les travaux des chercheurs ?

Maintenant, les résultats de l'étude

Quels sont les meilleurs langages par critère ?

Le tableau ci-dessous présente les résultats globaux (en moyenne) pour la consommation d'énergie (Energy), le temps d'exécution (Time) et la consommation maximale de la mémoire (Mb) normalisés par rapport au langage le plus efficace pour le critère mesuré. La première colonne donne le nom des langages de programmation, précédés des lettres (c), (i) ou (v) qui indiquent respectivement que le langage est compilé, interprété ou est un langage de machine virtuelle. Pour l'énergie consommée, on lit par exemple que C a la valeur 1,00 alors que Lisp a la valeur 2,27. Cela veut d'abord dire que C est le langage qui consomme le moins d'énergie et que Lisp consomme 2,27 fois plus d'énergie que C.


Le top 5 des langages qui consomment le moins d'énergie est donc C (1,00), Rust (1,03), C++ (1,34), Ada (1,70) et Java (1,98). À l'opposé, les langages les plus voraces en énergie sont Perl (79,58), Python (75,88), Ruby (69,91), Jruby (46,54) et Lua (45,98). Je vous laisse repérer votre langage préféré...

Au niveau de la rapidité des langages, le top 5 reste inchangé : C, Rust, C++, Ada et Java. Ainsi, les langages les plus rapides sont-ils ceux qui consomment le moins d'énergie ? Les chercheurs y apportent une réponse dans leur étude, mais on peut déjà voir que ce n'est pas parfaitement le cas, bien qu'il semble y avoir une forte corrélation. Parmi les langages les plus lents, on retrouve encore Lua, Ruby, Perl et Python dans le top 5, qui se voient rejoints par TypeScript.

Pour en venir aux langages qui consomment le moins de mémoire, la palme d'or revient à Pascal (1,00), suivi par Go (1,05), C (1,17), Fortran (1,24) et C++ (1,34) pour fermer le top 5. Cette fois, Python (2,80) remonte dans la première moitié du classement, tandis que Perl (6,26) se retrouve encore dans les 5 pires langages.

Quels sont les meilleurs langages si l'on combine plusieurs critères ?

Le tableau ci-dessous présente quatre classements en combinant plusieurs objectifs : temps d'exécution et mémoire utilisée, énergie consommée et temps d'exécution, énergie consommée et mémoire utilisée, et enfin les trois critères en même temps. Pour chaque classement, chaque ligne représente un ensemble optimal de Pareto, c'est-à-dire un ensemble de langages « équivalents » du point de vue des critères combinés. L'ordre de chaque ligne représente également le rang des langages dans le classement associé.


Certaines applications nécessitent la prise en compte de deux facteurs - par exemple, la consommation d’énergie et le temps d’exécution. Dans ce cas, comme le montre le tableau ci-dessus, « le langage C est la meilleure solution, car il domine dans les deux objectifs », écrivent les chercheurs. Si vous essayez de gagner du temps en utilisant moins de mémoire, C, Pascal et Go « sont équivalents » et sont les meilleures options. Il en est de même si vous regardez les trois critères (temps d'exécution, consommation d'énergie et utilisation de la mémoire). Mais si vous voulez simplement économiser de l’énergie tout en utilisant moins de mémoire, les meilleurs choix possible sont C ou Pascal.

Les chercheurs ont également comparé les résultats des langages compilés et interprétés (avec une catégorie distincte pour les langages exécutés sur des machines virtuelles). Leur étude inclut également une comparaison des différents paradigmes de programmation : fonctionnel, impératif, orienté objet et script.

Langages compilés VS langages interprétés VS langages exécutés sur des machines virtuelles

Comme on peut le voit dans le premier tableau, l'étude montre que « les langages compilés ont tendance à être les plus rapides et les plus écoénergétiques. En moyenne, les langages compilés ont consommé 120 J pour exécuter les solutions, tandis que pour les langages de machine virtuelle et interprétés, leurs consommations moyennes étaient respectivement de 576 J et 2365 J. »

Cette tendance peut également être observée pour le temps d'exécution. « Les langages compilés ont pris en moyenne 5103 ms, les langages de machine virtuelle, 20 623 ms et les langages interprétés, 87 614 ms ». En outre, comme nous l'avons déjà fait remarquer, « les 5 principaux langages nécessitant moins d’énergie et de temps pour exécuter les solutions sont : C, Rust, C++, Ada et Java ; parmi ceux-ci, seul Java n'est pas compilé ».

Aussi, les cinq langages les plus lents sont tous interprétés : Lua, Python, Perl, Ruby et Typescript. Et les cinq langages consommant le plus d'énergie sont également des langages interprétés : Perl, Python, Ruby, JRuby et Lua. Les chercheurs précisent toutefois qu'en même temps, lorsqu'il s'agit de manipuler des chaînes avec une expression régulière, trois des cinq langages les plus économes en énergie se révèlent être des langages interprétés (TypeScript, JavaScript et PHP), « bien qu'ils aient tendance à ne pas être très efficaces en énergie dans d'autres scénarios. »

Les langages compilés ont également pris les cinq premières places du classement des langages qui utilisent le moins d’espace mémoire. « En moyenne, les langages compilés avaient besoin de 125 Mo, les langages de machine virtuelle, de 285 Mo et les interprétés, de 426 Mo », ont indiqué les chercheurs. Les langages interprétés comme JRuby, Dart, Lua et Perl occupaient quatre des cinq dernières places, ce qui signifie qu'ils utilisent en général plus d'espace mémoire.

Comparaison des paradigmes de programmation

Lorsque l'on compare les différents paradigmes, la programmation impérative est souvent la meilleure des solutions. Les langages de ce groupe ont utilisé beaucoup moins d'énergie en moyenne - et se sont exécuté beaucoup plus vite - que les langages orientés objet, fonctionnels et de script. « En moyenne, les langages impératifs ont consommé 125 J et pris 5585 ms, les langages orientés objet ont consommé 879 J et pris 32 965 ms, les langages fonctionnels ont consommé 1367 J et pris 42 740 ms et les langages de script ont consommé 2320 J et pris 88 322 ms », indiquent les chercheurs. « Pour l'utilisation de la mémoire, les langages impératifs avaient besoin de 116 Mo, 249 Mo pour les langages orientés objet, 251 Mo pour les langages fonctionnels et enfin, 421 Mo pour les langages de script. »

Les langages les plus rapides sont-ils les plus verts ?

Les chercheurs ont examiné de près l’hypothèse...