1:/* Me´todo do Trapézio Paralelo 
   2:* 
   3:* Entrada: Nenhuma. 
   4:* Saída: Estimativa da integral de a até b de f(x) 
   5:* usando o método do trapézio e n trapezóides.  
   6:* 
   7:* Algoritmo: 
   8:* 1. Cada processo calcula o seu intervalo 
   9:* de integração. 
  10:* 2. Cada processo estima a integral de f(x) 
  11:* sobre seu intervalo utilizando o método do trapézio
  12:* 3a. Cada processo != 0 envia sua integral para 0. 
  13:* 3b. Processo 0 soma os valores recebidos dos  
  14:* processos individuais e imprime o resultado. 
  15:* 
  16:* Nota: f(x), a, b, e n são todos fixos.
  17:*/ 
  18:
  19:#include <stdio.h> 
  20:
  21:/* Estaremos utilizando funções e definições MPI. */ 
  22:#include "mpi.h" 
  23:
  24:float f(float x) { 
  25:        float return_val; 
  26:        /* Calcula f(x). Armazena o valor calculado em return_val. */ 
  27:        . . . 
  28:        return return_val; 
  29:}
  30:float Trap(float local_a, float local_b, int local_n, float h) { 
  31:        float integral; /* Armazena o resultado em integral */ 
  32:        float x; 
  33:        int i; 
  34:        integral = (f(local_a) + f(local_b))/2.0; 
  35:        x = local_a; 
  36:        for (i = 1; i != local_n­1; i++) { 
  37:                x += h; 
  38:                integral += f(x); 
  39:        }
  40:        integral *= h; 
  41:        return integral; 
  42:} /* Trap */
  43:
  44:main(int argc, char** argv) { 
  45:        int my_rank;            /* Rank do meu processo */ 
  46:        int p;                  /* O número de processos */ 
  47:        float a = 0.0;          /* Limite esquerdo */ 
  48:        float b = 1.0;          /* Limite direito */ 
  49:        int n = 1024;           /* Número de trapezóides */ 
  50:        float h;                /* Comprimento da base do trapezoide */ 
  51:        float local_a;          /* Limite esquedo do meu processo */ 
  52:        float local_b;          /* Limite direito do meu processo  */ 
  53:        int local_n;            /* Numero de trapezoides que devo calcular */ 
  54:        float integral;         /* Integral no meu intervalo */ 
  55:        float total;            /* Integral total */ 
  56:        int source;             /* Processo enviando a integral */ 
  57:        int dest = 0;           /* Todas as mensagens vão para  0 */ 
  58:        int tag = 50; 
  59:        MPI_Status status; 
  60:        
  61:        /* Permite ao sistema iniciar o  MPI */ 
  62:        MPI_Init(&argc, &argv); 
  63:
  64:        /* Pega o rank do meu processo */ 
  65:        MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); 
  66:
  67:        /* Encontra quantos processos estão ativos */ 
  68:        MPI_Comm_size(MPI_COMM_WORLD, &p); 
  69:
  70:        h = (b­a)/n; /* h is the same for all processes */ 
  71:        local_n = n/p; /* So is the number of trapezoids */ 
  72:        
  73:        /* Comprimento do intervalo de integração cada 
  74:        * processo = local_n*h. Então meu intervalo 
  75:        * inicia em: */ 
  76:
  77:        local_a = a + my_rank * local_n * h; 
  78:        local_b = local_a + local_n * h; 
  79:        integral = Trap(local_a, local_b, local_n, h); 
  80:
  81:        /* Soma as integrais calculadas por cada processo */ 
  82:
  83:        if (my_rank == 0) { 
  84:                total = integral; 
  85:                for (source = 1; source < p; source++) { 
  86:                        MPI_Recv(&integral, 1, MPI_FLOAT, source, tag, 
  87:                        MPI_COMM_WORLD, &status); 
  88:                        total += integral; 
  89:                } 
  90:        } else { 
  91:                MPI_Send(&integral, 1, MPI_FLOAT, dest, 
  92:                tag, MPI_COMM_WORLD); 
  93:        }
  94:        
  95:        /* Imprime o resultado*/ 
  96:        if (my_rank == 0) { 
  97:                printf("Com n = %d trapezoides, nossa estimativa \n", n); 
  98:                printf("da integral de %f até %f = %f \n", a, b, total); 
  99:        } 
 100:        /* Derruba o MPI */ 
 101:        MPI_Finalize(); 
 102:} /* main */