Computao Embaraosamente Paralela Computao embaraosamente paralela Um processamento
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 Dados de entrada Processos Resultados
Criação dinâmica de processos com técnica mestre-escravo spawn() send() Envio de dados iniciais Escravos Mestre recv() send() recv() Coleta resultados
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
Partição em regiões para os processos individuais x Processo 80 y 640 80 480 Mapeia
Partição em regiões para os processos individuais Processo 10 640 Mapeia 480
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];
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(n 2)
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
Conjunto de Mandelbrot • Simplificando o cálculo de
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ó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); }
Paralelizando o cálculo do conjunto de Mandelbrot com alocação dinâmica de tarefas Pool de trabalho (xa, ya) (xc, yc) (xb, yb) Tarefa Retorna resultados/ pede nova tarefa (xe, ye) (xd, yd)
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);
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 Linhas tratadas nos escravos (count) 0 Término Linha enviada Incremento disp_height Linha retornada Decremento
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
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 2 Área total=4 Área = 2 • • 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
Calculando uma integral f(x) 1 1 x 1 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,
Calculando uma integral (método alternativo) • Gere valores aleatórios para x entre x 1 e x 2, calcule f(x) e a soma dos valores de f(x) • Exemplo: Calcular sum = 0; for (i = 0; i < N; i++) { xr = rand_v(x 1, x 2); sum = sum + xr*xr -3 *xr; } area = (sum /N) * ( x 2 -x 1);
Implementação paralela Mestre Soma parcial Pedido Escravos Número aleatório Processo gerador de números aleatórios
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);
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
Geração paralela de números aleatórios x 1 x 2 xk-1 xk xk+1 xk+2 x 2 k-1 x 2 k
- Slides: 26