Docstoc

Efficient Code Generation for Automatic Parallelization and

Document Sample
Efficient Code Generation for Automatic Parallelization and Powered By Docstoc
					                             Efficient Code Generation for
                             Automatic Parallelization and
                                    Optimization

                                                 Cédric Bastoul

                                         Proposé par : Albert Cohen

                             Présenté par : L.Landwerlin, J.Rahmé, M.Thiam



Efficient Code Generation for Automatic Parallelization and Optimization
Intérêt

        Code efficace                        Génération automatique
   Processeurs complexes                       Langages de programmation
     pipelines                                  ne permettant pas l'accès à
     MMX (Matrix Math                           ces fonctionnalitées
      eXtention), SSE (Streaming
      SIMD Extensions), Altivec,                Opération pénible
      ...
                                                Dépendant du matériel
     ...




Efficient Code Generation for Automatic Parallelization and Optimization   2
Plan
    I. Introduction
      1.Représentation polyédrique
      2.Schéma de génération
    II.Travaux antérieurs
    III.Génération
      1.Algorithme de génération de code
      2.Problèmes de génération
    IV.Expérimentations
      1.Implémentation
      2.Résultats
    V.Conclusion

Efficient Code Generation for Automatic Parallelization and Optimization   3
Représentation polyèdrique

     Un polyèdre est un solide délimité par des faces
      polygonales.
     Représentation d'une classe de boucles (for/while)
      “nids de boucles” par des -polyèdres paramètrés




Efficient Code Generation for Automatic Parallelization and Optimization   4
Représentation polyèdrique




                          int i, j;
                          for (i = 1 ; i < n ; i++)
                             for (j = 1 ; j < n ; j++)
                                if (i <= -j + n + 2)
                                    I1;

Efficient Code Generation for Automatic Parallelization and Optimization   5
Représentation polyèdrique


    Condition de modélisation par un polyèdre :
        limites et conditions doivent déprendre de :
            compteur d'une boucle englobante

            constante

            paramètres formels

      SCoP (Static Control Part)




Efficient Code Generation for Automatic Parallelization and Optimization   6
 Représentation polyèdrique




                                                   int i, j;
                                                   for (i = 1 ; i < n ; i++)
                                                      for (j = 1 ; j < n ; j++)
                                                         if (i <= -j + n + 2)
                                                             I1;
I1




 Efficient Code Generation for Automatic Parallelization and Optimization     7
 Schéma de génération

 Code

                       Trouver
                                                  Générer
                      un nouvel                                             Optimisations
Analyser                                          du code
                        ordre                                                  locales
                                               réordonnancé
                     d'exécution



                                                                            Code optimisé




 Efficient Code Generation for Automatic Parallelization and Optimization                   8
Travaux antérieurs

   Méthode de Quilleré et al.
  - Donne de bons résultats quand il faut générer un code pour
    plusieurs polyèdres

 - Possède plusieurs limitations :
   - la complexité
   - Génération de code avec pas unitaire seulement
   - Code non optimisé



Efficient Code Generation for Automatic Parallelization and Optimization   9
Plan
    I. Introduction
      1.Représentation polyédrique
      2.Schéma de génération
    II.Travaux antérieurs
    III.Génération
      1.Algorithme de génération de code
      2.Problèmes de génération
    IV.Expérimentations
      1.Implémentation
      2.Résultats
    V.Conclusion

Efficient Code Generation for Automatic Parallelization and Optimization   10
  Algorithme de génération de code (1)

       Entrées                                                                 Sortie

Liste des polyèdres
            Contexte            Algorithme de génération                      Boucles imbriqués
                                         de Code
          Dimension



- Liste des polyèdres transformés :
- Contexte : l’ensemble des contraintes sur les paramètres globaux
- Boucles imbriqués : qui implémentent l’ordre d’exécution de la fonction de ré-
ordonnancement
   Efficient Code Generation for Automatic Parallelization and Optimization               11
Algorithme de génération de code (2)




             Figure 1                                             Figure 2




              Le polyèdre transformé de S1 qu’on doit parcourir
              Le polyèdre transformé de S2 qu’on doit parcourir

Efficient Code Generation for Automatic Parallelization and Optimization     12
Algorithme de génération du code (3)
              S1 et S2              S1                         do i = 1  6 (pas = 2)



                                                                do i = 7  n (pas = 2)


                                                do i = 1  6 (pas = 2)
                                                      do j = 1  7-i
                                                            S1
                                                            S2
 Etapes :                                             do j = 8-i  n
                                                            S1
-Séparer les projections en polyèdres disjoints
                                                 do i = 7  n (pas = 2)
-Génération du code de parcours pour ‘i’              do j = 1  n
-Génération des boucles imbriqués                           S1

