Introduction à l'énergie dans l'informatique

Les ordinateurs deviennent de plus en plus puissants et effectuent des calculs de plus en plus rapidement. Toutefois, cette puissance de calcul a un coût. En effet, l'augmentation de la puissance de calcul des machines s'accompagne d'une consommation accrue d'énergie électrique pour délivrer cette puissance. Pour les périphériques mobiles, les utilisateurs le ressentent directement étant donné l'impact sur l'autonomie. Mais ce n'est pas le seul domaine où la problématique de l'énergie est devenue cruciale. En effet, les superordinateurs sont composés de plusieurs milliers de nœuds de calcul (ou processeurs) et consomment tellement d'énergie électrique, qu'il ne sera bientôt plus possible de les alimenter correctement. Par exemple, le Tianhe-2, le superordinateur le plus puissant en 2013 a une consommation de 17 MW équivalant à la consommation d'environ 21 000 habitants français. Afin de continuer à produire des superordinateurs plus puissants, il devient donc essentiel de réduire leur consommation électrique.

Deux métriques sont couramment utilisées pour qualifier la performance énergétique des programmes. La première est la puissance, la seconde : l'énergie. Ces deux métriques représentent deux choses distinctes, mais liées. La notion la plus simple à comprendre est l'énergie. Elle correspond grossièrement à la quantité d'énergie à fournir à l'ordinateur pour qu'il puisse réaliser le calcul qu'on lui demande. Plus le calcul sera long et complexe, plus la quantité d'énergie nécessaire pour réaliser ce calcul est importante. La puissance peut être vue comme une consommation énergétique instantanée. Celle-ci ne dépend pas de la quantité (ou longueur) du calcul. Pour bien comprendre, on peut considérer une analogie avec un trajet en voiture. Notre voiture consomme une certaine quantité d'essence, c'est-à-dire d'énergie. Plus nous roulons vite et plus nous roulons longtemps, plus il faudra d'essence. Dans cette analogie, la puissance est équivalente à la consommation instantanée. Cette consommation instantanée ne dépend pas de la durée du parcours, mais plutôt de notre vitesse : plus on roule vite, plus la consommation instantanée sera importante. La consommation instantanée est liée à la quantité d'essence : la quantité d'essence consommée correspond à la consommation moyenne sur le trajet multipliée par le temps de parcours. De la même façon, puissance et énergie sont liées : l'énergie est égale à la puissance moyenne multipliée par le temps, ou plus exactement à l'intégrale de la puissance par le temps.

On exprime souvent la puissance en watts (W) et l'énergie en joules (J) ou kilowatt-heure (kWh). Un joule correspond à un watt-seconde, c'est-à-dire à la consommation d'un watt pendant une seconde. Le kilowatt-heure correspond, comme son nom l'indique, à la consommation de mille watts pendant une heure. On a donc l'équivalence suivante : 1 kWh = 3 600 000 J.

Mathématiquement, on exprime l'énergie en utilisant la formule suivante (on utilise couramment « e » pour noter l'énergie et « P » pour la puissance) :

On peut voir sur le schéma la puissance consommée par l'exécution d'un programme. Lorsque le programme n'est pas encore démarré ou après qu'il a fini, la puissance consommée est relativement faible. On appelle P-idle cette puissance. Elle correspond à la puissance nécessaire pour maintenir l'ordinateur allumé. Lorsque le programme s'exécute, on voit sur le schéma que la puissance consommée est plus importante. En effet, l'ordinateur a besoin de plus d'électricité pour pouvoir faire les calculs demandés. On appelle P-avg la puissance moyenne nécessaire à l'exécution du programme.

Nous n'avons pas encore parlé de l'énergie nécessaire à l'exécution du programme. En réalité l'énergie nécessaire à l'exécution du programme est égale à l'intégrale de P-avg sur le temps d'exécution du programme, c'est-à-dire ici P-avg multipliée par le temps d'exécution.

Une fois ces notions maîtrisées, on peut envisager réduire cette énergie. Différentes techniques sont présentées par la suite pour réduire la consommation énergétique.

