You are on page 1of 72

1

CENTRO UNIVERSITRIO EURPIDES DE MARLIA


FUNDAO DE ENSINO EURPIDES SOARES DA ROCHA

BACHARELADO EM CINCIA DA COMPUTAO

Anlise e implementao de algoritmo paralelo distribudo para fatorao


de nmeros inteiros utilizando Java RMI

LUIS PAULO RODRIGUES PASTOR

Marlia, 2013

2
CENTRO UNIVERSITRIO EURPIDES DE MARLIA
FUNDAO DE ENSINO EURPIDES SOARES DA ROCHA

BACHARELADO EM CINCIA DA COMPUTAO

Anlise e implementao de algoritmo paralelo distribudo para fatorao


de nmeros inteiros utilizando Java RMI

Monografia
apresentada
ao
Centro Universitrio Eurpides de
Marlia como parte dos requisitos
necessrios para a obteno do
grau de Bacharel em Cincia da
Computao.
Orientador: Prof. Mauricio Duarte

Marlia, 2013

AGRADECIMENTOS
Todo agradecimento vai para as pessoas que de alguma forma, direta ou
indiretamente, contriburam para que eu chegasse a este ponto de minha vida.
Os obstculos que so colocados parecem que at de propsito, fazem com que a
nossa vitria se torne ainda mais grandiosa. A realizao vem com trabalho, dedicao e
pensamento positivo. Sempre h um caminho quando se tem um obstculo, e este caminho s
vezes pode at se tornar um atalho.
Agradeo primeiramente a Deus, por ter me conduzido na realizao deste
objetivo, por me dar a motivao e vontade de concluir este ciclo, permitindo que chegasse
at aqui, e pela mo colocada sobre mim para que todas as dificuldades fossem superadas.
Agradeo a minha famlia, meu pai Moacir, minha me Rosngela, e meu irmo
Joo Pedro, pois sempre acreditaram que chegaria at aqui, e me deram a oportunidade para
uma formao profissional. A colaborao que tiveram at mesmo em gestos simples nos
infinitos dias desses quatro anos tambm merece um agradecimento especial.
Agradeo a meu orientador, professor Mauricio Duarte, pela ateno e prontido
em todos os momentos, principalmente nos que estive meio perdido.
Agradeo ao professor Ricardo Jos Sabatine, pela colaborao e conselhos dados
ao final e inicio de suas aulas ao longo do desenvolvimento deste projeto.
Agradeo aos meus amigos, que estiveram comigo nesta mesma caminhada, e
atravs dos conselhos e palavras de motivao trocadas, tambm so responsveis para que
chegasse at aqui.
Muito Obrigado a todos!

SUMRIO
INTRODUO ........................................................................................................................ 13
OBJETIVOS ......................................................................................................................... 14
ORGANIZAO DO TRABALHO ................................................................................... 14
1. SISTEMAS DISTRIBUDOS .............................................................................................. 16
1.1. Middleware .................................................................................................................... 16
1.2. Objetivos de um Sistema Distribudo ............................................................................ 17
1.3. Sistemas de Computao Distribudos .......................................................................... 20
1.3.1. Clusters ................................................................................................................... 21
1.3.2. Tipos de Clusters .................................................................................................... 23
1.4. Sistemas Distribudos Baseados em Objetos. ................................................................ 25
2. COMPUTAO PARALELA ............................................................................................. 26
2.1. Taxonomias de Arquiteturas Paralelas ........................................................................... 26
2.2. Computao Paralela Distribuda .................................................................................. 28
3. MECANISMOS DE COMUNICAO REMOTA E AMBIENTES DE TROCA DE
MENSAGENS .......................................................................................................................... 30
3.1. Sockets ........................................................................................................................... 30
3.2. Message Passing Interface (MPI) .................................................................................. 31
3.4. RMI Java ....................................................................................................................... 34
4. IMPLEMENTAO DO ALGORITMO ............................................................................ 38
4.1. Fatorao de nmeros inteiros ....................................................................................... 38
4.1.1. Mtodo de Fermat ................................................................................................... 38
4.2. Criptografia RSA ........................................................................................................... 39
4.3. Desenvolvimento do Algoritmo.................................................................................... 40
4.3.1. Algoritmo Sequencial ............................................................................................. 41
4.3.2. Algoritmo Paralelo Distribudo .............................................................................. 42
4.4. Execuo da aplicao ................................................................................................... 52
4.4.1. Execuo Sequencial .............................................................................................. 52
4.4.2. Execuo Paralela Distribuda ................................................................................ 52
5. TESTES E RESULTADOS .................................................................................................. 55
5.1. Speedup e Eficincia ..................................................................................................... 55
5.2. Cenrios de Teste ........................................................................................................... 56
5.2.1. Cenrio 01 .............................................................................................................. 57
5.2.2. Cenrio 02 .............................................................................................................. 58
5.2.3. Cenrio 03 .............................................................................................................. 59

5.2.4. Cenrio 04 .............................................................................................................. 63


5.2.5. Cenrio 05 .............................................................................................................. 64
5.2.6. Cenrio 06 .............................................................................................................. 66
5.3. Concluses Finais .......................................................................................................... 69
5.4. Trabalhos Futuros .......................................................................................................... 70
Referncias Bibliogrficas ........................................................................................................ 71

