Anda di halaman 1dari 8

Primeira lista de Exerc cios.

Programao Paralela ca
Prof. Santiago Valds Ravelo e

Exerc cios Resolvidos


Para comear so dados alguns exerc c a cios resolvidos em sala de aula, que serviro a de guia para algumas soluoes. c

1. Considere o problema de dado um vetor de n elementos, calcular a soma dos elementos do vetor. Faa um algoritmo c para solucionar este problema.
Dados: int[]v: vetor de elementos; begin 2 int soma = 0; 3 for (inti = 0; i < v.Length; i + +) do 4 som+ = v[i]; 5 end 6 return soma; 7 end Algorithm 1: Algoritmo sequncial que calcula a soma dos elementos de e um vetor
1

2. Considere o algoritmo do exerc cio anterior e faa uma c verso paralela para o mesmo com P processadores. a 3. Do algoritmo anterior, calcule: grau de desempenho (speedup), parte do cdigo que foi paralelizado, parte do o cdigo que no foi paralelizado, ganho obtido, e porcento a agem da melhoria.
Para calular o speedup temos que calcular o tempo do algoritmo sequencial (o nmero de operaes deste algoritmo) u co

Dados: int[]v: vetor de elementos; int[]somas: vetor de elementos resultados para cada processador; 1 begin 2 int id = Get P roc ID(); 3 int somas[id] = 0; 4 int ini = id v.Length/P ; 5 int f im = ini + v.Length/p; 6 for (inti = ini; i < v.Length && i < f im; i + +) do 7 somas[id]+ = v[i]; 8 end 9 end Algorithm 2: Algoritmo que calcula em paralelo, a soma de um bloco do vetor

Dados: int[]v: vetor de elementos; begin 2 int []somas =new int[P ]; 3 P arallel Call(Soma P aralela , v, somas); 4 int soma = 0; 5 for (inti = 0; i < P ; i + +) do 6 soma+ = somas[i]; 7 end 8 return soma; 9 end Algorithm 3: Algoritmo master que chama a execuo do algoritmo anca terior
1

Dados: int[]v: vetor de elementos; begin 2 /*faz uma atribuio*/ ca 3 int soma = 0; 4 /*entra no loop n vezes, onde n = v.Length*/ 5 for (inti = 0; i < v.Length; i + +) do 6 /*em cada execuo do loop faz duas operaes: uma soma e uma ca co atribuio*/ ca 7 som+ = v[i]; 8 end 9 return soma; 10 end Algorithm 4: Algoritmo sequncial que calcula a soma dos elementos de e um vetor
1

Temos ento que o algoritmo 4, tem como nmero de operaes: 1+2n (uma a u co atribuio mais o que faz em cada iterao, que uma atribuio e uma soma). ca ca e ca Agora analisemos a verso paralela. a Dados: int[]v: vetor de elementos; int[]somas: vetor de elementos resultados para cada processador; 1 begin 2 /*uma atribuio*/ ca 3 int id = Get P roc ID(); 4 /*uma atribuio*/ ca 5 int somas[id] = 0; 6 /*uma multiplicao, uma diviso e uma atribuio*/ ca a ca 7 int ini = id v.Length/P ; 8 /*uma diviso, uma soma e uma atribuio*/ a ca 9 int f im = ini + v.Length/p; n 10 /*entra no loop P vezes*/ 11 for (inti = ini; i < v.Length && i < f im; i + +) do 12 /*em cada execuo do loop faz duas operaes: uma soma e uma ca co atribuio*/ ca 13 somas[id]+ = v[i]; 14 end 15 end Algorithm 5: Algoritmo que calcula em paralelo, a soma de um bloco do vetor
n n co Temos que o algoritmo 5 realiza: 1 + 1 + 3 + 3 + 2 P = 8 + 2 P operaes. n n Desta forma o algoritmo 6 realiza: P + 8 + 2 P + 1 + 2P = 9 + 3P + 2 P operaes. co Logo o speedup do algoritmo paralelo resulta:

s=

