computa o embara osamente paralela n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Computação Embaraçosamente Paralela PowerPoint Presentation
Download Presentation
Computação Embaraçosamente Paralela

Loading in 2 Seconds...

play fullscreen
1 / 26
drew-powers

Computação Embaraçosamente Paralela - PowerPoint PPT Presentation

108 Views
Download Presentation
Computação Embaraçosamente Paralela
An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  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