%%
%% $Id$
%%
%% Copyright 1989-2016 MINES ParisTech
%%
%% This file is part of PIPS.
%%
%% PIPS is free software: you can redistribute it and/or modify it
%% under the terms of the GNU General Public License as published by
%% the Free Software Foundation, either version 3 of the License, or
%% any later version.
%%
%% PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
%% WARRANTY; without even the implied warranty of MERCHANTABILITY or
%% FITNESS FOR A PARTICULAR PURPOSE.
%%
%% See the GNU General Public License for more details.
%%
%% You should have received a copy of the GNU General Public License
%% along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
%%
\documentclass[12pt]{article}

\usepackage[latin1]{inputenc}
\input{/usr/share/local/lib/tex/macroslocales/Dimensions.tex}

\newcommand{\titre}{PROJET PIPS \\
		RESULTATS SUR LES PROGRAMMES TESTS
}

\newcommand{\auteur}{
        	François IRIGOIN \\
        	Pierre JOUVELOT \\
\vspace{0.5cm}
{\it Le présent document a été établi en exécution du contrat
No.~88.017.01 passé par la Direction des Recherches, Etudes et
Techniques (Délégation Générale pour l'Armement)}
}
\newcommand{\docdate}{Décembre 1990}
\newcommand{\numero}{E143}

\begin{document}
\input{/usr/share/local/lib/tex/macroslocales/PageTitre.tex}

{\it Le présent document a été établi en exécution du contrat
No.~88.017.01 passé par la Direction des Recherches, Etudes et
Techniques (Délégation Générale pour l'Armement)}

\vspace{2cm}

\tableofcontents

\newpage

\section*{Introduction}

Nous présentons d'abord les résultats obtenus sur les cas d'école par
les phases d'analyse de programmes et par les phases de transformations
de programmes. Nous analysons ensuite les résultats obtenus sur les
programmes réels de test fournis par l'ONERA.

\section{Tests des phases d'analyse}

Seule parmi les phases d'analyse, la recherche de relations linéaires
entre variables scalaires se prête à la constitution de programmes
de démonstration. En effet, les calculs des effets des instructions et
ceux des {\em SDFI} ne produisent pas des résultats lisibles. Le calcul
des {\em use-def chains} produit un graphe, encore plus difficile à étudier.

La validité de ces analyses doit donc être estimée par l'utilisateur en
fonction des résultats de parallélisation.

\subsection{Analyse intraprocédurale}

\paragraph{Effet de l'enveloppe convexe}

~\newline
Programme initial:
\begin{verbatim}
      program intrar
      i = 3
      if(j.eq.6) then
         k = 0
      else
         k = 1
      endif
      end
\end{verbatim}

Programme décoré avec les préconditions:
\begin{verbatim}
      PROGRAM INTRAR
C                       P() {}
      I = 3
C                       P(I) {I==3}
      IF ((J.EQ.6)) THEN
C                       P(I) {J==6, I==3}
         K = 0
      ELSE
C                       P(I) {I==3}
         K = 1
      ENDIF
C                       P(K, I) {0<=K, K<=1, I==3}
      RETURN
      END
\end{verbatim}

\subsection{Analyse interprocédurale}

Mise en évidence de l'effet de la sélection de l'option
interprocédurale pour le calcul des {\em transformers}.

Programme initial:
\begin{verbatim}
      program interr
      i = 3
      j = 4
      call swap(i,j)
      end
      subroutine swap(n,m)
      integer t
      t = n
      n = m
      m = t
      return
      end
\end{verbatim}

Préconditions obtenues intraprocéduralement\footnote{En fait, il
s'agit d'une analyse interprocédurale où seuls les {\em SDFI} de la
routine \verb+SWAP+ sont pris en compte.}:
\begin{verbatim}
      PROGRAM INTERR
C                       P() {}
      I = 3
C                       P(I) {I==3}
      J = 4
C                       P(J, I) {J==4, I==3}
      CALL SWAP(I, J)
C                       P(J, I) {}
      RETURN
      END
\end{verbatim}

Résultat de l'analyse interprocédurale:
\begin{verbatim}
      PROGRAM INTERR
C                       P() {}
      I = 3
C                       P(I) {I==3}
      J = 4
C                       P(J, I) {J==4, I==3}
      CALL SWAP(I, J)
C                       P(J, I) {J==3, I==4}
      RETURN
      END
\end{verbatim}

\newpage

\section{Tests des transformations}

Nous présentons successivement la privatisation, la parallélisation en
présence de tests, la parallélisation avec distribution de boucles, la
parallélisation avec échange des instructions et enfin la
parallélisation avec utilisation des préconditions. Nous vérifions que
nous détectons bien plusieurs niveaux de parallélisme, nous montrons que
nous pouvons procéder à des échanges de boucles dans des cas généraux,
puis nous finissons en comparant les sorties purement parallèles,
utilisant Fortran~77 étendu, et les sorties vectorielles, utilisant
Fortran~90.

\subsection{Privatisation (expansion et substitution en avant)}

L'algorithme de Cholesky ne peut être parallélisé que si les deux
utilisations de la variable X sont reconnues comme indépendantes et que
si X est privatisée dans les boucles portant sur I et sur J.

Programme original:
\begin{verbatim}
C
C     CHOLESKI METHOD - VERSION 1
C
C     PRIVATIZATION
C     DEPENDENCE COMPUTATION WITH AND WITHOUT EXECUTION CONTEXT
C
      SUBROUTINE CHOLES(A, P, N)
      REAL X, A(N,N), P(N)
C
      DO I = 1, N
         X = A(I,I)
         DO K = 1, I-1
            X = X - A(I,K)*A(I,K)
         ENDDO
         P(I) = 1.0 / SQRT(X)
         DO J = I+1, N
            X = A(I,J)
            DO KK = 1, I-1
               X = X -A(I,J) * A(I,KK)
            ENDDO
            A(J,I) = X * P(I)
         ENDDO
      ENDDO
C
      RETURN
      END
\end{verbatim}

Programme transformé après privatisation:
\begin{verbatim}
C
C     CHOLESKI METHOD - VERSION 1
C
C     PRIVATIZATION
C     DEPENDENCE COMPUTATION WITH AND WITHOUT EXECUTION CONTEXT
C
      SUBROUTINE CHOLES(A, P, N)
      REAL X, A(N,N), P(N)
C
      DO I = 1,N,1                                                     0003
         PRIVATE KK,J,K,X
         X = A(I,I)                                                    0004
         DO K = 1,(I-1),1                                              0006
            X = (X-(A(I,K)*A(I,K)))                                    0007
         ENDDO
         P(I) = (1.0/SQRT(X))                                          0008
         DO J = (I+1),N,1                                              0010
            PRIVATE KK,X
            X = A(I,J)                                                 0011
            DO KK = 1,(I-1),1                                          0013
               X = (X-(A(I,J)*A(I,KK)))                                0014
            ENDDO
            A(J,I) = (X*P(I))                                          0015
         ENDDO
      ENDDO
      RETURN
      END
\end{verbatim}

\subsection{Parallélisation en présence de tests}

La présence de tests ne perturbe pas la reconnaissance des boucles
parallèles.

Version initiale:
\begin{verbatim}
      program goto
      real t(200)
      
      do 10 i=1,100
         if( i.lt.50 ) goto 20
         do 30 j=1,200
            t(j) = 3.14159
 30      continue
 20      continue
 10   continue
      
      end
\end{verbatim}

Version parallélisée:
\begin{verbatim}
      PROGRAM GOTO
      REAL T(200)
      
      DO 10 I = 1,100,1                                                0003
         PRIVATE I
         IF ((I.LT.50)) THEN                                           0009
         ELSE
            GOTO 99996
         ENDIF
99994    CONTINUE                                                      0004
10       CONTINUE                                                      0014
         GOTO 99992
99996    CONTINUE                                                      0006
         DOALL 30 J = 1,200,1
            PRIVATE J
            T(J) = 3.14159                                             0012
         ENDDO
         GOTO 99994
99992    CONTINUE
      ENDDO
      RETURN
      END
\end{verbatim}

La régénération du graphe de contrôle n'est pas particulièrement
adroite, mais le code généré ne devrait pas perturber un compilateur.
Il faudrait bien sûr améliorer ce point si PIPS devait être utilisé
interactivement.

\subsection {Parallélisation et distribution de boucles}

La distribution de boucles permet de  paralléliser certaines
boucles. Elle est souvent associée à  une autre transformation de
programme. Dans l'exemple suivant, elle permet de paralléliser une
partie de la boucle.

Programme initial:

\begin{verbatim}
      program ditrb
      real t(10)
      real v(10)
      n=10
      do 100 i = 1, 10
         t(i) = t(i-1)+2
         v(i)=t(i)+v(i)
 100  continue
      end
\end{verbatim}

Programme obtenu après parallélisation:

\begin{verbatim}
      PROGRAM DITRB
      REAL T(10)
      REAL V(10)
      N = 10
      DO 100 I = 1,10,1
         T(I) = (T((I-1))+2)
      DOALL 100 I = 1,10,1
         V(I) = (T(I)+V(I))
      ENDDO
      RETURN
      END
\end{verbatim}


\newpage
\subsection{Parallélisation et échange des instructions }

Intervertir l'ordre d'exécution des instructions dans un corps de
boucles permet de vectoriser ou de paralléliser certaines
boucles supplémentaires.
Le programme suivant en est un exemple: 

Programme initial:

\begin{verbatim}

      program dists
      real t1(11,10)
      real t2(10,10)
      
      do 100 i = 1, 10,1
         do 100 j = 1,10,1
            t1(i,j) = 0
            t2(i,j)=t2(i,j) + t1(i+1,j)
 100     continue
         end

\end{verbatim}

L'interversion  des deux  instructions permet  de  vectoriser les boucles, 
ou  de les distribuer et de les paralléliser.
La  boucle d'indice I  n'aurait pas été parallélisée dans la version
initiale du programme.

Le programme obtenu après la phase de parallélisation est le suivant:

\begin{verbatim}

      PROGRAM DISTS
      REAL T1(11,10)
      REAL T2(10,10)

      DOALL 100 I = 1,10,1
         PRIVATE I
         DOALL 100 J = 1,10,1
            PRIVATE J
            T2(I,J) = (T2(I,J)+T1((I+1),J))                            0007
         ENDDO
      ENDDO
      DOALL 100 I = 1,10,1
         PRIVATE I
         DOALL 100 J = 1,10,1
            PRIVATE J
            T1(I,J) = 0                                                0006
         ENDDO
      ENDDO
      RETURN
      END
\end{verbatim}




\subsection{Parallélisation  utilisant les préconditions}


L'utilisation  des préconditions  permet de paralléliser certaines
boucles qui ne l'auraient pas été nécessairement.
Dans l'exemple suivant, elles vont permettre de paralléliser la boucle 
d'incide I.

Programme initial:

\begin{verbatim}

      program prec
      real MAT(10,10)
      
      do 100 I = 1,10,1
         MAT(I,I) = 0.0
         do 100 J = 1,I - 1,1
            MAT(I,J) = 1.0
            MAT(J,I) = -1.0
 100     continue
         end
\end{verbatim}

 
La phase de calcul des préconditions donne les informations suivantes:

\begin{verbatim}

      PROGRAM PREC
      REAL MAT(10,10)

C                       P() {}
C                       P() {}
C                       P() {}
      DO 100 I = 1,10,1      
C                       P(J, I) {I<=10, 1<=I}
C                       P(J, I) {1<=I, I<=10}
         MAT(I,I) = 0.0      
C                       P(J, I) {I<=10, 1<=I}
         DO 100 J = 1,(I-1),1
C                       P(J, I) {J+1<=I, 1<=J, I<=10, 1<=I}
C                       P(J, I) {1<=I, I<=10, 1<=J, 1+J<=I}
            MAT(I,J) = 1.0   
C                       P(J, I) {J+1<=I, 1<=J, I<=10, 1<=I}
            MAT(J,I) = (-1.0)
C                       P(J, I) {1<=I, I<=10, 1<=J, 1+J<=I}
100         CONTINUE         
         ENDDO
      ENDDO
C                       P(J, I) {}
      RETURN
      END

\end{verbatim}

Ces informations utilisées lors de  la phase de parallélisation
permettent de paralléliser la boucle d'indice I:

\begin{verbatim}

      PROGRAM PREC
      REAL MAT(10,10)

     DOALL 100 I = 1,10,1
         PRIVATE I
         MAT(I,I) = 0.0                                                0004
      ENDDO
      DOALL 100 I = 1,10,1
         PRIVATE I
         DOALL 100 J = 1,(I-1),1
            PRIVATE J
            MAT(I,J) = 1.0                                             0007
         ENDDO
      ENDDO
      DOALL 100 I = 1,10,1
         PRIVATE I
         DOALL 100 J = 1,(I-1),1
            PRIVATE J
            MAT(J,I) = (-1.0)                                       
         ENDDO
      ENDDO
      RETURN
      END
\end{verbatim}

~\newpage
\subsection{Parallélisation et boucles imbriquées}

\begin{verbatim}
      program iloop
      real mat(10,10)

      do 100 i = 1, 10,1
         do 100 j = 1,10,1
            mat(i,j) = 0
 100     continue
         end
\end{verbatim}

Programme obtenu après parallélisation:

\begin{verbatim}
   PROGRAM ILOOP
      REAL MAT(10,10)

       DOALL 100 I = 1,10,1
         PRIVATE I
         DOALL 100 J = 1,10,1
            PRIVATE J
            MAT(I,J) = 0                                               0006
         ENDDO
      ENDDO
      RETURN
      END
\end{verbatim}

\subsection {Parallélisation du produit de matrices}

Programme initial:

\begin{verbatim}
      program matmul
      real a(10,10)
      real b(10,10)
      real c(10,10)
      
      l =10
      n=10
      m=10
      do 100 i = 1, l,1
         do 100 j = 1,n,1
            c(i,j) = 0
            do 100 k=1,m,1
               c(i,j)=c(i,j) + a(i,k) * b(k,j)
 100        continue
            end
\end{verbatim}

Programme obtenu après parallélisation:

\begin{verbatim}

     PROGRAM MATMUL
      REAL A(10,10)
      REAL B(10,10)
      REAL C(10,10)

      L = 10                                                           0002
      N = 10                                                           0003
      M = 10                                                           0004
      DOALL 100 I = 1,L,1
         PRIVATE I
         DOALL 100 J = 1,N,1
            PRIVATE J
            C(I,J) = 0                                                 0009
         ENDDO
      ENDDO
      DOALL 100 I = 1,L,1
         PRIVATE I
         DOALL 100 J = 1,N,1
            PRIVATE J
            DO 100 K = 1,M,1
               PRIVATE K
               C(I,J) = (C(I,J)+(A(I,K)*B(K,J)))                       0012
            ENDDO
         ENDDO
      ENDDO
      RETURN
      END
\end{verbatim}


\subsection {Inversion de boucles}


 De manière générale, l'inversion de boucles  est utilisée pour
augmenter la localité des données utilisées et permettre la
vectorisation de la boucle la plus interne dans le corps de boucles.

~\newpage
\subsubsection{Inversion de boucles sur un domaine triangulaire}

Dans l'exemple suivant, l'inversion des deux boucles d'indices i et j
permet de vectoriser la boucle la plus interne.

Programme initial:

\begin{verbatim}
      program loop4

      real t(10,10)
      real v(10,10)

      do 100 i = 1, 5
         do 100 j = 1, i          
            t(j+1,i)=t(j,i) + v(j,i)
 100     continue
         end

\end{verbatim}

Programme obtenu après l'inversion  des deux  boucles:

\begin{verbatim}
      PROGRAM LOOP4

      REAL T(10,10)
      REAL V(10,10)

      DO 100 Ip = 1,5,1                                                0004
         DO 100 Jp = Ip,5,1                                            0006
            T((1+Ip),Jp) = (T(Ip,Jp)+V(Ip,Jp))                         0007
100         CONTINUE                                                   0008
         ENDDO
      ENDDO
      RETURN
      END


\end{verbatim}

\subsubsection{Inversion de boucles sur un domaine plus complexe}

Dans l'exemple suivant, la boucle la plus interne est échangée avec 
la plus externe. Cette opération permet d'augmenter la localité des
données accédées. Tous les éléments des tableaux m et t seront
accédés de manière contigüe. 

~\newpage
Programme initial:

\begin{verbatim}
      program loop3

      real t(10,10,10)
      real m(10,10)

      N = 10
      do 100 i = 1, 10
         do 100 j = i+1, 10-i
            do 100 k = j, N
               m(i,j)  = m(i,j) + 2 * t(i,j,k) 
 100        continue
            end

\end{verbatim}

Programme obtenu après l'inversion  des boucles:

\begin{verbatim}
      PROGRAM LOOP3
      REAL T(10,10,10)
      REAL M(10,10)

      N = 10                                                           0002
      DO 100 Ip = 2,N,1                                                0004
         DO 100 Jp = 2,Ip,1                                            0006
            DO 100 Kp = 1,MIN((10-Jp), (-1+Jp)),1                      0008
               M(Kp,Jp) = (M(Kp,Jp)+(2*T(Kp,Jp,Ip)))                   0009
100            CONTINUE                                                0010
            ENDDO
         ENDDO
      ENDDO
      RETURN
      END

\end{verbatim}

\subsection{Géneration de code vectoriel}

Pour obtenir une sortie en style Fortran~90, il faut mettre la
propriété \verb+PRETTYPRINT_FORTRAN90+ à vrai dans le fichier
\verb+properties.rc+ local.

\begin{verbatim}
      program vector
      real a(10,10), b(100)
      
      do 100 i = 1, 10
         do 200 j = 1, 10
            a(i,j) = 0.
 200     continue
 100  continue
      
      do 300 i = 1, 100
         b(i) = 1.
 300  continue
      
      end
\end{verbatim}
\begin{verbatim}
      PROGRAM VECTOR
      REAL A(10,10), B(100)
      
      DOALL 100 I = 1,10,1
         PRIVATE I
         A(I,(/I,I=1,10,1/)) = 0.
      ENDDO
      B((/I,I=1,100,1/)) = 1.
      RETURN
      END
\end{verbatim}

A noter que la réutilisation de la variable {\tt I} dans le format
vectoriel n'entre pas en conflit avec l'indice {\tt I} de la boucle la
plus englobante, les scopes étant différents.

\subsection{Génération de code parallèle}

Vu le manque de lisibilité du code vectoriel utilisant les DO implicites dans
les expressions d'indices, l'option par défaut consiste à ne
générer que du code parallèle. Il n'est donc pas nécessaire de
s'inquiéter du fichier \verb+properties.rc+ local, à moins qu'il ne
modifie justement la variable \verb+PRETTYPRINT_FORTRAN90+.

\begin{verbatim}
      program vector
      real a(10,10), b(100)
      
      do 100 i = 1, 10
         do 200 j = 1, 10
            a(i,j) = 0.
 200     continue
 100  continue
      
      do 300 i = 1, 100
         b(i) = 1.
 300  continue
      
      end
\end{verbatim}

\begin{verbatim}
      PROGRAM VECTOR
      REAL A(10,10), B(100)
      
      DOALL 100 I = 1,10,1
         PRIVATE I
         DOALL 200 J = 1,10,1
            PRIVATE J
            A(I,J) = 0.                                                0006
         ENDDO
      ENDDO
      DOALL 300 I = 1,100,1
         PRIVATE I
         B(I) = 1.                                                     0011
      ENDDO
      RETURN
      END
\end{verbatim}

\newpage

\section{Tests en vraie grandeur}

Les quatre programmes fournis par l'ONERA en tant qu'échantillons
représentatifs des méthodes numériques couramment utilisées pour des
travaux liés à la défense nationale ont été étudiés de quatre
manières différentes.

Ils ont tout d'abord permis de définir et de valider les restrictions
à Fortran qui ont été admises pour réduire le volume de travail lié
à l'analyse sémantique et la prise en compte de constructions ne
pouvant en aucun cas conduire à des exécutions parallèles. Les
résultats ont été décrits dans un précédent rapport
(EMP-CAI-I~E/103, octobre 1988).

Depuis cette date, ces choix ont été largement validés sur des
programmes plus nombreux. La première limitation qu'il faudrait retirer
concerne la notion de \verb+BLOCKDATA+ qui intervient trop souvent
pourqu'il soit possible de demander aux usagers de les remplacer par des
assignations dans le programme principal. Un deuxième problème s'est
révélé au moment du link: il n'est pas possible d'avoir une variable
ayant le même nom qu'un symbole global comme un COMMON ou une SUBROUTINE.

Ensuite une analyse manuelle des codes a été effectuée par un
analyste-numéricien pour définir le maximum de parallélisme que PIPS
pouvait trouver.
Cette étude très fastidieuse n'a pu être menée complètement
que pour le programme TMINES qui ne contient pas de parallélisme
interprocédural, alors que sa détection est l'objectif premier du
projet PIPS.

Puis les quatre programmes ont été soumis au paralléliseur de
Cray Research, {\em FPP}, de manière à pouvoir disposer d'une
référence commerciale.

Enfin, les quatre programmes ont été soumis à PIPS en utilisant
diverses options pour le test de dépendance. L'analyse manuelle des
résultats et la comparaison des divers résultats sont extrêmement
fastidieuses et elles ne font pas directement l'objet du contrat PIPS.
Il s'agit plutôt de son évaluation.

Il a donc fallu réduire le champ des essais et l'essentiel des efforts
s'est porté sur le programme {\em TMINES}.

\subsection{Programme TMINES}

Comme il a déjà été indiqué auparavant, le programme TMINES ne
contient pas de parallélisme interprocédural dans des boucles DO.
PIPS et FPP détectent comme parallèles les mêmes boucles.

L'algorithme de distribution de boucles de PIPS s'avère contenir une
erreur qui se manifeste lorsqu'une variable inductive d'une boucle
externe est utilisée dans une expression de borne de boucle. Ce
problème peut être résolu (temporairement) en effectuant un
remplacement de la variable inductive par une expression faisant
intervenir les indices de boucles.

Le programme TMINES contient plusieurs variables inductives
multidimensionnelles que les méthodes actuelles ne peuvent pas
convertir. La transformation devrait donc être effectuée à la main.
La plupart des endroits où il peut être utile de la faire peuvent être
rapidement détectés en recherchant les boucles dont la parallélisation
n'est empêchée que par une unique dépendance.

Le programme TMINES est intégralement analysé et parallélisé
interprocéduralement par PIPS. Il n'est bien sûr pas possible d'en
donner le listing complet.  A titre d'exemple, voici la version
parallélisée de CALMAT, une des subroutines les plus importantes de TMINES:

\begin{verbatim}
      SUBROUTINE CALMAT(IM,JM,KM,R,CX,CY,CZ,BEL,BELK)
C
      DIMENSION CX(IM,JM,KM),CY(IM,JM,KM),CZ(IM,JM,KM),R(IM,JM,KM)
      DIMENSION BEL(37,IM-1,JM-1)
      DIMENSION BELK(37,IM-1,JM-1,KM-1)
C
      COMMON/POLXYZ/PXX(8,8,9),PYY(8,8,9),PZZ(8,8,9),PXY(8,8,9)
     $             ,PXZ(8,8,9),PYZ(8,8,9),P(8,9,3),W(9)
      COMMON/MACH/XMACH,XMIN,XMAX,XNEWT,IDEC
      COMMON/VECT/X(8,3,81),A(3,3,81),SURF(81),TEMP(81),RES(81,8)
     $,S11(81),S12(81),S13(81),S22(81),S23(81),S33(81)
      COMMON/SECM/SECM1(25,25),SECM2(25,25)
C
C
C
      IMM = (IM-1)                                                     0002
      JMM = (JM-1)                                                     0003
C
      KMM = (KM-1)                                                     0004
      DOALL 101 K = 1,KM,1
         PRIVATE K
         DOALL 101 J = 1,JM,1
            PRIVATE J
            R((/I,I=1,IM,1/),J,K) = 0.
         ENDDO
      ENDDO
C
      DO 1 K = 1,KMM,1
         PRIVATE K
         DOALL 11 LB = 1,37,1
            PRIVATE LB
            DOALL 11 J = 1,JMM,1
               PRIVATE J
               BEL(LB,(/I,I=1,IMM,1/),J) = 0.
            ENDDO
         ENDDO
         DO 10 J = 1,JMM,1
            PRIVATE J
            X(1,1,(/I,I=1,IMM,1/)) = CX((/I,I=1,IMM,1/),J,K)
            X(1,2,(/I,I=1,IMM,1/)) = CY((/I,I=1,IMM,1/),J,K)
            X(1,3,(/I,I=1,IMM,1/)) = CZ((/I,I=1,IMM,1/),J,K)
            X(2,1,(/I,I=1,IMM,1/)) = CX((/I,I=(1+1),(1+IMM),1/),J,K)
            X(2,2,(/I,I=1,IMM,1/)) = CY((/I,I=(1+1),(1+IMM),1/),J,K)
            X(2,3,(/I,I=1,IMM,1/)) = CZ((/I,I=(1+1),(1+IMM),1/),J,K)
            X(3,1,(/I,I=1,IMM,1/)) = CX((/I,I=(1+1),(1+IMM),1/),(J+1)        -1
     &      ,K)
            X(3,2,(/I,I=1,IMM,1/)) = CY((/I,I=(1+1),(1+IMM),1/),(J+1)        -1
     &      ,K)
            X(3,3,(/I,I=1,IMM,1/)) = CZ((/I,I=(1+1),(1+IMM),1/),(J+1)        -1
     &      ,K)
            X(4,1,(/I,I=1,IMM,1/)) = CX((/I,I=1,IMM,1/),(J+1),K)
            X(4,2,(/I,I=1,IMM,1/)) = CY((/I,I=1,IMM,1/),(J+1),K)
            X(4,3,(/I,I=1,IMM,1/)) = CZ((/I,I=1,IMM,1/),(J+1),K)
            X(5,1,(/I,I=1,IMM,1/)) = CX((/I,I=1,IMM,1/),J,(K+1))
            X(5,2,(/I,I=1,IMM,1/)) = CY((/I,I=1,IMM,1/),J,(K+1))
            X(5,3,(/I,I=1,IMM,1/)) = CZ((/I,I=1,IMM,1/),J,(K+1))
            X(6,1,(/I,I=1,IMM,1/)) = CX((/I,I=(1+1),(1+IMM),1/),J,(K+        -1
     &      1))
            X(6,2,(/I,I=1,IMM,1/)) = CY((/I,I=(1+1),(1+IMM),1/),J,(K+        -1
     &      1))
            X(6,3,(/I,I=1,IMM,1/)) = CZ((/I,I=(1+1),(1+IMM),1/),J,(K+        -1
     &      1))
            X(7,1,(/I,I=1,IMM,1/)) = CX((/I,I=(1+1),(1+IMM),1/),(J+1)        -1
     &      ,(K+1))
            X(7,2,(/I,I=1,IMM,1/)) = CY((/I,I=(1+1),(1+IMM),1/),(J+1)        -1
     &      ,(K+1))
            X(7,3,(/I,I=1,IMM,1/)) = CZ((/I,I=(1+1),(1+IMM),1/),(J+1)        -1
     &      ,(K+1))
            X(8,1,(/I,I=1,IMM,1/)) = CX((/I,I=1,IMM,1/),(J+1),(K+1))
            X(8,2,(/I,I=1,IMM,1/)) = CY((/I,I=1,IMM,1/),(J+1),(K+1))
            X(8,3,(/I,I=1,IMM,1/)) = CZ((/I,I=1,IMM,1/),(J+1),(K+1))
            DO 30 L = 1,8,1
               PRIVATE L
               SURF((/I,I=1,IMM,1/)) = W(L)
               DOALL 2 LJ = 1,3,1
                  PRIVATE LJ
                  DOALL 2 LK = 1,3,1
                     PRIVATE LK
                     A(LK,LJ,(/I,I=1,IMM,1/)) = 0.
                  ENDDO
               ENDDO
               DOALL 2 LJ = 1,3,1
                  PRIVATE LJ
                  DOALL 2 LK = 1,3,1
                     PRIVATE LK
                     DO 2 LL = 1,8,1
                        PRIVATE LL
                        A(LK,LJ,(/I,I=1,IMM,1/)) = (A(LK,LJ,(/I,I=1,         -1
     &                  IMM,1/))+(X(LL,LK,(/I,I=1,IMM,1/))*P(LL,L,LJ)        -1
     &                  ))
                     ENDDO
                  ENDDO
               ENDDO
               DO 3 LL = 1,3,1
                  PRIVATE LL
                  TEMP((/I,I=1,IMM,1/)) = A(LL,LL,(/I,I=1,IMM,1/))
                  SURF((/I,I=1,IMM,1/)) = (SURF((/I,I=1,IMM,1/))*TEMP        -1
     &            ((/I,I=1,IMM,1/)))
                  A(LL,LL,(/I,I=1,IMM,1/)) = 1.
                  DOALL 4 LJ = 1,3,1
                     PRIVATE LJ
                     A(LL,LJ,(/I,I=1,IMM,1/)) = (A(LL,LJ,I)/TEMP(I))
                  ENDDO
                  DO 5 KK = 1,2,1
                     PRIVATE KK
                     KKK = (1+MOD(((KK-1)+LL), 3))                     0084
                     TEMP((/I,I=1,IMM,1/)) = A(KKK,LL,(/I,I=1,IMM,1/)        -1
     &               )
                     A(KKK,LL,(/I,I=1,IMM,1/)) = 0.
                     DOALL 6 LJ = 1,3,1
                        PRIVATE LJ
                        A(KKK,LJ,(/I,I=1,IMM,1/)) = (A(KKK,LJ,I)-(           -1
     &                  TEMP(I)*A(LL,LJ,I)))
                     ENDDO
                  ENDDO
               ENDDO
               S11((/I,I=1,IMM,1/)) = (((A(1,1,(/I,I=1,IMM,1/))*A(1,1        -1
     &         ,(/I,I=1,IMM,1/)))+(A(1,2,(/I,I=1,IMM,1/))*A(1,2,             -1
     &         (/I,I=1,IMM,1/))))+(A(1,3,(/I,I=1,IMM,1/))*A(1,3,             -1
     &         (/I,I=1,IMM,1/))))
               S22((/I,I=1,IMM,1/)) = (((A(2,1,(/I,I=1,IMM,1/))*A(2,1        -1
     &         ,(/I,I=1,IMM,1/)))+(A(2,2,(/I,I=1,IMM,1/))*A(2,2,             -1
     &         (/I,I=1,IMM,1/))))+(A(2,3,(/I,I=1,IMM,1/))*A(2,3,             -1
     &         (/I,I=1,IMM,1/))))
               S33((/I,I=1,IMM,1/)) = (((A(3,1,(/I,I=1,IMM,1/))*A(3,1        -1
     &         ,(/I,I=1,IMM,1/)))+(A(3,2,(/I,I=1,IMM,1/))*A(3,2,             -1
     &         (/I,I=1,IMM,1/))))+(A(3,3,(/I,I=1,IMM,1/))*A(3,3,             -1
     &         (/I,I=1,IMM,1/))))
               S12((/I,I=1,IMM,1/)) = (((A(1,1,(/I,I=1,IMM,1/))*A(2,1        -1
     &         ,(/I,I=1,IMM,1/)))+(A(1,2,(/I,I=1,IMM,1/))*A(2,2,             -1
     &         (/I,I=1,IMM,1/))))+(A(1,3,(/I,I=1,IMM,1/))*A(2,3,             -1
     &         (/I,I=1,IMM,1/))))
               S13((/I,I=1,IMM,1/)) = (((A(1,1,(/I,I=1,IMM,1/))*A(3,1        -1
     &         ,(/I,I=1,IMM,1/)))+(A(1,2,(/I,I=1,IMM,1/))*A(3,2,             -1
     &         (/I,I=1,IMM,1/))))+(A(1,3,(/I,I=1,IMM,1/))*A(3,3,             -1
     &         (/I,I=1,IMM,1/))))
               S23((/I,I=1,IMM,1/)) = (((A(2,1,(/I,I=1,IMM,1/))*A(3,1        -1
     &         ,(/I,I=1,IMM,1/)))+(A(2,2,(/I,I=1,IMM,1/))*A(3,2,             -1
     &         (/I,I=1,IMM,1/))))+(A(2,3,(/I,I=1,IMM,1/))*A(3,3,             -1
     &         (/I,I=1,IMM,1/))))
               SURF((/I,I=1,IMM,1/)) = ABS(SURF(I))
               BEL(37,(/I,I=1,IMM,1/),J) = (BEL(37,(/I,I=1,IMM,1/),J)        -1
     &         +SURF((/I,I=1,IMM,1/)))
               IJL = 0                                                 0108
               DO 8 IL = 1,8,1
                  PRIVATE IL
                  DO 8 JL = IL,8,1
                     IJL = (IJL+1)                                     0113
                     BEL(IJL,(/I,I=1,IMM,1/),J) = (BEL(IJL,(/I,I=1,          -1
     &               IMM,1/),J)+(SURF((/I,I=1,IMM,1/))*((((((S11(            -1
     &               (/I,I=1,IMM,1/))*PXX(IL,JL,L))+(S22((/I,I=1,IMM,        -1
     &               1/))*PYY(IL,JL,L)))+(S33((/I,I=1,IMM,1/))*PZZ(IL        -1
     &               ,JL,L)))+(S12((/I,I=1,IMM,1/))*PXY(IL,JL,L)))+(         -1
     &               S13((/I,I=1,IMM,1/))*PXZ(IL,JL,L)))+(S23((/I,I=1        -1
     &               ,IMM,1/))*PYZ(IL,JL,L)))))
                  ENDDO
               ENDDO
            ENDDO
            DOALL 39 L = 1,8,1
               PRIVATE L
               RES((/I,I=1,IMM,1/),L) = 0.
            ENDDO
            IND = 0                                                    0124
            DO 40 IL = 1,7,1
               PRIVATE IL
               IND = (IND+1)                                           0127
               RES((/I,I=1,IMM,1/),IL) = (RES((/I,I=1,IMM,1/),IL)+(          -1
     &         BEL(IND,(/I,I=1,IMM,1/),J)*X(IL,1,(/I,I=1,IMM,1/))))
               DO 40 JL = JJ,8,1
                  IND = (IND+1)                                        0134
                  RES((/I,I=1,IMM,1/),IL) = (RES((/I,I=1,IMM,1/),IL)+        -1
     &            (BEL(IND,(/I,I=1,IMM,1/),J)*X(JL,1,(/I,I=1,IMM,1/))        -1
     &            ))
                  RES((/I,I=1,IMM,1/),JL) = (RES((/I,I=1,IMM,1/),JL)+        -1
     &            (BEL(IND,(/I,I=1,IMM,1/),J)*X(IL,1,(/I,I=1,IMM,1/))        -1
     &            ))
               ENDDO
            ENDDO
            RES((/I,I=1,IMM,1/),8) = (RES((/I,I=1,IMM,1/),8)+(BEL(36,        -1
     &      (/I,I=1,IMM,1/),J)*X(8,1,(/I,I=1,IMM,1/))))
            R((/I,I=(1+1),(1+IMM),1/),J,K) = (R((I+1),J,K)-RES(I,2))
            R((/I,I=1,IMM,1/),J,K) = (R(I,J,K)-RES(I,1))
            R((/I,I=(1+1),(1+IMM),1/),J,(K+1)) = (R((I+1),J,(K+1))-          -1
     &      RES(I,6))
            R((/I,I=1,IMM,1/),J,(K+1)) = (R(I,J,(K+1))-RES(I,5))
            R((/I,I=(1+1),(1+IMM),1/),(J+1),K) = (R((I+1),(J+1),K)-          -1
     &      RES(I,3))
            R((/I,I=1,IMM,1/),(J+1),K) = (R(I,(J+1),K)-RES(I,4))
            R((/I,I=(1+1),(1+IMM),1/),(J+1),(K+1)) = (R((I+1),(J+1),(        -1
     &      K+1))-RES(I,7))
            R((/I,I=1,IMM,1/),(J+1),(K+1)) = (R(I,(J+1),(K+1))-RES(I,        -1
     &      8))
         ENDDO
         DOALL 66 LB = 1,37,1
            PRIVATE LB
            DOALL 66 I = 1,IMM,1
               PRIVATE I
               BELK(LB,I,(/I,I=1,JMM,1/),K) = BEL(LB,I,(/I,I=1,JMM,1         -1
     &         /))
            ENDDO
         ENDDO
      ENDDO
      DO 1 K = 1,KMM,1
         PRIVATE K
         DO 10 J = 1,JMM,1
            PRIVATE J
            DO 40 IL = 1,7,1
               PRIVATE IL
               JJ = (IL+1)                                             0128
            ENDDO
         ENDDO
      ENDDO
      DOALL 7 J = 1,JM,1
         PRIVATE J
         SECM1(J,(/I,I=1,KM,1/)) = (-R(1,J,K))
      ENDDO
      DOALL 7 J = 1,JM,1
         PRIVATE J
         SECM2(J,(/I,I=1,KM,1/)) = R(IM,J,(/I,I=1,KM,1/))
      ENDDO
      RETURN
      END

\end{verbatim}

A noter les déclarations de type PRIVATE pour les variables locales à
un corps de boucle.

\subsection{Programme OA118}

La version parallélisée du module GRAD1 dans OA118.f est donnée
ci-dessous. Aucun parallélisme interprocédural n'est détecté mais
il a quand même été nécessaire d'analyser les sous-programmes
appelés, \verb+PMAT+, \verb+SDOT+ et \verb+SOLV3+.

\begin{verbatim}
       SUBROUTINE GRAD1(B,X)
C MULTI GRADIENT  SANS FENETRAGE
C 
       PARAMETER(NFAC=49,IRMAX=50)
      COMMON/OASET/PIO2
      COMMON/OACOF/AA(NFAC,NFAC)
       DIMENSION A(IRMAX,IRMAX),B(NFAC),X(NFAC)
       DIMENSION ALFA(IRMAX),R(NFAÇIRMAX),S(NFAÇIRMAX)
       DIMENSION Y(NFAC),Z(NFAC),RS(IRMAX),D(IRMAX)
      RRM = 1.E-20                                                     0002
C 111 X(I)=B(I)/AA(I,I)
      Y((/I,I=1,NFAC,1/)) = 0.
      X((/I,I=1,NFAC,1/)) = 0.
      R((/I,I=1,NFAC,1/),1) = (B(I)-Y(I))
      IPM = 50                                                         0010
      IPP = 1                                                          0011
      IP = 1
99997 IF ((IP.LE.IPM)) THEN
      ELSE
         GOTO 99996
      ENDIF
      IPP0 = IPP                                                       0014
      IPP = (IPP+1)                                                    0015
      IPQ = IP                                                         0016
      Y((/I,I=1,NFAC,1/)) = R((/I,I=1,NFAC,1/),IPP0)
      CALL PMAT(Y, Z)                                                  0020
      S((/I,I=1,NFAC,1/),IPP0) = Z((/I,I=1,NFAC,1/))
      DO 3 II = 1,IPQ,1
         Y((/I,I=1,NFAC,1/)) = S((/I,I=1,NFAC,1/),II)
         DO 5 JJ = II,IPQ,1
            Z((/I,I=1,NFAC,1/)) = S((/I,I=1,NFAC,1/),JJ)
            A(II,JJ) = SDOT(NFAC, Y, 1, Z, 1)                          0034
         ENDDO
         DO 5 JJ = II,IPQ,1
5           A(JJ,II) = A(II,JJ)                                        0035
         ENDDO
         Z((/I,I=1,NFAC,1/)) = R((/I,I=1,NFAC,1/),IPP0)
3        RS(II) = SDOT(NFAC, Y, 1, Z, 1)                               0039
      ENDDO
      CALL SOLV3(IPQ, A, RS, D)                                        0040
      R((/I,I=1,NFAC,1/),IPP) = R((/I,I=1,NFAC,1/),IPP0)
      DO 42 II = 1,IPQ,1
         X((/I,I=1,NFAC,1/)) = (X((/I,I=1,NFAC,1/))+(RS(II)*R((/I,I=1        -1
     &   ,NFAC,1/),II)))
      ENDDO
      DO 43 II = 1,IPQ,1
         R((/I,I=1,NFAC,1/),IPP) = (R(I,IPP)-(RS(II)*S(I,II)))
      ENDDO
      Y((/I,I=1,NFAC,1/)) = R((/I,I=1,NFAC,1/),IPP)
      RR = SDOT(NFAC, Y, 1, Y, 1)                                      0057
      WRITE (FMT=*,UNIT=6) IP,RR                                       0058
      WRITE (FMT=*,UNIT=100) IP,RR                                     0059
      IF ((RR.LT.RRM)) THEN                                            0065
      ELSE
         GOTO 99993
      ENDIF
99996 CONTINUE                                                         0060
99991 RETURN
      GOTO 99990
99993 CONTINUE                                                         0062
2     CONTINUE                                                         0066
      IP = (IP+1)
      GOTO 99997
99990 CONTINUE
      END
\end{verbatim}

A noter la présence des instructions de branchement aux étiquettes de
la forme 9999x qui correspondent à la regénération sous forme de
programme Fortran du graphe de contrôle structuré.

\subsection{Programme CR2CNF}

Le programme CR2CNF est intégralement traité par PIPS.

La version parallélisée de MATELT, subroutine de CR2CNF, est donnée
ci-dessous. Il faut remarquer le degré d'imbrication élevé des boucles
DO. Il ne permet pas l'utilisation directe des techniques d'analyse
sémantique développées par Halbwachs et Cousot.

\begin{verbatim}
C*********************************************************************
      SUBROUTINE MATELT(DAE,IMPRE)
      IMPLICIT REAL*8(A-H,O-Z)
C  ROUTINE DE CALCUL DE LA MATRICE DES INTEGRALES SUR LE PRISME DE
C  REFERENCE DES PRODUITS DES DERIVEES PARTIELLES DES FONCTIONS DE
C  BASE . DAE(K1,J1,K2,J2) = INTEGRALE DE DPHI(K1,J1)*DPHI(K2,J2)
      DIMENSION DAE(3,6,3,6),Y(3,6)
C  INITIALISATION DU TABLEAU DES COORDONNEES DES POINTS DE QUADRATURE .
      Z = (1./(2.*SQRT(3.)))                                           0002
      DO 1 I = 1,3,1
         Y(I,(/I,I=1,6,1/)) = 0.
      ENDDO
      Y(3,(/I,I=1,3,1/)) = (0.5-Z)
      Y(3,(/I,I=4,6,1/)) = (0.5+Z)
      DO 4 J = 1,4,3
         Y(1,J) = 0.5                                                  0016
      ENDDO
      DO 4 J = 1,4,3
         Y(1,(J+1)) = 0.5                                              0017
      ENDDO
      DO 4 J = 1,4,3
         Y(2,(J+1)) = 0.5                                              0018
      ENDDO
      DO 4 J = 1,4,3
         Y(2,(J+2)) = 0.5                                              0019
      ENDDO
      DOALL 5 K = 1,3,1
         DOALL 5 L = 1,3,1
            DO 5 I = 1,6,1
               DO 5 J = 1,6,1
C  CALCUL DE LA MATRICE DAE .
5                 DAE(K,I,L,J) = 0.                                    0029
               ENDDO
            ENDDO
         ENDDO
      ENDDO
      DOALL 6 K = 1,3,1
         DOALL 6 L = 1,3,1
            DO 6 I = 1,6,1
               DO 6 J = 1,6,1
                  DO 6 NQ = 1,6,1
                     DAE(K,I,L,J) = (DAE(K,I,L,J)+((DPHI(K, I, Y(1,NQ        40
     &               ))*DPHI(L, J, Y(1,NQ)))/12.))                     0040
                  ENDDO
               ENDDO
            ENDDO
         ENDDO
      ENDDO
      IF ((IMPRE.LE.0)) THEN                                           0047
      ELSE
         GOTO 99996
      ENDIF
99994 CONTINUE
      RETURN
      GOTO 99992
99996 CONTINUE                                                         0044
      WRITE (UNIT=6,FMT=*)                                                   48
     &'   MATRICES DES INTEGRALES DES DERIVEES DES FONCTIONS'          0048
      WRITE (UNIT=6,FMT=*) '   DE BASE SUR LE PRISME UNITAIRÉ         0049
      DOALL 8 K = 1,3,1
         DOALL 8 L = 1,3,1
            WRITE (UNIT=6,FMT=1000) K,L                                0054
         ENDDO
      ENDDO
      DO 8 K = 1,3,1
         DO 8 L = 1,3,1
            WRITE (UNIT=6,FMT=2000) ((DAE(K,I,L,J)),J = 1,6,1)),I = 1        55
     &      ,6,1)                                                      0055
         ENDDO
      ENDDO
      GOTO 99994
99992 CONTINUE
      END
\end{verbatim}

\subsection{Programme AILE}

Le programme AILE est intégralement traité par PIPS. L'exemple choisi est
celui de la routine \verb+GEOM+. Les boucles 89 et 33 sont correctement
parallélisées mais les boucles 88, 111 et 222 restent séquentielles.
Les causes de l'attitude prudente du paralléliseur n'ont pas pu être
découvertes.

\begin{verbatim}
      SUBROUTINE GEOM
C******************************************************
C      NXYZ    FICHIER DES COORDONNEES DES NOEUDS
C      NGEO    FICHIER DES COEF. ET DES NORMALES
C      NDIST   FICHIER DES RAYONS NUMERIQUES
C      MAILLAGE SYMETRIQUE / XOY
C******************************************************
      DIMENSION T(52,21,60)
      COMMON/CT/T
      COMMON/CTI/TITXYZ(8),TITRE0(8),IT0,TITRE(8),IT
      COMMON/IO/LEÇIMP,KIMP,NXYZ,NGEO,NDIST
      COMMON/CI/I1,I2,IMAX,I1P1,I1P2,I2M1,I2M2,IBF
      COMMON/CJ/J1,J2,JMAX,J1P1,J1P2,J2M1,J2M2,JA,JB,JAM1,JBP1
      COMMON/CK/K1,K2,KMAX,K1P1,K1P2,K2M1,K2M2
      COMMON/CKI1/KI1,LI1,MI1
      COMMON/CKI2/KI2,LI2,MI2
      DATA KPRE,KCOR/1,-1/
      DATA N1,N3,N4,N7,N10,N14,N17/1,3,4,7,10,14,17/
C
      READ (UNIT=NXYZ) TITXYZ                                           0002
      READ (UNIT=NXYZ) N,N,N,N,N,N                                      0003
      READ (UNIT=NXYZ) (((T(J,K,L), J = J1,JA,1), K = K1,K2,1), L = 7          4
     &,9,1)                                                             0004
      READ (UNIT=NXYZ) (((T(J,K,L), J = J1,JA,1), K = K1,K2,1), L = 4          5
     &,6,1)                                                             0005
      READ (UNIT=NXYZ) (((T(J,K,L), J = J1,JA,1), K = K1,K2,1), L = 1          6
     &,3,1)                                                             0006
      DO 88 K = K1,K2,1
         DO 88 J = J1,JA,1
            T(J,K,10) = (((KI2*T(J,K,7))+(LI2*T(J,K,4)))+(MI2*T(J,K,1         11
     &      )))                                                         0011
         ENDDO
      ENDDO
      DO 88 K = K1,K2,1
         DO 88 J = J1,JA,1
            T(J,K,11) = (((KI2*T(J,K,8))+(LI2*T(J,K,5)))+(MI2*T(J,K,2         12
     &      )))                                                         0012
         ENDDO
      ENDDO
      DO 88 K = K1,K2,1
         DO 88 J = J1,JA,1
            T(J,K,12) = (((KI2*T(J,K,9))+(LI2*T(J,K,6)))+(MI2*T(J,K,3         13
     &      )))                                                         0013
         ENDDO
      ENDDO
\end{verbatim}
\begin{verbatim}
C     BUFFER OUT (NGEO,0) (T(1,1,17),T(JMAX,KMAX,25))
      CALL COEF(N10, N7, N17, I2, KPRE, ID)                             0015
      IF ((UNIT(NGEO).LT.0)) THEN                                       0026
      ELSE
         GOTO 99995
      ENDIF
99993 CONTINUE                                                          0016
C     BUFFER OUT (NGEO,0) (T(1,1,17),T(JMAX,KMAX,25))
      CALL COEF(N7, N4, N17, I2M1, KPRE, ID)                            0027
      IF ((UNIT(NGEO).LT.0)) THEN                                       0037
      ELSE
         GOTO 99991
      ENDIF
99989 CONTINUE                                                          0028
      CALL COEF(N7, N4, N17, I2, KCOR, ID)                              0038
      CALL NORM(N10, N7, N4, N14, N17, I2)                              0039
C     BUFFER OUT (NGEO,0) (T(1,1,17),T(JMAX,KMAX,25))
      CALL EXTR(N7, N17)                                                0040
      IF ((UNIT(NGEO).LT.0)) THEN                                       0050
      ELSE
         GOTO 99987
      ENDIF
99985 CONTINUE
C     BUFFER OUT (NGEO,0) (T(1,1,14),T(JMAX,KMAX,16))
22    CONTINUE                                                          0041
      IF ((UNIT(NGEO).LT.0)) THEN                                       0060
      ELSE
         GOTO 99983
      ENDIF
99981 CONTINUE                                                          0051
      DO 111 K = K1,K2,1
         DO 111 J = J1,J2,1
            T(J,K,13) = SQRT(AMIN1(T(J,K,ID), T(J,K,(ID+2))))           0065
         ENDDO
      ENDDO
      IF ((UNIT(NDIST).LT.0)) THEN                                      0076
      ELSE
         GOTO 99979
      ENDIF
99977 CONTINUE                                                          0067
      II = I1P1
99976 IF ((II.LE.I2M1)) THEN
      ELSE
         GOTO 99975
      ENDIF
      I = ((I1+I2)-II)                                                  0079
      IM = (I-1)                                                        0080
      IF ((I.EQ.I2M1)) THEN                                             0086
      ELSE
         GOTO 99972
      ENDIF
\end{verbatim}
\begin{verbatim}
99970 CONTINUE                                                          0081
C     BUFFER OUT (NGEO,0) (T(1,1,17),T(JMAX,KMAX,25))
      CALL COEF(N4, N1, N17, IM, KPRE, ID)                              0090
      IF ((UNIT(NGEO).LT.0)) THEN                                       0100
      ELSE
         GOTO 99967
      ENDIF
99965 CONTINUE                                                          0091
      CALL COEF(N4, N1, N17, I, KCOR, ID)                               0101
      CALL NORM(N7, N4, N1, N14, N17, I)                                0102
C     BUFFER OUT (NGEO,0) (T(1,1,17),T(JMAX,KMAX,25))
      CALL EXTR(N4, N17)                                                0103
      IF ((UNIT(NGEO).LT.0)) THEN                                       0113
      ELSE
         GOTO 99963
      ENDIF
99961 CONTINUE                                                          0104
      DO 222 K = K1,K2,1
         DO 222 J = J1,J2,1
            T(J,K,13) = SQRT(AMIN1(T(J,K,ID), T(J,K,(ID+2))))           0118
         ENDDO
      ENDDO
      IF ((UNIT(NDIST).LT.0)) THEN                                      0129
      ELSE
         GOTO 99959
      ENDIF
99957 CONTINUE                                                          0120
100   CONTINUE                                                          0130
      II = (II+1)
      GOTO 99976
99959 IF ((UNIT(NDIST).EQ.0)) THEN                                      0126
      ELSE
         GOTO 99954
      ENDIF
99952 CONTINUE                                                          0018
      STOP                                                              0175
99951 RETURN
      GOTO 99949
99954 GOTO 99952
99963 IF ((UNIT(NGEO).EQ.0)) THEN                                       0110
      ELSE
         GOTO 99948
      ENDIF
      GOTO 99952
99948 GOTO 99952
99967 IF ((UNIT(NGEO).EQ.0)) THEN                                       0097
      ELSE
         GOTO 99946
      ENDIF
      GOTO 99952
99946 GOTO 99952
99972 CONTINUE                                                          0083
      CALL POUSSE(N4, N3, N7)                                           0087
      CALL POUSSE(N1, N3, N4)                                           0088
      READ (UNIT=NXYZ) (((T(J,K,L), J = J1,JA,1), K = K1,K2,1), L = 1         89
     &,3,1)                                                             0089
      GOTO 99970
\end{verbatim}
\begin{verbatim}
99975 DOALL 89 K = K1,K2,1
         T((/I,I=J1,JA,1/),K,10) = (((KI1*T((/I,I=J1,JA,1/),K,1))+(           -1
     &   LI1*T((/I,I=J1,JA,1/),K,4)))+(MI1*T((/I,I=J1,JA,1/),K,7)))
      ENDDO
      DOALL 89 K = K1,K2,1
         T((/I,I=J1,JA,1/),K,11) = (((KI1*T((/I,I=J1,JA,1/),K,2))+(           -1
     &   LI1*T((/I,I=J1,JA,1/),K,5)))+(MI1*T((/I,I=J1,JA,1/),K,8)))
      ENDDO
      DOALL 89 K = K1,K2,1
         T((/I,I=J1,JA,1/),K,12) = (((KI1*T((/I,I=J1,JA,1/),K,3))+(           -1
     &   LI1*T((/I,I=J1,JA,1/),K,6)))+(MI1*T((/I,I=J1,JA,1/),K,9)))
      ENDDO
      CALL COEF(N1, N10, N17, I1, KCOR, ID)                             0139
      CALL NORM(N4, N1, N10, N14, N17, I1)                              0140
C     BUFFER OUT (NGEO,0) (T(1,1,17),T(JMAX,KMAX,25))
      CALL EXTR(N1, N17)                                                0141
      IF ((UNIT(NGEO).LT.0)) THEN                                       0151
      ELSE
         GOTO 99941
      ENDIF
99939 CONTINUE                                                          0142
      DOALL 333 K = K1,K2,1
         T((/I,I=J1,J2,1/),K,13) = SQRT(AMIN1(T(J,K,ID), T(J,K,(ID+2)         -1
     &   )))
      ENDDO
      IF ((UNIT(NDIST).LT.0)) THEN                                      0167
      ELSE
         GOTO 99937
      ENDIF
99935 CONTINUE                                                          0158
      ENDFILE (UNIT=NDIST)                                              0168
      ENDFILE (UNIT=NGEO)                                               0169
      REWIND (UNIT=NDIST)                                               0170
      REWIND (UNIT=NGEO)                                                0171
      REWIND (UNIT=NXYZ)                                                0172
      GOTO 99951
99937 IF ((UNIT(NDIST).EQ.0)) THEN                                      0164
      ELSE
         GOTO 99934
      ENDIF
      GOTO 99952
99934 GOTO 99952
99941 IF ((UNIT(NGEO).EQ.0)) THEN                                       0148
      ELSE
         GOTO 99932
      ENDIF
      GOTO 99952
99932 GOTO 99952
99979 IF ((UNIT(NDIST).EQ.0)) THEN                                      0073
      ELSE
         GOTO 99930
      ENDIF
      GOTO 99952
99930 GOTO 99952
99983 IF ((UNIT(NGEO).EQ.0)) THEN                                       0057
      ELSE
         GOTO 99928
      ENDIF
      GOTO 99952
99928 GOTO 99952
99987 IF ((UNIT(NGEO).EQ.0)) THEN                                       0047
      ELSE
         GOTO 99926
      ENDIF
      GOTO 99952
99926 GOTO 99952
99991 IF ((UNIT(NGEO).EQ.0)) THEN                                       0034
      ELSE
         GOTO 99924
      ENDIF
      GOTO 99952
99924 GOTO 99952
99995 IF ((UNIT(NGEO).EQ.0)) THEN                                       0023
      ELSE
         GOTO 99922
      ENDIF
      GOTO 99952
99922 GOTO 99952
99949 CONTINUE
      END
\end{verbatim}

\section{Conclusion}

Cette première version du paralléliseur PIPS donne des résultats
satisfaisants sur les programmes de test. Les objectifs définis dans le
contrat sont atteints mais il reste encore beaucoup de travail à
effectuer pour exploiter l'investissement réalisé jusqu'ici. 

D'une part, il faudrait examiner en détail le code parallèle produit
pour voir ce qui n'a pas été trouvé et tâcher d'y remédier. Il
faudrait que ce travail soit effectué sur un nombre de programmes aussi
grand que possible ce qui améliorera aussi la fiabilité de PIPS.
Ce travail est à la fois ingrat, coûteux en temps et difficilement
publiable.

D'autre part, il faudrait choisir une machine cible et ajouter les
transformations de programme nécessaires à une bonne exploitation du
parallélisme en fonction de la hiérarchie mémoire et des divers
overheads associés à cette machine cible. Cette machine cible et son
compilateur faciliteraient aussi la validation des résultats et
permettraient de quantifier les résultats des optimisations et analyses
effectuées.

\end{document}