LISTA DE FIGURAS
Figura 1 Sistema distribudo organizado como middleware (TANENBAUM, 2007).........17
Figura 2 Exemplo genrico de um cluster (TOULOUEI, 2010)...........................................22
Figura 3 Classificao das arquiteturas paralelas segundo Taxonomia de Tanenbaum
(SAITO, 2007)..........................................................................................................................27
Figura 4 Sistema computacional paralelo distribudo (SAITO, 2007)..................................29
Figura 5 Sockets (DA SILVA; FRANCO; AVELINO, 2006)................................................31
Figura 6 Modelo de execuo do MPI (PITANGA, 2008)....................................................33
Figura 7 Camadas do Middleware (COLOURIS, 2007)........................................................35
Figura 8 Organizao dos elementos de um sistema distribudo usando Java RMI
(PEREIRA, 2003......................................................................................................................36
Figura 9 Trecho do cdigo sequencial onde so realizados os clculos para se chegar as
fatores........................................................................................................................................41
Figura 10 Organizao dos componentes da aplicao e seus respectivos parmetros.......42
Figura 11 Mtodo de diviso do algoritmo sequencial..........................................................43
Figura 12 Diviso dos intervalos para os escravos ...............................................................45
Figura 13 Trecho do cdigo que faz a chamada das threads ................................................47
Figura 14 Construtor da thread..............................................................................................48
Figura 15 Trecho do cdigo onde realizado a invocao ao mtodo remoto....................48
Figura 16 Trecho do cdigo onde o objeto remoto registrado no RMIRegistry ...............49
Figura 17 Interface com a assinatura de seu mtodo ............................................................50
Figura 18 Trecho do cdigo onde so realizados os clculos para se chegar as fatores .....51
Figura 19 Exemplo de diviso dos intervalos onde o nmero de iteraes sempre o
mesmo.......................................................................................................................................62
Figura 20 Exemplo de diviso dos intervalos onde o nmero de iteraes modifica com a
adio de escravos....................................................................................................................68

LISTA DE TABELAS
Tabela 1. Modelo de construo dos cenrios...........................................................................53
Tabela 2. Resultados obtidos com testes realizados no cenrio 01...........................................57
Tabela 3. Resultados obtidos com testes realizados no cenrio 02...........................................58
Tabela 4. Resultados obtidos com testes realizados no cenrio 03...........................................60
Tabela 5. Resultados obtidos com testes realizados no cenrio 04...........................................63
Tabela 6. Resultados obtidos com testes realizados no cenrio 05...........................................65
Tabela 7. Resultados obtidos com testes realizados no cenrio 06...........................................66

LISTA DE GRFICOS
Grfico 1. Distribuio das mdias dos tempos de execuo no cenrio 01..........................58
Grfico 2. Distribuio das mdias dos tempos de execuo no cenrio 02..........................59
Grfico 3. Distribuio das mdias dos tempos de execuo no cenrio 02..........................61
Grfico 4. Distribuio das mdias dos tempos de execuo no cenrio 03..........................64
Grfico 5. Distribuio das mdias dos tempos de execuo no cenrio 04..........................65
Grfico 6. Distribuio das mdias dos tempos de execuo no cenrio 05.........................67

10

LISTA DE SIGLAS
AES Advanced Encryption Standard
API Application Programming Interface
DNS Domain Name System
Gbps Gigabits per second
HPC High Performance Computing
IP Internet Protocol
LAN Local Area Network
Mbps Megabits per second
MIMD Multiple Instruction Multiple Data
MISD Multiple Instruction Single Data
MPP Massively Parallel Processing
RMI Remote Method Invocation
RPC Remote Procedure Call
RSA Rivest Shamir Adleman
SIMD Single Instruction Multiple Data
SISD Single Instruction Single Data
TCP Transmission Control Protocol
UDP User Datagram Protocol
URL Uniform Resource Locator
WAN Wide Area Network

11

RESUMO
O objetivo deste trabalho efetuar uma anlise do desempenho de uma aplicao
que implemente um algoritmo com a funo de realizar a fatorao de nmeros inteiros de
maneira paralela distribuda, baseando-se na metodologia de fatorao proposta por Fermat e
utilizando o mecanismo da linguagem Java para programao distribuda, chamado RMI
(Remote Method Invocated). Este algoritmo ser executado de maneira sequencial, e de
maneira paralela, sobre um cluster composto por mquinas de caractersticas homogneas,
utilizando o paradigma mestre-escravo, onde cada escravo participante da execuo ter a
responsabilidade de executar um trecho de cdigo, cooperando com a execuo. A fatorao
de nmeros inteiros um dos mtodos utilizados para que se consiga quebrar uma chave
criptogrfica RSA, possuindo um tempo de execuo extremamente grande na fatorao de
um nmero de um cenrio real de criptografia, por isso muitos estudos so realizados para
encontrar maneiras de obter ganhos no tempo de execuo de uma fatorao, e por estes
motivos esta abordagem foi selecionada para ser aplicada neste projeto. Aps a execuo e
coleta dos resultados obtidos atravs de testes realizados em diferentes cenrios, os resultados
sero analisados, e ento, ser verificado e comparado o desempenho das diversas execues
realizadas, dando a possibilidade de se verificar em quais cenrios houve ganho ou perda de
desempenho, e os fatores que impactam diretamente no desempenho da aplicao.

Palavras-Chave: Sistemas Distribudos, Java RMI, Computao Paralela, Clusters, Fatorao


de Nmeros Inteiros, Criptografia RSA.

12

ABSTRACT
The objective of this paper is to analyze the performance of an application that
implements an algorithm to perform the integers factorization in parallel distributed, based on
the methodology factorization proposed by Fermat and using the mechanism of the Java
language to distributed programming, called RMI (Remote Method Invocated). This
algorithm will be executed sequentially and in parallel on a cluster composed of homogeneous
machines characteristics, using the master-slave paradigm, where each participant slave
execution has the responsibility of executing a piece of code, cooperating with the execution.
The factorization of integers is responsible for one of the methods that can break a
cryptographic key RSA, having an execution time extremely large in the number factorization
from a real scenario of encryption, so many studies are conducted to find ways to get gains in
the runtime of a factorization, and for these reasons this approach was selected to be applied
in this project. Upon execution and collection of results obtained from tests carried out in
different scenarios, the results are analyzed, and then will be checked and compared the
performance of several executions, giving the possibility to check on what scenarios there was
a gain or loss of performance and the factors that impacted directly in the application
performance.

Keywords: Distributed Systems, Java RMI, Parallel Computing, Clusters, Integer


Factorization, RSA Encryption.

13

INTRODUO
Grandes desafios computacionais em vrios segmentos da computao desafiam
os profissionais desta rea que cada vez mais crescente pelo mundo todo. Sempre houve
uma maneira de resolver problemas que estavam na frente de pesquisadores naquele exato
momento ao longo da histria, ou por necessidade daquele contexto histrico, ou pelo simples
prazer de criar algo novo que fosse mudar o dia-a-dia de pessoas normais. Com o passar do
tempo e a evoluo dos computadores, vem aumentando o grau dos desafios que a computao tenta solucionar, e computadores que antes eram suficientes se tornaram incapazes de
ajudar.
A utilizao de supercomputadores uma alternativa para problemas mais complexos, porm o seu alto custo, e sua dificuldade em se aumentar o poder de processamento,
inviabilizam o uso desta soluo. Uma soluo financeiramente vivel e interessante o uso
de sistemas distribudos com processamento paralelo. A combinao entre estas reas da
computao pode ajudar profissionais de vrios segmentos da computao a resolverem certos
problemas de maneira em que o processamento possa ser dividido e distribudo pelas mquinas que formam um sistema, desse modo podem ser diminudos os custos com hardware,
(pois interligar mquinas caseiras em uma rede de alta velocidade mais barato que a aquisio de um supercomputador), e possivelmente obter um melhor desempenho no processamento (DANTAS, 2005).
Para implementao de um sistema distribudo necessrio que haja uma maneira
em que os computadores interligados se comuniquem pela rede. Existem alguns mtodos utilizados na computao como Sockets, RPC, entre outros, porm existe um mtodo para a programao distribuda exclusivo da linguagem Java, o RMI (Remote Method Invocated).
O RMI proporciona todas as ferramentas necessrias para a implementao de um
sistema distribudo utilizando a linguagem Java. Como esta API faz a funo de middleware,
o programador fica despreocupado com diferenas entre tecnologias de rede e de hardware,
por exemplo. A comunicao ento feita pela invocao de mtodos remotos, onde um cliente utiliza os servios disponibilizados pelo servidor, esta comunicao ocorre de maneira
sncrona (PEREIRA, 2003).
O obstculo que impede o paralelismo atravs de invocaes remotas acontece
justamente pela comunicao ser sncrona. Uma maneira de contornar este obstculo com a
utilizao de threads, que podem ser criadas para efetuarem invocaes remotas no mesmo
instante, de modo paralelo.

14

Observando esta possibilidade, surgem diversas aplicaes que podem ser


exploradas utilizando este ambiente paralelo distribudo para execuo. Problemas complexos
que divididos em partes menores podem gerar desempenho melhor que um processamento
sequencial. Para isso, necessrio que testes sejam realizados para verificar em que momento
benfico o paralelismo e quais fatores impactam em uma melhora ou piora no desempenho.

OBJETIVOS
Este trabalho tem como objetivo efetuar uma anlise e verificao no desempenho
e custo/beneficio da paralelizao de um algoritmo para fatorao de nmeros inteiros, atravs
da execuo sequencial e paralela, utilizando o mecanismo RMI da linguagem Java para a
comunicao entre as mquinas em diversos cenrios de execuo, com uma variao na
quantidade de escravos utilizados nos mesmos. O algoritmo ser implementado com base em
um mtodo para fatorao de nmeros inteiros proposto por Fermat. A fatorao de nmeros
inteiros uma maneira para que se consiga quebrar chaves criptogrficas RSA, onde a
fatorao ir resultar no encontro de dois fatores primos, que aplicados a outros
procedimentos possibilitam a quebra da chave criptogrfica.
Porm a fatorao deste nmero demanda um tempo de processamento
extremamente grande e se torna invivel para execuo em uma nica unidade de
processamento. Uma soluo seria a paralelizao deste problema. Com isso, espera-se por
meio deste trabalho, verificar atravs das anlises no desempenho de testes com nmeros
inteiros de menor tamanho, identificar cenrios propcios para a paralelizao e fatores que
causam impacto no desempenho desta aplicao.

ORGANIZAO DO TRABALHO
A organizao do trabalho procurou apresentar primeiramente os conceitos que
envolvem a elaborao desta monografia. No primeiro captulo ser apresentada toda parte
conceitual sobre sistemas distribudos e suas caractersticas principais. Na sequencial, ser
apresentado um captulo contendo informaes que caracterizam toda parte conceitual da
computao paralela. No terceiro captulo, sero abordados mecanismos para comunicao
remota e ambientes de troca de mensagens. Ao final da parte conceitual, sero apresentados
todos os passos para elaborao e implementao do algoritmo sequencial e do algoritmo

15

paralelo distribudo. E por fim, os resultados obtidos com os testes realizados de maneira
sequencial e paralela, seguido das concluses finais sobre o trabalho.

16

1. SISTEMAS DISTRIBUDOS
Um grande avano tecnolgico ocorreu na dcada de 80 com o desenvolvimento
de processadores de alto desempenho e com a inveno de redes de computadores de alta
velocidade, como as LANs e as WANs.
As LANs so redes pequenas de tamanho restrito que podem interligar de
dezenas a centenas de computadores, que pertencem a uma mesma organizao ou a um
mesmo local. Essas redes locais se caracterizavam por possuir um pequeno trfego de
informaes, porm o avano da tecnologia fez com que essas redes suportem um grande
trafego de informaes. (TANENBAUM; STEEN, 2007).
J as redes de longa distncia, as WANs, interligam milhes de computadores por
todo o planeta a uma velocidade que pode chegar a gigabits por segundo. Esse avano
tecnolgico permitiu que sistemas utilizando vrios computadores conectados por uma rede
de alta velocidade fossem facilmente implementados (TANENBAUM; STEEN, 2007).
O principal objetivo que leva a construo de tal sistema a necessidade dos
usurios em compartilhar recursos, sendo que o maior exemplo de um sistema distribudo a
internet, que comunica e compartilha recursos com usurios do mundo todo. A comunicao
entre os componentes de um sistema distribudo para o compartilhamento de recursos feita
atravs da troca de mensagem, e por estes componentes serem independentes um dos outros,
podem haver diferenas em questes como hardware, rede, sistemas operacionais, que
dificultem ou at mesmo impeam a comunicao entre os componentes. Para tratar este
problema utilizamos uma camada de software denominada middleware (COULOURIS;
DOLLIMORE; KINDBERG, 2007).

1.1. Middleware
O cenrio onde vrios computadores independentes esto conectados utilizando
uma rede de alta velocidade, dando ao usurio a impresso de estar utilizando um sistema
nico e coerente, uma das definies propostas para um sistema distribudo. Estes vrios
computadores que fazem parte de um sistema distribudo so componentes independentes, por
isso podem possuir caractersticas diferentes em relao ao hardware, e para que cada
componente desse sistema consiga relevar essas diferenas buscando a troca de informaes
com os outros componentes, necessrio uma camada de software denominada middleware.

17

Esta camada alm de mascarar a heterogeneidade encontrada nos tipos de rede utilizada, no
hardware, e sistema operacional, abstrai e facilita ao programador, questes da implementao
do sistema distribudo (COULOURIS; DOLLIMORE; KINDBERG, 2007). A camada de
middleware est ilustrada na Figura 1.

Figura 1 Sistema Distribudo organizado como Middleware (TANENBAUM, 2007)

O middleware faz com que as aplicaes e usurios possam interagir de maneira


uniforme e consistente com um sistema distribudo. Alguns exemplos de middleware so:
Corba, Java RMI, este ltimo ser melhor abordado no item 3.4.

1.2. Objetivos de um Sistema Distribudo


A implementao de um sistema distribudo deve traar alguns objetivos para que
este possua caractersticas que iro facilitar a vida de quem utiliza e de quem faz a
manuteno no sistema (TANENBAUM; STEEN, 2007). Oferecer facilidade, segurana e
eficcia aos usurios e as aplicaes que se utilizam do sistema o objetivo final na
implementao de um sistema distribudo. Para atingir este objetivo, alguns pontos devem ser
tratados na implementao do sistema.
Os servios oferecidos pelo sistema devem ser padronizados, e essa questo
tratada com a utilizao de interfaces, que so comumente usadas para oferecer padres que
definem a sintaxe e a semntica dos servios oferecidos.
Para facilitar a insero de novos componentes, ou at mesmo a modificao dos
que j esto em funcionamento, o sistema distribudo deve ser extensvel, ou seja, uma
alterao feita em um componente do sistema no deve obrigar a uma nova alterao em um
segundo componente, para isso importante que o sistema seja bem organizado,
preferencialmente divido em componentes de tamanho reduzido.

18

Com a rpida expanso da internet pelo mundo todo, fica cada vez mais
indispensvel que um sistema distribudo seja escalvel. Segundo Neuman, (NEUMAN,
1994) escalabilidade pode ter trs dimenses diferentes no mnimo, a primeira em relao ao
tamanho, a facilidade de se aumentar o nmero de usurios e recursos disponibilizados pelo
sistema, a segunda em relao escalabilidade em termos geogrficos, onde um usurio
pode estar longe geograficamente de um recurso, e a terceira a escalabilidade em relao a
termos administrativos, a facilidade em se gerenciar um sistema que envolva dados e recursos
de muitas organizaes diferentes (COULOURIS; DOLLIMORE; KINDBERG, 2007).
A escalabilidade de um sistema pode enfrentar alguns problemas principais, que
so: servios centralizados, dados centralizados, e algoritmos centralizados. Quando um
servio oferecido implementado por apenas um servidor, e com o passar do tempo o nmero
de usurios e aplicaes que utilizam aquele servio vai aumentando, a capacidade de
armazenamento e de processamento pode ficar limitada, o que impede o crescimento do
sistema, este caso exemplifica o problema com servios centralizados.
Dados centralizados so to problemticos quanto servios centralizados, pois so
utilizados apenas um banco de dados para armazenar as informaes, isto sobrecarregaria os
meios que o acessam.
Para impedir que se tenha uma quantidade excessiva de mensagens no sistema,
algoritmos centralizados devem ser evitados a todo custo, pois o excesso de mensagens
sobrecarregaria a rede. O ideal utilizar algoritmos que sejam descentralizados, e em geral
suas caractersticas so: nenhuma das mquinas que compem o sistema possui todas as
informaes sobre o estado do mesmo, as decises tomadas pelas mquinas so baseadas nas
informaes que as mesmas possuem, a falha de uma mquina no interfere no algoritmo, e
no h dependncia de um relgio global (COULOURIS; DOLLIMORE; KINDBERG,
2007).
Algumas tcnicas podem ser aplicadas para minimizar ou at mesmo resolver
estes problemas de escalabilidade apresentados anteriormente.
Ocultar as latncias de comunicao: quando se tenta evitar ao mximo esperar
por respostas remotas de servios requisitados. A ideia utilizar uma comunicao assncrona
que ao invs do processo do lado do cliente ficar ocioso esperando uma resposta do processo
do lado do servidor, ele executa outra atividade enquanto espera a resposta.
Ocultar as latncias de distribuio consiste em dividir um componente em partes
menores e distribu-lo pelo sistema, como no caso do Sistema de Nomes de Domnio da
Internet (DNS), que distribui o servio por vrios servidores que tratam certa quantidade de

19

requisies, essa tcnica evita de certo modo sobrecarregar os servidores e possibilita o


aumento da Internet pelo mundo todo.
Considerando que estes problemas de escalabilidade aparecem frequentemente
sob forma de perda de desempenho, interessante replicar componentes pelo sistema
distribudo, a replicao vai aumentar a disponibilidade, ajudar no balanceamento entre os
componentes, e pode ainda ocultar alguns problemas de comunicao (TANENBAUM;
STEEN, 2007).
A questo da transparncia sem dvida a meta mais discutida que um sistema
distribudo deve seguir, sua definio consiste na ocultao de aspectos que fazem com que
um sistema distribudo aparente ser um sistema nico e consistente.
Diferentes tipos de transparncia podem estar presentes em um sistema
distribudo, como a transparncia de acesso, de localizao, migrao, relocao, replicao,
concorrncia, e de falha.
A transparncia de acesso oculta as diferenas existentes na representao dos
dados e no modo como um recurso acessado. A transparncia de localizao oculta para os
usurios a real localizao do dado ou servio requisitado, que o caso da URL, que mascara
em qual servidor seu servio est situado.
Quando um recurso pode ser movido para outro local sem afetar o modo como
este recurso acessado, o sistema possui uma transparncia de migrao. J a transparncia
de relocao trata de ocultar a movimentao de um recurso em uso sem que o usurio
perceba essa mudana. Na transparncia de replicao o usurio no consegue identificar se o
recurso que esta utilizando na verdade uma rplica do recurso original.
Transparncia de concorrncia acontece quando dados podem ser acessados por
mais de um usurio ao mesmo tempo sem que este perceba. Por fim, a transparncia a falha
tem como objetivo mascarar as falhas que um sistema distribudo pode apresentar, ou
mascarar que o sistema se recuperou de uma falha, este tipo de transparncia difcil ou at
mesmo impossvel de tratar, pois um recurso pode apresentar vrios estados, e para o usurio,
no momento do acesso o recurso pode estar apenas disponvel ou indisponvel, no mostrando
seu real estado, como exemplo, um recurso pode estar apenas ocupado (indisponvel no
momento), onde uma tentativa de acesso aps um tempo traria o recurso como disponvel, ou
estar danificado onde qualquer tentativa de acesso a qualquer momento traria o recurso como
indisponvel (COULOURIS; DOLLIMORE; KINDBERG, 2007).
Contudo, aplicar ao mximo as tcnicas de transparncia em um sistema
distribudo nem sempre o melhor a se fazer, por no ser vivel financeiramente e por s

20

vezes o melhor a se fazer mostrar o problema ao usurio para que ele decida pelo que fazer.
(TANENBAUM; STEEN, 2007).

1.3. Sistemas de Computao Distribudos


Existem diferentes tipos de sistemas distribudos referentes sua utilizao,
alguns deles so: sistemas de computao distribudos, sistemas de informao distribudos e
sistemas embutidos distribudos (TANENBAUM; STEEN, 2007). O tipo de sistema
distribudo que ser utilizado neste projeto so os sistemas de computao distribudos, que
ser discutido na sequencia.
Dentro da classe dos sistemas de computao distribudos pode-se fazer uma
separao entre um grupo onde so utilizados um conjunto de computadores com hardware
semelhante, com o mesmo sistema operacional e interligados por meio de uma rede local de
alta velocidade, este grupo pode ser denominado de computao de cluster. No outro grupo as
caractersticas so totalmente diferentes da computao de cluster, com computadores que
podem apresentar uma grande diferena de hardware, sistema operacional e tecnologia de
rede e ainda podem estar em redes de domnios administrativos diferentes, a chamada
computao em grade (TANENBAUM; STEEN, 2007).
Os sistemas de computao de cluster so na maioria das vezes designados a
resolver algum problema complexo, que dividido entre os ns que compem o cluster para
quebrar o problema em tarefas de menor complexidade, deste modo, estas partes do problema
so executadas em paralelo nos ns, utilizando tambm a tcnica da computao paralela, que
ser mais bem abordada no capitulo 2.
Processamento de dados, computao cientifica, anlises financeiras, previses
meteorolgicas so algumas das aplicaes que comumente utilizam computao de cluster,
todas elas necessitam de um alto grau computacional. Este tipo de computao ficou muito
mais acessvel com o passar do tempo, aonde o preo de mquinas com alto desempenho no
chega a ser um absurdo (BACELLAR, 2010). As vantagens apresentadas pelos sistemas de
cluster so: expansibilidade, baixo custo, alta disponibilidade, tolerncia a falhas, e
balanceamento de carga, porm tambm apresentam desvantagens como: a manuteno dos
ns, monitorao dos ns, e o gargalo que se forma com a troca de informaes
(BACELLAR, 2010).

21

1.3.1. Clusters
Quando dois ou mais computadores esto interligados, normalmente prximos
geograficamente e esto sendo utilizados para resolver um mesmo problema, temos a
definio de um cluster. Os computadores que formam um cluster so denominados ns,
nodes ou nodos. Cada n do cluster deve passar ao usurio a imagem de que o sistema nico
e coerente, para isso necessrio que haja transparncia do uso da computao paralela
distribuda em questes como: mtodos de sincronizao, comunicao (troca de mensagens),
distribuio de tarefas, e outros fatores que podem afetar a transparncia do sistema.
Lembrando que o conceito de transparncia deve estar quase que totalmente aplicado em um
sistema distribudo, pois nem sempre interessante mascarar a distribuio do sistema para o
usurio (TOULOUEI, 2010).
A Figura 2 apresenta um exemplo genrico de um cluster, formado por alguns ns
denominados ns escravos, que esto interligados por uma rede de alta velocidade e so
responsveis pela execuo das instrues, e um n controlador que fica responsvel pela
distribuio e controle das instrues, alm do monitoramento dos ns escravos.

22

Figura 2 Exemplo genrico de um cluster (TOULOUEI, 2010).

Os clusters esto sendo muito utilizados devido a ser mais vivel financeiramente
que a aquisio de um supercomputador, alm de que um cluster proporciona flexibilidade no
momento em que h a necessidade de se aumentar o poder de processamento, ou ento
diminuir o poder de processamento para problemas menos complexos, a remoo ou adio
de ns ao cluster, implica apenas em um balanceamento da carga de processamento
(DANTAS, 2005).
Os componentes necessrios para que seja possvel projetar um cluster,
basicamente so:
Os computadores que representam os ns, e so responsveis pela parte da
execuo dos algoritmos ou trechos de um algoritmo. Alguns clusters utilizam
um n para ser o responsvel pela distribuio de tarefas aos ns escravos, este
n que distribu tarefas denominado n mestre.
A parte de transmisso de dados fica por conta das redes de internet, que
composta pelo meio fsico, mecanismos de controle de transmisso de dados, e
pela poltica de sincronizao. A tecnologia de rede mais utilizada a Ethernet,

23

sendo composta pela Fast Ethernet e pela Gigabit Ethernet. A Fast Ethernet
muito utilizado em clusters, podendo chegar a uma velocidade que varia entre
10 Mbps a 100 Mbps, j a Gigabit Ethernet pode chegar a 1 Gbps
(BACELLAR, 2010).
Um sistema operacional que tem a funo de controlar o funcionamento do
computador, gerenciando a utilizao e o compartilhamento de todos os
recursos disponveis. O sistema operacional utilizado pode ser especifico para
clusters, ou ento sistemas operacionais comuns para computadores pessoais.
Bibliotecas de passagem de mensagem, para a comunicao entre processos,
estas bibliotecas sero melhores abordadas no capitulo 3.
Aplicaes paralelas, para se utilizarem do servio final que o cluster
disponibiliza, a execuo em paralelo, lembrando que se for extrado ao
mximo o paralelismo das aplicaes, melhor ir ser o desempenho na
execuo.
As inmeras vantagens, dentre elas, a facilidade de se agrupar computadores
pessoais, e a viabilidade financeira, fez com que os clusters tivessem vrias implementaes,
projetadas por empresas, faculdades, dentre outras organizaes. E essas diferentes
implementaes foram separadas e nomeadas de acordo com suas caractersticas semelhantes.
No h uma taxonomia aceita para se classificar ambientes de clusters, porm,
com base em algumas caractersticas presentes nos clusters, possvel efetuar uma
classificao, tomando como base alguns aspectos como: limite geogrfico, utilizao dos
ns, tipo de topologia, aplicaes alvo, e tipos de ns (DANTAS, 2005).

1.3.2. Tipos de Clusters


Em um primeiro momento os clusters estavam relacionados apenas computao
de alto desempenho, conhecida como High Performance Computing (HPC), porm surgiram
mais duas ramificaes com o intuito de refinar o propsito da implementao de um cluster.
Essas duas novas ramificaes se referem ao cluster de alta disponibilidade, e o cluster de
balanceamento de carga. Lembrando que esses dois tipos de cluster podem estar combinados
dentre de apenas uma implementao.
Em grande parte das residncias, ou at mesmo de empresas, quando um
computador de um usurio comum apresenta algum problema e fica inoperante, no h uma

24

urgncia ou certo desespero em estar colocando o computador em funcionamento novamente,


pelo fato de no haver perdas significativas. Agora, se o computador em questo um
servidor, que responsvel por disponibilizar todos os dados e servios informatizados de
uma empresa, ou este computador seja uma pea fundamental na logstica de uma
organizao, h neste caso uma urgncia para que o computador volte a operar normalmente,
pois podem ocorrer perdas significativas em diversos pontos, como o financeiro. Este caso
exemplifica o tipo de cluster de alta disponibilidade, que tm a funo de manter os dados e
servios de uma organizao sempre disponveis, utilizando a redundncia de software e de
hardware. Os mesmos dados e servios so replicados pelos ns do cluster, onde esto sempre
sincronizados. Cada n monitora os outros ns do cluster, sendo que um n apenas o
principal e quando este n fica inoperante, outro logo assume seu lugar e passa a oferecer os
servios que estavam sendo disponibilizados naquele momento, esta troca acontece sem que o
usurio perceba qualquer tipo de modificao (TOULOUEI, 2010).
Para evitar a sobrecarga sobre apenas um n do cluster, e consequentemente evitar
que o n fique indisponvel, as requisies no devem ser direcionadas para um mesmo n.
Para isso necessrio que haja um balanceamento da carga de processamento, onde todos os
ns sejam os ns principais, com o objetivo de melhorar o desempenho, distribuindo trabalhos
e balanceando o processamento pelos ns do cluster. Este tipo de cluster, denominado de
cluster de balanceamento de carga muito utilizado para minimizar os graves problemas de
servios online que recebem muitos acessos e podem ficar indisponveis por conta disso. Um
cluster de balanceamento de carga bem projetado permite que sejam mantidas a qualidade de
acesso ao servio e a velocidade da resposta de requisio, alm de que todo este
balanceamento fica transparente ao usurio (DANTAS, 2005).
Como dito no inicio deste subcaptulo, os clusters de alto desempenho foram o
inicio e o primeiro tipo de cluster projetado. O objetivo destes clusters realizar um
processamento paralelo onde se consiga ganhar desempenho. Este alto poder de
processamento e os ganhos obtidos com o paralelismo importantssimo para servios como:
processamento de dados, previso do tempo, anlises financeiras, modelagem astronmica,
entre outros.
O cluster de alto desempenho possui caractersticas similares a de um
supercomputador, pelo fato dos ns que formam o cluster trabalharem juntos para resoluo
de um problema, transmitindo a imagem de ser uma nica unidade de processamento. Uma
diferena que importante e muitas vezes influenciam na escolha pela utilizao do cluster ao
invs de um supercomputador, o valor financeiro, pois o cluster formado pelo

25

agrupamento de computadores populares, que com o passar do tempo adquiriram um valor


acessvel a todos.

1.4. Sistemas Distribudos Baseados em Objetos.


Este tipo de sistema distribudo tem como base a utilizao do modelo clienteservidor e do paradigma de orientao a objetos, que servir para que se tenham objetos
distribudos no sistema, onde os recursos e servios s estaro disponveis aps ser feito um
vinculo do processo cliente a um objeto que oferece recursos e servios, e que se encontra
com seu estado localizado no servidor (PEREIRA, 2003).
Quando acontece esta vinculao entre um cliente e um objeto remoto, um proxy
carregado como um objeto local no lado do cliente, implementando a interface do objeto
remoto, com a funo de montar chamadas a mtodos e desmontar chamadas a mtodos por
meio de mensagens, e passar o resultado desta chamada para o cliente. O objeto em si est
localizado no lado do servidor, e disponibiliza a mesma interface que o lado do cliente
implementou. Quando so requisitados os servios oferecidos pelo objeto remoto, um proxy
do lado do servidor recebe as requisies, as desmonta e ento repassa ao objeto para que o
mtodo mais apropriado seja executado (COLOURIS, 2007).
Uma caracterstica de grande parte dos objetos distribudos que eles no
possuem um estado distribudo, mas sim, um estado que reside em apenas uma mquina. O
que distribudo em outras mquinas so somente as interfaces implementadas pelo objeto
(TANENBAUM; STEEN, 2007).
Invocaes a mtodos de objetos distribudos podem utilizar definies
predefinidas de interfaces, onde essas interfaces devem estar sob o conhecimento dos clientes
no momento do seu desenvolvimento, e caso ocorram mudanas na interface, a aplicao
cliente dever ser recompilada para que possa utilizar a interface modificada, esta abordagem
de invocao denominada de invocao esttica. Outra abordagem de invocao acontece
quando somente h a necessidade de uma aplicao selecionar qual mtodo ir invocar em
tempo de execuo, esta abordagem denominada de invocao dinmica (TANENBAUM;
STEEN, 2007).

26

2. COMPUTAO PARALELA
Cada vez mais a computao exige um alto grau de complexidade e desempenho
para resolver problemas que esto em torno de diversas reas de atuao, como: reas cientficas, mdicas, militares, entre outras, e necessitam de um alto poder computacional para fazer
o processamento de algoritmos complexos com grande quantidade de dados. O surgimento da
computao paralela se deu pela necessidade de se obter um desempenho que uma nica unidade de processamento no conseguia obter (DETOMINI, 2010).
Uma definio para computao paralela apresentada pela literatura, por meio de
Quinn (QUINN, 1987) de que a computao paralela o processamento de informaes que
enfatiza a manipulao concorrente dos dados. Esta manipulao pode pertencer a um ou mais
processos que objetivam resolver um nico problema.
O entendimento de computao paralela envolve o conhecimento de trs essncias, so elas: concorrncia, paralelismo e granularidade (SAITO, 2007). A concorrncia a
disputa entre dois ou mais processos para execuo. O paralelismo consiste na diviso de uma
aplicao em partes, onde essas partes so executadas por vrios elementos de processamento
no mesmo intervalo de tempo, buscando o melhor desempenho (DETOMINI, 2010). A granularidade definida pela razo entre o tempo necessrio para o clculo de determinada operao e os custos envolvidos nas trocas de mensagens. A granularidade pode ser fina (conjunto
de instrues simples), mdia ou grossa (conjunto de instrues complexas) (DETOMINI,
2010).
No entanto uma mquina ou um sistema que trabalhe em paralelo no ser de
muita utilidade se no for extrado ao mximo seu poder de processamento, para que isto
ocorra preciso que se tenham tambm excelentes programas paralelos, onde se paralelize
tudo o que possvel, o que se torna uma tarefa complexa para os programadores
(DETOMINI, 2010).

2.1. Taxonomias de Arquiteturas Paralelas


As arquiteturas paralelas procuram agrupar unidades que possuem caractersticas
semelhantes. Dentre as diversas classificaes propostas, a taxonomia de Flynn muito citada, esta taxonomia teve origem na dcada de 70, nela so formados quatro grupos para classificar as arquiteturas.

27

Levando em conta que um computador executa uma sequencia de instrues sobre


uma sequencia de dados, so analisados o fluxo de instrues e o fluxo de dados, que podem
ser definidos como simples ou mltiplos. As classes formadas foram: SISD (Single Instruction Single Data), MISD (Multiple Instruction Single Data), SIMD (Single Instruction Multiple Data), MIMD (Multiple Instruction Multiple Data (DETOMINI, 2010).
A taxonomia de Tanenbaum subdividiu a classe MIMD em outras duas novas
classes, a de multiprocessadores, que so processadores independentes que utilizam apenas
um nico espao de endereamento (fortemente acoplados) efetuando loads e stores (carrega e
armazena) para a comunicao entre os processadores. E a de multicomputadores que so
processadores que possuem um espao de endereamento distinto e que se comunicam atravs
da troca de mensagem utilizando sends e receives (envia e recebe) atravs de uma rede de
comunicao (DETOMINI, 2010).
A Figura 3 representa as vrias classes de mquinas com arquitetura paralela que
podem existir segundo a taxonomia de Tanenbaum.

Figura 3 Classificao das arquiteturas paralelas segundo Taxonomia de Tanenbaum (SAITO, 2007).

Na classe SISD somente um nico fluxo de instrues age sobre um nico fluxo
de dados. Na classe MISD alguns fluxos de instrues agem sobre apenas um nico fluxo de
dados, onde cada unidade de processamento recebe uma diferente instruo que ser
executada em cima de um mesmo fluxo de dados. As diversas instrues so executadas ao

28

mesmo tempo sobre um mesmo espao de memria, o que torna esta tcnica impraticvel e a
classe sem nenhum aproveitamento prtico. Na classe SIMD apenas um nico fluxo de
instruo executado sobre diversos fluxos de dados, onde uma mesma instruo enviada
aos processadores que esto envolvidos no trabalho e estes executam em paralelo sobre
diferentes fluxos de dados, neste caso necessrio que a memria no esteja implementada
como um nico modulo de memria. Na classe MIMD diversas instruo so executadas
sobre diversos fluxos de instrues, onde um processador recebe um fluxo de instruo
diferente das demais instrues enviadas ao outros processadores envolvidos e estas
instrues so executadas sobre diferentes fluxos de dados para cada unidade de
processamento, assim como no caso da classe SIMD, necessrio que a memria no esteja
implementada como um nico modulo de memria (DE ROSE, 2001).

2.2. Computao Paralela Distribuda


Computao paralela e sistemas distribudos so duas ramificaes da computao que surgiram por razes diferentes mais que juntas proporcionaram uma maneira vivel
economicamente de ganhar desempenho. A utilizao de sistemas distribudos trouxe as vantagens de transparncia de acesso aos recursos, tolerncia a falhas, e confiabilidade. As melhorias obtidas em relao tecnologia de rede, capacidade de processamento e ferramentas
de software tornou os sistemas distribudos um cenrio adequado para a aplicao da computao paralela, que tambm levou algumas de suas vantagens, como a eficcia e o ganho de
desempenho (SAITO, 2007).
O que diferencia essas duas reas, que na computao paralela os computadores
tm seu processamento dedicado para um fim especifico, e normalmente possuem caractersticas semelhantes quanto ao hardware e sistema operacional. J em sistemas distribudos, os
computadores podem estar distantes geograficamente, na maioria das vezes no dedicando
seu processamento para apenas um propsito e podendo ter caractersticas totalmente diferentes nas questes de hardware e software (TOLOUEI, 2010).
Um sistema computacional paralelo distribudo pode ser observado na Figura 4,
onde fica claro que o trabalho de um n do sistema executado utilizando uma memria exclusiva para aquele n, dando ao sistema a caracterstica de ser fracamente acoplado. Por possuir esta caracterstica, a troca de mensagens a soluo para a comunicao entre os ns do

29

sistema, levando um alto custo de comunicao e sincronizao para sistemas paralelos distribudos (SAITO, 2007).

Figura 4 Sistema computacional paralelo distribudo (SAITO, 2007).

Com o aperfeioamento das redes de comunicao e as mquinas populares se tornando


mquinas com alto poder de processamento e com um valor acessvel a qualquer individuo, os
sistemas distribudos se difundiram com a computao paralela proporcionando compartilhar
recursos e ter um alto desempenho (DETOMINI, 2010).

30

3. MECANISMOS DE COMUNICAO REMOTA E AMBIENTES DE


TROCA DE MENSAGENS
Se no existisse a comunicao entre computadores no existiriam sistemas
distribudos, a comunicao permite que ampliemos para inmeros, os campos em que a
computao pode ser aplicada. E graas a mecanismos que permitem essa comunicao pela
troca de mensagens, foi possvel aplicar a computao paralela sobre sistemas distribudos,
estes mecanismos esto muitas vezes incorporados com a linguagem que ser utilizada.
O modelo de comunicao mais utilizado em aplicaes distribudas o modelo
cliente/servidor. Este modelo funciona basicamente atravs da requisio-resposta, no qual o
cliente faz uma solicitao ao servidor por meio de uma mensagem, requisitando um servio
que o mesmo oferece, aps receber esta solicitao o servidor executa a tarefa e retorna ao
cliente o resultado da solicitao. Sabendo disto, existem diferentes maneiras de fazer uma
comunicao em um sistema distribudo utilizando este modelo, mecanismos de mais baixo
nvel como sockets, e mecanismos de nveis mais altos, como o RPC, e no caso da utilizao
da linguagem de programao Java, o RMI. Para paralelizao de aplicaes existem tambm
algumas bibliotecas que auxiliam nesta questo, como o caso do MPI.

3.1. Sockets
Este mecanismo de mais baixo nvel possibilita a comunicao entre duas
mquinas, onde uma mquina espera por conexes em uma determinada porta.
Quando um processo necessita estabelecer um canal de comunicao com outra
mquina, uma porta local selecionada para formar um canal de comunicao com uma outra
porta de um processo remoto, estas portas so denominadas sockets e possuem a funo de
estabelecer este canal de comunicao, efetuando o envio e recebimento de informaes entre
os dois processos.

31

Figura 5 Sockets (DA SILVA; FRANCO; AVELINO, 2006)

A comunicao entre processos utilizando sockets pode ser feita baseando-se em


dois modos diferentes. Um dos modos orientado a conexo, que utiliza o protocolo TCP
(Transmission Control Protocol) e outro modo que orientado a datagrama e utiliza o
protocolo UDP (User Datagrama Protocol). Os dois modos de comunicao tm em comum
a atuao sobre o protocolo IP (Internet Protocol) (DA SILVA; FRANCO; AVELINO, 2006).
O modo orientado a conexo, que utiliza o protocolo TCP, funciona da seguinte
maneira: o servidor fica aguardando por conexes em uma determinada porta, e para o cliente
conseguir estabelecer uma comunicao com o servidor, este deve saber previamente algumas
informaes, como: saber qual host o servidor, e qual o nmero da porta em que ele est
atendendo. Aps o servidor aceitar a comunicao com o cliente, um socket criado na porta
do servidor e ento o canal de comunicao entre o cliente e o servidor est devidamente
estabelecido (DA SILVA; FRANCO; AVELINO, 2006).
No modo que no orientado a conexo, e que utiliza o protocolo UDP, o
funcionamento totalmente diferente do modo orientado a conexo. O protocolo de transporte
UDP no oferece garantia de entrega dos dados, portanto as aplicaes que utilizam este
modo devem de alguma maneira utilizar mtodos que ofeream controle de fluxo,
recuperao dos dados perdidos, eliminao de dados duplicados. Por possuir estas
caractersticas, o protocolo UDP bem simples e rpido, porm no oferece a mesma
confiabilidade que o protocolo TCP. Neste modo no estabelecida uma conexo entre cliente
e servidor, o cliente apenas envia um datagrama (mensagem) a outro host da rede, e caso o
host receptor no esteja aguardando por uma mensagem, a mesma perdida.

3.2. Message Passing Interface (MPI)

Devido falta de padronizao entre as bibliotecas de troca de mensagem para

32

computao paralela e a incompatibilidade entre diferentes plataformas de hardwares e


sistemas operacionais, alguns problemas foram aparecendo. Para se padronizar, oferecer uma
interoperabilidade aos desenvolvedores e tentar minimizar estes problemas, foi criado uma
biblioteca de troca de mensagens para computao paralela, chamada MPI, esta biblioteca
oferece um padro, onde este se limita apenas a nvel de biblioteca de troca de mensagens,
no criando uma camada particular para tratar esta questo (TOLOUEI, 2010).
Projetado em um frum aberto constitudo por diversas organizaes na dcada de
90, o projeto MPI foi ganhando diferentes implementaes com o passar dos anos, algumas
proprietrias, outras de cdigo aberto, porm todas seguindo o mesmo padro de usabilidade e
funcionamento (JNIOR, 2010).
O MPI um ambiente de passagem de mensagens comumente utilizado, neste
ambiente um processo de uma determinada aplicao utiliza funes para fazer a
comunicao com outros processos (SABATINE, 2007). A comunicao acontece
basicamente na troca de mensagens (troca de dados e sincronizao) por uma rede de alta
velocidade que interliga os ns que compem um cluster. As mensagens trocadas so
compostas por informaes referentes ao endereo de alocao dos dados, a identificao do
processo emissor e do processo receptor, e a identificao dos processos que podem receber a
mensagem (TOLOUEI, 2010).
O principal objetivo do MPI se tornar o padro de interface mais utilizado,
assumindo o lugar de bibliotecas de interfaces especficas, levando um melhor desempenho e
um aperfeioamento na comunicao dos ns que fazem parte do sistema. Este ambiente de
troca de mensagens no possui gerenciamento dinmico de processos, por isso tendem a ser
mais eficientes, pois no haver um excesso de processos em tempo de execuo (JNIOR,
2010).
Como mostra a Figura 5, no momento da execuo de uma aplicao que utiliza
MPI, os processos so divididos em processos menores e ento so distribudos pelos ns do
cluster. Cada n executa o processo que lhe foi enviado e retorna o resultado ao n mestre. Os
processos trabalham com memria fracamente acoplada, ou seja, em um sistema de memria
distribuda.

33

Figura 6 Modelo de execuo do MPI (PITANGA, 2008).

Uma vantagem encontrada no MPI a sua portabilidade e sua independncia de


plataforma. Um cdigo MPI desenvolvido para uma arquitetura A com sistema operacional B,
pode ser portado para uma arquitetura C com sistema operacional D, com poucas ou nenhuma
alterao no cdigo (PITANGA, 2008).
3.3. RPC
Entre os mecanismos de comunicao que podem ser utilizados em sistemas
distribudos, vale ressaltar o RPC (Remote Procedure Call).
O RPC foi criado com base em observaes no funcionamento do mecanismo de
transferncia de dados dentro de um programa em um nico computador. A partir da, surgiu a
ideia de levar o mesmo conceito desta funcionalidade para um ambiente distribudo, onde
seria possvel efetuar chamadas a procedimentos remotos, ou seja, localizados em outros
computadores. Em geral, o objetivo do RPC tornar a comunicao distribuda transparente
ao desenvolvedor, abstraindo-o de questes de diferenas de hardware, fazendo com que
chamadas a procedimentos remotos sejam o mais parecido possvel com chamadas a
procedimentos locais. A chamada de procedimento remoto feita de maneira sncrona, onde o
processo que efetuou a chamada suspenso at o procedimento chamado terminar sua
execuo (NODA, 2005).
Este mecanismo muito utilizado em muitos sistemas distribudos, porm no
oferece algumas vantagens que o RMI (Remote Method Invocated), um mecanismo de

34

comunicao mais recente consegue oferecer e por isso vem sendo muito utilizado em
sistemas distribudos atuais.

3.4. RMI Java


De acordo com (SARAMAGO, 2012), RMI essencialmente o RPC, porm, por
RMI ser implementado utilizando a linguagem Java algumas vantagens so apontadas para o
uso de RMI, como: a segurana, a portabilidade, o garbage collection distribudo, a facilidade
de desenvolvimento e utilizao. Outro fator que diferencia a utilizao do RPC para a
utilizao do RMI que o RPC no consegue criar instncias de objetos, e assim no d
suporte referncia remota, portanto em sistemas orientado a objetos o RMI substituiu as
chamadas a procedimentos remotos (BARCELLOS, 2002).
O RMI consiste em um mecanismo da linguagem de programao Java que
disponibiliza um conjunto de funcionalidades para possibilitar ao programador o
desenvolvimento de aplicaes Java que utilizem objetos distribudos, mantendo uma
semntica muito semelhante programao de uma aplicao que envolva apenas objetos
locais, essa semntica s no exatamente igual, pois quando se trata de objetos distribudos,
h questes de rede que devem ter tratamentos de erros e execues particulares (PEREIRA,
2003). A restrio do RMI em apenas poder ser utilizado em aplicaes escritas em Java
uma caracterstica importante a ser constada e que pode ser considerada como uma
desvantagem.
A camada que est abaixo da aplicao e acima dos protocolos de comunicao,
sistema operacional e hardware a camada onde est posicionado o RMI, como ilustrado na
Figura 7, esta camada tem a funo de dar transparncia nas diferenas das camadas inferiores
e possibilitar que um objeto local possa invocar mtodos de um objeto remoto que est
disponibilizando seus servios atravs de uma interface (COLOURIS, 2007).

35

Figura 7 Camadas do Middleware (COLOURIS, 2007)

Como um sistema distribudo que implementado utilizando a linguagem Java


trabalhar com o conceito de orientao a objetos, uma classe ir conter a implementao de
todos os servios disponibilizados pelo sistema, que ficaro disponveis para invocaes de
clientes por meio de objetos distribudos.
No momento em que o cliente se vincula a um objeto distribudo acontece a
criao de duas entidades. No lado do cliente criado um proxy denominado stub, que fica
situado no espao de endereamento do cliente. O stub um representante local que
implementa a mesma interface que o objeto que est representando, sua responsabilidade
fazer a serializao dos parmetros de uma invocao e envi-la ao servidor. No lado do
servidor um objeto denominado skeleton faz a comunicao direta com o cliente por meio do
stub, o skeleton tem a responsabilidade de decodificar os parmetros recebidos na invocao e
repassar ao servidor para que o mtodo mais apropriado para aquela invocao seja
executado, e mais tarde, serializar a resposta que ser encaminhada ao stub para ser repassada
aplicao. Objetos em RMI so passados por referncia nas invocaes de chamadas e nas
mensagens de resposta, enquanto tipos primitivos so passados por valor (PEREIRA, 2003).
A organizao e localizao dos componentes de um sistema distribudo baseado
em objetos e que utiliza invocao de mtodos remotos est sendo representada na Figura 8,
na imagem podemos visualizar o stub localizado no lado do cliente, o skeleton que est
localizado no lado do servidor, e tambm nmeros que indicam a ordem dos passos do
momento em que a aplicao invoca um mtodo, at o momento em que esta mesma
aplicao utiliza os resultados recebidos do servio invocado.

36

Figura 8 Organizao dos elementos de um sistema distribudo usando Java RMI (PEREIRA, 2003).

Para um melhor entendimento, esto descritos em ordem os passos que acontecem


na comunicao, do inicio da invocao de um mtodo por um cliente, at o momento em que
a aplicao recebe os valores de retorno. So estes os passos:

Surge a necessidade da aplicao cliente utilizar um servio disponibilizado


pelo servidor. Esta necessidade passada ao stub que ficar responsvel por
toda a comunicao e decodificao dos parmetros envolvidos.

O stub inicia uma conexo com o servidor em que o objeto remoto est localizado. As informaes que precisam ser enviadas ao servidor so colocadas
no parmetro da invocao e serializadas pelo stub para posterior envio. A
invocao est pronta e ento transmitida ao servidor pela rede.

O servidor cria um elemento denominado skeleton que ficar responsvel


por receber as invocaes que chegam do stub.

Logo aps receber a invocao, o skeleton decodifica os parmetros e repassa ao servidor para que este execute o mtodo que ir atender a necessidade
da aplicao cliente.

O mtodo executado e o resultado passado ao skeleton para que este faa


a comunicao corresponde mensagem de retorno.

Antes de enviar a resposta ao cliente, o skeleton serializa os parmetros da


resposta e ento a transmite pela rede.

O stub recebe a resposta enviada pelo skeleton.

37

Aps receber, o stub decodifica os parmetros da mensagem de reposta e repassa a aplicao cliente para que esta utilize o resultado do servio utilizado.

Todos os servios oferecidos ficaro disponveis em um objeto remoto como dito


anteriormente, porm para que o cliente possa efetuar consultas aos servios oferecidos
preciso que o objeto remoto se registre junto a um servidor de nomes. A utilizao de um
servio que atribui nomes a diversos recursos, como computadores, usurios, arquivos, e
objetos remotos, por exemplo, muito til no projeto de um sistema distribudo. A execuo
de um servio oferecido por um objeto remoto, no caso do Java RMI, acontece aps o cliente
efetuar uma solicitao sobre determinado nome que estar representando o recurso
procurado.
O objeto se registra em uma porta especifica do host por meio do mtodo bind
disponibilizado pela classe java.rmi.Naming, passando uma referncia do objeto e o nome do
mesmo. Este servidor registra os objetos remotos associando-os a um nome, por meio deste
nome que o cliente ir procurar o objeto, atravs do mtodo lookup que tambm
disponibilizado pela classe java.rmi.Naming. Ao encontrar, o servidor de nomes retorna ao
cliente a localizao do objeto remoto, atravs de uma referncia do objeto remoto (NODA,
2005).
Este servio de localizao de nomes denominado RMIRegistry e uma
ferramenta que acompanha a mquina virtual Java. Por padro os objetos remotos so
registrados na porta 1099 do host, mas nada impede que esta porta seja alterada ou omitida.
A escolha do RMI como mecanismo de comunicao no desenvolvimento deste
projeto se deu pelo fato do RMI ser um mecanismo pertencente linguagem de programao
Java, permitindo a utilizao do paradigma de orientao a objetos, sendo que toda
implementao dos algoritmos de fatorao, tanto o algoritmo sequencial, como o algoritmo
paralelo distribudo, serem feitas utilizando a linguagem. Alm de que o RMI um
mecanismo mais recente em comparao a outros mecanismos, e por isso pode apresentar
caractersticas ainda no apresentadas em outros estudos ou pesquisas.

38

4. IMPLEMENTAO DO ALGORITMO
Este captulo visa apresentar as caractersticas do projeto desenvolvido, com questes que
envolvem o embasamento da implementao do algoritmo, como: fatorao de nmeros
inteiros e criptografia RSA, a implementao do algoritmo em si, o modo como o algoritmo
foi paralelizado, e os diferentes modos de execuo.

4.1. Fatorao de nmeros inteiros


Tema muito discutido ao longo da histria da humanidade, a fatorao de nmeros
inteiros tambm muito discutida at na atualidade, ainda mais quando utilizada para
implementao de mtodos de criptografia.
Grande parte dos mtodos modernos de criptografia assume que a fatorao de
nmeros inteiros um problema difcil de ser solucionado. Um mtodo de criptografia que
utiliza este conceito a criptografia RSA, muito utilizada na computao. Neste caso da
criptografia RSA, levado em considerao que fcil gerar um nmero inteiro
extremamente grande que seja produto de dois nmeros primos inteiros, porm muito difcil
encontrarmos os dois nmeros primos (fatores) que geraram este nmero inteiro
extremamente grande.
Existem algumas maneiras de se fazer a fatorao de nmeros inteiros, como o
mtodo de fatorao por tentativas, mtodo de Pollard, mtodos de curvas elpticas e o
mtodo que iremos abordar na sequencia, o mtodo de Fermat (ANTUNES, 2002).

4.1.1. Mtodo de Fermat


O mtodo de fatorao desenvolvido por Fermat baseia-se que um determinado
nmero n composto, pode ter seus fatores encontrados, assumindo que n = 2 - 2 = (x - y) (x
+ y) temos que (x + y) (x y) so fatores de n, onde n por suposio um nmero mpar e x e
y so nmeros inteiros positivos tal que n = (x + y) (x y) = n. Este mtodo de fatorao
considerado eficiente, e muito mais eficiente quando o valor de n possui um fator primo perto
da raiz quadrada de n.
O mtodo de Fermat consiste inicialmente em x contendo a parte inteira da raiz
quadrada de n, x = [], caso 2 = n, ento acontece o caso mais simples onde n seria um

39

quadrado perfeito e x seria um dos fatores de n. Caso no seja um quadrado perfeito, o x


incrementado de um em um at que y assuma um nmero inteiro na equao 2 .
Depois disto, os fatores de n podem ser encontrados facilmente, sendo um dos fatores o (x +
y) e outro o (x y).
Deve-se considerar quando n assume um nmero composto e quando n assume
um nmero primo. Quando composto a fatorao de n mostra que existe um nmero inteiro
x > [] onde 2 um nmero menor que

( + 1)

como nmero primo, o nico valor possvel de x

. Quando o n em questo se apresenta

( + 1)
2

(BARNAB, 2009) (ANTUNES,

2002).

4.2. Criptografia RSA


Muitas vezes uma troca de informaes entre duas pessoas requer sigilo, e quando
esta troca de informaes acontece utilizando a internet como meio de comunicao,
inevitvel que se utilize algum mtodo para que esta informao no seja interpretada por
entidades ou pessoas que no sejam aquelas que realmente devem receber a mensagem.
O mtodo utilizado para codificao da mensagem a criptografia, que vem sendo
utilizado h muito tempo, como o caso da cifra de Csar, mtodo clssico de criptografia onde
as letras do alfabeto eram substitudas por letras de trs posies frente, e no caso das
guerras, onde as mensagens eram cifradas para que estratgias de guerras no fossem
descobertas pelos inimigos.
Em um perodo mais recente tm-se dois tipos de criptografia, a criptografia
simtrica e a criptografia assimtrica. A criptografia simtrica utiliza uma mesma chave para
se criptografar e para descriptografar uma mensagem. Este mtodo relativamente rpido,
porm inseguro pelo fato de ser necessrio o compartilhamento da chave, sendo que no h
um meio de comunicao seguro para a distribuio da mesma. O algoritmo mais utilizado
para este tipo de criptografia hoje em dia o AES (Advanced Encryption Standard)
(DETOMINI, 2010).
Na criptografia assimtrica so utilizadas duas chaves, uma para criptografar a
mensagem e outra para descriptografar. A chave utilizada para criptografar a mensagem e que
pode ser de conhecimento de qualquer pessoa denominada chave pblica, enquanto a chave
que utilizada para descriptografar a mensagem, e que de conhecimento exclusivo do
destinatrio denominada chave privada, cada chave privada deve ser referente a uma nica

40

chave pblica, pois apenas ela conseguir decifrar a mensagem. Um exemplo quando uma
pessoa A deseja enviar uma mensagem para pessoa B, a pessoa A deve utilizar a chave pblica
de B para criptografar a mensagem, e depois de enviada, a pessoa B usa sua chave privada
para decifrar a mensagem. O algoritmo mais utilizado para este tipo de criptografia o RSA
(Rivest Shamir Adleman), que relativamente mais lento que o AES, porm oferece maior
segurana.
O mtodo utilizado pelo RSA para criptografar mensagens a base para o
desenvolvimento deste projeto. Este mtodo utiliza a multiplicao de grandes nmeros
primos como parte do seu processo para criptografar uma mensagem, onde esta multiplicao
ir gerar um nmero inteiro extremamente grande, e para que se consiga quebrar a
criptografia RSA basta encontrar os dois fatores primos a partir do nmero inteiro gerado na
multiplicao dos mesmos. A maior segurana que oferece este mtodo de criptografia em
relao a outros, esta relacionada a dificuldade, em termos de tempo e tecnologia, para se
fatorar um nmero extremamente grande (DETOMINI, 2010).
Para a soluo deste problema, existem alguns mtodos de fatorao de nmeros
inteiros, o mtodo de Fermat assume caractersticas que de certa forma facilitam sua
implementao e a diviso do problema em partes que podem ser paralelizadas, alm de sua
ideia estar baseada em um poderoso mtodo de fatorao de nmeros inteiros, o mtodo do
Crivo quadrtico. Por estes motivos o mtodo de Fermat foi selecionado para ser utilizado na
implementao deste projeto.

4.3. Desenvolvimento do Algoritmo


O algoritmo foi desenvolvido inicialmente para uma execuo de maneira
sequencial, e depois foi adaptado para que fosse possvel uma execuo paralela.
Para a execuo de forma paralela o algoritmo utilizado sofreu algumas alteraes
para que fosse possvel paralelizar o processamento, distribuindo as tarefas entre os ns que
compunham o cluster, porm as mudanas ficam apenas nessa questo, pois os clculos
efetuados para chegar ao resultado necessrio so exatamente iguais para o algoritmo
sequencial como para o algoritmo paralelo.
A seguir ser melhor explicado como foi desenvolvido, e o funcionamento do
algoritmo sequencial e do algoritmo paralelo distribudo.

41

4.3.1. Algoritmo Sequencial


O algoritmo sequencial foi desenvolvido na linguagem de programao Java,
baseado na implementao de todo o mtodo de Fermat, onde todos os clculos e iteraes
necessrias para se chegar aos fatores ficou todo sob responsabilidade de apenas uma
maquina, sendo desnecessria a implementao de mais componentes. Abaixo, na Figura 9,
est sendo mostrado o trecho do cdigo que realiza os clculos necessrios para implementar
o mtodo de Fermat.

Figura 9 Trecho do cdigo sequencial onde so realizados os clculos para se chegar as fatores.

Neste trecho possvel visualizar o lao de repetio onde realizado o


incremento da varivel x a cada iterao que y no assume um valor inteiro, at o momento
onde y assume um valor inteiro e se torna possvel chegar aos dois fatores.

42

4.3.2. Algoritmo Paralelo Distribudo


O desenvolvimento do algoritmo para execuo paralela tambm foi caracterizado
pela utilizao da linguagem de programao Java, e um de seus mecanismos, o Java RMI,
que permite a utilizao da programao distribuda por meio da aplicao.
Baseando-se no paradigma mestre-escravo, foram implementados um cliente, que
possui a funo do mestre, de dividir os dados e distribuir as partes para os servidores, que
possuem o papel dos escravos dentro do paradigma, estes executam o mesmo cdigo fonte
(mesmas instrues) sobre os diferentes dados recebidos do mestre, desta forma, a aplicao
se encaixa na classe SIMD (Single Instruction Multiple Data) das arquiteturas paralelas de
acordo com a taxonomia de Tanenbaum.
A Figura 10 representa de maneira bem clara como organizado o paradigma
mestre-escravo de acordo com a utilizao do Java RMI, com os Servidores tendo a mesma
funo de um escravo, e o Cliente, a de um mestre.

Figura 10 Organizao dos componentes da aplicao e seus respectivos parmetros.

Para que o cliente RMI disponibilize os intervalos para os servidores, necessrio


que os servidores implementem um cdigo que receba estes intervalos, para isso preciso
encontrar no algoritmo sequencial um trecho de cdigo que permita uma diviso do problema,
e posteriormente uma paralelizao do cdigo.
Esta diviso do problema est representada na Figura 11, sendo que o retngulo
azul presente na imagem representa o algoritmo sequencial.
Primeiramente feita uma anlise para identificar um trecho do cdigo sequencial

43

que apresente caractersticas paralelizveis. Aps este trecho ser identificado (representado
pelo retngulo vermelho na Figura 11), feita uma diviso de maneira que as partes geradas
possam ser distribudas pelos servidores, estas partes podem ser caracterizadas por trechos de
cdigos idnticos ou no. Para este projeto, as partes distribudas ente os servidores so
idnticas, e executam as mesmas instrues, recebendo valores distintos para executarem,
onde estes valores so representados por intervalos distintos de nmeros inteiros que cada
servidor ter que executar. Na Figura 11, estes intervalos esto sendo representados pelas
cores verde, roxo e amarelo.

Figura 11 Mtodo de diviso do algoritmo sequencial.

A maneira como funciona a aplicao implementada para este projeto ocorre com
o cliente efetuando invocaes de maneira paralela aos mtodos remotos disponibilizados
pelos servidores, que executam as partes que possuem do algoritmo. Aps as execues terem
ocorrido, o servidor que obteve o resultado transmite a resposta ao cliente para que este possa
mostrar ao usurio o resultado obtido.
Com a utilizao do RMI faz-se necessrio que sejam implementadas interfaces e
outros componentes para que seja possvel sua utilizao, portanto, o lado do cliente, que ser
denominado mestre, ser composto pela classe cliente e por outros componentes, e o lado dos
servidores, que sero denominados escravos, ser composto para cada servidor, pela classe
servidor e por outros componentes necessrios.
A partir destas caractersticas o desenvolvimento do algoritmo paralelo foi
dividido em duas etapas principais. A primeira etapa visa implementao dos componentes

44

que fazem parte do mestre (cliente). Em sequencia, a segunda etapa visa implementao dos
componentes que pertencem ao lado do escravo (servidor).
Inicialmente, ser descrito todos os componentes que pertencem ao lado do
mestre, e depois, todos os componentes que pertencem ao lado dos escravos.

4.3.2.1. Implementao do Mestre


A responsabilidade pela diviso e distribuio do problema entre os ns escravos,
e pela invocao dos mtodos remotos toda do n mestre. Ele quem vai gerenciar toda a
aplicao, distribuindo os intervalos de valores a serem executados pelos escravos e
recebendo como retorno os fatores encontrados por algum dos ns escravos.
Para que o problema da comunicao sncrona imposto pela utilizao do Java
RMI fosse resolvido e a invocao dos mtodos remotos ocorresse de maneira paralela, foi
necessria a utilizao de threads, onde cada thread criada se torna responsvel pela
invocao a um mtodo remoto relacionado a um nico escravo.
Na implementao do cdigo executado pelo n mestre foram necessrias as
seguintes classes: Cliente.java, ThreadEscravo.java, InterfaceEscravo.java.

4.3.2.2. Classe Cliente.java


No inicio do desenvolvimento desta classe, so declaradas e inicializadas no
mtodo principal, algumas das variveis necessrias. Dentre as responsabilidades das mesmas
esto: receber tempo inicial do inicio da execuo, controle de lao de repetio, quantidade
de escravos utilizados, o nmero que ser fatorado, e um vetor para armazenar valores
inteiros, que agrupados em pares vo representar os limites iniciais e finais dos intervalos a
serem executados pelos ns escravos. O agrupamento dos pares que formam o intervalo
feito de maneira lgica, sendo que ele s pode ser observado no momento em que o par de
posies do vetor passado por referncia ao servidor que ir execut-lo. O modo como os
pares de posies do vetor so agrupados para formar um intervalo est representado pela
Figura 12.

45

Figura 12 Diviso dos intervalos para os escravos.

Aps as declaraes das variveis utilizadas e a explicao de como o vetor


utilizado para armazenar os intervalos, o mtodo de Fermat comea a ser implementado no
lado do cliente. O primeiro passo calcular a raiz quadrada do valor a ser fatorado. Este valor
a ser fatorado ser identificado como n para facilitar a explicao.
O valor encontrado ao se calcular a raiz quadrada de n incrementado em uma
unidade e corresponde ao valor inicial a ser incrementado nas iteraes seguintes, este valor
guardado na primeira posio do vetor responsvel por formar os intervalos de valores, e ser
denominado xInicial.
A princpio ser criado um intervalo principal, que depois ser dividido em
intervalos menores de acordo com o nmero de escravos utilizados. Para criar este intervalo
principal falta gerar um valor final que represente o limite mximo do intervalo, j que o
limite mnimo do intervalo o xInicial descrito acima.
Atravs de testes preliminares com a fatorao de diversos nmeros inteiros, no
foi possvel encontrar nenhum padro ou lgica no nmero de iteraes que acontece at que
os fatores sejam encontrados, para que fosse possvel definir o final do intervalo de maneira
que os intervalos gerados aps a diviso para os escravos no ficassem com um tamanho
muito extenso e prejudicassem o desempenho.
Com isso, o valor de xFinal ser ajustado de acordo com as necessidades, para
que se consiga mostrar cenrios de execues particulares, portanto o ambiente de testes se
torna totalmente controlado. O ajuste ser feito controlando o tamanho do intervalo principal
que ir afetar tambm, o intervalo que cada escravo ir receber para executar, este
procedimento vai representar o mesmo que se fossem aumentados o nmero de escravos.
O modo encontrado para se gerar um xFinal, foi atravs da implementao de um
mtodo que identifica a quantidade de dgitos que compe o valor de n, e assim criar o maior
valor que aquela quantidade de dgitos pode formar, sendo este o valor de xFinal.

46

Esta forma de gerar o xFinal tambm se baseou nos testes preliminares, onde foi
possvel identificar que o valor de xInicial, ao ser incrementado, no ir ultrapassar de
maneira alguma o maior valor que se pode formar com a quantidade de dgitos do nmero n.
Caso o nmero n tenha 7 dgitos por exemplo, o xFinal ser correspondido pelo nmero
9999999, que estar armazenado na ltima posio do vetor.
Com o valor do xFinal definido, j possvel dividir o intervalo entre o xInicial e
o xFinal em quantos outros intervalos for necessrio, de acordo com o nmero de escravos
utilizados na execuo. Os valores que correspondem aos limites dos intervalos so
armazenados dentro do vetor, e aps todos os valores serem definidos e armazenados, a
responsabilidade da classe Cliente passa a ser a de criar a quantidade de threads necessrias.
A definio da quantidade mxima de threads que podem ser criadas pela
aplicao feita de maneira esttica, pois como os testes sero realizados em um nmero fixo
de cenrios, e a quantidade de threads ser igual quantidade de escravos utilizados na
execuo, no h necessidade de uma criao dinmica de threads.
Antes de uma execuo, define-se de maneira manual apenas a quantidade de
escravos utilizados, deixando que a aplicao inicie o nmero correto de threads para o
respectivo cenrio. As seguintes situaes podem ocorrer: a criao de apenas uma thread
quando apenas um escravo for utilizado, duas threads para quando dois escravos forem
utilizados, trs threads para quando trs escravos forem utilizados, quatro threads para quando
quatro escravos forem utilizados, e cinco threads para quando cinco escravos forem
utilizados.
Aps estarem criadas, as threads recebem como parmetro na sua chamada, o
valor de n, duas posies do vetor que correspondem a um intervalo de valores, e o tempo em
que se iniciou a execuo da aplicao, como demonstrado na Figura 13.

47

Figura 13 Trecho do cdigo que faz a chamada das threads.

A classe Cliente.java finaliza sua execuo neste momento transferindo para as


threads a responsabilidade de invocar os mtodos remotos.

4.3.2.3. Implementao das Threads


Ao serem criadas e chamadas pela classe Cliente.java as threads tm o objetivo
de invocar o mtodo remoto e mostrar o resultado recebido como retorno, as threads
implementadas utilizam-se do mtodo lookup disponibilizado pela classe java.rmi.Naming
para procurar pelo mtodo que foi registrado anteriormente por um objeto no servidor de

48

nomes.
No construtor da thread, so recebidos da classe Cliente.java, o nmero a ser
fatorado, um intervalo de nmeros inteiros, e o tempo inicial da execuo. O cdigo do
construtor da thread representado pela Figura 14.

Figura 14 Construtor da thread.

O trecho do cdigo onde feita a invocao do mtodo remoto e exibio do


retorno recebido esto contidos no mtodo run que pertence a interface Runnable
implementada pelas threads. Este cdigo mostrado na Figura 15.

Figura 15 Trecho do cdigo onde realizada a invocao ao mtodo remoto.

4.3.2.4. Implementao do Escravo


Dependendo do cenrio, uma variao no nmero de escravos vai ocorrer, porm,

49

independentemente da quantidade de escravos, a instruo que cada um deles executa a


mesma. O que modifica de um escravo para o outro so os dados que vo atuar sobre as
instrues. Esses dados na verdade so intervalos de nmeros inteiros que so recebidos por
cada escravo na chamada de seu mtodo remoto. A partir da, os escravos executam seu
cdigo, que caracterizado pela implementao do mtodo de Fermat, incrementando o
primeiro nmero do intervalo a cada iterao, at que se encontre o valor esperado, ou at que
todos os nmeros inteiros do intervalo tenham sido executados.
Ao final, apenas um dos escravos ir encontrar os dois fatores que sero
retornados para thread cliente. E quando um dos escravos encontrar os dois fatores, a
execuo dos outros escravos ignorada, pois o que interessa efetuar uma verificao no
perodo em que se inicia a execuo at o momento em que so encontrados os dois fatores.
O lado do escravo composto por uma interface, InterfaceServidor.java, e duas
classes: Servidor.java, e a InterfaceServidorImplementada.java.

4.3.2.5. Classe Servidor.java


A tarefa de registrar o objeto remoto no servidor de nomes e manter o escravo
escutando invocaes fica por conta da classe Servidor.java. O registro acontece atravs da
chamada ao mtodo rebind, que tem a funo de fazer a ligao entre o nome especificado e o
objeto remoto, substituindo qualquer ligao feita anteriormente. O trecho do cdigo que
implementa esta funcionalidade segue abaixo representado pela Figura 16.

Figura 16 Trecho do cdigo onde o objeto remoto registrado no RMIRegistry.

4.3.2.6. Classe InterfaceServidor.java


As interfaces so implementadas contendo apenas as assinaturas dos mtodos,
deixando para que uma classe implemente todos mtodos da interface. Neste caso, a interface
assina apenas um mtodo, denominado parte, referente parte que um especfico servidor vai

50

executar. Abaixo segue a Figura 17 que representa o cdigo da interface.

Figura 17 Interface com a assinatura de seu mtodo.

Caso haja uma mudana no cenrio de execuo, e sejam adicionados mais


escravos, outras interfaces sero criadas para cada escravo adicionado.

4.3.2.7. Classe InterfaceServidorImplementada.java


A

classe

InterfaceServidorImplementada.java

implementa

interface

InterfaceServidor.java, com isto a classe consiste da implementao dos mtodos contidos na


interface, no caso desta aplicao, apenas um mtodo ser implementado.
A implementao do mtodo definida pelo mtodo de Fermat, onde o escravo
tenta resolver uma fatorao de um nmero inteiro com base no intervalo de valores recebido
por uma invocao do cliente. O trecho do mtodo onde feito o clculo para encontrar os
fatores mostrado na Figura 18.

51

Figura 18 Trecho do cdigo onde so realizados os clculos para se chegar aos fatores.

O cdigo apresentado idntico ao cdigo do algoritmo sequencial, a diferena


que na execuo paralela, este cdigo estar contido nas implementaes das diversas
interfaces distribudas entre os escravos utilizados na execuo. O comportamento do cdigo
apresentado na Figura 18 acontece de maneira que a execuo s ser interrompida at que
uma destas condies seja satisfeita: o valor de y assuma um valor inteiro, ou o valor de x, ao
ser incrementado, chegue ao final do intervalo passado pelo cliente.
O primeiro passo multiplicar o primeiro valor do intervalo recebido por ele
mesmo, subtrair pelo nmero a ser fatorado, representado pelo n, e encontrar a raiz quadrada
deste nmero que ento armazenada em y.
O segundo passo verificar se y um nmero inteiro, e para se verificar esta
condio, divide-se y por 1, e com o resto da diviso possvel determinar se y um nmero
inteiro, pois caso o resultado seja 0, y um valor inteiro, caso o resultado seja um nmero
diferente de zero, o valor de x no inteiro e ento incrementado e o primeiro passo
novamente realizado, at que o valor de y seja um nmero inteiro.
Aps a varivel y assumir um valor inteiro, os dois fatores j podem ser

52

encontrados. O primeiro fator encontrado atravs da soma do valor de x com o valor de y, e


o outro encontrado atravs da subtrao do valor de x pelo valor de y. Estes ento so
transmitidos como retorno para thread que efetuou a invocao a este escravo e ento exibidos
pela aplicao.

4.4. Execuo da aplicao


A aplicao foi executada de duas maneiras distintas, execuo sequencial e
execuo paralela, de acordo com os cdigos implementados anteriormente. A seguir ser
mostrado como foi executado o algoritmo para dois casos, e em quais cenrios as execues
ocorreram.

4.4.1. Execuo Sequencial


A execuo sequencial foi realizada em uma mesma mquina, com seis cenrios
que se distinguiam apenas pelo nmero inteiro utilizado para fatorao. Os nmeros utilizados
foram os mesmos dos testes realizados de maneira paralela distribuda, e sero apresentados
no item 5.2.
Em cada um dos cenrios foram realizadas 10 execues de onde se calculou a
mdia, que foi o resultado levado em conta como medida de desempenho, de onde foi
possvel calcular outras medidas para anlise. Os resultados da execuo sequencial sero
apresentados no captulo 5, em uma tabela respectiva ao cenrio de execuo, juntamente com
os resultados da execuo paralela, para facilitar as anlises e uma comparao entre ambas.

4.4.2. Execuo Paralela Distribuda


Aps a execuo e coleta dos resultados provenientes da execuo sequencial,
chega vez de se testar a aplicao em um ambiente paralelo distribudo, e para isso
necessrio que sejam feitas alteraes no cdigo e implementao de novos componentes que
vo executar em outros ns do sistema, como exemplificado no item 4.3.2.
Aps toda implementao dos componentes necessrios para compor a aplicao,
hora de executar o cdigo em diferentes tipos de cenrios.
Ao todo foram organizados seis cenrios, diferenciados apenas pelo nmero

53

inteiro a ser fatorado. A execuo em cada um dos cenrios leva em considerao outros seis
modos de execuo, so eles: execuo do algoritmo sequencial; execuo do algoritmo
utilizando uma mquina mestre e uma mquina escravo; execuo utilizando uma mquina
mestre e duas mquinas escravos; execuo utilizando uma mquina mestre e trs mquinas
escravos, execuo utilizando uma mquina mestre e quatro mquinas escravos, e uma
execuo utilizando uma mquina mestre e cinco escravos. Cada cenrio realizou os seis
modos de execuo, permitindo que fossem realizadas comparaes entre eles.
Todos os cenrios foram executados em um ambiente distribudo paralelo
controlado, onde o nmero inteiro a ser fatorado ser escolhido e inserido manualmente no
algoritmo antes da execuo de cada cenrio. A escolha do nmero inteiro ser feita utilizando
critrios para que os testes realizados possam mostrar casos onde ocorreu perda de
desempenho e onde ocorreu ganho de desempenho, dando a possibilidade de se explicar cada
caso, e tambm para que o tempo de uma nica execuo seja vivel para realizao de todos
os testes, pois sero realizadas 10 execues para o processamento sequencial e 10 execues
para cada quantidade de escravos utilizados na execuo paralela. Alguns dos critrios
utilizados que interferem diretamente no desempenho so: o tamanho e a distncia dos
fatores, que interferem diretamente no nmero de iteraes que ir ocorrer na execuo.
Sabendo disso, foi utilizado um mesmo modelo para a construo de todos os
cenrios, onde este modelo est sendo representado pela Tabela 1. Nesta figura, a letra X que
vem aps a palavra cenrio, representa o nmero do cenrio, que pode ser 01, 02, 03, 04,
05, 06, e a letra Y representa o nmero inteiro que ser fatorado no cenrio em questo.
Tabela 1 Modelo de construo dos cenrios

A escolha dos dois nmeros primos foi feita de maneira aleatria, observando e
garantindo que a multiplicao dos dois no gere um nmero que tenha acima de treze dgitos,
pois um nmero maior que esta quantidade de dgitos tomaria um tempo ainda maior para que

54

todas as execues dentro de todos os cenrios fossem concludas, sabendo que o tempo e a
infra-estrutura necessria muitas vezes escasso. Porm, com um nmero de treze dgitos
para ser fatorado, j possvel efetuar as anlises e concluses necessrias.

55

5. TESTES E RESULTADOS
Os testes foram todos realizados no laboratrio 01 do Centro Universitrio
Eurpides Soares da Rocha de Marlia UNIVEM. As mquinas utilizadas possuam
configurao homognea, onde executavam o sistema operacional Windows 7 Professional 32
bits, com processador Intel Core 2 Duo - E7500 de 2.94GHz e memria de 4Gbytes. As
mesmas estavam conectadas em uma rede padro ethernet 100Mbits, interligadas atravs da
utilizao de um switch.
A presena da plataforma Java nas mquinas possibilitou a execuo dos testes
que faz uso do mecanismo de comunicao Java RMI para a comunicao distribuda.
O desempenho foi analisado em cima de testes em diferentes tipos de cenrios em
um ambiente paralelo distribudo controlado. Foram necessrios seis cenrios para compor
todos os testes, sendo que a composio de cada um deles ser melhor detalhada nos capitulo
5.3.
Ao trmino da execuo dos testes, foi calculada a mdia dos tempos de execuo
de cada um dos cenrios, o que possibilitou efetuar uma anlise estatstica dos resultados
coletados. Algumas das medidas calculadas foram: desvio padro, speedup e eficincia.

5.1. Speedup e Eficincia


Speedup uma mtrica utilizada para verificar a razo entre o tempo da execuo
sequencial (em um nico processador) pelo tempo da execuo em paralelo (em p
procesadores), determinando o desempenho da aplicao. A equao 1 representa o clculo
para obteno do speedup.

S=

Onde:
S = speedup obtido atravs da razo de Ts e Tp.
Ts = tempo de execuo da aplicao sequencial.
Tp = tempo de execuo da aplicao em paralelo, com p processadores.

(1)

56

Eficincia tambm uma mtrica utilizada para verificar o tempo em que os


processadores esto ativos, e o quanto da potncia computacional disponvel foi utilizado na
execuo. calculada atravs da razo entre o speedup e o nmero de processadores
utilizados (SABATINE, 2007). A equao 2 representa este clculo.

E=

(2)

Onde:
E = eficincia obtida atravs da razo entre Sp e p.
Sp = speedup obtido atravs da razo de Ts e Tp.
p = nmero de processadores utilizados.
Estas duas mtricas sero aplicadas utilizando os tempos mdios obtidos atravs
dos testes realizados nos diferentes cenrios de execuo e estaro disponveis nas tabelas
com outras mtricas do respectivo cenrio.

5.2. Cenrios de Teste


Os resultados obtidos atravs dos testes foram coletados conforme o tempo de
execuo dos mesmos, e convertidos para uma nica medida de tempo, os segundos (s).
Todos os testes realizados sero descritos por meio de uma breve explicao de como foi
realizado e quais dados foram utilizados em cada um dos cenrios, alm da construo de uma
tabela, onde foi possvel apresentar algumas medidas para anlise, so elas: mdia, desvio
padro, speedup, e eficincia.
As tabelas proporcionaram a construo de grficos que facilitam representar uma
comparao entre o tempo mdio da execuo sequencial com os tempos de cada uma das
execues paralelas.
Ao serem mostrados cenrios com caractersticas semelhantes em relao ao
desempenho obtido, uma concluso parcial foi realizada buscando verificar quais fatores
influenciaram no desempenho similar entre eles.

57

5.2.1. Cenrio 01
Neste primeiro cenrio, o nmero a ser fatorado o 2.100.044.300.161, onde seus
fatores so os nmeros primos, 1.500.007 e 1.400.023. A utilizao deste nmero se deu por
causa do tempo de execuo vivel que este apresenta, pelos fatores estarem a uma distncia
relativamente pequena um do outro, e por apresentar resultados interessantes de serem
analisados. Ao ser testado de maneira sequencial e paralela, em um ambiente distribudo, com
os testes da execuo paralela sendo realizados com um, dois, trs, quatro e cinco escravos,
foram obtidos os resultados que esto sendo apresentados pela Tabela 2.
Tabela 2 Resultados obtidos com testes realizados no cenrio 01

Aps observao dos resultados obtidos, foi possvel observar que houve perda de
desempenho em relao s execuo em paralelo com a execuo sequencial. E conforme o
nmero de escravos utilizados nos testes foi aumentando, o tempo de execuo tambm
aumentou. Este fato fica bem caracterizado ao ser analisada a eficincia, que diminui
medida que novos escravos vo sendo adicionados. No Grfico 1, mostrado abaixo, fica bem
visvel a crescente no tempo mdio de execuo conforme o nmero de escravos aumenta.

58

Grfico 1 Distribuio das mdias dos tempos de execuo no cenrio 01.

5.2.2. Cenrio 02
Para este segundo cenrio, o nmero escolhido para ser fatorado foi o
1.125.033.750.133, onde seus fatores so os nmeros primos, 1.500.007 e 750.019. Este
nmero foi escolhido, pois possui um tempo de execuo vivel para ser testado nos diversos
cenrios, pelos fatores estarem em uma distancia mdia um do outro, diferentemente da
distncia pequena entre os fatores do primeiro cenrio, e por apresentar resultados
interessantes para serem analisados. Ao ser testado de maneira sequencial e paralela, em um
ambiente distribudo, com os testes da execuo paralela sendo realizados com um, dois, trs,
quatro e cinco escravos, foram obtidos os resultados que esto sendo apresentados pela Tabela
3.
Tabela 3 Resultados obtidos com testes realizados no cenrio 02

Ao analisar os resultados obtidos neste cenrio 02 foi possvel observar que

59

aconteceu uma situao semelhante a do cenrio 01, onde houve perda de desempenho em
relao s execues em paralelo com a execuo sequencial, e a medida que o nmero de
escravos aumentou, o tempo mdio de execuo aumentou, e a eficincia diminuiu. Neste
cenrio 02, o tempo mdio de todas as execues foi superior ao tempo de execuo obtido
em todas as execues do cenrio 01.
No Grfico 2 mostrado abaixo tambm possvel verificar a piora no desempenho
atravs da crescente que ocorre nas colunas do grfico ao se aumentar o nmero de escravos.
O tempo mdio das execues em comparao com o tempo mdio do cenrio 1 tambm
aumentou.

Grfico 2 Distribuio das mdias dos tempos de execuo no cenrio 02.

5.2.3. Cenrio 03
Neste terceiro cenrio, o nmero escolhido para ser fatorado foi o
150.005.200.021, pois possui fatores mais distantes um do outro em relao aos cenrios
anteriores, onde seus fatores so os nmeros primos, 1.500.007 e 100.003, alm de apresentar
um tempo vivel de execuo e resultados interessantes de serem analisados. Ao ser testado
de maneira sequencial e paralela, em um ambiente distribudo, com os testes da execuo
paralela sendo realizados com um, dois, trs, quatro e cinco escravos, foram obtidos os
resultados que esto sendo apresentados pela Tabela 4.

60

Tabela 4 Resultados obtidos com testes realizados no cenrio 03

Observando e analisando os resultados obtidos neste cenrio 03, foi possvel


identificar que aconteceu uma situao semelhante a do cenrio 01 e cenrio 02, onde houve
perda de desempenho em relao s execues em paralelo com a execuo sequencial, onde
o aumento do nmero de escravos utilizados nos testes fez com que o tempo de execuo da
aplicao paralela tambm aumentasse. Outro fator a se considerar que todas as mdias dos
tempos de execuo neste cenrio foram superiores a todas as mdias dos tempos de execuo
obtidos nos testes realizados nos cenrios 01 e 02. No cenrio 01, por exemplo, a mdia de
todos os tempos de execuo ficou em torno de 0,5 segundos, j no cenrio 02, essa mdia
ficou entre 19,5 e 20,0 segundos, e no cenrio 03, em torno dos 125,0 segundos.
Esse aumento no tempo mdio das execues facilitou a observao da diferena
entre os tempos de execuo de testes com diferentes quantidades de escravos no mesmo
cenrio. Abaixo no Grfico 3 possvel verificar a crescente no tempo de execuo a medida
que o nmero de escravos aumenta, e o tempo mdio das execues em comparao com os
tempos mdios dos cenrios anteriores.

61

Grfico 3 Distribuio das mdias dos tempos de execuo no cenrio 03.

Concluso Parcial dos Trs Primeiros Cenrios


Nestes trs cenrios de testes at aqui relatados, foi possvel observar que a
execuo em sequencial obteve um melhor desempenho do que todas as execues em
paralelo. Tanto nas execues com apenas um, ou dois escravos, como na execuo com cinco
escravos, o desempenho foi inferior ao desempenho da execuo sequencial. Isso porque, ao
serem analisadas as execues e o comportamento do algoritmo, foi possvel observar que ao
se dividir e distribuir os intervalos aos escravos, o tamanho de todos os intervalos gerados
ainda continuaram muito grandes. Esta situao ocorre por causa da quantidade de escravos
utilizados, que neste caso, os cinco escravos utilizados nos testes podem ser considerados um
nmero pequeno de escravos, pois com essa quantidade ainda no h uma diviso do
processamento ou quantidade de intervalos necessrios para que se consiga algum ganho de
desempenho.
Esta diviso em cinco intervalos faz com que o nmero que precise ser encontrado
pelo mtodo de Fermat para se chegar aos fatores, permanea ainda sempre no primeiro
intervalo, como mostrado na Figura 19, ou seja, a aplicao vai sempre executar um mesmo
nmero de vezes em todas as execues efetuadas, diferenciando apenas no nmero de
escravos utilizados em cada uma delas. O aumento do nmero de escravos neste caso o
nico fator que vai impactar no desempenho, interferindo para uma piora no tempo de
processamento, pois como o nmero a ser encontrado sempre vai estar no primeiro intervalo,
e o primeiro intervalo estar contido no primeiro escravo, de nada adiantar aumentar o

62

nmero de escravos, pois o mestre ter que efetuar uma invocao a mais a cada escravo
adicionado, aumentando a utilizao da rede para troca de mensagens.
A Figura 19 mostra um exemplo de quando a diviso dos intervalos propicia um
melhor desempenho para execuo sequencial, o exemplo mostrado no faz referncia a
nenhum dos testes realizados anteriormente, mas representa o mesmo que aconteceu em cada
um dos trs primeiros cenrios.

Figura 19 Exemplo de diviso dos intervalos onde o nmero de iteraes sempre o mesmo.

Na Figura 19 o trao em vermelho representa o nmero que o mtodo de Fermat


precisa para conseguir gerar os fatores, e observando, consegue-se verificar que cinco
escravos no o suficiente para fazer com que este nmero modifique de intervalo e
proporcione um nmero menor de iteraes.
Foi possvel observar tambm o aumento do tempo mdio de todas as execues
do cenrio 01 para todas as execues do cenrio 02, e do cenrio 02 para o cenrio 03, este
fato acontece devido distncia dos fatores primos. Conforme a distncia entre os fatores
aumenta, o tempo de execuo tambm aumenta, ento, quanto mais prximo estiverem os
fatores, mais rpida ser a execuo.
A seguir foram efetuados mais trs testes em outros trs cenrios, onde o mesmo
ambiente de execuo dos primeiros trs cenrios foi mantido, modificando apenas o nmero

63

a ser fatorado.

5.2.4. Cenrio 04
Aps se verificar e explicar a perda de desempenho obtida nos cenrios 01, 02, e
03, outros testes foram realizados onde foi possvel observar caractersticas diferentes em
relao a estes trs primeiros cenrios.
No quarto cenrio, o nmero escolhido para ser fatorado foi o 2.832.547, onde
seus fatores so os nmeros primos, 10.009 e 283. Este nmero foi escolhido, pois possui um
tempo de execuo vivel para ser testado, e por apresentar resultados interessantes e
diferentes dos resultados dos cenrios anteriores. Ao ser testado de maneira sequencial e
paralela, em um ambiente distribudo, com os testes da execuo paralela sendo realizados
com um, dois, trs, quatro e cinco escravos, foram obtidos os resultados que esto sendo
apresentados pela Tabela 5.
Tabela 5 Resultados obtidos com testes realizados no cenrio 04

As anlises efetuadas sobre os resultados obtidos neste cenrio 04, possibilitou


identificar situaes onde houve ganho de desempenho, neste caso, a execuo com trs,
quatro, e cinco escravos apresentou um menor tempo de processamento que a execuo
sequencial, e tambm com as execues com um, e dois escravos.
Aps se verificar a melhora de desempenho na execuo com trs escravos, foi
possvel verificar que nas execues seguintes, com quatro e cinco escravos, o desempenho
sempre continuou melhor que o processamento sequencial. Porm, ao analisar o tempo mdio
das execues que tiveram desempenho melhor que a execuo sequencial, possvel
observar, que na execuo com quatro escravos o tempo mdio de processamento foi maior
do que na execuo com trs escravos, e na execuo com cinco escravos o tempo mdio
voltou a ser menor que na execuo com quatro escravos e menor que em todas as execues

64

anteriores. O motivo de isto acontecer ser explicado ao trmino da descrio dos prximos
cenrios.
Abaixo os dados referentes ao tempo mdio das diferentes execues foram
distribudos pelo Grfico 4, facilitando uma melhor interpretao dos resultados deste cenrio
04.

Grfico 4 Distribuio das mdias dos tempos de execuo no cenrio 04.

5.2.5. Cenrio 05
No cenrio 05, o nmero escolhido para ser fatorado foi o 905.131.559, onde seus
fatores so os nmeros primos, 100.559 e 9.001. A escolha deste nmero se deu pelo fato dele
possuir um tempo de execuo vivel para ser testado, e por apresentar resultados
interessantes para serem analisados e explicados.
Aps ser realizada a execuo de maneira sequencial e paralela, em um ambiente
distribudo com os testes da execuo paralela sendo realizados com um, dois, trs, quatro e
cinco escravos, foram obtidos os resultados que esto sendo apresentados pela Tabela 6.

65

Tabela 6 Resultados obtidos com testes realizados no cenrio 05

Aps observao e anlise dos resultados obtidos neste cenrio 05 foi possvel
identificar que na execuo com trs escravos houve o melhor desempenho registrado, com o
speedup e a eficincia assumindo valores extremamente altos, e que aps esta melhora, o
tempo mdio foi aumentando novamente com o aumento dos escravos, porm ainda sim se
manteve inferior ao tempo mdio da execuo sequencial. A semelhana com o cenrio 04
acontece apenas no momento em que h uma melhora no desempenho, que verificada na
utilizao de trs escravos. Neste mesmo momento tambm pode ser verificada uma melhora
considervel na eficincia.
Abaixo os dados referentes ao tempo mdio de execuo foram distribudos pelo
Grfico 5, facilitando uma melhor interpretao dos resultados deste cenrio 05.

Grfico 5 Distribuio das mdias dos tempos de execuo no cenrio 05.

66

5.2.6. Cenrio 06
Neste sexto e ltimo cenrio a ser testado, o nmero escolhido para ser fatorado
foi o 16.765.699.193, onde seus fatores so os nmeros primos, 880.043 e 19.051. Este
nmero tambm foi selecionado pelo fato de possuir um tempo de execuo vivel para ser
testado, e por apresentar resultados interessantes para serem analisados. Ao ser testado de
maneira sequencial e paralela, em um ambiente distribudo, com os testes da execuo
paralela sendo realizados com um, dois, trs, quatro e cinco escravos, foram obtidos os
resultados que esto sendo apresentados pela Tabela 7.

Tabela 7 Resultados obtidos com testes realizados no cenrio 06

Os resultados observados neste cenrio 06 foram semelhantes aos resultados


verificados no cenrio anterior, que comeou a apresentar ganhos de desempenho na execuo
com trs escravos e depois o desempenho foi piorando conforme o nmero de escravos ia
aumentando, porm esta piora no chegou a tornar o desempenho da execuo sequencial
melhor que o desempenho da execuo com quatro e cinco escravos.
Os resultados deste cenrio foram distribudos pelo Grfico 6, onde ficou mais
fcil efetuar uma comparao entre as diferentes execues.

67

Grfico 6 Distribuio das mdias dos tempos de execuo no cenrio 06.

Concluso Parcial dos Trs ltimos Cenrios


Nestes trs ltimos cenrios de testes relatados foi possvel observar que em
algum dos casos a execuo em paralelo obteve um melhor desempenho em relao
execuo sequencial.
O melhor desempenho obtido em algumas das execues em paralelo foi efeito da
diminuio do intervalo proposto inicialmente, que afetou o tamanho dos intervalos que cada
escravo executou.
A diminuio do tamanho do intervalo inicial gerou os mesmos resultados que se
fossem aumentados o nmero de escravos utilizados na execuo, pois assim como aumentar
o nmero de escravos, diminuir o tamanho do intervalo inicial fez com que as divises
posteriores para a quantidade de escravos utilizados em uma determinada execuo gerassem
intervalos de tamanho menor.
Com intervalos de tamanho menor, os escravos executam um menor nmero de
iteraes, e consequentemente diminuem seu tempo de processamento. O ajuste no tamanho
do intervalo foi a maneira encontrada para que no fosse necessrio utilizar um nmero
grande de mquinas, por ser invivel em questo do tempo que seria utilizado nos testes, e
pela disponibilidade do hardware necessrio.
Ao se dividir os intervalos para os escravos executarem, o nmero que precisava
ser encontrado por algum deles para chegar aos dois fatores primos no ficou localizado
sempre no mesmo intervalo, devido diminuio no tamanho dos intervalos, que fez com que

68

este nmero mudasse de intervalo, podendo estar localizado mais prximo do inicio de um
dos intervalos, diminuindo o nmero de iteraes necessrias e o tempo de processamento.
Diferentemente dos trs primeiros cenrios analisados, estes trs ltimos cenrios obtiveram
um nmero menor de iteraes nas execues com trs ou mais escravos e por este motivo foi
possvel verificar uma melhora no desempenho em relao execuo sequencial.
A Figura 20 mostra um exemplo de quando a diviso dos intervalos propicia um
melhor desempenho para execuo paralela, o exemplo mostrado no faz referncia a nenhum
dos testes realizados, mas representa o mesmo que aconteceu nestes trs ltimos cenrios.

Figura 20 Exemplo de diviso dos intervalos onde o nmero de iteraes modifica com a adio de escravos.

Com a diviso em vrios intervalos possvel verificar que o nmero de escravos


no responsvel diretamente pelo melhor desempenho obtido nos testes, no caso do exemplo
da Figura 20 sim, pois a execuo com cinco escravos obteve o melhor desempenho dentre as
outras execues, porm, ao observar a execuo com trs e quatro escravos possvel
verificar que a execuo com trs escravos obteve melhor desempenho que a execuo com
quatro escravos. O fator que influencia diretamente no desempenho a posio do nmero
que o mtodo de Fermat precisa encontrar dentro do intervalo, visto que quanto mais perto do
inicio do intervalo estiver, menor o nmero de iteraes para se chegar at ele, e melhor o
desempenho. Apesar da quantidade de escravos no ser um fator que vai impactar diretamente

69

no desempenho, o nmero de escravos pode assegurar que quanto maior for sua quantidade,
maior ser a possibilidade de se obter o melhor desempenho dentre todas as execues
posteriores, pois a cada escravo adicionado, menor sero os intervalos.

5.3. Concluses Finais


Aps todos os cenrios serem devidamente testados, possvel chegar a uma
concluso final sobre o custo/beneficio da execuo do algoritmo para fatorao de nmeros
inteiros.
A execuo de modo sequencial apresenta um custo/beneficio melhor do que a
execuo paralela quando o nmero que o mtodo de Fermat procura para conseguir gerar os
fatores primos do nmero inteiro fica localizado sempre no primeiro intervalo, mesmo que o
nmero de escravos aumente. Isso acontece, pois a quebra do intervalo proposto inicialmente
ainda acaba por gerar intervalos grandes para serem distribudos, devido ao tamanho do
intervalo inicial ser muito grande para ser dividido pela pequena quantidade de escravos
utilizados em determinada execuo. Ao executar a aplicao, o nmero que precisa ser
encontrado sempre fica localizado no primeiro escravo, modificando apenas o nmero de
invocaes efetuadas pelo mestre, e consequentemente o aumento do uso da rede. Portanto a
execuo sequencial geralmente vai apresentar melhor desempenho quando so utilizados
poucos escravos na execuo, devido justamente a diviso do intervalo inicial gerar intervalos
de grande tamanho.
Para que a execuo paralela tenha uma melhora no custo/beneficio em relao
execuo sequencial, o ideal seria a utilizao de dezenas de mquinas, para que haja uma
diviso em mais intervalos e estes fiquem ainda menores, porm com a diminuio manual do
tamanho dos intervalos j possvel visualizar ganhos de desempenho. Essa diminuio no
tamanho dos intervalos causa os mesmos resultados que um aumento no nmero de escravos,
facilitando a realizao dos testes pela no necessidade da utilizao de muitas mquinas.
Conforme o nmero de escravos aumenta e os intervalos vo ficando menores, o
nmero que o mtodo de Fermat procura pode mudar de intervalo, e dependendo da sua
localizao no novo intervalo, o tempo de processamento ser modificado. A melhor das
solues quando este nmero se encontra no comeo do intervalo, pois um menor nmero
de iteraes vai ocorrer, e a pior das solues quando este nmero se encontra ao final do
intervalo. No momento em que novos escravos vo sendo adicionados, o tamanho dos

70

intervalos vai diminuindo proporcionalmente, e com uma grande diviso de intervalos


dificilmente haver um caso onde a execuo sequencial ter melhor desempenho que a
execuo paralela, devido a uma execuo com muitos escravos gerar intervalos pequenos
para serem distribudos entre os mesmos, maximizando as chances do nmero necessrio para
a resoluo da fatorao estar localizado no inicio do intervalo, gerando um nmero menor de
iteraes.

5.4. Trabalhos Futuros


Para trabalhos futuros, podem ser feitos testes mais refinados contendo uma
imagem igual Figura 19 e a Figura 20 para cada um dos testes realizados, mostrando onde
ficou localizado o nmero necessrio para se chegar aos dois fatores com um exemplo real.
Outra possibilidade modificar o cdigo do algoritmo paralelo distribudo para que este no
se limite apenas execuo com cinco escravos, deixando irrestrita a alterao na quantidade
de escravos necessrios para uma determinada execuo, para que aps sejam feitos testes
mais profundos com a utilizao de dezenas de mquinas por exemplo. Alm dessas
possibilidades, outras diversas mudanas ou melhorias podem ser feitas neste projeto,
buscando encontrar novas caractersticas e mostrar de maneira cada vez mais clara os
fundamentos das concluses tiradas.

71

Referncias Bibliogrficas
ANTUNES, C. M. Mtodos de Fatorao de Nmeros Inteiros. Porto Alegre, 2002.
BACELLAR H. V. Cluster: Computao de Alto Desempenho. Instituto de Computao,
2010.
BARNAB, V. C. Uma introduo aos mtodos de fatorao de inteiros de Fermat e
Pollard. Dourados, Universidade Estadual do Mato Grosso do Sul, 2009.
BERNARDI, E. F. F. Utilizao de programao paralela e distribuda para quebra de
chaves de criptografia RSA. Porto Alegre: PUCRS, 2006.
COULOURIS G; DOLLIMORE J; KINDBERG T. Sistemas Distribudos.4 ed., So
Paulo: Artmed, 2007.
DANTAS, M. A. R. Computao Distribuda de Alto Desempenho: Redes, Clusters e
Grids Computacionais. Editora Axcel, 2005.
DA SILVA, D; FRANCO, C. E. C; AVELINO, F. D,Implementao de Sockets e Threads
no desenvolvimento de sistemas cliente /Servidor: Um estudo em VB.NET. Resende,
Associao Educacional Dom Bosco, 2006
DE ROSE, C. A. F. Arquiteturas Paralelas. Pontifcia Universidade Catlica do Rio
Grande do Sul, 2001.
DETOMINI, R. C. Explorao de Paralelismo em Criptografia utilizando GPUs. S. J.
R. Preto, Universidade Julio de Mesquita Filho, 2010.
JNIOR, E.P. F. Construindo Supercomputadores com Linux: Cluster Beowulf. Centro Federal de Educao Tecnolgica de Gois, Goinia, 2005.
NODA, A. K. Mecanismo de Invocao Remota de Mtodos em Mquinas Virtuais.
Pontifcia Universidade Catlica do Paran, 2005.
PEREIRA, F. M. Q. Arcademis: Um Arcabouo para Construo de Sistemas de Objetos Distribudos em Java, Belo Horizonte: UFMG Dezembro, 2003.
PITANGA, M. Construindo Supercomputadores com Linux. 3 ed, Rio de Janeiro, Brasport, 2008.
QUINN, M. J. Designing Efficient Algorithms for Parallel Computers. McGraw-Hill,
Inc., Nova Iorque, NY, EUA, 1987.
SABATINE, R. J. Implementao de Algoritmo Paralelo para Apoiar o Processamento
de Imagens utilizando JPVM. Marlia: Univem, 2007, pp. 23-43.

72

SAITO, P. T. M. Otimizao do Processamento de Imagens Mdicas Utilizando a Computao Paralela. Marlia: Univem, 2007, pp. 22-62.
SARAMAGO, J. A. F. G. Um Middleware para Computao Paralela em Clusters de
Multicores. Faculdade de Cincias e Tecnologia, Universidade Nova de Lisboa, 2012.
TANENBAUM, A. S; STEEN M. V. Sistemas Distribudos. 2 ed., Rio de Janeiro: Prentice-Hall, 2007.
TOLOUEI, D. V. L. Clusters Computacionais de Alto Desempenho. Vila Velha, 2010.