2.7  Optimisations du compilateur 2/5

• Substitutions d’appels de fonctions
  • exemple de programme :

    #include <stdio.h>
    int addition(int x,int y){ return x+y; }
    int main(void){
    int a,b,c;
    printf("Donnez 3 entiers\n");
    scanf("%d %d %d",&a,&b,&c);
    printf("%d\n",addition(a,addition(b,c)));
    return 0;
    }
    

  • compilation avec gcc :

    $ gcc -Wall -O2 --dump-tree-einline --dump-tree-optimized \
          substitution.c -o substitution
    

  • résultat :

    $ cat substitution.c.026t.einline2
    main ()
    {
      int D.1794,D.1793,D.1793,D.1790,D.1789,D.1789,D.1783,D.1782,D.1780;
      int a,b,c,a.13,b.12,c.11; 
    <bb 2>:
      __builtin_puts (&"Donnez 3 entiers"[0]);
      scanf (&"%d %d %d"[0], &a, &b, &c);
      c.11_1 = c;
      b.12_2 = b;
      D.1790_8 = c.11_1 + b.12_2;
      D.1789_10 = D.1790_8;
      D.1780_3 = D.1789_10;
      a.13_4 = a;
      D.1794_9 = D.1780_3 + a.13_4;
      D.1793_11 = D.1794_9;
      D.1782_5 = D.1793_11;
      printf (&"%d\n"[0], D.1782_5);
      D.1783_6 = 0;
      return D.1783_6;
    }
    $ cat substitution.c.126t.optimized 
    main ()
    {
      int a,b,c;
    <bb 2>:
      __builtin_puts (&"Donnez 3 entiers"[0]);
      scanf (&"%d %d %d"[0], &a, &b, &c);
      printf (&"%d\n"[0], (b + c) + a);
      return 0;
    }
    

  • exercice : "fonctions imbriquées" :
    • créez un répertoire Optimisation ;
    • modifiez le programme précédent ;
    • transformez addition en soustraction ;
    • soustraction doit appeler oppose ;
    • vérifiez que les substitutions aient pris place.
• Déroulement de boucles
  • exemple de programme :

    #include <stdio.h>
    #define TAILLE 10
    int main(void){
    int a[TAILLE];
    int resultat=0;
    int i;
    for(i=0;i<TAILLE;i++) scanf("%d",&a[i]);
    for(i=0;i<TAILLE;i++) resultat += a[i];
    return resultat;
    }
    

  • compilation avec gcc :

    $ gcc -Wall -O3 --dump-tree-cunroll --dump-tree-optimized \
          deroulement.c -o deroulement
    

  • résultat :

    $ cat deroulement.c.126t.optimized 
    main ()
    {
      int resultat.48;
      int resultat.46;
      int resultat.44;
      int resultat.42;
      int resultat.40;
      int resultat.38;
      int resultat.36;
      int resultat.34;
      int a[10];
    <bb 2>:
      scanf (&"%d"[0], &a);
      scanf (&"%d"[0], &a[1]);
      scanf (&"%d"[0], &a[2]);
      scanf (&"%d"[0], &a[3]);
      scanf (&"%d"[0], &a[4]);
      scanf (&"%d"[0], &a[5]);
      scanf (&"%d"[0], &a[6]);
      scanf (&"%d"[0], &a[7]);
      scanf (&"%d"[0], &a[8]);
      scanf (&"%d"[0], &a[9]);
      resultat.34 = a[0] + a[1];
      resultat.36 = resultat.34 + a[2];
      resultat.38 = resultat.36 + a[3];
      resultat.40 = resultat.38 + a[4];
      resultat.42 = resultat.40 + a[5];
      resultat.44 = resultat.42 + a[6];
      resultat.46 = resultat.44 + a[7];
      resultat.48 = resultat.46 + a[8];
      return a[9] + resultat.48;
    }
    

  • Exercice "calcul du gain" :
    • modifiez le programme deroulement.c ;
    • ajoutez une seconde dimension au tableau a ;
    • remplissez le tableau à l’aide de la fonction rand ;
    • rajoutez une boucle pour sommer sur la matrice entière ;
    • utilisez l’utilitaire time pour les comparaisons ;
    • comparez le temps d’exécution du programme non optimisé ...
    • avec le temps d’exécution du programme optimisé -O3 ;
    • conclusion ?
• Récursion terminale :
  • exemple de programme :

    #include <stdio.h>
    int puissance(int a,int b){
    if(b==0) return 1;
    else return puissance(a,b-1)*a;
    }
    int main(void){
    int a,b;
    scanf("%d %d",&a,&b);
    printf("%d\n",puissance(a,b));
    return 0;
    }
    

  • compilation avec gcc :

    $ gcc -Wall -O2 --dump-tree-optimized recursion.c -o recursion
    

  • résultat :

    $ cat recursion.c.126t.optimized 
    puissance (a, b)
    {
      int mult_acc.13;
    <bb 2>:
      if (b == 0) goto <bb 6>; else goto <bb 5>;
    <bb 6>:
      mult_acc.13 = 1;
      goto <bb 4>;
    <bb 5>:
      mult_acc.13 = 1;
    <bb 3>:
      b = b + -1;
      mult_acc.13 = mult_acc.13 * a;
      if (b == 0) goto <bb 4>; else goto <bb 3>;
    <bb 4>:
      return mult_acc.13;
    }
    

  • Exercice "multiplication récursive" :
    • modifiez le programme recursion.c ;
    • au lieu de calculer une puissance avec des multiplications ...
    • ... calculez une multiplication avec des additions ;
    • pourquoi l’optimisation est-elle plus aboutie ?