Discussion :

[black.scratch]

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 :

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

[kain_tn]

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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]);
	}
}

[black.scratch]

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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

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

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

[kain_tn]

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