Code compact et logiciel écoénergétique

À l'époque où les microprocesseurs sur puce venaient d'être inventés, les étudiants de premier cycle en ingénierie avaient souvent un avant-goût de la véritable programmation informatique sur des machines comme le mini-ordinateur PDP-11 de DEC. En plus d'essayer d'écrire des programmes qui fonctionnaient correctement sur le PDP-11, les étudiants de l'époque devaient également rendre leur code compact. Dans ces premiers cours d'informatique, les étudiants s'attiraient les foudres de leurs professeurs lorsqu'ils rendaient des programmes comportant 20 lignes de code assembleur qui auraient pu tenir en 15 lignes. La raison de leur consternation était évidemment que la mémoire coûtait cher. Le PDP-11 ne disposait généralement que de 4096 mots (16 bits) de mémoire de lecture/écriture contenant des noyaux magnétiques de 22 mil auxquels on accédait à l'aide de fils.

Ordinateur PDP-11 de Digital Equipment Corporation (DEC). (Source de l'image : flickr)

Aujourd'hui, les cours de programmation mettent toujours l'accent sur un code compact. Mais tout porte à croire que les cours de programmation pourraient bientôt privilégier l'écriture non seulement de code compact, mais aussi de logiciels qui réduisent la consommation d'énergie.

Le rendement énergétique du code informatique était autrefois un sujet marginal. Il intéressait essentiellement les programmeurs de petits systèmes embarqués où il fallait traiter la dissipation de puissance d'un microcontrôleur pour optimiser la durée de vie de la pile bouton assurant l'alimentation. Désormais, le rendement énergétique des logiciels se généralise. Il est de plus en plus courant de voir les utilisateurs de smartphones éviter les applications qui utilisent énormément le processeur, simplement pour conserver un peu plus de batterie sur leur téléphone. Même les systèmes basés sur le cloud font attention au rendement énergétique des logiciels en raison de leur impact sur les émissions de carbone des data centers.

À première vue, on pourrait penser que le code compact est déjà écoénergétique. Il s'avère que cette règle empirique est parfois vraie, mais pas toujours. De plus, le rendement énergétique d'un programme informatique dépend généralement du langage dans lequel il est écrit. Les langages compilés sont plus écoénergétiques que les langages interprétés ou ceux qui composent les machines virtuelles. Il peut toutefois y avoir de grandes différences en termes de rendement énergétique, même entre des langages compilés qui semblent être apparentés les uns aux autres.

Des travaux réalisés par des chercheurs au Portugal (https://dl.acm.org/doi/10.1145/3136014.3136031) ont permis de mieux comprendre le lien entre l'énergie, le temps et l'utilisation de la mémoire et la programmation écoénergétique. Ils ont analysé les performances de 27 langages logiciels en matière de rendement énergétique. Pour ce faire, ils ont utilisé des compilateurs, des interpréteurs et des machines virtuelles de pointe, et ont observé ce qui se passait lorsqu'ils exécutaient 13 programmes différents pour comparer la façon dont les algorithmes couramment utilisés peuvent être mis en œuvre dans divers langages de programmation populaires.

Par exemple, un programme de référence a mesuré le temps nécessaire pour calculer l'interaction entre plusieurs particules dans un système. Un autre a affecté et désaffecté de nombreux arbres binaires. Un troisième a mis à jour une table de hachage et l'a utilisée pour compter des séquences spécifiques de nucléotides d'ADN.

Les chercheurs ont remarqué qu'il existait une fausse idée commune selon laquelle la consommation d'énergie dans les logiciels était proportionnelle au temps d'exécution : plus c'est rapide, mieux c'est. Ainsi, réduire le temps d'exécution d'un programme permettrait de limiter sa consommation d'énergie dans les mêmes proportions. Mais cette relation n'est pas forcément simple, car l'énergie dissipée est le produit de la puissance utilisée et de la durée. Ainsi, un programme plus rapide peut ne pas être plus écoénergétique s'il consomme plus d'énergie pendant son exécution.

Par conséquent, les chercheurs ont trouvé plusieurs cas où le classement de la consommation d'énergie d'un langage de programmation différait de celui de son temps d'exécution. Par exemple, dans un test de référence impliquant la génération et l'écriture de séquences d'ADN aléatoires, Fortran s'est avéré être le deuxième langage le plus écoénergétique, alors qu'il arrivait à la huitième place en termes de temps d'exécution. Et lors du calcul d'arbres binaires, la consommation d'énergie des langages Pascal et Chapel se situait dans une fourchette de 10 %, alors que Chapel prend environ 55 % de temps d'exécution en moins.

Certaines conclusions des chercheurs ne sont pas surprenantes. Un constat : le langage C est, dans l'ensemble, le plus rapide et le plus écoénergétique (57 J, 2019 ms en moyenne pour s'exécuter). Après le langage C, les quatre principaux langages nécessitant le moins d'énergie et de temps pour exécuter les tests de référence se sont avérés être Rust (59 J, 2103 ms), C++ (77 J, 3155 ms), Ada (98 J, 3740 ms) et Java (114 J, 3821 ms). Et comme on pouvait s'y attendre, les langages compilés étaient beaucoup plus écoénergétiques que les langages interprétés ou de machines virtuelles. Les programmes compilés nécessitaient en moyenne 120 J pour exécuter les solutions, tandis que les langages de machines virtuelles et les langages interprétés consommaient respectivement 5760 J et 2365 J.

Il n'est donc pas surprenant que les cinq derniers langages en matière de rendement énergétique et de temps d'exécution étaient tous des langages interprétés : Perl (4604 J), Python (4390 J), Ruby (4045 J), JRuby (2693 J) et Lua (2660 J) pour l'énergie ; Lua (16 7416 ms), Python (14 5178 ms), Perl (13 2856 ms), Ruby (119 832 ms) et TypeScript (93 292 ms) pour le temps.

Les chercheurs ont également montré où va la majeure partie de l'énergie dissipée. La consommation d'énergie basée sur le processeur représente toujours la majorité de l'énergie consommée. En moyenne, le processeur consomme près de 90 % de l'énergie, la mémoire DRAM consommant le reste, que le langage soit compilé, interprété ou virtuel.

Dans l'ensemble, les chercheurs portugais affirment qu'il est relativement facile de déterminer le meilleur langage logiciel si les développeurs ne se préoccupent que du temps d'exécution et de la consommation d'énergie. Mais le choix n'est pas automatique si l'utilisation de la mémoire est également un facteur.

Il y a donc une bonne nouvelle pour la planète : il est possible d'optimiser les logiciels pour améliorer leur rendement énergétique. Pour les étudiants qui apprennent la programmation, il y a en revanche une mauvaise nouvelle : vous pouvez désormais vous attirer les foudres de votre professeur de programmation non seulement pour avoir rendu un programme qui n'est pas suffisamment compact, mais aussi pour un programme qui n'est pas suffisamment écoénergétique.