computação embaraçosamente paralela. computação embaraçosamente paralela um processamento que...
TRANSCRIPT
Computação Embaraçosamente Paralela
Computação embaraçosamente paralela
• Um processamento que pode ser dividido em um número de partes completamente independentes, cada uma podendo se executada por um processador diferente
Processos
Dados de entrada
Resultados
Criação dinâmica de processos com técnica mestre-escravo
spawn()send()
Mestre
recv()
Envio de dados iniciais
Coleta resultados
Escravosrecv()
send()
Exemplos
(a) Deslocamento: deslocar um objeto de x na dimensão x e y na dimensão y
(b) Mudança de escala: mudar a escala de um objeto por um fator Sx na dimensão x e por Sy na dimensão y
(c) Rotação: rotacionar um objeto de um ângulo em relação à origem do sistema de coordenadas
xxx yyy
xxSx yySy
sincos yxx cossin yxy
Partição em regiões para os processos individuais
80
80
480
640
x
yProcesso
Mapeia
Partição em regiões para os processos individuais
10
480
640
Processo
Mapeia
Pseudocódigo para executar deslocamento de imagem
• Mestrefor (i=0, row=0; i < 48; i++, row = row+10) send (row, Pi); }
for (i=0; i < 480; i++) for (j=0; j < 640; j++) temp_map[i][j]=0;for (i=0; i < (640*480); i++) { recv(oldrow, oldcol, newrow, newcol, Pany); if !((newrow < 0) || (newrow >=480) || (newcol < 0) || newcol >=640)) temp_map[newrow][newcol]=map[oldrow][oldcol]; }for (i=0; i < 480; i++) for (j=0; j < 640; j++) map[i][j]= temp_map[i][j];
Pseudocódigo para executar deslocamento de imagem
• Escravo
recv(row, Pmestre);
for (oldrow=row; oldrow < (row +10); oldrow++) for (oldcol=0; oldcol < 640; oldcol++) { newrow = oldrow + delta_x; newcol = oldcol + delta_y; send (oldrow, oldcol,newrow,newcol,Pmestre);
}
Análise de complexidade
• Seqüencial
• Paralela– Comunicação
– Computação
– Tempo total de execução
Para uma constante p, O(n2)
)(2 22 nOnts
)()4()( 22 npOttnttpmttt datastartupdatastartupdatastartupcomm
pnOp
ntcomp /2 22
commcompp ttt
Conjunto de Mandelbrot
• Conjunto de pontos no plano complexo que são quase estáveis (diminuem e aumentam, mas não passam de certo limite) quando calculados pela iteração da função
onde é a (k+1) iteração do número complexo z=a+bi e c é um número complexo que dá a posição do ponto no plano complexo
• Valor inicial de z é 0 e iterações são executadas até que a magnitude de z (zlength) seja maior que 2 ou número de iterações alcançou limite máximo
czz kk 2
1
1kz
22 bazlength
Conjunto de Mandelbrot
• Simplificando o cálculo de
czz kk 2
1
imagimagrealimag
realimagrealreal
czzz
czzz
zabibaibabiaz
2
22
222222
2
iteração cada para de valor do Cálculo22
Rotina seqüencial para calcular valor de um ponto retornando número de iterações
structure complex { float real; float imag;}
int cal_pixel(complex c){int count, max;complex z;float temp, lengthsq;max=256;z.real=0; z.imag=0;count=0;do { temp=z.real*z.real -z.imag*z.imag +c.real; z.imag=2*z.real*z.imag + c.imag; z.real=temp; lengthsq=z.real*z.real+z.imag*z.imag; count ++} while ((lengthsq < 4.0) && (count < max));return count;}
Mudança de escala do sistema de coordenadas
• Para ser eficiente computacionalmente:scale_real=(real_max - real_min)/disp_width;scale_imag = (imag_max - imag_min)/disp_height;
• Incluindo a mudança de escala, temos o seguinte códigofor (x = 0; x < disp_width; x++) for (y = 0; y < disp_height; y++) { c.real = real_min +((float) x * scale_real); c.imag = imag_min + ((float) y * scale_imag); color = cal_pixel(c); display(x, y, color); }
Paralelizando o cálculo do conjunto de Mandelbrot com alocação dinâmica de
tarefas
(xc,yc)(xa,ya) (xe,ye)
(xb,yb) (xd,yd)
Pool de trabalho
TarefaRetorna resultados/
pede nova tarefa
Código para a técnica de pool de trabalho
• Mestrecount = 0;row = 0;for (k=0; k < procno; k++) { send(&row, Pk, data_tag); count++; row++; }do { recv (&slave, &r, color, Pany, result_tag); count--; if (row < disp_height) { send (&row, Pescravo, data_tag); row ++; count ++; } else send (&row, Pescravo, terminator_tag); display ( r, color);} while (count > 0);
Código para a técnica de pool de trabalho
• Escravo
recv(y, Pmestre, ANYTAG, source_tag);while (source_tag == data_tag) { c.imag = imag_min + ((float) y * scale_imag); for (x = 0; x <disp_width; x++) { c.real = real_min + ((float) x * scale_real); color[x] = cal_pixel(c); } send (&i, &y, color, Pmestre, result_tag); recv (y, Pmestre, source_tag);};
Terminação do contador
0 disp_heightLinha enviadaIncremento
Linha retornadaDecremento
Linhas tratadas nos escravos (count)
Término
Análise de complexidade• Seqüencial
• Paralelo– Fase 1: Comunicação - um número de linha é enviado para cada escravo
– Fase 2: Computação - Escravos executam o cálculo de Mandelbrot em paralelo
– Fase 3: Comunicação - Resultados são enviados para o mestre por envios individuais
– Complexidade geral
)(max nOnts
)(1 datastartupcomm ttst
sntcomp
max
)(2 datastartupcomm vttut
)()(maxdatastartupdatastartupp vttutts
snt
Métodos de Monte Carlo
• A base dos métodos de Monte Carlo é utilizar seleções aleátorias para os cálculos • Exemplo: Cálculo de
• Pontos dentro do quadrado são escolhidos aleatoriamente e verifica-se a fração desses pontos que está dentro do círculo• Dado um número suficiente de amostras aleatórias, essa fração será /4
Área = 2
2
Área total=4
422)1(
quadrado do Áreacírculo do Área 2
Calculando uma integral
1
1
1
f(x)
x
21 xy 1
0
2
41 dxx
Um par de números aleatórios (xr, yr) pode ser gerado entre 0 e 1 e contado como dentro do círculo se , ou seja, 21 rr xy 122 rr xy
Calculando uma integral (método alternativo)
• Gere valores aleatórios para x entre x1 e x2, calcule f(x) e a soma dos valores de f(x)
• Exemplo: Calcular
sum = 0;for (i = 0; i < N; i++) { xr = rand_v(x1, x2); sum = sum + xr*xr -3 *xr;}area = (sum /N) * ( x2-x1);
))((1lim)(Área 11
2
2
1
xxxfN
dxxfN
ir
x
xN
2
1
)3(I 2x
x
dxxx
Implementação paralela
Mestre
Escravos
Processo geradorde números aleatórios
Somaparcial
Pedido
Númeroaleatório
Pseudocódigo
• Mestrefor (i = 0; i < N/n; i++) { for (j = 0; j < n; j+=) xr[j] = rand (); recv(Pany, req_tag, Pfonte); send(xr, &n, Pfonte, compute_tag); } for (i = 0; i < slave_no; i++) { recv(Pi, req_tag); send(Pi, stop_tag); }sum=0;reduce_add(&sum, Pgroup);
Pseudocódigo
• Escravo
sum = 0;send(Pmaster, req_tag);recv(xr, &n, Pmestre, source_tag);while (source_tag == compute_tag) { for (i = 0; i < n; i++) sum = sum +xr[i] * xr[i] -3 * xr[i]; send(Pmestre, req_tag); recv(xr, &n, Pmaster, source_tag);}reduce_add(&sum, Pgroup);
Geração de números aleatórios
• Geração de uma seqüência de números pseudo aleatórios
mcaxx
xxxxxxxx
ii
nniii
mod)(
,,...,,,,...,,
1
1113,21
Geração paralela de números aleatórios
maaaacCmaA
mCAxx
mcaxx
kkk
iki
ii
mod)...( ,mod onde
mod)(
mod)(
0121
1
x1 x2 xk-1 xk xk+1 xk+2 x2k-1 x2k