Efficient Code Generation for Automatic Parallelization and Optimization            13
Boucles à pas non unitaires (1)




           Polyèdre de départ                            Transformation
                 : fonction de transformation ayant pour matrice T = [1 2]

 Il peut être parfois nécessaire de ne pas parcourir certaines
 

 valeurs
  dans certaines dimensions
    Problème survient : quand T est non uni-modulaire (dét ≠ 1 )
 Les Trous : points avec des images rationnelles dans l’espace
 d’origine
Efficient Code Generation for Automatic Parallelization and Optimization     14
Boucles à pas non unitaires (2)



                     Transformation en utilisant l’algorithme modifié
                                    par les auteurs

      Algorithme initial                    Algorithme modifié par les auteurs




Efficient Code Generation for Automatic Parallelization and Optimization         15
Indépendance des degrés(1)

   Définition
    Indépendance entre les compteurs
    utilisés par les instructions considérées
    ou à exécuter.

   Exemple
      4 matrices A, B, C, D dans M[n,n].
      On doit calculer E= A x B & F= C x D




Efficient Code Generation for Automatic Parallelization and Optimization   16
Indépendance des degrés(2)
Exemple (suite1)                                  Exemple (suite2)
pour t=1 à n                                      pour t=1 à n
   Pour i=1 à n                                      Pour i=1 à n
       Pour j=1 à n                                      Pour j=1 à n
         E[i,j] += A[i,t] * B[t,j]                         E[i,j] += A[i,t] * B[t,j]

     Pour i=1 à n                                           Pour j=1 à n
        Pour j=1 à n                                         F[i,j] += C[i,t] * D[t,j]
          F[i,j] += C[i,t] * D[t,j]
                                                       Itérations: 2n3 + n2 + n
     Itérations: 2n3 + 2n2 + n


Efficient Code Generation for Automatic Parallelization and Optimization                 17
Indépendance des degrés (3)
   Exemple (Fin)

           pour t=1 à n
              Pour i=1 à n
                  Pour j=1 à n
                    E[i,j] += A[i,t] * B[t,j]
                    F[i,j] += C[i,t] * D[t,j]

                Itérations: n3 + n2 + n




Efficient Code Generation for Automatic Parallelization and Optimization   18
Plan
    I. Introduction
      1.Représentation polyédrique
      2.Schéma de génération
    II.Travaux antérieurs
    III.Génération
      1.Algorithme de génération de code
      2.Problèmes de génération
    IV.Expérimentations
      1.Implémentation
      2.Résultats
    V.Conclusion

Efficient Code Generation for Automatic Parallelization and Optimization   19
Implantation
    Sous le nom CLooG (Chunky Loop Generator)
    Disponible sous licence GNU à (http://www.prism.uvsq.fr)
    Applicable à plusieurs systèmes
    Avoir au préalable PIP/PipLib




Efficient Code Generation for Automatic Parallelization and Optimization   20
  Tests
                                                                                 Infos générales sur
                                           ScoPs                                     les données
                                         tous             riche   Paramétrique         d’entrée
                    apsi                  109                80        80(14)
                     art                   62                28         27(8)    infos sur la forme
                   lucas                   11                 4         4(13)
                  quake                    40                20         14(7)
                                                                                   des polyèdres


                                    Domaine d'itération
                            tous       point          rectangle        prisme         autre
      apsi                 2192        1156               1036              0             0
       art                   499        331                142              0             0
     lucas                 2070         317               1753              0             0
    quake                    639        367                216              9             0



                                    Génération de code                                Résultats
                                   suboptimal        dupliqué           temps
                    apsi                    1           9118               58
                     art                    0             623               2
                   lucas                    1           6832              127
                  quake                     0             740               8

Efficient Code Generation for Automatic Parallelization and Optimization                        21
Résultats(1)

                                  Génération de code
               initial    suboptimal   dupliqué temps
Apsi           2192             1                  9118            58
Art             499             0                   623             2
Lucas          2070             1                  6832           127
Quake           639             0                   740             8


         Comparaison entre ces deux colonnes nous donne un facteur
         de duplication de l’ordre de 3.4


Efficient Code Generation for Automatic Parallelization and Optimization   22
Résultats(2)

   Résultats encourageants
      Utilisation
               de la mémoire acceptable
      De même que le temps de génération du CC

   Autres expériences montrent son efficacité
             ~10 polyèdres
      Sans      explosion
             Mémoire
             Temps



Efficient Code Generation for Automatic Parallelization and Optimization   23
Conclusion
        Compilation : Optimisation, Parallélisme
        Solution
           plusieurs méthodes(naïve, étude des polyèdres 1 à 1, …)
           meilleure méthode : polyèdre (Quilleri et al.)

        Apports de l’article
             Modèle de transformation générale
                  Matrices quelconques,
                  Pas non unitaires
                  Fonctions de parcours non entière
             Montrer que la méthode donne des résultats optimaux avec des
              problèmes réels
        Perspectives
           Chevauchement des polyèdres
           complexité

Efficient Code Generation for Automatic Parallelization and Optimization   24

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:9
posted:4/4/2012
language:
pages:24