Avant de considérer les optimisations énergétiques, il est important de savoir comment mesurer la consommation d'un ordinateur ou d'un processeur. Pour mesurer l'énergie à l'échelle d'un ordinateur, il faut généralement brancher un wattmètre à l'ordinateur. Il s'agit d'un outil de mesure qui sert justement à mesurer la puissance consommée. Cette solution est précise, car elle permet de savoir combien consomme un ordinateur complet, mais elle est également chère et complexe.

Lorsque cela est suffisant, il est aussi possible de mesurer l'énergie consommée par le processeur grâce à des sondes d'énergie introduites récemment sur les processeurs Intel (à partir de la génération SandyBridge). Donc si vous possédez un tel processeur, vous pourrez facilement surveiller l'énergie et la puissance consommées par votre processeur.

I-C-1. Model-Specific Register▲

Les « Model-Specific Register » (MSR) (page de manuel des MSR) sont des registres spécifiques notamment utilisés dans le débogage et l'analyse des applications. Depuis la génération SandyBridge, les processeurs Intel possèdent des registres particuliers (technologie RAPL), qui contiennent la puissance consommée par le processeur.

Sous Linux, ces registres sont disponibles via /dev/cpu/N/msr où N est le numéro du cœur à observer.

Il est souvent nécessaire de lire la documentation des constructeurs de CPU afin de connaître les registres exacts à utiliser.

L'exemple ci-dessousExemple propose un code C simple permettant de lire les informations sur l'énergie.

I-C-2. Intel Energy Checker SDK▲

Plusieurs solutions existent pour réduire e-idle. En effet, comme cette consommation énergétique a lieu par le simple fait que la machine soit allumée (sans travailler), il est théoriquement possible de l'arrêter tant qu'elle n'est pas utilisée pour du calcul.

I-D-1. S-states▲

I-D-2. C-states▲

La réduction de e-avg est généralement plus difficile à obtenir que celle de e-idle. En effet, cette fois, la réduction de la consommation énergétique doit se faire alors qu'un programme est en cours d'exécution. Étant donné que l'énergie est égale à la puissance fois le temps d'exécution, nous avons deux possibilités : réduire le temps d'exécution ou réduire la puissance consommée. Il faut par contre être très prudent et s'assurer que par exemple une diminution de la puissance ne provoque pas une augmentation trop importante du temps d'exécution.

I-E-1. Réduction du temps d'exécution▲

I-E-2. Réduction de la puissance▲

