changes

matrix.c

@@ -99,7 +99,16 @@ void Insert_Matrix(double **a, int a_dim0, int a_dim1, int pos_dim0, int pos_dim
 	int i,j;
 	for(i=0; i < b_dim0 - offset_dim0_left - offset_dim0_right; i++) {
 		for(j=0; j < b_dim1 - offset_dim1_left - offset_dim1_right; j++) {
-			a[pos_dim0 + i][pos_dim0 + j] = b[offset_dim0_left + i][offset_dim1_right + j];
+			a[pos_dim0 + i][pos_dim1 + j] = b[offset_dim0_left + i][offset_dim1_right + j];
+		}
+	}
+}
+
+void Insert_Array_In_Matrix(double **a, int a_dim0, int a_dim1, int pos_dim0, int pos_dim1, double *b, int b_dim0, int b_dim1, int offset_dim0_left, int offset_dim0_right, int offset_dim1_left, int offset_dim1_right) {
+	int i,j;
+	for(i=0; i < b_dim0 - offset_dim0_left - offset_dim0_right; i++) {
+		for(j=0; j < b_dim1 - offset_dim1_left - offset_dim1_right; j++) {
+			a[pos_dim0 + i][pos_dim1 + j] = b[(offset_dim0_left + i) * b_dim1 + offset_dim1_right + j];
 		}
 	}
 }
\ No newline at end of file

proj.c

 
+#define min(X,Y) (((X) < (Y)) ? (X) : (Y))
+#define max(X,Y) (((X) > (Y)) ? (X) : (Y))
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
@@ -9,27 +11,38 @@
 double eps = 0.001;
 double delta_t = 0.000001;
 double alpha = 1;
