Probleme gauss-seidel parallelise avec MPI

**leetimber5** · 19/01/2010, 23h13

Bonjour,
je debute en MPI, et je suis en train de paralleliser gauss-seidel en dimension 2 avec deux processeurs. J'ai divise le domaine en 2, j'ai fait calculer la moitie des valeurs par le processus 1, l'autre par le processus 2, je les ai fait echanger les erreurs maximales et les valeurs dont chacun avait besoin. Puis j'ai envoye le tout au processus 0.
Lorsque je compile, pas de probleme. Mais lors de l'execution, j'ai beau attendre rien ne se passe.. Je ne comprends pas, tout me semble logique..
Voici ce que j'ai fait:

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#include <iostream>
#include <math.h>
#include<mpi.h>
using namespace std;
 
int main(int argc; char** argv) {
double u[200][200];
double t;
double eps=0.00000001;
double erreur, erreur_max1, erreur_max2, erreur_max;
int iter_max=50000;
int iter;
int i,j;
int j1=(int)(N/2-1); // le premier processus va calculer u jusqu'a la j1-ieme ligne, et l'autre a partir de la j1+1-ieme
int N=200;
double * uj1;// va contenir les valeurs de u sur la ligne j1 :il est necessaire de les stocker pour pouvoir les envoyer du 1er au 2nd processus
double * uj11;// va contenir les valeurs de u sur la ligne j1+1 :il est necessaire de les stocker pour pouvoir les envoyer du 2nd au 1er processus
 
int rang, p;
 
MPI_Status status;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&rang);// rang designe le numero de processus
MPI_Comm_size(MPI_COMM_WORLD,&p);// p designe le nombre de processus
 
uj1=new double[N-2]; 
uj2=new double[N-2]; 
 
//-------------------------------------------------------------------------------------------------------------------
//Voyons ce que fait le processus 1, qui se charge des calculs de u de la 0-ieme ligne a la j1-ieme
 
if (rang==1){ 
 
//initialisation de u
for (i=0;i<=N-1;i++){
for (j=0; j<=j1;j++){
u[i][j]=(double)j/(double)N;
}
}
 
//Prise en compte des conditions aux limites
 
for(j=0;j<=j1;j++)
{u[0][j]=0.0; // u=0 sur le bord i=0
u[N-1][j]=0.0;}// u=0 sur le bord i=N-1
// on a bien u=0 sur le bord j=0, car on a initialisÃ© u Ã* j/N donc pour j=0, on a bien u=0
 
iter=0;
do {
	erreur_max1=0.0;//initialisation de l'erreur Ã* 0
 
	for(i=1;i<=N-2;i++){
	for(j=1;j<=j1;j++){
 
	t=0.25*(u[i-1][j]+u[i+1][j]+u[i][j-1]+u[i][j+1]);
	erreur=fabs(t-u[i][j]);
	if(erreur>erreur_max1)erreur_max1=erreur;
	u[i][j]=t;
	}
	uj1[i]=u[i][j1];// on remplit uj1 avec les valeurs de la j1-ieme ligne
	}
	iter=iter+1;
	MPI_Send(&erreur_max1,1,MPI_DOUBLE,1,2,MPI_COMM_WORLD);// envoi de l'erreur max au processus 2
	MPI_Recv(&erreur_max1,1,MPI_DOUBLE,2,1,MPI_COMM_WORLD);// Reception de l'erreur max au processus 2
        if(erreur_max1>erreur_max2) erreur_max1=erreur_max2;
     } while( (iter<iter_max)&& (erreur_max1 > eps));
 
MPI_Send(&u,N*N/2,MPI_DOUBLE,1,0,MPI_COMM_WORLD);// envoi de u au processus 0 
MPI_Send(&uj1,N-2,MPI_DOUBLE,1,2,MPI_COMM_WORLD);// envoi de la ligne j1 au processus 2
 
MPI_Recv(&uj11,N-2,MPI_DOUBLE,2,1,MPI_COMM_WORLD);// Reception de la ligne j1+1 envoyee par le processus 2
 
 
 
}
//-----------------------------------------------------------------------------------------------------------------------
 
//-------------------------------------------------------------------------------------------------------------------
// Voyons ce que fait le processus 2, qui se charge des calculs de u de la j1+1-ieme ligne a la N-1-ieme
 
