Discussion :

[grut211]

Bonjour à tous,

Dans un de nos programme nous avons ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
      real    x(-nfx:nfx,-nfy+1:jma+nfy,-nfz+1:kma+nfz)
      real    y(1:jma+2,1:kma+2), a(-nfx:nfx,-nfy:nfy,-nfz:nfz)
c
      integer i,j,k,i2,j2,k2
c
      do k = 1,kma
        do j = 1,jma
          y(j+1,k+1) = 0.0
c
          do k2 = -nfz,nfz
            do j2 = -nfy,nfy
              do i2 = -nfx,nfx
                y(j+1,k+1) = y(j+1,k+1) + x(i2,j+j2,k+k2)*a(i2,j2,k2)
               enddo
             enddo
          enddo
        enddo
      enddo

Je voudrais paralléliser cette subroutine avec OpenMP. Je suis malheureusement totalement inculte avec OpenMP. J'ai lu qqs cours et programmer des boucles simples avec OpenMP ne me pose pas de problème. La compilation et l'execution non plus. Mais pour ces 5 boucles imbriquées je suis un peu perdu.

Y aurait il des âmes charitables dans le coin pour m'aider? idées, suggestions?

Merci d'avance,
Bye

[Marlan]

Bonjour,

Premièrement, as-tu réellement besoin de ces 5 boucles ? Il est nécessaire d'optimiser avant de paralléliser, tu gagneras en lisibilité si tu peux t'affranchir de quelques boucles. Par exemple, la boucle sur i2 n'est pas utile.

Ensuite, pour la parallélisation, l'optimal est toujours de chercher à paralléliser la boucle la plus externe, tant que cela est possible. Cela ne peut etre fait que s'il n'y a pas de dépendance en l'indice de boucle précédent et/ou suivant.

Dans ton cas, si je reprends l'expression :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
y(j+1,k+1) = y(j+1,k+1) + x(i2,j+j2,k+k2)*a(i2,j2,k2)

on voit ici qu'on ne peut pas paralléliser (pas de façon triviale en tout cas) suivant l'indice j et k car une dépendance existe en j+1 et k+1.

La première chose que l'on peut faire ici est de s'affranchir de la boucle sur i2 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
y(j+1,k+1) = y(j+1,k+1) + sum(x(:,j+j2,k+k2)*a(:,j2,k2))

Maintenant on peut paralléliser simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
     do k = 1,kma
        do j = 1,jma
          y(j+1,k+1) = 0.0
          !$OMP PARRALEL DEFAULT(SHARED)
          !$OMP DO
          do k2 = -nfz,nfz
            do j2 = -nfy,nfy
                y(j+1,k+1) = y(j+1,k+1) + sum(x(:,j+j2,k+k2)*a(:,j2,k2))
             enddo
          enddo
         !$OMP END DO
         !$OMP END PARALLEL 
       enddo
      enddo

En première approche, cette parallélisation devrait etre correcte.
Cela étant dit, elle est loin d'être optimale puisque l'on créé jma*kma régions parallèles. Si ces deux variables sont grandes et que nfy et nfk sont petit, une chutte dramatique des performances est à prévoir (la performance
peut etre pire que si tu n'utilisais qu'un seul processeur).

[grut211]

Merci de ton aide!

c'est malheureusement ce que je craignais (la dépendance sur j et k).

Mais à ce sujet il y a qqch qui m'échappe:

- à gauche de l'équation on a y(j+1,k+1) et à droite aussi. Donc ça ne pose pas de problème de dépendance. Pour un j+1 et un k+1 donné on utilise/modifie la même valeur du tableau.

- à droite de l'équation on a x(,j+j2,k+k2). Le tableau x n'est pas modifié par une de ces boucles. Donc pour un j et un k donné on va tjs avoir la même valeur. Et là je n'arrive à pas à voir/comprendre s'il y a un pb de dépendance ou pas...


Bonne journée

[Marlan]

Tu devrais regarder du côté des fonctions REDUCTION d'openmp. Je pense que tu pourras peut etre trouver une solution de ce côté là.

Bon courage et tiens nous au courant,

Marlan

[Marlan]

Ah oui, effectivement, j'ai confondu x et y

En ce cas, la prallélisation peut s'écrire simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
     !$OMP PARRALEL DEFAULT(SHARED)
     !$OMP DO
     do k = 1,kma
        do j = 1,jma
          y(j+1,k+1) = 0.0
          do k2 = -nfz,nfz
            do j2 = -nfy,nfy
                y(j+1,k+1) = y(j+1,k+1) + sum(x(:,j+j2,k+k2)*a(:,j2,k2))
             enddo
          enddo
       enddo
      enddo
      !$OMP END DO
      !$OMP END PARALLEL

Car, comme tu le signales, il n'y a pas de dépendences suivant y.