UNIVERSIDADE ESTADUAL DE MATO GROSSO DO SUL

FELIPE PEREIRA PEREZ

BRBARA PURKOTT CEZAR

RELATRIO
2 TRABALHO PRTICO PPD

DOURADOS MS
2012

Introduo

Esse relatrio tem como objetivo apresentar as implementaes dos algoritmos de produto matrizvetor e matriz-matriz, seus respectivos tempos de execuo para entradas de tamanhos diferentes e
os speed-ups bem como a anlise e comparao de todos os dados obtidos.

Produto Matriz-Vetor (verso 1)

Nessa verso do produto matriz-vetor enviado para cada processo uma linha da matriz e o vetor
que deve ser multiplicado. Ento executada a multiplicao da seguinte forma:
for(i=0;i<div;i++){
vetr[i]=0;
for(z=0;z<lin;z++)
vetr[i]=vetr[i]+(vet[z]*mat[i][z]);
}

Aonde em um vetor resultante so salvos os resultados da multiplicao.

1
2
4
8
16
32
64

128
0,0002
0,0005
0,0010
0,0012
0,0029
0,0054
0,0176

256
0,0008
0,0007
0,0018
0,0033
0,0039
0,0078
0,0123

512
0,0027
0,0024
0,0008
0,0159
0,0093
0,0270
0,0001

1024
0,0121
0,0250
0,0469
0,0823
0,2047
0,4899
1,6598

2048
0,0456
0,0839
0,1281
0,1998
0,3999
1,1434
2,9977

4096
0,1612
0,2580
0,3684
0,6035
1,0229
2,4174
6,9828

8192
4,8506
0,9996
1,3527
1,8765
3,2100
6,6019
17,4992

Na tabela acima so mostrados os tempos de execuo para as diferentes entradas e quantidade de

processos diferentes. Gerando o grfico abaixo!
20,0000
18,0000
16,0000
14,0000
12,0000
10,0000
8,0000
6,0000
4,0000
2,0000
0,0000

128
256
512
1024
2048
4096
8192
1

Os speed-ups dessa implementao so os seguintes:

128
2,5
5
6
14,5
27
88

256
0,875
2,25
4,125
4,875
9,75
15,375

512
0,888889
0,296296
5,888889
3,444444
10
0,037037

1024
2,066116
3,876033
6,801653
16,91736
40,4876
137,1736

2048
1,839912
2,809211
4,381579
8,769737
25,07456
65,73904

4096
1,600496
2,28536
3,743797
6,345533
14,99628
43,31762

8192
0,206078
0,278873
0,386859
0,661774
1,361048
3,607636

E pode ser visto no grfico abaixo:

160
140

128

120

256

100

512

80

1024

60

2048

40

4096

20

8192

0
1

Pode ser observado que para as entrada que foram utilizadas, a quantidade de dados no foi
suficiente para uma melhora no tempo do processamento, havendo melhora s na matriz de 8192
com 2 processadores.

Produto Matriz-Vetor (verso 2)

Nessa verso do produto matriz-vetor enviado para cada processo uma coluna da matriz e a
posio do vetor que deve ser multiplicado com mesmo ndice da matriz. Ento executada a
multiplicao da seguinte forma:
for(i=0;i<div;i++)
for(z=0;z<col;z++)
mat[i][z]=mat[i][z]*vet[i];

Os tempos dessa execuo so mostrados na tabela abaixo.

1
2
4
8
16
32
64

128
0,0002
0,0030
0,0008
0,0015
0,0064
0,0115
0,0489

256
0,0006
0,0007
0,0017
0,0070
0,0049
0,0090
0,0624

512
0,0029
0,0019
0,0040
0,0097
0,0211
0,0153
0,0228

1024
0,0107
0,0234
0,0402
0,0844
0,1743
0,4303
1,2639

2048
0,0392
0,0797
0,1143
0,2303
0,3893
0,9215
2,9799

4096
0,1627
0,2463
0,3498
0,5684
1,0877
2,4517
6,8567

8192
3,4300
0,9965
1,2967
1,7434
3,1728
6,4492
17,5205

Gerando o seguinte grfico:

20,0000
18,0000
16,0000
14,0000
12,0000
10,0000
8,0000
6,0000
4,0000
2,0000
0,0000

128
256
512
1024
2048
4096
8192
1

O speed-up dessa multiplicao segue na tabela abaixo:

128
15
4
7,5
32
57,5
244,5

E gera o grfico abaixo:

256
1,166667
2,833333
11,66667
8,166667
15
104

512
0,655172
1,37931
3,344828
7,275862
5,275862
7,862069

1024
2,186916
3,757009
7,88785
16,28972
40,21495
118,1215

2048
2,033163
2,915816
5,875
9,931122
23,50765
76,01786

4096
1,513829
2,149969
3,493546
6,68531
15,06884
42,14321

8192
0,290525
0,378047
0,50828
0,925015
1,880233
5,108017

300
128

250

256

200

512
150