1 + 2n n 9 + 3P + 2 P

1+2n Note que: limn s = limn 9+3P +2 n = P P Ou seja, para n sucientemente grande o algoritmo paralelo garante que ser a aproximadamente P vezes mais rpido que o sequencial. a Note que a parte do cdigo que foi paralelizada foi a soma dentro do loop o de n P elementos, pois cou de forma sequencial a soma dentro do loop de P elementos, no nal da verso paralela. Logo temos que o nmero de operaes a u co que foram paralelizadas resulta: 2(n P ) (uma soma e uma atribuio por cada ca entrada no loop). Desta forma temos que a parte do cdigo paralelizada foi: o

m=

2(n P ) 2n + 1

Note que: limn m = limn 2(nP ) = 1 2n+1

Dados: int[]v: vetor de elementos; begin 2 /*P atribuies*/ co 3 int []somas =new int[P ]; n 4 co /*8 + 2 P operaes*/ 5 P arallel Call(Soma P aralela , v, somas); 6 /*uma atribuio*/ ca 7 int soma = 0; 8 /*entra no loop P vezes*/ 9 for (inti = 0; i < P ; i + +) do 10 /*em cada execuo do loop faz duas operaes: uma soma e uma ca co atribuio*/ ca 11 soma+ = somas[i]; 12 end 13 return soma; 14 end Algorithm 6: Algoritmo master que chama a execuo do algoritmo anca terior
1

Daqui temos que para instncias com n sucientemente grande, a parte das a operaes que foram paralelizadas 1, ou seja quase o cdigo inteiro. co e o A parte do cdigo que no foi paralelizado resulta: o a 1m=1 2n 2P 2n + 1 2n + P P +1 = = 2n + 1 2n + 1 2n + 1

P +1 Onde: limn 1 m = limn 2n+1 = 0 Ou seja, para n sucientemente grande, a parte das operaes no parco a alelizadas quase nula em comparao com o valor de n. e ca O ganho obtido resulta de aplicar a lei de Amdhal: n (9 + 3P + 2 P )(2n + 1) n (9 + 3P + 2 P )(P + 1) + (2n 2P )(2n + 1)
4n2

g=

1 (1 m) +

m s

1
P +1 2n+1

2n2P n 9+3P +2 P

P P Onde: limn g = limn (9+3P +2 n )(P +1)+(2n2P )(2n+1) = limn 4n2 =

(9+3P +2 n )(2n+1)
P

1 P

Ou seja, para valores de n sucientemente grande o ganho do algoritmo 1 paralelo ser quase P a E a porcentagem de melhoria resulta:
n n 1 9 + 3P + 2 P 2n 2 P + 1 9 3P 2n PP 8 3P 1 (1 )100% = (1 )100% = 100% = 100% s 2n + 1 2n + 1 2n + 1

Onde: limn

1 2n PP 83P 2n+1

100% =

P 1 P 100%

Ou seja, para n sucientemente grande temos que a porcentagem de melhoria 1 aproximadamente PP 100%, que para um nmero grande de processadores, e u isso implica que que a melhoria quase o 100%. e

4. Considere a seguinte verso paralela para solucionar o a problema de somar os elementos de um vetor. Determine quais problemas pode ter, ilustre como solucionar esses problemas com uso de semforos. a
Dados: int[]v: vetor de elementos; intsoma: varivel compartilhada que armazena a soma; a 1 begin 2 int id = Get P roc ID(); 3 int s = 0; 4 int ini = id v.Length/P ; 5 int f im = ini + v.Length/p; 6 for (inti = ini; i < v.Length && i < f im; i + +) do 7 s+ = v[i]; 8 end 9 soma+ = s; 10 end Algorithm 7: Algoritmo que calcula em paralelo, a soma de um bloco do vetor

Dados: int[]v: vetor de elementos; begin 2 int soma; 3 P arallel Call(Soma P aralela , v, soma); 4 return soma; 5 end Algorithm 8: Algoritmo master que chama a execuo do algoritmo anca terior
1