+MPI_Datatype MPI_process_info;
+
+void Create_MPI_Type_t_process_info() {
+	t_process_info mock;
+	MPI_Datatype type[7] = {MPI_INT, MPI_INT, MPI_INT, MPI_INT, MPI_INT, MPI_INT, MPI_INT};
+	int blocklen[7] = {1, 1, 1, 1, 1, 1, 1};
+	MPI_Aint disp[7];
+	disp[0] = (int)&(mock.rank) - (int)&mock;
+	disp[1] = (int)&(mock.coord0) - (int)&mock;
+	disp[2] = (int)&(mock.coord1) - (int)&mock;
+	disp[3] = (int)&(mock.start_m) - (int)&mock;
+	disp[4] = (int)&(mock.start_n) - (int)&mock;
+	disp[5] = (int)&(mock.end_m) - (int)&mock;
+	disp[6] = (int)&(mock.end_n) - (int)&mock;
+	MPI_Type_create_struct(7, blocklen, disp, type, &MPI_process_info);
+	MPI_Type_commit(&MPI_process_info);
+}
 
 int main(int argc, char **argv)
 {
-
 	MPI_Init(&argc, &argv);
 	int m, n;
+	double **root_field;
 	double **partial_field;
 	double start, end;
 	t_process_info pi;
+	t_process_info *infos;
 
-	process_args(argc, argv, &m, &n, &eps, &delta_t);
+	Create_MPI_Type_t_process_info();
 
-/*
-	a = New_Matrix(m, n);
-	if (a == NULL) {
-		fprintf(stderr, "Can't allocate matrix !\n");
-		exit(1);
-	}
+	process_args(argc, argv, &m, &n, &eps, &delta_t);
 
-	Init_Matrix(a, m, n, 0);
-*/
 	int pid, num_p;
 	if(MPI_Comm_rank(MPI_COMM_WORLD, &pid)) {
 		fprintf(stderr, "Cannot fetch PID\n");
@@ -41,6 +54,16 @@ int main(int argc, char **argv)
 		exit(1);
 	}
 
+	if(pid == 0) {
+		root_field = New_Matrix(m, n);
+		if (root_field == NULL) {
+			fprintf(stderr, "PID %s: Can't allocate root_field !\n", pid);
+			exit(1);
+		}
+
+		Init_Matrix(root_field, m, n, 0);
+	}
+
 	if(pid == 0) {
 		printf("number of processes: %d\n", num_p);
 	}
@@ -84,63 +107,137 @@ int main(int argc, char **argv)
 	pi.start_m = coord[0] * m_per_pro;
 	pi.end_m = (coord[0]+1)*m_per_pro -1;
 	pi.start_n = coord[1] * n_per_pro;
-	pi.end_n = (coord[0]+1) * n_per_pro -1;
+	pi.end_n = (coord[1]+1) * n_per_pro -1;
 	if(pi.end_m > m - 1) {
 		pi.end_m = m - 1;
 	}
 	if(pi.end_n > n - 1) {
 		pi.end_n = n - 1;
 	}
+	pi.coord0 = coord[0];
+	pi.coord1 = coord[1];
+	pi.rank = pid;
 
-	// print own info
-	printf("pid(%d,%d) from (%d, %d) to (%d,%d)\n",
-		coord[0],
-		coord[1],
-		pi.start_n,
-		pi.start_m,
-		pi.end_n,
-		pi.end_m
-	);
+	int matrix_size[2];
+	matrix_size[0] = pi.end_m - pi.start_m + 3;
+	matrix_size[1] = pi.end_n - pi.start_n + 3;
+
+	if(MPI_Comm_size(cart_comm, &num_p)) {
+		fprintf(stderr, "Cannot fetch size of cart\n");		
+		exit(1);
+	}
+
+	if(pid == 0) {
+		infos = malloc(sizeof(t_process_info) * num_p);
+	}
+
+	if(MPI_Gather(&pi, 1, MPI_process_info, infos, 1, MPI_process_info, 0, cart_comm)) {
+		fprintf(stderr, "Gather failed\n");		
+		exit(1);
+	}
 
-	double delta_a;
-	partial_field = New_Matrix(pi.end_m - pi.start_m + 2, pi.end_n - pi.start_n + 2);
-	double **partial_field_tmp = New_Matrix(pi.end_m - pi.start_m + 2, pi.end_n - pi.start_n + 2);
 	int i,j;
+
+	if(pid == 0) {
+		for(i = 0; i < num_p; i++) {
+			printf("pid: %d->(%d,%d) from (%d, %d) to (%d,%d)\n", 
+				infos[i].rank,
+				infos[i].coord0,
+				infos[i].coord1,
+				infos[i].start_m,
+				infos[i].start_n,
+				infos[i].end_m,
+				infos[i].end_n
+			);
+		}
+	}
+
+	double delta_a;
+	partial_field = New_Matrix(matrix_size[0], matrix_size[1]);
+	if (partial_field == NULL) {
+		fprintf(stderr, "PID %d: Can't allocate partial_field %d, %d end_M: %d, start_m: %d, end_n: %d, start_n: %d!\n", 
+			pid, 
+			matrix_size[0], 
+			matrix_size[1],
+			pi.end_m,
+			pi.start_m,
+			pi.end_n,
+			pi.start_n
+		);
+		exit(1);
+	}
+
+	double **partial_field_tmp = New_Matrix(matrix_size[0], matrix_size[1]);
 	double **swap;
 	double hx = 1.0/(double)m;
 	double hy = 1.0/(double)n;
 	double hx_square = hx * hx;
 	double hy_square = hy * hy;
 
-	double max_delta_t = 0.25*((min(hx,hy))*(min(hx,hy)))/alpha;  /* minimaler Wert f�r Konvergenz */
+	double max_delta_t = 0.25*((min(hx,hy))*(min(hx,hy)))/alpha;  /* minimaler Wert für Konvergenz */
 	if (delta_t > max_delta_t) { 
 		delta_t = max_delta_t;
-		printf ("Info: delta_t set to %.10lf.\n", delta_t);
+		if(pid == 0)
+			printf ("Info: delta_t set to %.10lf.\n", delta_t);
 	}
-	for(i = 1; i < pi.end_m - pi.start_m + 1; i++) {		// catch edges
-		for(j = 1; j < pi.end_n - pi.start_n + 1; j++) {	// catch edges
+
+	for(i = 1; i < pi.end_m - pi.start_m + 2; i++) {		// catch edges
+		for(j = 1; j < pi.end_n - pi.start_n + 2; j++) {	// catch edges
+			/*
 			delta_a = alpha * 
 				    ( (partial_field[i+1][j] + partial_field[i-1][j] - 2.0 * partial_field[i][j]) / (hy_square)
 					 +(partial_field[i][j-1] + partial_field[i][j+1] - 2.0 * partial_field[i][j]) / (hx_square) );
 			delta_a = delta_a * delta_t;
 			partial_field_tmp[i][j] = partial_field[i][j] + delta_a;
-
+			
 			if(delta_a > maxdiff)
 				maxdiff = delta_a;
+			*/
+			partial_field_tmp[i][j] = 8;
 		}
 	}
 	swap = partial_field_tmp;
 	partial_field_tmp = partial_field;
 	partial_field = swap;
 	
-
+	//Send_To_Root(partial_field, pi.end_m - pi.start_m + 2, pi.end_n - pi.start_n + 2);
+	MPI_Send(partial_field[0], matrix_size[0]*matrix_size[1], MPI_DOUBLE, 0, 0 ,cart_comm);
 	if(pid == 0) {
-		Write_Matrix(partial_field, pi.end_m - pi.start_m + 2, pi.end_n - pi.start_n + 2);
+		MPI_Request *requests = malloc(sizeof(MPI_Request) * num_p);
+		double **allocation = malloc(sizeof(double*) * num_p);
+		for(i = 0; i < num_p; i++) {
+			allocation[i] = malloc(sizeof(double) * (infos[i].end_m - infos[i].start_m + 3) * (infos[i].end_n - infos[i].start_n + 3));
+			MPI_Irecv(allocation[i], 
+				(infos[i].end_m - infos[i].start_m + 3) * (infos[i].end_n - infos[i].start_n + 3), 
+				MPI_DOUBLE, 
+				infos[i].rank, 
+				MPI_ANY_TAG, 
+				cart_comm,
+				&requests[i]
+			);
+		}
+		for(i = 0; i < num_p; i++) {
+			int current;
+			MPI_Waitany(num_p, requests, &current, MPI_STATUS_IGNORE);
+			Insert_Array_In_Matrix(
+				root_field, 
+				m, 
+				n, 
+				infos[current].start_m, 
+				infos[current].start_n, 
+				allocation[current], 
+				infos[current].end_m - infos[current].start_m + 3, 
+				infos[current].end_n - infos[current].start_n + 3, 
+				1, 1, 1, 1);
+			free(allocation[current]);
+		}
+		free(requests);
+		free(allocation);
+		Write_Matrix(root_field, m, n);
 	}
 
 	// write neighbar_com function
 
-
 	//MPI_Gather()
 	MPI_Finalize();
 

project.h

@@ -3,9 +3,13 @@ void Delete_Matrix(double **matrix);
 void Write_Matrix(double **a, int m, int n);
 void Init_Matrix(double **a, int m, int n, int init_value);
 void Insert_Matrix(double **a, int a_dim0, int a_dim1, int pos_dim0, int pos_dim1, double **b, int b_dim0, int b_dim1, int offset_top, int offset_right, int offset_bottom, int offset_left);
+void Insert_Array_In_Matrix(double **a, int a_dim0, int a_dim1, int pos_dim0, int pos_dim1, double *b, int b_dim0, int b_dim1, int offset_top, int offset_right, int offset_bottom, int offset_left);
 void process_args(int argc, char **argv, int *m, int *n, double *eps, double *delta_t);
 
 typedef struct {
+	int rank;
+	int coord0;
+	int coord1;
 	int start_m;	// first tile to process in X-axis
 	int start_n;	// first tile to process in Y-axis
 	int end_m;	// last tile to process in X-axis