1024

100

2048

50

4096

8192
1

Nessa verso tambm observado que no houve melhora significativa para as entradas utilizadas,
tendo tambm melhora somente na entrada de 8192 quando utilizado com 2 processadores.

Produto Matriz-Vetor (verso 3)

Nessa verso do produto matriz-vetor enviado para cada processo um setor da matriz sendo feita a
diviso da matriz tanto nas colunas quanto nas linhas e as posio do vetor que deve ser multiplicado
com mesmos ndice do setor da matriz que foi enviado para o processador. Ento executada a
multiplicao da seguinte forma:
for(i=0;i<div*2;i++){
for(z=0;z<div*2;z++){
matr[i][z]=matr[i][z]*vet[z];
}
}

Os tempos de execuo dessa multiplicao esto na tabela abaixo:

1
4
8
16
32
64

128
0,0002
0,0002
0,0001
0,0000
0,0000
0,0001

Gerando o seguinte grfico:

256
0,0008
0,0006
0,0002
0,0001
0,0000
0,0001

512
0,0027
0,0022
0,0024
0,0002
0,0001
0,0001

1024
0,0121
0,0369
0,0167
0,0006
0,0002
0,0004

2048
0,0456
0,1349
0,0823
0,0423
0,0008
0,0003

4096
0,1612
0,5393
0,2618
0,1304
0,0794
0,0446

8192
4,8506
2,0704
1,0735
0,5495
0,3021
0,1716

6,0000
128

5,0000

256

4,0000

512
3,0000

1024

2,0000

2048

1,0000

4096
8192

0,0000
1

E os seguintes speed-ups
128
1
0,5
0
0
0,5

256
0,75
0,25
0,125
0
0,125

512
0,814815
0,888889
0,074074
0,037037
0,037037

1024
3,049587
1,380165
0,049587
0,016529
0,033058

2048
2,958333
1,804825
0,927632
0,017544
0,006579

4096
3,345533
1,624069
0,808933
0,492556
0,276675

8192
0,426834
0,221313
0,113285
0,062281
0,035377

E respectivo grfico:

9000
8000
7000
6000
5000
4000
3000
2000
1000
0

128
256
512

1024
2048

4096
8192
1

Foi observado uma melhora em todas as entradas utilizadas como pode ser observado no grfico dos
tempos, quanto mais eram feitas as divises da matriz pelos processadores, o programa ento
demonstrou melhora significativa para todas as entradas.

Produto Matriz-Matriz
Nessa verso do produto matriz-matriz enviado para cada processo uma coluna da matriz e uma
linha da outra matriz. Ento executada a multiplicao da seguinte forma:

for(i=0;i<div;i++){
for(z=0;z<div;z++){
matriz[i][z]=0;
for(y=0;y<col;y++){
matriz[i][z]=matriz[i][z]+(mat[z][y]*vet[z][y]);
}
}
}

O que gerou a seguinte tabela de tempos e respectivo grfico:

1
2
4
8
16
32
64

128
0,0216
0,0171
0,0074
0,0139
0,0238
0,0210
0,0408

256
0,1569
0,0884
0,0477
0,0282
0,1337
0,0382
0,1096

512
1,2982
0,6468
0,3155
0,1749
1,1063
0,1675
0,2162

1024
10,0747
5,2642
2,6009
1,4767
6,1155
1,6316
7,6967

2048
79,4017
41,6161
20,0296
10,5502
6,1155
5,3188
8,0168

4096
642,7056
332,1263
158,8908
80,7074
43,0997
27,1323
27,4135

8192
5076,3045
2761,2959
1340,2754
660,5346
351,3845
239,9459
248,9713

6000,0000
128

5000,0000

256

4000,0000

512
3000,0000

1024

2000,0000

2048

1000,0000

4096
8192

0,0000
1

Os speed-ups dessa multiplicao so apresentados abaixo:

128
0,7917
0,3426
0,6435
1,1019
0,9722
1,8889

256
0,5634
0,3040
0,1797
0,8521
0,2435
0,6985

512
0,4982
0,2430
0,1347
0,8522
0,1290
0,1665

1024
0,5225
0,2582
0,1466
0,6070
0,1620
0,7640

2048
0,5241
0,2523
0,1329
0,0770
0,0670
0,1010

4096
0,5168
0,2472
0,1256
0,0671
0,0422
0,0427

8192
0,5440
0,2640
0,1301
0,0692
0,0473
0,0490

2,0000
128
1,5000

256
512

1,0000

1024
2048

0,5000

4096
8192

0,0000
1

A multiplicao de matrizes foi a melhor demonstrao de utilizao do MPI, j que para todas as
entradas houve uma diminuio significativa no tempo de processamento. Porm observada
tambm que a partir de certa quantidade de processadores algumas entradas j no so to efetivas,
portanto quanto maior a entrada deve-se usar uma quantidade de processadores que seja
compatvel com o seu processamento, para que haja melhor aproveitamento de suas diviso entre os
processadores.