Os problemas surgem pela falta de sincronia entre os processos paralelos, sendo que a varivel soma compartilhada, temos ento que processos concocra e a rentes podem estar fazendo modicando ela ao mesmo tempo, o que no pode a acontecer porque dois processos no podem estar na regio critica ao mesmo a a tempo. Uma soluo usanod um semforo binrio resulta nos algoritmos 9 e 10. ca a a

Dados: int[]v: vetor de elementos; intsoma: varivel compartilhada que armazena a soma; a Semaforosem: semforo; a 1 begin 2 int id = Get P roc ID(); 3 int s = 0; 4 int ini = id v.Length/P ; 5 int f im = ini + v.Length/p; 6 for (inti = ini; i < v.Length && i < f im; i + +) do 7 s+ = v[i]; 8 end 9 sem.P (); 10 soma+ = s; 11 sem.V (); 12 end Algorithm 9: Algoritmo que calcula em paralelo, a soma de um bloco do vetor

Dados: int[]v: vetor de elementos; begin 2 Semaforo sem = 1; 3 int soma; 4 P arallel Call(Soma P aralela , v, soma, sem); 5 return soma; 6 end Algorithm 10: Algoritmo master que chama a execuo do algoritmo ca anterior
1

Lista de Exerc cios


A seguir esto listado os exerc a cios para o estudo individual.

E1. Relacione as diferentes topolog paralelas, comparandoas as, e dando exemplos, se puder, de arquiteturas para cada uma. E2. Quais diferencias existem entre threads e processos? E3. Para cada os seguintes problemas, de um algoritmo sequencial, e encontre uma verso paralela com P procesa sadores. Em todos os casos calcule: grau de desempenho (speedup), parte do cdigo que foi paralelizado, parte do o cdigo que no foi paralelizado, ganho obtido, e porcento a agem da melhoria.
Problema 1. Dados dois vetores x, y con n elementos cada, calcular encontrar: z = x + y. Problema 2. Dado um vetor x com n elementos, e um inteiro , calcular o vetor: y = x. Problema 3. Dado um vetor de inteiros encontrar o m nimo e o mximo. a Problema 4. Dada uma matriz com m linhas e n colunas, encontrar a soma de todos os elementos da matriz. Problema 5. Dada uma matriz com m linhas e n colunas, encontrar o maior elemento. Problema 6. Dada uma matriz com m linhas e n colunas, retornar a linha com menor soma dos elementos nela.

E4. D soluoes usando semforos, monitores e passagem e c a de mensagens para os seguintes problemas.
Jantar dos Filsofos: Um grupo de n lsofos se dispe para jantar o o o um prato que para comer, cada lsofo precisa de dois garnhos, mas s o o contam com n garnhos, onde o garnho 1 pode ser usado pelo lsofo 1 o ou 2, o garnho 2 pode ser usado pelo lsofo 2 ou 3, assim o granho o i (1 i < n), pode ser usado pelo lsofo i e o i + 1, e o garnho n o podeser usado pelo lsofo n e o 1. O objetivo garantir que cada lsofo o e o (processo), consiga comer (entrar na regio cr a tica), para o que necessrio e a use os dois garinhos, e quando ele os usa, nenhum poutro lsofo os pode o usar.

Leitores e Escritores: Neste problema temos dois tipos de processos, os leitores e os escritores, todos acessando ` mesma regio cr a a tica. S o que quando um leitor entra, nenhum escritor pode entrar, porm podem e entrar mais leitores, e quando um escritor entra na regio cr a tica, no a podem entrar nem leitores nem outrosescritores. O objetivo conseguir e que todos os leitores e escritores, tenham acesso em algum momento ` a regio cr a tica. Barbeiro Dorminhoco: Dados m barbeiros e clientes que chegam na barberia, que tem n cadeiras de espera, se h barbeiros desocupados ento a a o barbeiro atendo o cliente, seno, caso existam cadeiras vazias o cliente a entra e aguarda, caso contrrio vai embora. O objetivo programar os a e barbeiros e os clientes evitando condies de corrida. co