if (rang==2){ 
 
//initialisation de u
for (i=0;i<=N-1;i++){
for (j=j1+1; j<=N-1;j++){
u[i][j]=(double)j/(double)N;
}
}
 
//Prise en compte des conditions aux limites
for(i=0;i<=N-1;i++)
{u[i][N-1]=1.0;} //u=0 sur le bord j=N-1
for(j=j1+1;j<=N-2;j++)
{u[0][j]=0.0; // u=0 sur le bord i=0
u[N-1][j]=0.0;}// u=0 sur le bord i=N-1
 
 
iter=0;
do {
	erreur_max2=0.0;//initialisation de l'erreur Ã* 0
 
	for(i=1;i<=N-2;i++){
	for(j=j1+1;j<=N-2;j++){
 
	t=0.25*(u[i-1][j]+u[i+1][j]+u[i][j-1]+u[i][j+1]);
	erreur=fabs(t-u[i][j]);
	if(erreur>erreur_max2)erreur_max2=erreur;
	u[i][j]=t;
	}
	uj11[i]=u[i][j1];// on remplit uj11 avec les valeurs de la j1+1-ieme ligne
	}
	iter=iter+1;
	MPI_Send(&erreur_max2,1,MPI_DOUBLE,1,1,MPI_COMM_WORLD);// envoi de l'erreur max au processus 1
	MPI_Recv(&erreur_max1,1,MPI_DOUBLE,1,2,MPI_COMM_WORLD);// Reception de l'erreur max envoyee par le processus 1
	if(erreur_max2>erreur_max1) erreur_max2=erreur_max1;
     } while( (iter<iter_max)&& (erreur_max2 > eps));
 
MPI_Send(&u,N*N/2,MPI_DOUBLE,2,0,MPI_COMM_WORLD);// envoi de u au processus 0 
MPI_Send(&uj11,N-2,MPI_DOUBLE,2,1,MPI_COMM_WORLD);// envoi de la ligne j1+1 au processus 1
 
 
MPI_Recv(&uj1,N-2,MPI_DOUBLE,1,2,MPI_COMM_WORLD);// Reception de la ligne j1 envoyee par le processus 1
 
}
//-----------------------------------------------------------------------------------------------------------------------
 
// Voyons ce que fait le processus 0, qui se charge de rassembler les resultats
 
 
if (rang==0) {
MPI_Recv(&u,N*N/2,MPI_DOUBLE,2,0,MPI_COMM_WORLD);
MPI_Recv(&u,N*N/2,MPI_DOUBLE,1,0,MPI_COMM_WORLD);
cout <<"valeur de u au centre : " << u[N/2][N/2] << endl;
}
 
MPI_Finalize();
 
return 0;
 
}

Qu'en pensez-vous?
Merci d'avance

**leetimber5** · 21/01/2010, 18h49

Bonjour,
j'ai arrange mon programme. Desormais il donne quelque chose lors de l'execution, mais bloque au bout d'un moment. Mon probleme semble se trouver au niveau des echanges.. En particulier pour l'echange des erreurs entre le processeur 1 et le 2: J'ai utilise MPI_Reduce, afin de trouver le max des erreurs de chaque processeur (1 et 2), mais ca ne semble pas marcher.. Pensez-vous que cela peut venir du fait que le processeur 0 est maitre, (et ne fait donc rien) et que donc cette fonction ne peut pas etre utilisee?
Voici ce que j'ai fait:

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include <iostream>
#include <math.h>
#include<mpi.h>
using namespace std;
 
