Computa

1
Computação Embaraçosamente Paralela
2
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 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

5
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 (i0, row0 i lt 48 i, row row10)
• send (row, Pi)
• for (i0 i lt 480 i)
• for (j0 j lt 640 j)
• temp_mapij0
• for (i0 i lt (640480) i)
• recv(oldrow, oldcol, newrow, newcol, Pany)
• if !((newrow lt 0) (newrow gt480)
  (newcol lt 0) newcol gt640))
• temp_mapnewrownewcolmapoldrowoldco
  l
• for (i0 i lt 480 i)
• for (j0 j lt 640 j)
• mapij temp_mapij

8
Pseudocódigo para executar deslocamento de imagem

• Escravo
• recv(row, Pmestre)
• for (oldrowrow oldrow lt (row 10) oldrow)
• for (oldcol0 oldcol lt 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 (k1) iteração do número
  complexo zabi 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
• max256
• z.real0 z.imag0
• count0
• do
• tempz.realz.real -z.imagz.imag c.real
• z.imag2z.realz.imag c.imag
• z.realtemp
• lengthsqz.realz.realz.imagz.imag
• 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 lt disp_width x)
• for (y 0 y lt 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 (k0 k lt procno k)
• send(row, Pk, data_tag)
• count
• row
• do
• recv (slave, r, color, Pany,
  result_tag)
• count--
• if (row lt disp_height)
• send (row, Pescravo, data_tag)
• row
• count
• else
• send (row, Pescravo,
  terminator_tag)
• display ( r, color)
• while (count gt 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 ltdisp_width x)
• c.real real_min ((float) x
  scale_real)
• colorx 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
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
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 x1 e x2,
  calcule f(x) e a soma dos valores de f(x)
• Exemplo Calcular
• sum 0
• for (i 0 i lt N i)
• xr rand_v(x1, x2)
• sum sum xrxr -3 xr
• area (sum /N) ( x2-x1)

22
Implementação paralela
23
Pseudocódigo

• Mestre
• for (i 0 i lt N/n i)
• for (j 0 j lt n j)
• xrj rand ()
• recv(Pany, req_tag, Pfonte)
• send(xr, n, Pfonte, compute_tag)
• for (i 0 i lt slave_no i)
• recv(Pi, req_tag)
• send(Pi, stop_tag)
• sum0
• 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 lt n i)
• sum sum xri xri -3 xri
• 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
xk1
xk2
x2k-1
x2k