parallélisation openmp boucles imbriquées

Version imprimable

Bonjour,

Je suis tout nouveau sur ce forum et j'ai quelques soucis avec ompenmp pour paralléliser ce bout de code (en c++) qui est une fonction que j'appelle de manière itérative dans une boucle principale:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
//*****************************************************************************
  void inline f1(double***u,double***v,double***w,double***p,double***nus,
		     const double&dt,const double&C2,const int&filtre){
  const int nxm5=nx-5;
  int i,j,k,im2,im3,ip1,ip2,ip3,ip4,km3,jm3;
  double dtdv;
  for(k=3;k<nzm3;k++){
    km3=k-3;
    for(j=3;j<nym3;j++){
      jm3=j-3;
 
      for(i=0;i<nxm5;i++){
	ip1=i+1;
	ip2=i+2;
	ip3=i+3;
	ip4=i+4;
	f2(C2,p[ip1][j][k],p[ip2][j][k],p[ip3][j][k],p[ip4][j][k],
	    u[ip1][j][k],u[ip2][j][k],u[ip3][j][k],u[ip4][j][k],
	    v[ip1][j][k],v[ip2][j][k],v[ip3][j][k],v[ip4][j][k],
	    w[ip1][j][k],w[ip2][j][k],w[ip3][j][k],w[ip4][j][k],
	    nus[ip1][j][k],nus[ip2][j][k],nus[ip3][j][k],nus[ip4][j][k],dt,
	    V[ip1][j][k],V[ip2][j][k],V[ip3][j][k],V[ip4][j][k],Sx[jm3][km3],
	    wall[ip1][j][k],wall[ip2][j][k],wall[ip3][j][k],wall[ip4][j][k],
	    f[0][i],f[1][i],f[2][i],f[3][i],f[4][i],filtre);
 
	if(wall[ip2][j][k]==0 || wall[ip3][j][k]==0)
	  f[2][i]=f[3][i]=f[4][i]=nul;
      }
      for(i=3;i<nxm3;i++){
	if(wall[i][j][k]==1){
	  im2=i-2;
	  im3=i-3;
	  dtdv=dt/V[i][j][k];
	  p[i][j][k]-=dtdv*(f[0][im2]-f[0][im3]);
	  u[i][j][k]-=dtdv*(f[1][im2]-f[1][im3]);
	  v[i][j][k]-=dtdv*(f[2][im2]-f[2][im3]);
	  w[i][j][k]-=dtdv*(f[3][im2]-f[3][im3]);
	  nus[i][j][k]-=dtdv*(f[4][im2]-f[4][im3]);
	}
      }
    }
  }
}

En fait, je ne sais pas quelle boucle paralléliser... Toutes, seulement celle sur k? J'ai lu le peu de doc disponible sur le net et j'avoue que je m'y perds un peu...

Merci.

Salut.

Tu ne donnes pas assez d'informations concernant ta fonction.
En fait, si aucune variable n'est modifiée par plus d'une itération, alors tu peux simplement écrire écrire ça:
Code:

1 2 3 4 5 6 7 #pragma omp parallel for // C'est ici qu'il y a les meilleures performances selon la doc for() for(){ for() for() }
Le problème c'est que je n'ai aucune visibilité sur ta fonction TVD et sur ce qu'elle fait.
De plus, ton tableau 'f' (que je ne vois d'ailleurs pas déclaré, est-ce une variable globale?) semble être accédé par plus d'un thread à la fois:

ex:
Code:

1 2 if( wall[ip2][j][k] == 0 || wall[ip3][j][k] == 0 ) f[2][i] = f[3][i] = f[4][i] = nul;
(et la valeur NULL prend 2 L si c'est bien ça que tu veux écrire ^^)
Du coup, tu ne peux pas utiliser de 'parallel for simple' et tu es obligé de passer par un truc du genre:
Code:

1 2 3 4 5 6 7 8 9 #pragma omp parallel for shared(var) for() ... local_var = ton calcul pour le thread // variable locale au thread #pragma omp critical var = ton calcul avec local_var // tu modifie ta variable partagée avec la valeur du thread ... }
Sinon, tu peux aussi paralléliser certains morceaux. Par exemple cette boucle se prête très bien à la parallélisation simple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #pragma omp parallel for for(i = 3; i < nxm3; i++){ if( wall[i][j][k] == 1 ){ im2 = i - 2; im3 = i - 3; dtdv = dt / V[i][j][k]; p[i][j][k] -= dtdv * (f[0][im2] - f[0][im3]); u[i][j][k] -= dtdv * (f[1][im2] - f[1][im3]); v[i][j][k] -= dtdv * (f[2][im2] - f[2][im3]); w[i][j][k] -= dtdv * (f[3][im2] - f[3][im3]); nus[i][j][k] -= dtdv * (f[4][im2] - f[4][im3]); } }

Salut kain_tn et merci de ta réponse

TVD ne modifie que les valeurs f[0][i],f[1][i],f[2][i],f[3][i] et f[4][i] transmises, les autres variables ne changeant pas et ne servent qu'au calcul de f[0][i],f[1][i],f[2][i],f[3][i] et f[4][i]

f est un tableau déclaré comme variable globale, en effet.

Par contre, je ne comprends pas très bien ceci:
Code:

1 2 3 4 5 6 7 8 9 #pragma omp parallel for shared(var) for() ... __var = ton calcul pour le thread // variable locale au thread #pragma omp critical var = ton calcul avec __var // tu modifie ta variable partagée avec la valeur du thread ... }

13/07/2009, 11h59
Isythiel

shared(var) signifie que tous les threads partagent la même variable (et non pas un var indépendant par thread)

Du coup, il faut mettre ta variable en zone critique (deuxieme instruction openMP) lorsque tu changes sa valeur, pour qu'un seul thread y accède à la fois, et donc ainsi ne pas corrompre sa valeur.
13/07/2009, 12h03
Goten

Petite remarque soit dit en passant et qui n'a aucun rapport : évitez les noms de variable commençant par des underscores, surtout deux... C'est réservé à la SL... pourrait y'avoir des conflits de noms.
13/07/2009, 12h52
kain_tn

Citation:

Envoyé par Goten

Petite remarque soit dit en passant et qui n'a aucun rapport : évitez les noms de variable commençant par des underscores, surtout deux... C'est réservé à la SL... pourrait y'avoir des conflits de noms.

En effet, mais c'est juste plus facile à voir pour de simples explications dans un post :p

EDIT: c'est modifié dans mon post ;)