Paralleliser 5 boucles imbriquées avec OpenMP

Bonjour à tous,

Dans un de nos programme nous avons ceci:

Code:

---

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

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:

---

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:

---

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:

---

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).

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

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

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

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

Code:

---

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.