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 2

2

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

z

abibaibabiaz

2

22

222222

2

iteração cada para de valor do Cálculo

22

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

s

ntcomp

max

)(2 datastartupcomm vttut

)()(max

datastartupdatastartupp vttuttss

nt

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 Área

cí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);

))((1

lim)(Á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