Les programmes sont tous différents et chaque programme peut réagir différemment à un changement de fréquence. Cependant, on distingue généralement deux comportements extrêmes : les programmes intensifs en calculs (CPU bound) et, à l'opposé, ceux avec beaucoup d'accès mémoire (memory bound). Selon la quantité de calculs (et d'accès mémoire), un programme peut donc être plus ou moins CPU bound (et inversement, plus ou moins memory bound).

II-A-1. CPU Bound▲

II-A-2. Memory Bound▲

II-A-3. Exemple▲

II-B-1. Outils manuels▲

II-B-2. Outils automatiques▲

Le « Dynamic Concurrency Throttling » (DCT) est une technique d'économie d'énergie basée sur le nombre de cœurs à utiliser pour chaque région parallèle. En effet, l'exécution d'un calcul en parallèle réduit le temps de calcul, mais le gain n'est pas linéaire par rapport au nombre de cœurs utilisés. Chaque cœur supplémentaire consommera un supplément d'énergie. Lorsque l'accélération devient trop faible, il peut être intéressant d'utiliser moins de cœurs afin de limiter la consommation énergétique.

Les problèmes d'énergie touchent aussi les fermes de serveur, en particulier pour les sites web. Les sites web sont souvent hébergés dans des machines virtuelles permettant de faire fonctionner plusieurs machines virtuelles sur une machine physique. La consolidation de serveur consiste à optimiser le placement des machines virtuelles afin d'utiliser au maximum les machines physiques (efficacité augmentée) et aussi d'utiliser moins de machines physiques (extinction des machines non utilisées).

Ce programme initial utilise OpenMP pour incrémenter un compteur en parallèle. Voici le code :

#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include <omp.h>

#include "probe_time.h"
#include "probe_msr.h"

#define COUNTER 50000000

int main(int argc, char** argv)
{
   int msrFD = 0;
   double startPower=0;
   double endPower=0;
   long long unsigned startTime=0;
   long long unsigned endTime=0;
   
   
   msrFD = open_msr(0);
   if ( msrFD < 0 )
   {
      fprintf(stderr,"Fail to init MSR probe\n");
      return -1;
   }
   
   // Première mesure
   startTime = getTime();
   startPower = readPower(msrFD);
   
   fprintf(stdout,"Threads : %d\n",omp_get_max_threads());
   
   // Test
   {
      unsigned int n = 0;
      unsigned int i = 0;
      
      #pragma omp parallel for private(n)
      for (n = 0 ; n < COUNTER ; n++ )
      {
         #pragma omp critical
         {
            i+=sqrt(i);
         }
      }
      
      printf("Result %d\n",i);
   }
   
   // Seconde mesure
   endPower = readPower(msrFD);
   endTime = getTime();
   
   // On affiche la différence entre les deux mesures pour avoir une consommation
   printf("Energie : %f (J) | Temps : %llu (ms) | Puissance : %f (W)\n",endPower-startPower,endTime-startTime,(endPower-startPower)/((double)(endTime-startTime)/1000.0));
   
   // Nettoyage
   close(msrFD);
   
   return 0;
}

Sachant que la section parallélisée utilise une seule variable pour travailler, il est nécessaire de la protéger contre les accès concurrents grâce à #pragma omp critical.

La machine de test nous renvoie ces résultats :

Le #pragma omp critical permet de protéger la variable, mais entraîne aussi la mise en attente des threads et l'exécution du test devient séquentielle (un seul thread peut travailler à la fois). Deux optimisations sont alors possibles :

• réduire le temps d'exécution en optimisant la performance du programme ;
• réduire la puissance consommée par le programme en utilisant moins de ressources.

Pour améliorer la performance du programme, nous pouvons enlever la synchronisation des threads (et donc de la section critique), nous utiliserons une réduction pour cela. OpenMP va transformer la variable 'i' en variable locale au thread et additionnera chaque variable locale des threads à la fin de boucle. Voici le code modifié de la section parallélisée :

{
   unsigned int n = 0;
   unsigned int i = 0;
   
   #pragma omp parallel for private(n) reduction(+:i)
   for (n = 0 ; n < COUNTER ; n++ )
   {
      i++;
   }
   
   fprintf(stdout,"Result %d\n",i);
}

Maintenant, les huit threads peuvent s'exécuter en parallèle. Voici les nouveaux résultats :

L'optimisation en puissance consiste à réduire le nombre de threads utilisés. En effet, le programme contient une section critique qui empêche toute exécution parallèle ; on peut donc se contenter de moins de threads pour exécuter notre programme. En utilisant moins de threads, les cœurs inutilisés du processeur pourront alors ralentir et consommer moins d'énergie.

Le code nous permettant cela est le suivant :

{
   unsigned int n = 0;
   unsigned int i = 0;
   
   #pragma omp parallel for num_threads(nbThreads) private(n)
   for (n = 0 ; n < COUNTER ; n++ )
   {
      #pragma omp critical
      {
         i++;
      }
   }
   
   fprintf(stdout,"Result %d\n",i);
}

Le nombre de threads à utiliser est passé en argument par la variable nbThreads. Voici les résultats du test :

Voici la table récapitulative des résultats de nos trois benches :

On peut constater que nos efforts ont été utiles : dans les deux approches, nous avons pu diminuer la consommation énergétique de notre programme. Cependant, la version dans laquelle nous avons réduit le nombre de threads s'exécute trop lentement pour pouvoir battre la version parallèle. On consomme effectivement moins de puissance, mais pendant beaucoup plus longtemps qu'avec la version parallèle. La meilleure solution pour ce programme est donc clairement la parallélisation. C'est d'ailleurs généralement le cas si le programme peut se paralléliser facilement, mais ce n'est pas toujours facile de paralléliser correctement son programme.

Vous pouvez récupérer les programmes utilisés pour cette expérimentation dans cette archive.