Computação Embaraçosamente Paralela

1. Computação Embaraçosamente Paralela

2. Dados de entrada Processos Resultados 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

3. Criação dinâmica de processos com técnica mestre-escravo Envio de dados iniciais spawn() send() recv() Escravos Mestre send() recv() Coleta resultados

4. 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 Sxna 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

5. x Processo 80 y 640 80 Mapeia 480 Partição em regiões para os processos individuais

6. Partição em regiões para os processos individuais Processo 640 10 Mapeia 480

7. Pseudocódigo para executar deslocamento de imagem • Mestre for (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];

8. 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); }

9. Análise de complexidade • Seqüencial • Paralela • Comunicação • Computação • Tempo total de execução Para uma constante p, O(n2)

10. 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

11. Conjunto de Mandelbrot • Simplificando o cálculo de

12. 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; }

13. 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ódigo for (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); }

14. Paralelizando o cálculo do conjunto de Mandelbrot com alocação dinâmica de tarefas Pool de trabalho (xa,ya) (xe,ye) (xc,yc) (xd,yd) (xb,yb) Tarefa Retorna resultados/ pede nova tarefa

15. Código para a técnica de pool de trabalho • Mestre count = 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);

16. 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); };

17. Terminação do contador Linhas tratadas nos escravos(count) Linha enviada Incremento 0 disp_height Término Linha retornada Decremento

18. 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

19. Área total=4 Área =  2 2 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

20. f(x) 1 1 x 1 Calculando uma integral 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. Calculando uma integral (método alternativo) • Gere valores aleatórios para x entre x1e 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);

22. Mestre Soma parcial Pedido Escravos Número aleatório Processo gerador de números aleatórios Implementação paralela

23. Pseudocódigo • Mestre for (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);

24. 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);

25. Geração de números aleatórios • Geração de uma seqüência de números pseudo aleatórios

26. Geração paralela de números aleatórios x1 x2 xk-1 xk xk+1 xk+2 x2k-1 x2k