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