ARQUITETURA E ORGANIZAO DE COMPUTADORES
1 Introduo
Matrizes de tamanhos elevados
exigem processos longos para sua
multiplicao[1], porm de fcil
implementao, tanto de forma
sequencial quanto paralela.
Considerando duas matrizes de
5000 linhas e 5000 colunas, seriam
necessrias inmeras operaes
para cada dado da matriz resultante
(tambm 5000x5000). Para realizar
essa operao da forma mais
eficiente, alm do uso de
paralelismo, esse teste tambm tem
como objetivo identificar qual o
nmero de threads mais eficiente
para soluo do problema.
Considerando os 8 ncleos do
processador utilizado, o nmero
esperado de threads para o melhor
desempenho 8, porm sero feitos
testes com 2, 4, 5, 8, 10, 20, 25, 40,
50, 100, 125, 200, 250, 500, 1000,
2500 e 5000 threads.
2 Desenvolvimento
2.1 Detalhes Tcnicos
O processador utilizado para
efetuar os testes ser um Intel Core
i7 de 3.2 GHz (8 nucleos).
O sistema operacional
utilizado foi LINUX MINT 17.3.
O comando para leitura do
tempo de cada teste da thread foi
time do LINUX.
2.2 Sequencial
O primeiro foco do processo
era mostrar claramente os ncleos
do processador funcionando, devido
a isso, todas as matrizes deveriam
ser do tipo float. Contudo, as
matrizes eram muito grandes e
tornou-se necessrio o uso do tipo
static float.
A segunda parte foi preencher
as matrizes, onde a primeira seria
preenchida de 1s, a segunda de 1,5
e a resultante de zeros. Essa
operao de preencher as matrizes
durava em torno de um dcimo de
segundo, por isso, no foi
paralelizada.
A terceira parte foi a fatorao
de fato. Foram utilizados 3 fors um
dentro do outro que rodariam 5000
vezes cada. Onde os dois primeiros
determinavam a posio o vetor
resultante que receberia o dado,
sendo o primeiro lao a linha e o
segundo lao a coluna. O ltimo lao
era responsvel pelas operaes de
adio e multiplicao que
resultariam no valor que seria
agregado naquela posio da matriz
resultante.
2.3 Paralelo
A resoluo do problema em
paralelo no foi muito diferente do
sequencial, foi criado um struct com
dois ints dentro, esses dois ints tem
como funo dizer onde o primeiro
lao comea e onde ele termina,
para assim poder dividi-lo em
diversas threads.
Como o dado salvo sempre
em uma parte diferente da memria
e o resto leitura, no foi necessria
preocupao com vrias threads
escrevendo no mesmo lugar da
memria.
Para chamar as threads[2][3]
com mais facilidade, foi criado um
vetor de threads, um vetor de structs
e um lao. Uma varivel controlava o
tamanho de todos eles, pois era o
mesmo para todos, facilitando na
hora de testar vrios tamanhos de
threads atualizando apenas a
varivel principal e qual valor
deveria ser guardado dentro da
struct referente aquela thread.

3 Resultados

3.1 Trabalho dos ncleos

O funcionamento do
programa pode ser visto nas
imagens a seguir, cada imagem
mostrando um certo nmero de
threads ativo.

As imagens dizem respeito ao

programa rodando sequencialmente
e com 2, 4, 5 e 8 threads
respectivamente.
Os programas rodando com
mais do que 8 threads permanecem
com todos os ncleos trabalhando a
100% normalmente.

3.2 Tempo de Execuo

O tempo de execuo dos

programas pode ser visto na tabela e
no grfico a seguir.

TEMPO
SEQUENCIAL 12M 49S
2 THREADS 6M 18S
 4 THREADS 3M 34S estranho considerando que o
5 THREADS 3M 38S esperado era um aumento de
8 THREADS 3M 20S eficincia at chegar a 8 threads (o
10 THREADS 3M 38S
melhor resultado).
20 THREADS 3M 38S
25 THREADS 3M 38S
A partir de 8 threads os outros
40 THREADS 3M 39S resultados comearam a demorar
50 THREADS 3M 41S mais, mesmo que por poucos
100 THREADS 3M 46S segundos, o esperado seria a partir
125 THREADS 3M 45S desse ponto os resultados ficarem
200 THREADS 3M 44S gradualmente mais lentos, porm a
250 THREADS 3M 44S partir de 125 threads, os testes
500 THREADS 3M 41S
diminuram seu tempo, no ficaram
1000 THREADS 3M 36S
2500 THREADS 3M 35S mais rpidos que o teste com 8
5000 THREADS 3M 39S threads, mas ficaram mais rpidos
que o teste com 100 threads. Os
testes com 1000 e 2500 threads
Tempo conseguiram ser ainda mais rpidos
1000 que os outros com exceo dos
testes com 4 e 8 threads. O teste de
0
5000 threads conseguiu ser ainda
mais rpidos que o teste com 50
Tempo threads.

Referncias
Como pode ser visto tanto
pela tabela quanto pelo grfico, a [1]https://pt.wikipedia.org/wiki/Produt
execuo sequencial foi a mais lenta o_de_matrizes
de todos os processos, tendo 12
minutos e 49 segundos de durao. [2]http://pubs.opengroup.org/onlinep
A execuo com duas threads quase ubs/009695399/functions/pthread_e
diminui em 50% o tempo de xit.html
execuo j as outras execues
com 4 ou mais threads foram quase [3]https://pt.wikibooks.org/wiki/Progr
3,7 vezes mais rpidas que a ama%C3%A7%C3%A3o_Paralela_
operao em sequencial. em_Arquiteturas_Multi-
A operao mais rpida como Core/Programa%C3%A7%C3%A3o
previsto foi com 8 threads, sendo _em_Pthreads
3,845 vezes mais eficiente que a
operao sequencial.
Como fica evidente no grfico,
a partir de 4 threads a variao fica
muito pequena, porm houveram
muitos resultados inesperado,
constitudos dos testes com 5, 125,
200, 250, 500, 1000, 2500 e 5000.
O teste com 5 threads foi mais
lento que o com 4 threads o que foi