并行计算

开发平台：
C/C++

jacobi-mpi3.c：源码内容
							#include <stdio.h>
#include <string.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
#include "mpi.h"
double max(double a, double b) {
	if(a > b) return a; else return b;
}
int main(int argc,char *argv[]) {	
	int myId;
	int numWorkers;
	int gridSize;
	int stripSize;
	int numIter;
	double maxdiff = 0.0, globalmaxdiff = 0.0;
	MPI_Status status;
	int i, j, iter;
	double tipmatriz, //tempo inicio preenchimento matriz
				tfpmatriz, //tempo final preenchimento matriz 
				tlpmatriz, //tempo local preenchimento matriz
				tgpmatriz, //tempo global preenchimento matriz 
				tienmatriz, //tempo inicio enviar matriz 
				tfenmatriz, //tempo final enviar matriz
				tlenmatriz, //tempo local enviar matriz
				tgenmatriz, //tempo global enviar matriz
				tirematriz, //tempo inicio receber matriz 
				tfrematriz, //tempo final receber matriz
				tlrematriz, //tempo local receber matriz
				tgrematriz, //tempo global receber matriz
				tigmatriz, //tempo inicio calcular grid
				tfgmatriz, //tempo final calcular grid
				tlgmatriz, //tempo local calcular grid
				tggmatriz, //tempo global calcular grid
				tinmatriz, //tempo inicio calcular novo
				tfnmatriz, //tempo final calcular novo
				tlnmatriz, //tempo local calcular novo
				tgnmatriz, //tempo global calcular novo
				timmatriz, //tempo inicio calcular diff
				tfmmatriz, //tempo final calcular diff
				tlmmatriz, //tempo local calcular diff
				tgmmatriz; //tempo global calcular diff
				
	
		
	if ((argc <= 1) || (argc != 3)) {
		printf("nn");
		printf("Jacobi Iteration Versao Sequencialn");
		printf("Desenvolvido por Robertino Mendes Santiago Jrn");
		printf("Mestrado em Ciencia da Computacaon");
		printf("Universidade Estadual de Maringan");
		printf("Maringa - Parana - Brasilnn");
		printf("Syntax:n");
		printf("jacobi-serial [gridSize] [numWorkers] [numIter]n");		
		printf("gridSize: tamanho da matrizn");
		printf("numIter: numero de iteracoesnn");	
		return 0;
	} 
	
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &myId);
	MPI_Comm_size(MPI_COMM_WORLD, &numWorkers);
   
	/*
	Pega os argumentos da linha de comando
	*/
	gridSize = atoi(argv[1]);
	numIter = atoi(argv[2]);
	stripSize = gridSize/numWorkers;	
	
	if (gridSize % numWorkers != 0) {
		printf("O tamanho do grid deve ser multiplo do numero de processos!n");
		MPI_Abort(MPI_COMM_WORLD, 1);
		return 0;
	}
	  
	if(myId == 0) {			
		/*
   		Imprime informacoes na tela
   		*/
   		printf("----------------n");
   		printf("Tamanho Grid.: %dn", gridSize);
   		printf("Trabalhadores: %dn", numWorkers);
   		printf("Iteracoes....: %dn", numIter);
   		printf("StripSize: %dn", stripSize);
   		printf("----------------n");	
	}
	
	double** grid = (double **)malloc((stripSize+1) * sizeof(double *));
  	double** novo = (double **)malloc((stripSize+1) * sizeof(double *));
  	for(i=0;i< gridSize+1;i++) {
     	grid[i] = (double *)malloc((gridSize+1) * sizeof(double));
     	novo[i] = (double *)malloc((gridSize+1) * sizeof(double));
   	}
		
	tipmatriz = MPI_Wtime();
	
	for (i=0; i<stripSize; i++) 
		for (j=0; j<gridSize; j++) {
			grid[i][j] = 1.0;
			novo[i][j] = 1.0+j;
		}
			
	tfpmatriz = MPI_Wtime();
	tlpmatriz = tfpmatriz - tipmatriz;
	
	MPI_Allreduce(&tlpmatriz, &tgpmatriz, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
	
	tlenmatriz = 0.0;
	tlrematriz = 0.0;
	tlgmatriz = 0.0;
	tlnmatriz = 0.0;
	tlmmatriz = 0.0;
	
	for (iter=0; iter < (numIter/2); iter++) {
		
		
		if (myId < numWorkers -1) {
			tienmatriz = MPI_Wtime();
			MPI_Send(grid[stripSize], gridSize, MPI_DOUBLE, myId+1 , 0, MPI_COMM_WORLD);
			MPI_Send(novo[stripSize], gridSize, MPI_DOUBLE, myId+1 , 0, MPI_COMM_WORLD);
			tfenmatriz = MPI_Wtime();
			
			tlenmatriz += (tfenmatriz-tienmatriz);
		}
		if (myId > 0) {
			tirematriz = MPI_Wtime();
			MPI_Recv(grid[0], gridSize, MPI_DOUBLE, myId -1, 0, MPI_COMM_WORLD, &status);
			MPI_Recv(novo[0], gridSize, MPI_DOUBLE, myId -1, 0, MPI_COMM_WORLD, &status);
			tfrematriz = MPI_Wtime();
			
			tlrematriz += (tfrematriz-tirematriz);
		}
			
		if (myId > 0) {
			tienmatriz = MPI_Wtime();
			MPI_Send(grid[1], gridSize, MPI_DOUBLE, myId-1 , 1, MPI_COMM_WORLD);
			MPI_Send(novo[1], gridSize, MPI_DOUBLE, myId-1 , 1, MPI_COMM_WORLD);
			tfenmatriz = MPI_Wtime();
			
			tlenmatriz += (tfenmatriz-tienmatriz);			
		}
		
		if (myId < numWorkers -1) {
			tienmatriz = MPI_Wtime();
			MPI_Recv(grid[stripSize+1], gridSize, MPI_DOUBLE, myId+1, 1, MPI_COMM_WORLD, &status);
			MPI_Recv(novo[stripSize+1], gridSize, MPI_DOUBLE, myId+1, 1, MPI_COMM_WORLD, &status);
			tfenmatriz = MPI_Wtime();
			
			tlenmatriz += (tfenmatriz-tienmatriz);
		}
		
		maxdiff = 0.0;
		tinmatriz = MPI_Wtime();
		for (i=1; i<stripSize-1; i++) {
			for (j=1; j<gridSize-1; j++) {
				novo[i][j] = (grid[i-1][j] + grid[i+1][j] + grid[i][j-1] + grid[i][j+1]) * 0.25;
			}
		}
		tfnmatriz = MPI_Wtime();
		
		tlnmatriz += (tfnmatriz-tinmatriz);
		
		tigmatriz = MPI_Wtime();
		for (i=1; i<stripSize-1; i++) {
			for (j=1; j<gridSize-1; j++) {
				grid[i][j] = (novo[i-1][j] + novo[i+1][j] + novo[i][j-1] + novo[i][j+1]) * 0.25;
			}
		}
		tfgmatriz = MPI_Wtime();
		
		tlgmatriz += (tfgmatriz-tigmatriz);
		
		timmatriz = MPI_Wtime();
		for (i=1; i < stripSize-1; i++) {
			for (j=1; j < gridSize-1; j++) {
				maxdiff = max(maxdiff, abs(grid[i][j] - novo[i][j]));
			}
		}
		tfmmatriz = MPI_Wtime();
		
		tlmmatriz += (tfmmatriz-timmatriz);
		
		MPI_Allreduce(&maxdiff, &globalmaxdiff, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
		
		MPI_Allreduce(&tlenmatriz, &tgenmatriz, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
		MPI_Allreduce(&tlrematriz, &tgrematriz, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
		MPI_Allreduce(&tlgmatriz, &tggmatriz, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
		MPI_Allreduce(&tlnmatriz, &tgnmatriz, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
		MPI_Allreduce(&tlmmatriz, &tgmmatriz, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
					
	}
	if (myId == 0) {
		printf("Maxdiff...................: [%.2f]n", globalmaxdiff);
		printf("Tempo preenchimento matriz: [%.2f]n", tgpmatriz);		
		printf("Tempo enviar matriz.......: [%.2f]n", tgenmatriz);
		printf("Tempo receber matriz......: [%.2f]n", tgrematriz);
		printf("Tempo calcular grid.......: [%.2f]n", tggmatriz);
		printf("Tempo calcular novo.......: [%.2f]n", tgnmatriz);
		printf("Tempo calcular diff.......: [%.2f]n", tgmmatriz);
		printf("tempo:[%.2f]n ", (tgpmatriz+tgenmatriz+tgrematriz+tggmatriz+tgnmatriz+tgmmatriz));
	}
	MPI_Finalize();
	return 0;
	
}

						