int main(int argc, char** argv)
{
	double u[10][10];
	double t;
	int N=10;
	double eps=0.0001;
 
	int iter_max=50;
	int iter;
	int i,j;
	int j1=(int)((N/2)-1); // le premier processus va calculer u jusqu'a la j1-ieme ligne, et l'autre a partir de la j1+1-ieme
	double* fantome;// va contenir les valeurs de u sur la ligne j1+1 :il est necessaire de les stocker pour pouvoir les envoyer du 2nd au 1er processus
 
	int rang, p;
 
	MPI_Status status;
	MPI_Init(&argc,&argv);
	MPI_Comm_rank(MPI_COMM_WORLD,&rang);// rang designe le numero de processus
	MPI_Comm_size(MPI_COMM_WORLD,&p);// p designe le nombre de processus
 
	fantome = new double[N]; 
 
	//initialisation de u
	if(rang!=0)
	{double erreur,erreur_max = 0;
 
	for (i=0;i<=N-1;i++){
	for (j=(j1+1)*(rang-1);j<=rang*(j1-1)+2*rang-1;j++){
							u[i][j]=(double)j/(double)N;
							//cout << "i= "<<i << "j= " << j << "u= " << u[i][j] << endl; 
							   }
			}
 
				//Prise en compte des conditions aux limites
 
				for(j=0;j<=rang*(j1-1)+2*rang-1;j++)// normalment juska n-2 seulement...		
				{u[0][j]=0.0; // u=0 sur le bord i=0
				u[N-1][j]=0.0;}// u=0 sur le bord i=N-1
 
				for(i=0;i<=N-1;i++)			
				{u[i][N-1]=1.0;} //u=0 sur le bord j=N-1
 
			// on a bien u=0 sur le bord j=0, car on a initialisÃ© u Ã* j/N donc pour j=0, on a bien u=0
			//ok
 
			cout <<"Initialisation de fantome";
			//for(i= 1; i < N-1; ++i)
			for(i= 0; i <= N-1; ++i)				
			{fantome[i] = (double)(j1+rang-1)/(double)N;// Pour proc 1 nous donnera la j1-ieme ligne et pour proc2, la j1+1-ieme
			}// ok
 
		cout << "************ Fin initialisation **********\n";//ok
		iter=0;
 
		do 
		{
			cout << "---------- iter " << iter << "----------\n";
			erreur_max=0.0;//initialisation de l'erreur Ã* 0
 
			if(rang == 1)
			{
				MPI_Send(fantome,N,MPI_DOUBLE,2,20,MPI_COMM_WORLD);
				cout << "le proc " << rang <<"a bien envoye";
				MPI_Recv(fantome,N,MPI_DOUBLE,2,10,MPI_COMM_WORLD,&status);
				cout << "le proc " << rang <<"a bien rec";
			}				
			else
			{							
				MPI_Recv(fantome,N,MPI_DOUBLE,1,20,MPI_COMM_WORLD,&status);
				cout << "le proc " << rang <<"a bien recu";
				MPI_Send(fantome,N,MPI_DOUBLE,1,10,MPI_COMM_WORLD);
				cout << "le proc " << rang <<"a bien envoye";
			}
			//ok
			cout << " Debut calcul\n";	
			for(i=1;i<=N-2;i++)
			{	
				for(j=(j1+1)*(rang-1)+1;j<=rang*(j1-1)+rang-1;j++)//ok
				{ 
 
					t=0.25*(u[i-1][j]+u[i+1][j]+u[i][j-1]+u[i][j+1]);
					erreur=fabs(t-u[i][j]);
					if(erreur>erreur_max) 
						erreur_max=erreur;
 
					u[i][j]=t;//ok
 
				}
			}
 
 
			double erreur_rec =0;
 
 
			MPI_Reduce(&erreur_max,&erreur_rec,1,MPI_DOUBLE,MPI_MAX,1,MPI_COMM_WORLD);
			MPI_Send(&erreur_rec,N,MPI_DOUBLE,2,1,MPI_COMM_WORLD);
			MPI_Recv(&erreur_rec,N,MPI_DOUBLE,1,1,MPI_COMM_WORLD,&status);
 
			cout << "erreur_rec= "<< erreur_rec << endl;
                        cout << "erreur_max= "<< erreur_max<< "proc num "<< rang << endl;
			cout << "echange des erreurs\n";
			cout << "____terminer echange des erreurs___\n";
 
      		erreur_max=erreur_rec;
cout << "nvelle erreur max= "<< erreur_max <<endl;
 
      	//mise Ã* jour fantome
 
	for(i= 0; i <= N-1; ++i)				
			{fantome[i] = u[i][(int)(j1+rang-1)];}
cout << "Mise a jour de fantome faite"<< endl;      
      	iter=iter+1;
cout << "iter= "<< iter<< endl;
		}while( (iter < iter_max) && (erreur_max > eps));// fin du do while
	}
MPI_Finalize();		
return 0;	
}

Merci d'avance

Probleme gauss-seidel parallelise avec MPI

Threads & Processus C++

Discussions similaires

Partager

Partager