Você está na página 1de 2

Algoritmo de Ordenamento Rank:

Implementao em MPI Modelo Mestre Escravo


Carlos Henrique Menezes de Oliveira, Walter Lau Neto
Pontifcia Universidade Catlica do Rio Grande do Sul - Porto Alegre, Brasil
{carlos.oliveira.004, walter.lau}@acad.pucrs.br

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].

Fig. 1. Modelo Mestre Escravo

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

comunicao, pois se manda apenas um nmero. Ao fim, o


escravo retorna um vetor que corresponde somente ao total de
valores que ele operou, e no um vetor do tamanho total.
IV. E XECUO
Para a execuo dos algoritmos foram utilizadas mquinas
do Laboratrio de Alto Desempenho, na PUCRS. Para isso,
devemos copiar os arquivos necessrios para o cluster. Em
um ambiente linux, isso pode ser feito atravs do comando
scp. Depois devemos entrar no cluster, afim de compilar. Para
isso, usa-se os comandos ssh e ladcomp, respectivamente.
Por fim, devemos alocar a mquina desejada (no nosso caso,
executamos os algoritmos na mquina Cerrado), e executar
o programa. Foram usados os comandos ladalloc e ladrun.
Para a execuo dos algoritmos, foi alocada uma mquina do
cluster Cerrado. Cada mquina possui 12 ncleos, operando
a 2.4GHz [3]. Dentro da mquina, para as verses paralelas,
foram alocadas 3, 5 e 9 processadores, respectivamente. Vale
lembrar que um processador o mestre, e os demais os
escravos.

Fig. 2. Clculo de Speed Up

Fig. 3. Clculo de Eficincia


TABLE I
E FICINCIA
Processadores
1
3
5
9

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

qtd_dados, e o final dado pelo resultado da soma anterior


acrescido da varivel qtd_dados, novamente. No mestre, h
um controle para saber se ainda h algo para enviar ou para
receber. Se no houver, ele sinaliza uma flag e envia para os
escravos encerrarem. Os escravos retornam para o mestre um
vetor ordenado do tamanho da fatia, e o mestre concatena em
um vetor final. feito uma operao de merge para ordenar
o vetor final entre as fatias. Passando para o escravo somente
o ndice sobre o qual ele deve operar, h uma economia na

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.