PROCESSAMENTO PARALELO

AULA # 5
UMA APLICAÇÃO: INTEGRAÇÃO NUMÉRICA

Universidade Estadual de Santa Cruz

Bacharelado em Ciência da Computação
Prof. Dany Sanchez Dominguez
 INTEGRAÇÃO NUMÉRICA
Y

f(x)

a b x
•um enfoque para estimar o valor da integral, é
dividir a área baixo a curva em formas geométricas
regulares,
•calcular a área de cada uma das formas, e somar
todas as áreas,
 INTEGRAÇÃO NUMÉRICA
•se utilizarmos como forma regular o trapézio
teremos a regra dos trapézios,
Y

f(x)

a b x

•supomos que todos os trapézios tem a mesma

base, (h)
 INTEGRAÇÃO NUMÉRICA
• h = (b-a)/n , n é a quantidade de trapézios,
•um aumento do número de trapézios n, diminui
o erro de nossa estimativa,
•base dos trapézios:
[a, a+h]
[a+h, a+2h]
[a+2h, a+3h]
...
[a+(i-h)h, a+ih], i = 1, ... , n
 INTEGRAÇÃO NUMÉRICA
•Definimos: xi = a + ih , i = 0, ... , n
[xi-1, xi] , base
f(xi-1) , altura esquerda do trapézio,
Y
f(xi) , altura direita do trapézio .
f(xi-1)
f(x)

Ai = (h/2)[f(xi-1)+f(xi)]
f(xi)

h
xi-1 xi x
 INTEGRAÇÃO NUMÉRICA
•A área total:

•Ex. Use o a regra dos trapézios para estimar a

integral:
float f (float);

PROGRAMA SERIAL
int main()
{
float integral, a=0.0, b=1.0, h, x;
int n=512, i;

h = (b-a)/n;
integral = (f(a) + f(b))/2;
x = a;
for(i=1; i<=n-1; i++){
x += h;
integral += f(x);
}
integral *= h;

printf("Com n=%d trapezios, a estimativa da\n", n);

printf("integral de %.2f a %.2f e: %.6f\n", a, b, integra
return 0;
}

float f (float x){

return x*x + 1.0;
}
 PARLELIZANDO A REGRA DO TRAPÉZIO

•Existem vários enfoques para paralelizar um

programa serial,
•O enfoque mais simples é distribuir os dados
entre os processos,
•nossos dados são o intervalo [a, b] e seus n
trapézios associados,
•paralelizamos a regra do trapézio associando a
cada processo um subintervalo de [a, b]
 PARLELIZANDO A REGRA DO TRAPÉZIO

•cada processo estima a integral em um

subintervalo,
•para obter o resultado final devemos somar os
resultados obtidos em cada processo,
• p -> processos
• n -> trapézios, n é divisível por p
• nl = n/p -> numero de trapézios em um processo
•processos: r = 0, ... , p-1
 PARLELIZANDO A REGRA DO TRAPÉZIO

•divisão da tarefa: processo intervalo

0 [a, a+nl h]
1 [a+nl h, a+2nl h]
...
Y r [a+rnl h, a+(r+1)nl
h]
...
f(x) p-1 [a+(p-1)nl h, b]

a b x

0 1 2 3
 PARLELIZANDO A REGRA DO TRAPÉZIO

•Então cada processo precisa:

1. a quantidade total de processos,
2. o identificador do processo (rank),
3. o intervalo de integração [a, b],
4. o numero de trapézios n,
•1 e 2 são fornecidos por MPI,
•3 e 4 são dados de entrada do usuário, (por
enquanto inicializações)
•para computar o resultado final os resultados
locais devem ser enviados ao processador 0.
float f (float);
float Trap(float, float, int, float);

int main(int argc, char** argv)

{
float integral, a=0.0, b=1.0, h, x;
int n=512, i;
float local_a, local_b, total;
int rank, p;
MPI_Status status;

MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_Size(MPI_COMM_WORLD, &p);

h = (b-a)/n;
local_n = n/p;

local_a = a + rank*local_n*h;
local_b = local_a + local_n*h;
integral = Trap(local_a, local_b, local_n, h);
 if(rank==0){
total = integral;
for(i=1; i<p; i++){
MPI_Recv(&integral, 1, MPI_Float, i, 0,
MPI_COMM_WOLRD, &status);
total += integral;
}
printf("Com n=%d trapezios, a estimativa da\n", n);
printf("integral de %.2f a %.2f e: %.6f\n",
a, b, integral);
} else
MPI_Send(&integral, 1, MPI_FLOAT, 0, 0,
MPI_COMM_WOLRD);

MPI_Finalize();

return 0;
}
float f (float x){
return x*x + 1.0;
}

float Trap(float local_a, float local_b,

int local_n, float h){
float integral, x;
int i;

integral = (f(local_a) + f(local_b))/2.0;

x = local_a;
for(i=1; i<=local_n-1; i++){
x += h;
integral += f(x);
}
integral *= h;

return integral;
}
 PARLELIZANDO A REGRA DO TRAPÉZIO

•em nosso programa diferenciamos

explicitamente as variáveis significativas em
todos processos (variáveis globais*), das
variáveis individuais de cada processo (local_,
variáveis locais*),
•*em processamento paralelo variável global e
local tem um significado muito diferente do
significado em programação tradicional,
 E/S EM PROCESSAMENTO PARALELO
•um problema obvio de nosso programa é a
perdida de generalidade,
•a função f(x), e os dados de entrada a, b e n são
predefinidos,
•para mudar alguma dessas características o
programa deve ser recompilado,
•em relação a função f(x), podemos criar uma
livraria de funções e utilizar um ponteiro a
função em nosso programa, (isto não será
abordado)
 E/S EM PROCESSAMENTO PARALELO
•em relação aos dados de entrada (a, b e n)
algumas considerações podem ser feitas,
•Alguns sistemas paralelos permitem que todos
os processos recebam dados do dispositivo
padrão de entrada (teclado),
•entretanto, outros sistemas associam o
dispositivo padrão de entrada e o dispositivo
padrão de saída (vídeo) ao processo 0.
•Supor, a existência do segundo enfoque é mais
seguro, pois ele funciona em todos os sistemas,
 E/S EM PROCESSAMENTO PARALELO

•porem, é uma boa pratica de programação

quando todas as operações E/S são feitas pelo
processo 0,

•Exercício:
Modifique o programa anterior, introduzindo uma
função GET_DATA(), que leia os dados de
entrada no processo 0 e envie os dados lidos aos
outros processos.