Beruflich Dokumente
Kultur Dokumente
AbstractThe current work has as goal the comparison between the sequential implementation of the Rank Sort algorithm
and the parallel implementation, using the MPI library. To
run these algorithms we used clusters from High Performace
Laboratory - LAD - from PUCRS.
Index TermsMPI, Rank Sort, Master-Slave.
I. I NTRODUO
Neste trabalho se busca comparar o tempo de execuo do
algoritmo Rank Sort em duas verses, uma sequencial e uma
paralela, com a utilizao da biblioteca MPI. MPI [1] uma
biblioteca que permite a troca de mensagens entre processos
rodando em processadores separados, afim de sincroniz-los.
Assim, se faz necessrio a instalao da biblioteca no computador. Com o processamento paralelo, dividimos o trabalho
em diversos processadores, visando um ganho de desempenho
atravs da diminuio de processamento. Os algoritmos foram
implementados na linguagem C, em ambiente linux. Para
executar, deve-se passar dois argumentos por parmetro, sendo
o primeiro a quantidade de nmeros a ordenar, e o segundo
o nome do arquivo texto onde se encontram os nmeros. Ex.:
ladrun -np 5 trabalhoPPD 100000 valores.txt, onde o nmero
5 indica quantos processos disparar, o parmetro 100000
indica a quantidade de valores a ordenar, e o valores.txt indica
onde encontrar os valores.
II. O P ROBLEMA
O problema proposto sugere a implementao do algoritmo
de Rank Sort em uma verso paralela, atravs de um modelo
mestre escravo 1. Este modelo aloca um processador como
mestre, e os demais como escravos. O mestre efetua uma
computao inicial, e paraleliza o algoritmo distribuindo as
tarefas entre os escravos. Assim que um escravo retorna sua
fatia ordenada para o mestre, se ainda restam fatias a ordenar,
o mestre manda para o escravo. Aps, o mestre faz um merge
entre as fatias j retornadas a ele. Isso se faz necessrio pois,
ao receber uma fatia ordenada de um escravo, ela posta
em um vetor com as demais fatias. As fatias esto ordenadas
dentro delas, mas no entre elas. Aps o merge tm-se a
ordenao das fatias j retornadas pelos escravos. Na figura 1
inicialmente, na etapa 1, o mestre inicializa as variveis. Aps,
na etapa 2, ele distribui as tarefas para os escravos. Na etapa 3
os escravos executam essas tarefas, e retornam o resultado ao
mestre (etapa 4). Na etapa 5, o mestre faz o merge e imprime
os resultados [2].
III. O ALGORITMO
O algoritmo de Rank Sort percorre um vetor e conta quantos
nmeros so menores do que um dado valor. Com essa
informao, sabe-se seu ndice exato em um vetor de sada
ordenado.
A. Implementao Sequencial
Para a implementao sequencial, tm-se um vetor de
tamanho N, sendo este tamanho passado por parmetro na hora
da execuo do programa. Aps, o vetor ordenado. Medese seu tempo de execuo atravs da funo gettimeofday,
implementada na biblioteca time.h.
B. Implementaao Paralela
Na implementao paralela, o mestre se comunica com os
escravos, e manda para o escravo o ndice inicial sobre o
qual ele deve operar no vetor. Para sabermos o tamanho da
fatia do escravo, h a seguinte frmula: N/(4*M). Onde N
indica o total de nmeros para ordenar, M indica o nmero
de processadores, e a constante 4 indica quantas vezes cada
processador (escravo) deve executar. No nosso algoritmo, o
resultado dessa operao foi salvo na varivel qtd_dados. Assim, o ndice incial dado pela soma do ndice do escravo com
20000
1
3.347718058
8.6863197267
12.3504141437
40000
1
3.3106792989
7.1209067292
11.9585784238
100000
1
5.008088268
9.2744437796
13.2615584965
TABLE II
S PEED U P
Processadores
1
3
5
9
20.000
1
10.0431541741
43.4315986334
111.1537272933
40.000
1
9.9320378968
35.6045336458
107.6272058144
100.000
1
15.024264804
46.3722188982
119.3540264684
V. C ONCLUSO E R ESULTADOS
De acordo com a figura 2, podemos observar um ganho
de desempenho conforme aumentamos o nmero de processadores (escravos), pois assim pode se diminuir o gro de
trabalho para cada escravo. Contudo, se aumentarmos muito,
podemos ter uma perca de desempenho, pois aumenta-se muito
o overhead de comunicao. O clculo de Speed Up se d pela
diviso do tempo de execuo do algoritmo sequencial pelo
tempo de execuo do algoritmo paralelo. Os resultados podem ser vistos na tabela II . Na tabela de Speed Up os nmeros
20.000, 40.000 e 100.000 correspondem ao nmero de valores
a ordenar, enquanto o resultado nas clulas corresponem ao
valor de Speed Up plotado na figura 2. Para o clculo de
eficincia devemos dividir o Speed Up pela quantidade de
processadores. O resultado pode ser visto na tabela I, onde
os nmeros 20.000, 40.000 e 100.000 tambm correspondem
a quantidade de valores a ordenar. Pela figura 3, onde h um
grfico com os resultados de eficincia, podemos ver que o
ganho com a diviso de tarefas para o processamento paralelo
to significativo que o overhead de comunicao passa
praticamente imperceptvel, justificando o uso de programao
paralela no problema proposto. Contudo, tambm podemos
perceber a influncia direta do nmero de escravos com a
eficincia, pois aumentado-se o nmero de escravos pra 9 ela
comea a se estabilizar. Provavelmente se fosse aumentado
ainda mais o nmero de escravos, ela comearia a cair.
R EFERENCES
[1] http:http://moodle.pucrs.br/pluginfile.php/1349885/mod_folder/content/0/
MPI.pdf?forcedownload=1.
[2] G. Madalozzo, Adequao de Modelos Arquiteturais e Interfaces de
Programao Para Sistemas Many-Cores.
[3] http://www3.pucrs.br/portal/page/portal/ideia/Capa/LAD/
LADInfraestrutura/LADInfraestruturaHardware.