Processamento Distribuído PDF

Sistemas Distribudos usando PVM e RMI
Vincius Passos Montes
Uberlndia, Dezembro/2002.
Sistemas Distribudos usando PVM e RMI
Monografia apresentada ao Curso de Cincia da Computao do

Centro Universitrio do Tringulo - Unit, como requisito bsico
obteno do grau de Bacharel em Cincia da Computao, sob a
orientao do Prof. Marcos Alberto Lopes da Silva, Msc.
Sistemas Distribudos
Monografia apresentada ao Curso de Cincia da Computao do Centro Universitrio do Tringulo Unit, como requisito bsico obteno do grau de Bacharel em Cincia da Computao.
______________________________
Marcos Alberto Lopes da Silva, Msc.
(Orientador )
______________________________
Marcos Ferreira de Rezende, Dr.
(Avaliador )
______________________________
Edson Angoti Jnior, Msc.
(Avaliador )
______________________________
Marcos Ferreira de Rezende, Dr.
(Coordenador de Curso)
Agradecimentos
Todas as pessoas que me apoiaram em meus estudos, um agradecimento de uma forma toda especial aos
meus pais.
RESUMO
Este trabalho explica as principais vantagens e desvantagens da utilizao de sistemas distribudos, dando
enfoque as suas principais caractersticas, como sua arquitetura e como feita a comunicao. O estudo
explica duas ferramentas que so utilizadas na implementao dos sistemas distribudos, o PVM e o RMI,
mostrando as suas principais funes e caractersticas. O presente trabalho trar tambm todo um
processo de estudo de caso utilizando estas ferramentas, estudos estes que se dividem em trs problemas
com suas respectivas solues utilizando PVM e RMI, ou seja, cada problema ter uma soluo em PVM
e outra em RMI, ilustrando assim os conceitos das ferramentas e da implementao de sistemas
distribudos. O trabalho apresenta como principal objetivo demonstrar o processo de implementao de
sistemas distribudos, exemplificar e auxiliar no processo de utilizao das ferramentas, dando uma idia
ao programador qual ferramenta e onde utiliz-la. Cada metodologia tem sua vantagem sob determinados
aspectos: se o sistema a ser implementado utiliza conceitos de objetos ou se o sistema necessita ser em
tempo real. O trabalho ilustrar tambm os seus estudos de caso, dando ao leitor um conhecimento nas
duas formas de se programar utilizando estas ferramentas. Os estudos de caso que sero apresentados
neste trabalho so na maioria utilizando matrizes e vetores, e funes simples, as quais tem sua didtica
comprovada. Aps finalizar a leitura deste trabalho ser esperado que o leitor saiba utilizar e compreender
o processo de desenvolvimento de um sistema distribudo e a respectiva utilizao das ferramentas aqui
apresentadas.
SUMRIO
1.
Introduo..................................................................................................................................................... 1
2. Processamento Distribudo....................................................................................................................... 2
2.1. Introduo a Sistemas Distribudos.................................................................................................. 2
2.2. Vantagens dos Sistemas Distribudos.............................................................................................. 4
2.3. Desvantagens dos Sistemas Distribudos........................................................................................ 6
2.4. Caractersticas dos Sistemas Distribudos..................................................................................... 7
2.5. Arquitetura dos Sistemas Distribudos........................................................................................... 9
2.6. Comunicao nos dos Sistemas Distribudos............................................................................... 11
2.7. Concluso............................................................................................................................................
13
3. Tcnicas de Processamento Distribudo............................................................................................... 14
3.1. PVM......................................................................................................................................................
14
3.1.1. Uma Viso do PVM....................................................................................................................
14
3.1.2. Caractersticas do PVM........................................................................................................... 18
3.1.2.1. Identificao.......................................................................................................................
18
3.1.2.2. Controle de Processos...................................................................................................... 19
3.1.2.3. Tolerncia a Falhas...........................................................................................................
19
3.1.2.4. Gesto Dinmica de Grupos............................................................................................ 19
3.1.2.5. Envio de Sinais...................................................................................................................
20
3.1.2.6. As Rotinas de Comunicao............................................................................................ 20

3.1.2.7. Sequncia............................................................................................................................
21
3.1.3. Interface......................................................................................................................................
21
3.1.3.1. Controle de Processos...................................................................................................... 21
3.1.3.2. Passagem de Mensagens................................................................................................. 22
3.1.3.3. Memria em Blocos..........................................................................................................
23
3.1.3.4. Empacotamento..................................................................................................................
23
3.1.3.5. Desempacotamento............................................................................................................
24
3.1.3.6. Envio de Mensagens..........................................................................................................
24
3.1.3.7. Recepo de Mensagens...................................................................................................
25
3.1.3.8. Indicao de Mquinas Remotas..................................................................................... 25
3.2. RMI.......................................................................................................................................................
25
3.2.1. Funcionamento...........................................................................................................................
27
3.2.2. Serializao................................................................................................................................
28
3.2.3. "Stubs"e "Skeletons".............................................................................................................. 29
3.2.4. Ativao.......................................................................................................................................
30
3.2.5. Interface......................................................................................................................................
30
3.3. Concluso............................................................................................................................................
33
4. Aplicaes Utilizando PVM e RMI......................................................................................................
...34
4.1.Primeiro caso......................................................................................................................................
34
4.1.1.Implementao utilizando PVM............................................................................................... 34
4.1.2.Implementao em RMI.............................................................................................................
38
4.2.Segundo caso.......................................................................................................................................
42
4.2.2.Implementao utilizando RMI.................................................................................................
48
4.3.Terceiro caso.......................................................................................................................................
56
4.3.2.Implementao utilizando RMI.................................................................................................
60
4.4.Concluso.............................................................................................................................................
64
5.Concluso....................................................................................................................................................
66
Referncias Bibliogrficas.......................................................................................................................... 68
1 Introduo
A programao de sistemas distribudos est se tornando uma realidade devido as grandes

inovaes nas reas de redes de computadores e nas ferramentas de implementao desses sistemas.
O grande e rpido crescimento do processamento distribudo molda-se realidade de hoje, onde
temos informaes dispersas geograficamente. Dessa forma existe, na atualidade, uma grande
necessidade de sistemas que processem informaes distribudas geograficamente. Assim, neste trabalho
ser elaborado um estudo sobre os sistemas distribudos, dando enfoque a duas ferramentas utilizadas na
sua implementao e sero apresentados estudos de caso que ilustraro a teoria desenvolvida.
O capitulo 2 apresenta os principais conceitos dos sistemas distribudos mostrando as suas
vantagens e desvantagens.
No captulo 3 sero apresentadas as tcnicas de implementao utilizando as seguintes
ferramentas, PVM e RMI, as quais utilizam respectivamente as seguintes linguagens base, C\C++ e Java.
O captulo 4 mostra a utilizao exemplificada da implementao dos sistemas utilizando as
ferramentas abordadas no capitulo 3.
E finalmente o capitulo 5 que ser a concluso do estudo e das implementaes deste trabalho.
2 Processamento Distribudo
Da evoluo do processamento distribudo, as suas vantagens, desvantagens e caractersticas,

sero abordadas neste captulo.
2.1 Introduo a Sistemas Distribudos
A computao tem sido caracterizada pelas grandes mudanas ocorridas na rea de conectividade
dos recursos computacionais. De 1945 1985 os computadores eram mquinas grandes e carssimas e a
maioria deles eram independentes por falta de uma forma confivel de interlig-los. Surgiram, desde
ento, redes que permitiam a conexo de muitos computadores e a transmisso de dados a uma alta
velocidade. [TANENBAUM,1992]. Outro avano, nesta rea, foi dos microprocessadores, que tinham o
mesmo poder de processamento de um mainframe, ou seja o custo das mquinas diminuiu, e ficou mais
confivel a interconexo das mquinas. Essa maior facilidade de interconexo incentivou a idia dos
sistemas distribudos.
Os sistemas distribudos necessitam de softwares diferentes daqueles usados em sistemas
centralizados.
Hoje j encontram-se softwares confiveis para sistemas distribudos com
maior facilidade, mas isto depois de aproximadamente 15 anos da idia dos sistemas distribudos.
Alguns autores diferenciam drasticamente sistemas distribudos de sistemas paralelos, mas os
sistemas paralelos so na realidade sistemas distribudos, pois eles se enquadram perfeitamente na
definio prtica e terica de sistemas distribudos.
A definio mais simples de sistema distribudos : Um Sistema Distribudo o resultado da
integrao de sistemas computacionais autnomos combinados de forma a atingir um objetivo comum, ou

seja sistemas centralizados interligados por uma rede, compartilhando recursos fsicos, com o objetivo
de realizar alguma tarefa. Os sistemas paralelos tambm obedecem esta definio, mas alm de ter
sistemas em mquinas dispersas, os processos sendo processados paralelamente, no mesmo instante de
tempo. [TANENBAUM,1992]. A figura 2.1 ilustra um sistema distribudo.
Figura 2.1 sistema distribudo
O fato de ser possvel implementar um sistema distribudo no significa que seja uma boa
alternativa para resoluo de algum problema, pois hoje temos mquinas com alto poder de
processamento (ex. pode-se ter quatro discos rgidos de oitenta gigabytes em uma nica mquina) e baixo
custo, para decidir entre um sistema distribudo e um sistema centralizado, deve-se levar em conta o
custo/benefcio de cada um.
2.2 Vantagens dos Sistemas Distribudos
Deve-se diferenciar sistemas centralizados, onde normalmente se utiliza mainframes, dos PCs
independentes. Pois as vantagens dos sistemas distribudos sobre os sistemas centralizados so diferentes
das dos PCs independentes.
Sem sombra de dvida a grande vantagem dos sistemas distribudos sobre os sistemas
centralizados o baixo custo, isto devido ao fato que nas ltimas dcadas os microprocessadores tiveram
uma forte queda em seus preos, tornando assim mais acessvel a sua utilizao em massa em sistemas
distribudos, ou seja, mais barato comprar muitos processadores que comprar um mainframe, os
processadores tm menor custo. Alm de se ter um gasto menor com o sistema distribudo pode-se ainda
ter uma performance que jamais poder ser alcanada por um mainframe, ou seja, um sistema distribudo
com 20.000 microprocessadores, cada um dos quais rodando a 20 MIPS (Milhes de Instrues Por
Segundo), teria uma performance de 400.000 MIPS. No temos mainframes com essa capacidade de
processamento na atual tecnologia. Os sistemas distribudos tm melhor custo/beneficio em relao aos
sistemas centralizados, isto significa que o sistema distribudo mais barato e oferece maior eficincia no
processamento dos dados.[TANENBAUM,1992].
Existe ainda o fato que existem aplicaes que so necessariamente distribudas, por exemplo um
sistema de controle de trfego areo, este sistema exige alta confiabilidade e possui uma caracterstica
intrnseca, pois ele nunca pode parar, mesmo que percam 10% do seu funcionamento ele no pode parar.
O sistema correria grandes riscos de queda em sua totalidade, se utilizasse um sistema centralizado, o
sistema ficaria a merc do funcionamento do mainframe, isto significaria que se o mainframe parasse o
sistema tambm iria parar, tendo tambm a saturao da rede devido ao alto trfego de dados com
origem/destino ao mainframe. Com um sistema distribudo, o controle de trfego areo teria um risco bem
mais baixo de queda em sua totalidade e trfego se dispersaria, sendo assim este sistema necessita ser
distribudo. Outro problema um sistema bancrio, ele sistema possui mquinas distribudas em vrias
agncias, agncias estas dispersas fisicamente, a soluo mais vivel para este problema a utilizao de
sistema distribudo.
Quando se utilizada um sistema centralizado e se quer expandir o poder computacional deste
sistema a soluo comprar um mainframe melhor, caso j possua um mainframe top de linha
necessria a aquisio de um segundo mainframe, essa diviso vai prejudicar bastante o operacional da
empresa, alm do custo ser altssimo. Em um sistema distribudo este crescimento simples e tem um
custo mais barato do que nos sistemas centralizados, isto devido ao fato que para aumentar o poder
computacional de um sistema distribudo so adicionar novos microprocessadores. A tabela 2.1 ilustra,
de uma forma resumida, as vantagens dos sistemas distribudos sobre os sistemas centralizados.
Tabela 2.1 Vantagens dos sistemas distribudos sobre os centralizados[TANENBAUM,1992]
Economia
Os microprocessadores oferecem uma melhor

relao preo performance do que a oferecida
pelos mainframes.
Velocidade
Um sistema distribudo pode ter um poder de

processamento maior que o de qualquer
mainframe.
Distribuio
Algumas aplicaes envolvem mquinas separadas

fisicamente.
Confiabilidade
Se uma mquina sair do ar, o sistema como um

todo pode sobreviver.
Crescimento Incremental
O poder computacional pode crescer em doses

pequenas.
Com a idia de reduo de despesas pode-se pensar assim: Se os microprocessadores so

baratos, por que no dar um PC a cada pessoa?. A idia tem fundamento, mas tendo PCs isolados no
teramos o compartilhamento de dados. Em um sistema bancrio, um cliente tira o seu saldo em uma
cidade, e algumas horas depois ele tira o seu saldo novamente, s que agora em outra cidade, caso os
PCs fossem independente, cada cidade teria a sua base de dados, podendo assim ele possuir saldos
diferentes nas cidades distintas, ou seja , um caos no sistema financeiro deste banco. Para evitar este
problema necessita-se do compartilhamento de dados.
A carga de trabalho pode diferenciar em cada PC, sobrecarregando uns e tendo pouco
processamento em outros. Nos sistemas distribudos a carga de processamento uniformemente
distribuda para cada unidade. A tabela 2.2 mostra as vantagens dos sistemas distribudos em relao aos
PCs independentes.
Tabela 2.2 Vantagens dos sistemas distribudos sobre os PCs independentes[TANENBAUM,1992]
Compartilhament
Permite que mais de um usurio acesse uma base

de dados comum.
o de dados
Compartilhamento de dispositivos
Permite que mais de um usurio possa ter acesso a
perifricos muitos caros.

Comunicao
Torna muito mais simples a comunicao pessoa a

pessoa. Ex., empregando o correio eletrnico.
Flexibilidade
Espalha a carga de trabalho por todas as mquinas

disponveis ao longo da rede.
2.3 Desvantagens dos Sistemas Distribudos
Na atual fase dos softwares para sistemas distribudos os programadores e analistas no tm

experincia em projetos, implementao e implantao destes sistemas. Temos problemas na definio do
sistema operacional e na linguagem de programao. [TANENBAUM,1992].
Outro problema a rede, pois a tendncia de um sistema distribudo sempre crescer, sendo
assim pode chegar um momento que a rede sature. Mesmo tendo redes de altssimas velocidades, isto
seria comparvel ao gargalo de Newman ( a velocidade do processamento da mquina depende do
barramento), ou seja, o sistema distribudo depende da performance da rede. [TANENBAUM,1992].
A idia de compartilhamento de dados nos traz alguns problemas, isto porque, quando se tem
dado acessvel a todos perde-se em segurana. Os dados secretos no podem ser acessveis a certas
pessoas, mas estes dados esto acessveis ao sistema, sendo assim e possvel que uma pessoa sem
autorizao leia estes dados.
2.4 Caractersticas dos Sistemas Distribudos
Abaixo sero descritas as caractersticas bsicas dos sistemas distribudos.[DEITEL,1990].
Confiabilidade: O grande objetivo da construo de sistemas distribudos era faz-los mais

confivel que os sistemas centralizados. Em sistemas altamente confiveis a disponibilidade (o tempo em
que o sistema pode ser utilizado plenamente), tem que ser altssima. Para se ter uma disponibilidade alta
necessrio aumentar no nmero de cpias de certas peas-chaves e algumas funes importantes, ou seja,
aumentar a redundncia. No momento que se tem um maior nmero de certos dados pode se ter uma
inconsistncia alta, isto devido ao fato que difcil controlar todas as cpias, pode-se ter redundncia de
dados. Quando se tm muitas copias, mesmo que se consiga manter a integridade entre elas, tem-se outro
problema que a queda de desempenho devido ao fato de ter muitas coisas repetidas. Outro aspecto
relacionado confiabilidade a tolerncia a falhas, ou seja, o sistema no deve parar, ele apenas mascara
as falhas ocorridas.
Escalabilidade: solues para sistemas distribudos pequenos no funcionam para os sistemas
distribudos grandes. Normalmente em sistemas distribudos pequenos armazena-se uma tabela de e-mails
em apenas um servidor, enquanto em sistema de grande porte isso no deve ocorrer, porque o sistema fica
a merc do funcionamento deste servidor, todas as aplicaes que necessitam utilizar essa tabela s
funcionam se o servidor estiver funcionando. Existem alguns gargalos pr-definidos que podem ser
evitados: Componentes centralizados, exemplo: Um nico servidor de e-mails para todos os usurios;
Tabelas centralizadas, exemplo: Um nico catalogo de preos on-line; Algoritmos centralizados,
exemplo: Fazer roteamento com base em informaes completas. Todos os gargalos so centralizados, ou
seja, os sistemas distribudos de grande porte tendem a uma descentralizao muito grande. Para sistemas
robustos a centralizao afeta o funcionamento da rede em uma magnitude bem maior que os sistemas
distribudos de pequeno porte.
Performance: Nada vai adiantar se o sistema distribudo for transparente, confivel e tiver
escalabilidade se ele for lento. No geral quando se roda uma aplicao em um sistema distribudo esta
nunca pode ser mais lenta do que se for rodada em um sistema centralizado. As mtricas mais utilizadas
para a performance so o tempo de resposta e o nmero de jobs por hora (throughput). Temos ainda o
problema da rede, quanto mais trafego se tem na rede maior o tempo de resposta, ento a performance
fica limitada a rede. Quanto se tenta ter uma alta confiabilidade o sistema distribudo acaba perdendo em
performance, isto ocorre visto que para garantir a confiabilidade vrios dados so replicados, e perde
tempo com o aumento do trfego na rede.
Transparncia: uma das principais caracterstica dos sistemas distribudos. Os projetistas do
sistema fazem com que todos pensem que atrs de um sistema distribudo se tem um grande sistema
centralizado, na realidade engana-se os usurios, dando a eles a impresso de que todo sistema apenas
um grande microprocessador. Existem duas formas de se obter esta transparncia: no nvel do usurio e
no nvel dos programas, no nvel dos programas mais difcil de se conseguir est transparncia. Tem-se
varias transparncias, na tabela 2.4 sero listados alguns tipos de transparncia em um sistema distribudo,
explicando tambm o seu significado.
Tabela 2.4 Tipos de Transparncia
TIPO
Acesso
SIGNIFICADO
Entidades remotas e locais podem ser acessadas usando
operaes idnticas.
Localizao
Acesso sem o conhecimento da localizao.
Concorrncia
Usurios podem compartilhar os recursos.
Replicao
Mltiplas instancias de uma entidade pode ser usada para

aumentar a confiabilidade e desempenho.
Migrao
Permite o deslocamento das entidades sem afetar a
operao dos usurios ou programadores.

Desempenho
Permite ao sistema ser reconfigurado.
Escala
Permite ao sistema e as aplicaes serem expandidos sem

alterar a estrutura do sistema ou os algoritmos da
aplicao.
Paralelismo
Podem ocorre atividades paralelas sem que os usurios

venham a saber.
2.5 Arquitetura dos Sistemas Distribudos

A arquitetura dos sistemas distribudos se diferencia bastante da arquitetura dos sistemas
centralizados, mesmo ambos tendo uma idia de uma implementao em 4 camadas existe diferenciao
nestas camadas.
A arquitetura dos sistemas centralizados consiste em uma primeira camada de hardware, uma
segunda camada do sistema operacional, a terceira camada seria o suporte da linguagem de programao
e a quarta seria as aplicaes. [TANENBAUM,1992]. Esta idia ilustrada na figura 2.2.
Figura 2.2 Arquitetura de um sistema centralizado
Em um sistema centralizado o sistema operacional a principal camada de software. Ele

gerencia todos os recursos bsicos no sistema e fornece servios essenciais.
A arquitetura de um sistema distribudo seria dividida da seguinte forma: a primeira camada seria
o computador e o hardware da rede, a segunda camada seria os servios do kernel do sistema operacional
(S.O.), a terceira seria dividida em duas, a primeira seria o suporte para programao distribuda e a
segunda seria os servios abertos, e a quarta e ltima camada seria a aplicao. A figura 2.3 mostra a
arquitetura em camadas de um sistema distribudo. [TANENBAUM,1992].
Figura 2.3 Arquitetura de um sistema distribudo
Nos sistemas distribudos o papel do kernel do sistema operacional restrito ao gerenciamento

de recursos bsicos.
2.6 Comunicao nos Sistemas Distribudos
A grande diferena entre sistemas distribudos e centralizados est na comunicao entre

processos.
Em sistemas centralizados os processos que necessitam de se comunicar utilizam uma rea de
memria compartilhada, ou seja, os processos que esto se comunicando podem ler e escrever nesta rea
de memria. Existem ferramentas que evitam que os dados que esto nesta rea de memria percam a
inconsistncia, como a utilizao de uma varivel de semforo. Esta varivel de semfora e compartilhada
a todos os processos envolvidos na comunicao.
Em sistemas distribudos no existem nenhuma forma de compartilhamento, de tal maneira que

toda a comunicao entre processos deve ser refeita. Devido a total ausncia de memria compartilhada
nos sistemas distribudos, a comunicao em sistemas distribudos baseada em troca de mensagens. Por
exemplo: Quando o processo 1 quer comunicar com o processo 2, ele primeiro constri uma mensagem
em seu espao de endereamento. Logo em seguida ele executa uma chamada de sistema, que faz com
que o sistema operacional busque a mensagem e a envia ao processo 2. Resumidamente assim que
funciona a comunicao entre processos nos sistemas distribudos.
Para que essas mensagens sejam entendidas elas devem obedecer a certas regras, pois caso no
obedeam, pode ocorrer o fato do receptor da mensagem no entender o seu contedo. Por esse motivo
foram estabelecidas normas as quais as mensagens devem obedecer, ou seja, um padro. Este padro foi
criado pela ISO ( International Standars Organization ), e ficou conhecido como o modelo de referencia
para interconexo de sistemas abertos, ou simplesmente modelo OSI. A formalizao das regras de
comunicao chamado de protocolo. Os nveis do modelo OSI so mostrados na figura 2.4.
Figura 2.4 Nveis, interfaces e protocolos no modelo OSI da ISO
Definies das camadas do modelo OSI da ISO [DIAS,2000]:
A camada fsica define as conexes mecnicas e eltricas formadas pelos modens, linhas fsicas,
conectores, cabos e interfaces de hardware de comunicao dos equipamentos.
A camada de enlace e responsvel pela quebra de seqncia dos bits e pelo enquadramento
(Framming). Esta camada tambm faz o tratamento de erros de bits.
A camada de rede e responsvel pelo roteamento, ou seja, ela tem que garantir que os dados
consigam chegar at o destino, independente da sub-rede utilizada.
A camada de transporte tem como funo transportar os dados de forma confivel de uma mquina
origem a uma mquina destino, sem se preocupar com o tipo de meio fsico ou com a implementao
da camada de rede.
A camada de sesso uma verso aprimorada da camada de transporte, ela fornece facilidades para
a sincronizao. Em prtica esta camada quase nunca implementada.
A camada de apresentao e responsvel pelo significado dos bits transmitidos. Tem como objetivo
facilitar a comunicao entre mquinas com diferentes representaes internas.
A camada de aplicao na verdade os processos (programas), como o servidor de DNS, SMTP,

TELNET , FTP, etc.
Uma das formas mais comuns de se implementar a comunicao em sistemas distribudos

chamada remota a procedimentos, por fazer com que esta operao seja muito parecida com a chamada
convencional de subprogramas.
A chamada de procedimentos remotos tem como principais objetivos:
Permitir que uma mquina A chame procedimentos localizados em outras mquinas ( mquina B
ou mquina C) mecanismo unificado de alto nvel.
Nenhuma operao de troca de mensagem ou de entrada/sada deve ser visvel ao programador

(transparncia)
Fazer com que uma chamada remota se parea tanto quanto possvel com uma chamada local
(esconder a tecnologia da rede subjacente)
Mascarar as diferenas de representao de dados
2.7 Concluso
As vantagens dos sistemas distribudos, em relao aos sistemas centralizados, superam as
desvantagens, mesmo tendo o problema dos softwares para sistemas distribudos, problema este que j
est sendo solucionado. Com esses problemas no se deve parar de pensar na idia de sistemas
distribudos, pois a sua utilizao em algumas situaes bem vantajosa, por exemplo: um sistema
bancrio, sistema este distribudo geograficamente devido s limitaes fsicas de cada agncia. A
funcionalidade dos sistemas distribudos est totalmente ligada qualidade da rede, ou seja, uma rede de
alta performance e qualidade proporcionar um alto desempenho de um sistema distribudo. No captulo
seguinte sero abordadas algumas ferramentas utilizadas para implementao de softwares distribudos.
3 Tcnicas de Processamento Distribudo
Existem diferentes ferramentas para a implementao de sistemas distribudos, neste captulo

sero abordadas duas, o PVM e o RMI. O PVM uma ferramenta que utiliza as linguagens C, C++ e
Fortran, o RMI utiliza a linguagem Java.
3.1 PVM
O PVM ( Parallel Virtual Machine ) foi desenvolvido em 1989 no Oak Ridge National
Laboratory (ORNL), com a idia de interligar recursos computacionais numa rede, fornecendo ao
utilizador uma plataforma distribuda e paralela para rodar aplicaes, independentes da localizao, da
quantidade ou das diferenas entre os computadores na rede.
O processamento distribudo e paralelo um mtodo emergente nas novas tecnologias de

programao que permite resolver problemas complexos dividindo-o em pequenas tarefas. Problemas
estes na maioria de cunho cientfico.
3.1.1 Uma Viso do PVM
O PVM utiliza o modelo de passagem de mensagens como plataforma para utilizao da

computao distribuda numa vasta gama de computadores, que no ponto de vista do utilizador uma
enorme mquina virtual.
O PVM cria um enquadramento computacional uniforme que favorece o desenvolvimento rpido

e direto de aplicaes distribudas e paralelas, em equipamentos j existentes. O modelo computacional
simples e geral adaptando a uma grande variedade de estruturas de programao.
O PVM gerencia de forma transparente todo o encaminhamento de mensagens, a converso de
dados e o escalonamento de tarefas que se realiza numa rede heterognea de computadores.
O que o PVM oferece:[PVM,2001].
Programao simples uma aplicao uma coleo de tarefas cooperativas;
Tarefas com capacidades arbitrrias tanto ao nvel do controle como nas estruturas de
dependncia;
Desenvolvimento de aplicaes construtores apropriados do PVM escritos na linguagem de

controle do computador local;
Interface normalizada para pedir recursos mquina virtual;
Bibliotecas de rotinas - para iniciar e terminar tarefas atravs da rede;
Passagem de mensagens orientada para operaes em mquinas heterogneas;
Tipos fortes de dados tanto na emisso como na recepo;
Primitivas bsicas de comunicao vrios modelos de envio e recepo de mensagens;
Primitivas elaboradas de comunicao para difuso, sincronizao de grupos e soma global.
O PVM um conjunto interligado de bibliotecas e programas que fazem a emulao de um

sistema flexvel, de uso geral numa rede distribuda e heterognea de computadores. O PVM foi
construdo a partir dos seguintes princpios bsicos: [PVM-BOOK,1994].
Configurao personalizada: as tarefas, que constituem cada aplicao particular, executam
num conjunto de mquinas selecionadas pelo utilizador. Podem ser selecionadas quaisquer tipos de
mquinas. O conjunto inicial de computadores pode ser aumentado ou reduzido dinamicamente,
adequando a tolerncia falhas.
Acesso transparente ao hardware: as aplicaes olham para os equipamentos como uma
coleo virtual de processadores ou, em alternativa, podem explorar o hardware especfico colocando
determinadas tarefas em computadores determinados.
Computao baseada em processos: a unidade de paralelismo em PVM a tarefa,
(normalmente um processo), que um fluxo independente e seqencial de controle que alterna entre
computao e comunicao. O modelo no fora qualquer tipo de relao processo-processador, em
particular, pode dizer-se que mltiplas tarefas podem ser executadas num nico processador.
Modelo explcito de passagem de mensagens: as tarefas cooperam, enviando ou recebendo
voluntariamente mensagens. O tamanho de uma mensagem apenas limitado pela disponibilidade de
memria existente.
Heterogeneidade: de mquinas, redes e aplicaes. No que respeita ao modelo de comunicao,
a transferncia de informao inclui vrios tipos de dados, que podem ser circular entre computadores
com diferentes representaes de dados.
Multi-processadores: uso de mecanismos de passagem de mensagens nativas suportados pelo
hardware especifico.
O sistema composto por duas partes, o servidor PVMD e uma biblioteca de rotinas para a
interface com as aplicaes. O servidor, que tem de existir em cada um dos computadores que constituem
a mquina virtual, foi concebido de forma a poder ser instalado localmente em cada computador.
Para executar uma aplicao o usurio comea por iniciar o PVM e se segue a execuo da
aplicao, em qualquer um dos nodos que constitui a mquina virtual. Mltiplos usurios podem criar a
sua prpria mquina virtual, com os recursos associados, e cada usurio poder correr mltiplas
aplicaes simultaneamente.
A biblioteca contm um repertrio completo de rotinas primitivas necessrias para o

estabelecimento da cooperao entre tarefas. A biblioteca inclui rotinas acessveis ao usurio, para criao
de tarefas, a passagem de mensagens, a sincronizao entre tarefas e a alterao como um conjunto de
tarefas em que cada uma responsvel por uma das partes do problema. A esta diviso correspondem
duas possveis vises:
Paralelismo nas funes: a aplicao dividida em tarefas de acordo com a funcionalidade

esperada, isto cada tarefa responsvel por uma funo distinta. Exemplo: entrada de dados.
Paralelismo nos dados: neste mtodo mais habitual, todas as tarefas so iguais, mas cada uma
delas conhece apenas uma pequena parte do problema para o qual requerida a sua participao
na resoluo.
Atualmente, as linguagens hospedeiras que podem evocar o PVM so o C, C++ e o Fortran, que
foram escolhidas por se considerar que, a maioria das aplicaes cientificas desenvolvidas so escritas
nessas linguagens.
Os programa escritos em C e C++ podem ter acesso s bibliotecas do PVM se forem
convenientemente ligados bibliotecas publicas libpvm3.a. No caso do Fortran o acesso s bibliotecas
realizado por rotinas em vez de funes que usam bibliotecas de converso libfpvm3.a que por sua vez
evocam as rotinas C da biblioteca anterior. Em parte esta diferena e os nomes escolhidos para prefixo,
das funes ou rotinas correspondentes, existe uma correspondncia biunvoca entre funes em C e
rotinas em Fortran.
Em PVM todas as tarefas so identificadas por um nmero inteiro TID, nico em toda a mquina
virtual, que criado automaticamente pelo PVMD local sempre que uma nova tarefa gerada. O inteiro
codifica uma identificao no relevante para a aplicao.
Ao paradigma geral para o desenvolvimento de uma aplicao em PVM correspondem os
seguintes passos:
1. escrita de programas: em C, C++ ou Fortran que contem chamadas s bibliotecas do PVM,

correspondendo cada programa a uma tarefa da aplicao.
2. compilao: dos programas para cada arquitetura e respectiva instalao em localizao acessvel.
3. execuo: das aplicaes iniciando (manualmente) uma copia da tarefa inicial, mestre (pai), em
qualquer um dos computadores que constituem a mquina virtual.

4. gerao de novas tarefas: iniciadas pelas tarefas mestre que eventualmente realizam clculos e
transferem mensagens entre si.
O processo descrito representa apenas um cenrio tpico compatvel com a criao de novas
tarefas, iniciadas manualmente. As tarefas comunicam enviando e recebendo, explicitamente,
mensagens que identificam o destinatrio e o remetente com base nos respectivos nmeros de
identificao TIDs.
3.1.2 Caractersticas do PVM
O PVM no apenas uma biblioteca de funes de comunicao para troca de mensagens. Uma
parte importante do suporte lgico dedicado gesto de processos, das tarefas e de sinais na mquina
virtual. Uma parte dessa gesto assegurada pelo servidor PVMD.
As funes de administrao do ao usurio a capacidade de gerir totalmente a programao da
mquina permitindo a deteco de falhas dos computadores na rede, a criao dinmica de grupos e a
recuperao de falhas.
3.1.2.1 Identificao
Em PVM todas as tarefas so identificadas por um inteiro TID escolhido pelo PVMD local que a
representa de uma maneira nica na mquina virtual. Uma tarefa pode ser tambm identificada por um
nome de grupo e um nmero representando a sua posio no grupo.
Para obter a sua identificao a tarefa pode usar as funes pvm_mytid( ) e pvm_gettid( ) que
retornam respectivamente a identificao local ou no grupo.
3.1.2.2 Controle de Processos
O PVM possui funes que tornam possvel, a todo o momento, um processo registrar-se ou
desassociar-se da mquina virtual. A administrao da prpria mquina virtual faz-se atravs de outras
funes que alteram a constituio da mquina virtual, juntando ou retirando computadores acessveis na
rede.
O Console PVM uma interface com usurio para a gesto e monitorao das aplicaes na
mquina virtual. As tarefas de administrao podem ser realizadas por qualquer tarefa na aplicao
recorrendo s mesmas funes que o console.
3.1.2.3 Tolerncia a Falhas
A falha de qualquer computador (excluindo o mestre) ou a perda de acessibilidade detectada

automaticamente pelo PVM que retira do conjunto de mquinas que constituem a mquina virtual.
Qualquer usurio pode conhecer o estado da mquina virtual, mas a tolerncia s falhas cabe ao
programador que devera prever essas situaes de modo a desencadear os mecanismos que tornem
possvel a recuperao.
3.1.2.4 Gesto Dinmica de Grupos
Durante a execuo de uma aplicao as tarefas podem dinamicamente juntar-se ou retirar-se de

grupos, no havendo qualquer limite para o nmero de grupos a que uma tarefa pode pertencer.
3.1.2.5 Envio de Sinais
Em PVM h duas formas diferentes de uma tarefa enviar sinais s outras tarefas na aplicao. A
primeira replica o mecanismo utilizado em UNIX para o envio e recepo de sinais entre processos. A
segunda um mecanismo independente gerido pelo servidor PVMD que consiste no envio de avisos sob a
forma de um valor inteiro a que se cola uma etiqueta.
Atualmente o PVM emite um aviso sempre que h alterao da mquina virtual por entrada ou
sada de um computador ou quando uma tarefa termina.
3.1.2.6 As rotinas de Comunicao
O modelo de comunicao assume que uma tarefa pode enviar mensagens a qualquer outra
tarefa, na mquina virtual, no havendo limites para o tamanho das mensagens.
Os modos de comunicao em PVM incluem a emisso bloqueante assncrona, a recepo
bloqueante assncrona e a recepo no bloqueante. Na terminologia do PVM a emisso bloqueante
liberta a tarefa emissora imediatamente aps o bloco de memria fica livre. O assincronismo caracteriza
as operaes de emisso porque as tarefas no tm de esperar que seja lanada pela tarefa receptora a
operao correspondente de recepo. Opcionalmente permitido transferir diretamente dados entre as
tarefas. Neste caso, se a mensagens for grande, o emissor bloqueia at que a transferncia termine. [PVMBOOK,1994].
Em recepo no bloqueante a operao retorna imediatamente o valor da mensagem ou um sinal
que permite determinar se a mensagem j esta disponvel. No caso da recepo bloqueante a tarefa fica
literalmente suspensa at que a mensagem seja completamente depositada no bloco de memria. Uma
rotina suplementar permite a obteno de informao sobre a prpria mensagem.[PVM-BOOK,1994].
Para alm dos modos de comunicao ponto a ponto, o modelo inclui ainda a difuso entre os
elementos de um grupo e a difuso parcial para um conjunto de processos selecionveis pelo usurio. As
rotinas para comunicao em larga escala permitem tambm operaes de clculo global e reduo, tais
como a soma o mximo e mnimo.
3.1.2.7 Seqncia
O PVM garante que no h perda de seqncia de mensagens, isto , a

primeira mensagem a chegar vai se a primeira a ser retornada, mesmo que depois desta primeira tenham
outras mensagens.
Os blocos de memria so alocados dinamicamente sendo o tamanho mximo de cada
mensagem, a enviar ou a receber, limitado apenas pela quantidade de memria disponvel em cada
computador.
3.1.3 Interface
Ser apresentado em seguida um resumo das principais rotinas da biblioteca PVM, ou seja a
interface do PVM. A descrio de cada rotina inclui os parmetros, os possveis cdigos de retorno e
exemplos de aplicao escritos em linguagem C.
3.1.3.1 Controle de Processos
pvm_mytid(void)
pvm_parent(void)
A rotina pvm_mytid utilizada normalmente para registrar o processo na mquina virtual e obter
a respectiva identificao. O valor de retorno da rotina pvm_parent a identificao da tarefa que lanou
a tarefa atual.
char *file, **argv, *where;

int flags, count, *tids;
pvm_spawn(file,argv,flags,where,count,tids)
A rotina pvm_spawn lana o valor contido na varivel count de cpias do programa file na
mquina virtual. O parmetro argv um apontador para uma lista de argumentos a entregar para o
programa. A condio flag usada para especificar um conjunto de opes descritos no arquivo de
incluso pvm3.h. o parmetro tids o identificador global de cada uma das tarefas lanadas com sucesso.
3.1.3.2 Passagem de Mensagens
O envio de mensagens em PVM compreende os passos a seguir, podendo o receptor aceitar

mensagens de qualquer remetente e qualquer cdigo de etiquetagem.
A seqncia de envio de mensagens no PVM :
1. Alocao de um bloco de memria
2. Empacotamento no bloco de memria da informao a enviar
3. Envio da mensagem no bloco de memria
A comunicao por troca de blocos de memria tem vantagens significativas que decorrem da
facilidade com que podem ser incorporados mecanismos de comunicao de alta-velocidade em
ambientes heterogneos, ou a possibilidade de constituio de dados estruturados e respectivo
empacotamento e desempacotamento.
O controle de fluxo em PVM assegurado pelo servidor PVMD que garante que as mensagens
enviadas iro ser entregues mesmo que no tenha sido, at ao momento iniciada qualquer operao de
recepo. O controle de fluxo efetivo enquanto houver recursos de memria at que o receptor por sua
vez inicie o processo de recepo alocando uma rea de memria em bloco que possa conter a mensagem.
A perda de seqncia nas mensagens ultrapassada graas a definio da mensagem como uma
tupla < emissor, informao, cdigo de etiquetagem >.
3.1.3.3 Memria em Blocos
int enc;
pvm_initsend( enc );
As rotinas acima servem para manipular os blocos de memria usados durante as transferncias
de dados. Em PVM h, em cada momento, apenas um bloco de memria ativo. Na maior parte dos casos
apenas utilizada a rotina pvm_initsend que cria ou reinicia o bloco de memria ativo para envio.
A rotina pvm_initsend tem uma dupla ao, pois esta funo cria e recupera os blocos de
memria.
3.1.3.4 Empacotamento
As rotinas a seguir servem para encher os blocos de memria com informao a que
correspondem tipos de dados pr-definidos, (reais, inteiros, strings, etc), podem ser evocadas mltiplas
vezes para empacotar dados numa nica mensagem, no havendo limites para a complexidade da
informao contida numa nica mensagem. Tem apenas, de se garantir que as tarefas nas aplicaes
devero desempacotar as mensagens utilizando as operaes recprocas.
int *x, n_itens, stride;
float *a;
pvm_pkint(x, n_itens, stride);
pvm_pkfloat(a, n_itens, stride);
O primeiro argumento de cada um destas rotinas, no caso o x ou a, um apontador para o

primeiro elemento do tipo de dado correspondente, n_itens refere o nmero de itens e stride a extenso do
tipo usado para empacotamento.
3.1.3.5 Desempacotamento
A uma operao de empacotamento na emisso devera corresponder a operao de

desempacotamento inversa na recepo, que definir o mesmo tipo de dado, o mesmo nmero de itens e
idntica extenso.
int *x, n_itens, stride;
float *a;
pvm_upkint(x, n_itens, stride);
pvm_upkfloat(a, n_itens, stride);
Os argumentos tm o mesmo significado dos que foram usados no empacotamento.
3.1.3.6 Envio de Mensagens
int tid, msgtag;

pvm_send( tid, msgtag);
Para enviar uma mensagem pode usar-se a primitiva pvm_send e precisar o nmero tid de
identificao do processo receptor mas, tambm, necessrio colar uma etiqueta msgtag mensagem.
3.1.3.7 Recepo de Mensagens
int tid, msgtag;

pvm_recv(tid, msgtag);
O pvm_recv uma funo de recepo de mensagens bloqueante, ou seja, enquanto a mensagem

no for completamente recebida a tarefa receptora permanece bloqueada espera.
Os argumentos tm o mesmo significado que os usados no envio de mensagens.
3.1.3.8 Indicao de Mquinas Remotas
char *file, **argv, *where;

int flags, count, *tids;
pvm_spawn(file,argv,flags,where,count,tids)
A indicao de uma mquina remota feita atravs do argumento where, podendo ser
descriminado o IP ou o host da mquina a ser referenciada.
Para se adicionar hosts:
char **host;
int nro_hosts, *info_host;
pvm_addhosts(hosts, numero_hosts, info_hosts)
3.2 RMI
RMI (Remote Method Invocation) um mecanismo que permite a um objeto instanciado em

uma mquina virtual Java invocar mtodos de um objeto que foi instanciado em outra mquina virtual
Java, estas mquinas virtuais podem ou no ser no mesmo computador.
A comunicao feita entre esses objetos via chamada de mtodos remotos. Essas chamadas so
muito semelhantes quelas que operam em objetos no mesmo programa.
O modelo RPC ( Remote Procedure Calls ) da Sun baseado no modelo de chamada de
procedimentos remota, que por sua vez similar ao modelo de chamada de procedimento local. No caso
local, o objeto que realiza a chamada coloca os argumentos para o procedimento em uma localizao
especfica. Ento o controle transferido ao procedimento e depois eventualmente ele ganha o controle
novamente. Neste ponto, os resultados do procedimento so extrados da localizao especfica e o objeto
continua sua execuo.[DEITEL e DEITEL,2001].

O modelo de chamada a procedimento remoto semelhante. O processo executa a chamada
enviando uma mensagem ao processo servidor e ento espera por uma mensagem de resposta. A
mensagem inclui os parmetros do procedimento e a mensagem de resposta inclui os resultados da
chamada. Quando a resposta recebida, os resultados so extrados da mensagem e o processo que
executou a chamada continua sua execuo.
Do lado do servidor existe um processo adormecido esperando por uma mensagem de chamada.
Quando ela chega, o processo servidor extrai os parmetros do procedimento, calcula os resultados, envia
uma mensagem de resposta e volta a ficar adormecido esperando por outra mensagem de chamada.
Diferenas entre procedimentos locais e procedimentos remotos:
Tratamento de erros falhas ocorridas no servidor remoto ou na rede devem ser tratadas;
Variveis Globais e Efeitos Colaterais tendo em vista que o servidor no tem acesso a faixa de
endereos do cliente, argumentos escondidos no podem ser passados como variveis globais ou
retornados como efeitos colaterais.
Performance procedimentos remotos em geral operam em velocidades menores que chamadas a

procedimentos locais.
Autenticao a autenticao se faz necessria tendo em vista que chamadas a procedimentos

remotos trafegam em redes inseguras.
3.2.1 Funcionamento
O funcionamento de RMI consiste basicamente em dois programas, um seria o cliente e outro o

servidor. O servidor instancia objetos remotos, o referncia com um nome, e faz um vinculo ( bind ) dele
numa porta, onde este objeto espera por clientes que invoquem seus mtodos. J o cliente referencia
remotamente um ou mais mtodos de um objeto remoto. RMI fornece os mecanismos para que a
comunicao entre cliente e servidor seja possvel.
Aplicaes distribudas usando RMI precisam executar as seguintes aes:
Localizar objetos remotos uma aplicao pode usar dois mecanismos para obter referencias de
objetos remotos. Ela pode registrar o objeto remoto com a ferramenta de nomes do RMI, que se
chama rmiregistry, ou ela pode passar e retornar referencias aos objetos como parte de sua
operao normal
Se comunicar com objetos remotos os detalhes de comunicao entre objetos remotos so

tratados pelo RMI, ou seja, para o programador, a comunicao remota semelhante a uma
chamada ao mtodo localmente.
Carregar bytecodes de objetos mveis como o RMI permite que objetos remotos sejam
passados com o parmetro numa funo, ele fornece os mecanismos necessrios para carregar o
cdigo dos objetos remotos.
A figura 3.1 ilustra como uma aplicao RMI distribuda usa o rmiregistry para obter uma
referencia ao objeto remoto. O servidor chama o registro para associar um nome ao objeto remoto. O
cliente procura o objeto remoto pelo seu nome no registro do servidor e ento invoca um mtodo nele. A
ilustrao tambm mostra o RMI utilizando um servidor web para carregar os bytecodes, de servidor
para cliente e vice-versa, de acordo com as necessidades da aplicao.
Figura 3.1 Aplicao Distribuda [JAVA.RMI, 2000]
Vantagens de carregar o cdigo dinamicamente: Uma das principais vantagens do RMI sua
capacidade de baixar o cdigo de um objeto, caso a classe desse objeto no seja definida na mquina
virtual do receptor. Os tipos e o comportamento de um objeto, previamente disponvel apenas em uma
mquina virtual, agora podem ser transmitidos para outra mquina virtual, possivelmente remota. Essa
funcionalidade do RMI permite que o cdigo da aplicao seja atualizado dinamicamente, sem a
necessidade de recompilar o cdigo.
3.2.2 Serializao
A capacidade de armazenar e recuperar objetos em Java essencial quando se fala de RMI. A

maneira encontrada para armazenar esses objetos em uma forma serializada sem ocupar muita memria
foi representar os estados do objeto suficientes para reconstru-lo.
Objetos serializados em Java devem ser capazes de identificar e verificar a classe Java da qual
eles derivam e recuperar seu contedo para criar uma nova instncia.
Freqentemente, objetos armazenados fazem referncia a outros objetos. Esses outros objetos
tambm devem ser armazenados e na recuperao, todos devem ser dezarmazenados ao mesmo tempo,
para que as relaes entre eles no se percam.
3.2.3 Stubs e Skeletons
RMI usa um mecanismo padro empregado em sistemas RPC, para se comunicar com objetos
remotos, que so stubs e skeletons. O stub funciona semelhante a um proxy para o objeto remoto.
Quando um objeto local invoca um mtodo num objeto remoto, o stubfica responsvel por enviar a
chamada ao mtodo para o objeto remoto[DEITEL e DEITEL,2001].
Passos do stub quando invocado:
Iniciar conexo com a Virtual Machine que contm o objeto remoto.
Escrever e transmitir os parmetros para a Virtual Machine remoto.
Esperar pelos resultados da invocao do mtodo.
Ler os resultados retornados.
Retornar os valores ao objeto que executou a chamada.
O stub esconde a serializacao dos parmetros e toda a comunicao a nvel de rede, com o
objetivo de simplificar o mecanismo de realizao da chamada.

Na Virtual Machine remota, cada objeto deve ter um skeleton correspondente ao stub. O
skeleton responsvel por enviar a chamada ao objeto remoto.
Passos do skeleton quando recebe uma chamada:
Ler os parmetros enviados pelo stub.
Envocar o mtodo no objeto remoto.
Escrever e transmitir o resultado ao objeto que executou a chamada.
3.2.4 Ativao
Sistemas de objetos distribudos so projetados para suportar objetos persistentes de vida longa.
Tendo em vista que tais sistemas podem conter milhares de objetos, no se torna razovel que esses
objetos se tornem ativos e continuem sempre ativos, consumindo assim recursos preciosos do sistema.
Alm disso, clientes devem armazenar referncias persistentes aos objetos, para que a comunicao possa
ser restabelecida depois de uma queda no sistema, considerando que a referncia a um objeto s vlida
enquanto este estiver ativo.
Ativao em Java um mecanismo que prov referncias persistentes aos objetos, ao mesmo
tempo em que gerencia a execuo do mesmo. Em RMI, a ativao permite que objetos iniciem sua
execuo a medida que esta ao necessria.
Quando ativado, o objeto remoto acessado, caso ele no esteja sendo executado, e o sistema
inicia a execuo do objeto dentro da Java Virtual Machine apropriada.
3.2.5 Interface
Primeiro deve se criada a interface do servidor, nesta interface estaro os mtodos remotos que o
cliente utilizara para interagir com o servidor.
Exemplo:
public interface Teste extends Remote {

public void get( ) throws RemoteExeception;
}
Segundo
deve
implementar um servidor remoto RMI. Normalmente a declarao de um classe que implementa um

servidor e da seguinte forma:
Como foi declarado o mtodo get() na interface, deve-se implementar esse mtodo na classe
TesteImp, pelo motivo que esta classe a implementao da classe Teste e seus mtodos.
public class TesteImp extends UnicastRemoteObject implements

Teste
Esta classe
deve
implementar
todos
{
public TesteImp( )
os
mtodos
declarados
na
interface do servidor.
Uma vez que
a
super( );
est
definida e a classe
que
interface
implementa
servio remoto tenha
public void get( ) throws RemoteException

{
sido
criada,
prximo passo
no
desenvolvimento
da
aplicao distribuda
System.out.println(O flamengo bom!!!);
public static void main( String args[] ) thorows Exception

{
TesteImp tmp = new TesteImp( );
String serveObjectName = /127.0.0.1/Serv;
// atribuir o nome do servidor ao rmiregistry
Naming.rebind( serveObjectName, tmp);
System.err.println(Servidor no esta funcionando!!!);
desenvolver
cliente.
public class cliente {

public static void main ( String args[] 0 {
try {
TesteIpm objre = ( testeimp ) Naming.lookup(//127.0.0.1/Serv);
objre.get( );
}
catch ( java.rmi.ConnectException ec )
{
System.out.println(Conexo com servidor falhou);
}
catch ( Exception e)
{
e.printStackTrace( );
System.exit( 1 );
}
}
}
Na implementao da classe cliente, na linha 4, existir uma declarao de um objeto remoto do

servidor que estar localizado na url //127.0.0.1/Serv.
3.3 Concluso
Cada uma das ferramentas apresenta sua vantagem, ou seja, o PVM uma linguagem voltada
para aplicaes cientificas, devido a sua performance elevada, enquanto o RMI mais voltada para as
aplicaes comerciais, devido a sua fcil integrao com banco de dados e outras alternativas do Java. O
PVM no trabalha com o conceito de orientao a objetos, j o RMI todo implementado utilizando esses
conceitos, como herana, poliformismo, sobrecarga, etc. Aplicaes onde se necessita de tempo real e
processamento mais rpido o uso do PVM ideal, pois com se paralelismo intrnseco e a sua no
utilizao da Mquina Virtual Java torna-o mais aplicvel a esses sistemas, j o RMI possui a Mquina
Virtual Java e no implementa o paralelismo diretamente, perdendo assim em performance, mas
ganhando em segurana. No captulo seguinte sero apresentados casos de utilizaes destas ferramentas.
4 Aplicaes Utilizando PVM e RMI
Este captulo abordar diferentes estudos de casos, com devida implementao, utilizando RMI e
PVM. Em cada estudo ter uma implementao em RMI e outra em PVM, visando assim implementar a
mesma funcionalidade com as duas diferentes ferramentas.
4.1 Primeiro Caso
Algoritmo do primeiro caso: Multiplicar duas matrizes, uma com dimenso igual a 2x2 e outra
2x1. A multiplicao deve ser de forma que uma mquina, passe uma linha da primeira matriz e uma
coluna da segunda matriz, por vez, para uma outra mquina. A mquina que recebe os dados deve
retornar uma terceira matriz com o resultado.
4.1.1
Implementao utilizando PVM
Nesta implementao ser necessrio apenas um processo pai e um processo filho. O processo
pai vai definir as matrizes com valores fixos e depois inicializar o processo filho, ficando assim em espera
at que o processo filho retorne a matriz com o resultado. O processo filho vai receber os dados processar
a multiplicao e montar uma matriz resultado para posteriormente retornar ao processo pai. Como ser
utilizada uma matriz 2x2 e outra 2x1 necessitaremos apenas de inicializar o processo filho duas vezes,
sendo assim o processo pai vai ter duas tarefas, as quais sero as tarefas onde o processo filho vai entrar
em ao.
01 #include <stdio.h>
02 #include <pvm3.h>
03
04 #define TAM 2
05 #define NTASK 2
06
07 void main()
08 {
09 int info, tid[NTASK], v[TAM][TAM], a[TAM], i, j, soma[TAM];
10
11 pvm_mytid();
12 info=pvm_spawn("/home/computacao/g100020798/au4/filho",(char **)0,0,"",NTASK,tid);
13 if(info==NTASK)
14
15
for(i=0;i<TAM;i++)
16
17
for(j=0;j<TAM;j++)
18
19
v[i][j]=2;
20
21
a[i]=1;
22
23
for(i=0;i<NTASK;i++)
24
25
pvm_initsend(0);
26
pvm_pkint(v[i],NTASK,1);
27
pvm_send(tid[i],63);
28
29
pvm_initsend(0);
30
pvm_pkint(a,NTASK,1);
31
32
33
34
35
pvm_recv(tid[i],63);
36
pvm_upkint(&soma[i],1,1);
37
38
39
printf("\n");
40
41
for(j=0;j<TAM;j++)
42
printf("%d\n",soma[j]);
43
44
printf("\n");
45
46
47 else
48
printf("nao posso criar o processo filho");
49 pvm_exit();
50 exit(0);
51 }
Figura 4.1 Implementao em PVM do processo pai
O programa pai na linha 11 registra o processo na mquina virtual e obtm a respectiva

identificao. Na linha 12 tem a descrio do caminho onde est o processo filho (
"/home/computacao/g100020798/au4/filho" )
, o nmero de cpias do programa filho que sero lanadas na
mquina virtual ( NTASK ) e a identificao de cada um dos processos ( tid ). Ser feito um teste, visando
verificar se todos os processos foram inicializados na mquina virtual, isto na linha 13. Da linha 15 at a
22 as matrizes sero inicializadas. Nas linhas 25 e 29 sero inicializados blocos de memria. Nas linhas
26 e 30 ocorrer o empacotamento dos dados, e nas linhas 27 e 31o envio desses dados empacotados para
os blocos de memria. Na linha 35 ocorrer o recebimento dos dados e posteriormente o
desempacotamento ( linha 36 ). A impresso do resulta do ser nas linhas 41 e 42. As tarefas so
desassociadas da mquina virtual ( linha 49 ).
03
04 #define TAM 2
05
06 void main()
07 {
08 int pid, v[TAM], a[TAM], soma[TAM/2],tmp=0, i;
09
10 pvm_mytid();
11 pid=pvm_parent();
12
13 pvm_recv(pid, 63);
14 pvm_upkint(v,TAM,1);
15
17 pvm_upkint(a,TAM,1);
18
19 for(i=0; i<TAM;i++)
20
21
tmp=tmp+(a[i]*v[i]);
22
23 soma[0]=tmp;
24 pvm_initsend(0);
25 pvm_pkint(soma,TAM, 1);
26 pvm_send(pid, 63);
27 pvm_exit();
28 exit(0);
29 }
Figura 4.2 Implementao em PVM do processo filho
O programa filho na linha 10 registra o processo na mquina virtual e obtm a respectiva

identificao, na linha 11 ocorre a identificao da tarefa que lanou a tarefa atual na mquina virtual. As
linhas 13 e 16 ocorre o recebimento dos dados, e nas linhas 14 e 17 ocorre o desempacotamento dos
dados. Entre as linhas 19 e 22 feita a multiplicao das matrizes. Na linha 24 feita a inicializao de
um bloco de memria, na linha 25 ocorre o empacotamento dos dados e na linha 26 o envio dos dados. A
tarefa e desassociada da mquina virtual ( linha 27 ).
4.1.2
Implementao em RMI
Na implementao utilizando RMI sero necessrios trs programas, sendo: o programa pai , o
programa filho e a definio de interface do servidor. Na definio de interface do servidor teremos
apenas a declarao de uma funo soma que retorna um inteiro. No programa pai sero inicializadas as
matrizes e ocorrer a instanciao do objeto filho, chamando assim a sua funo soma. No programa filho
ser feita a soma e o retorno dessa nova matriz resultado para o programa pai.
01 import java.rmi.*;
02
03 public interface Filho extends Remote
04 {
05
public int[] Soma(int g[],int h[]) throws RemoteException;
06 }
Figura 4.3 Implementao em RMI da interface filho
A interface Filho descreve o mtodo que o cliente ( pai ), chamar para interagir com o objeto
remoto. A interface pode ter mais de um mtodo declarado. A interface Filho estende a interface Remote (
pacote Java.rmi ) na linha 03. Caso ocorra algum tipo de erro com a comunicao durante uma chamada
do mtodo remoto, um mtodo remoto dispara uma RemoteException ( um tipo de exceo verificada),
linha 05.
02 import java.rmi.server.*;
03 import java.util.*;
04 import java.io.*;
05 import java.net.*;
06
07 public class FilhoImp extends UnicastRemoteObject implements Filho
08 {
09
int soma[] = new int[1];
10
int tmp=0;
11
12
public FilhoImp() throws RemoteException
13
14
super();
15
16
public int[] Soma(int g[],int h[]) throws RemoteException
17
18
tmp=0;
19
for (int y=0;y<2;y++)
20
21
22
tmp = tmp + (g[y]*h[y]);

}
23
soma[0]=tmp;
24
return soma;
25
26
public static void main (String[] args) throws Exception
27
28
System.out.println("Servidor inicializado!");
29
FilhoImp rsi = new FilhoImp();
30
System.out.println("Criou o objeto servidor");
31
Naming.rebind("//localhost/Servidor", rsi);
32
System.out.println("O servidor esta OK e rodando!");
33
34 }
Figura 4.4 Implementao em RMI da classe filho
A classe FilhoImp implementa a interface Remote Filho ( linha 07 ). A classe FilhoImp estende a
classe UnicastRemoteObject ( pacote Java.rmi.server ), na linha 07. A classe UnicastRemoteObject
fornece toda funcionalidade bsica dos objetos remotos. As linhas 16 a 25 definem o mtodo soma, que
efetiva a soma dos elementos de um vetor. O mtodo main ( linhas 26 a 34 ) inicia o objeto FilhoImp
remoto que aceita chamadas de mtodos remotas de clientes e retorna o valro da soma para os clientes. A
linha 29 cria um objeto FilhoImp e automaticamente chama seu mtodo construtor. O nome do objeto
servidor definido na linha 31, esse nome o cliente fornecer para localizar o objeto servidor. A linha 31
chama o mtodo static rebind da classe Naming ( pacote Java.rmi ) para vincular o objeto remoto rsi de
FilhoImp ao rmiregistry ( gerenciador de objetos remotos ) e atribuir o nome //localhost/Servidor ao
objeto remoto.
03
04 public class Pai
05 {
06
int t=0,k=0;
07
int tmp[] = new int[2];
08
int soma[] = new int[2];
09
int vet[] = new int[2];
10
int vet2[][] = new int[2][2];
11
int v[] = new int[2];
12
13
public Pai()
14
15
for(int y=0;y<2;y++)
16
17
for (int j=0;j<2;j++)
18
19
vet2[y][j]=2;
20
21
vet[y]=1;
22
23
try
24
25
System.out.println("Client iniciando...");
26
Filho meuReg = (Filho) Naming.lookup("//localhost/Servidor");
27
while (k<2)
28
29
for (int i=0;i<2;i++)
30
31
v[i]=vet2[k][i];
32
33
tmp = meuReg.Soma(v,vet);
34
soma[k]=tmp[0];
35
k++;
36
37
38
for (int b=0;b<2;b++)
39
40
System.out.println("soma["+b+"] = " + soma[b]);
41
42
System.exit(0);
43
44
catch (java.rmi.ConnectException ce)
45
46
System.out.println("Conexo com servidor falhou!");
47
48
catch (Exception e)
49
50
e.printStackTrace();
51
System.exit(1);
52
53
}
}
54
55
public static void main(String[] args)
56
57
58
Pai rc = new Pai();

}
59 }
Figura 4.5 Implementao em RMI da classe pai
A classe Pai define o aplicativo de cliente que chama o mtodo remoto da classe FilhoImp. Da
linha 13 a 28 feita a inicializao do vetor. Na linha 26 chama o mtodo static lookup da classe
Naming para obter uma referncia remota que permite ao cliente invocar mtodos do objeto remoto
FilhoImp. O mtodo lookup retorna uma referncia Remote para um objeto que implementa a interface
remota Filho. Uma vez retornada esta referncia, ela atribuda a meuReg. O cliente utiliza meuReg para
chamar o mtodo remoto do objeto servidor como se ele fosse um mtodo de outro objeto definido
localmente na classe cliente.
4.2 Segundo Caso
Algoritmo do segundo caso: Verificar qual o maior elemento, menor elemento e a mdia de um
vetor dado. Cada uma das trs verificaes deve ser feitas em mquinas diferentes, ou seja, uma mquina
faz a verificao do maior, outra a verificao do menor e uma terceira a verificao da mdia. As
mquinas devem retornar um inteiro.
4.2.1
Implementao utilizando PVM
Na implementao deste problema ser necessrio trs processos filho e um processo pai. O
processo pai vai definir os elementos do vetor com valores fixos e depois inicializar os processos filhos,
sendo os quais: um processo filho para calcular a mdia, outro para pegar o elemento maior e outro
processo que retorna o menor elemento do vetor. O processo pai fica em espera at que os processos
filhos retorne o resultado. O processo filho vai receber os dados do vetor processar a busca ou o clculo
da mdia e retornar o resultado para o processo pai, posteriormente retornar o processamento ao processo
pai. Para soluo deste problema necessitaremos de fazer com que o processo pai inicie todos os trs
processos filhos.
03
04 #define TAM 10
05 #define NTASK 1
06
07 void main()
08 {
09 int info1,info2,info3, tid1[NTASK], tid2[NTASK], tid3[NTASK], v[TAM], i, max, mim, med;

10
11 for(i=0;i<TAM;i++)
12
v[i]=i+1;
13
14 i=0;
15
16
17 pvm_mytid();
18
19 info1=pvm_spawn("/home/computacao/g100020798/au5/filhomaior",(char
**)0,0,"",NTASK,tid1);
20 info2=pvm_spawn("/home/computacao/g100020798/au5/filhomenor",(char
**)0,0,"",NTASK,tid2);
21 info3=pvm_spawn("/home/computacao/g100020798/au5/filhomedia",(char
**)0,0,"",NTASK,tid3);
22
23
24 if(info1==NTASK && info2==NTASK && info3==NTASK)
25
26
pvm_initsend(0);
27
pvm_pkint(v,TAM,1);
28
pvm_send(tid1[i],63);
29
30
pvm_initsend(0);
31
pvm_pkint(v,TAM,1);
32
33
34
pvm_initsend(0);
35
pvm_pkint(v,TAM,1);
36
37
38
39
pvm_recv(tid1[i],63);
40
pvm_upkint(&max,1,1);
41
42
43
pvm_upkint(&mim,1,1);
44
45
46
pvm_upkint(&med,1,1);
47
48
49 else
50
51
52 printf("maior = %d",max);
53 printf("\nmenor = %d",mim);
54 printf("\nmedia = %d\n",med);
55
56 pvm_exit();
57 exit(0);
58 }
No programa pai feita a inicializao do vetor nas linhas 11 e 12. Na linha 17 o programa
registra o processo na mquina virtual e obtm a respectiva identificao. As linhas 19, 20 e 21 tm a
descrio do caminho onde esto os processos filhos, o nmero de copias de cada programa filho que
sero lanadas na maquina virtual ( NTASK ) e a identificao de cada um dos processos ( tid ) de cada
filho. Ser testado se todos os processos foram inicializados na maquina virtual, isto na linha 24. Nas
linhas 26, 30 e 34 sero inicializados blocos de memria. Nas linhas 27, 31 e 35 ocorrer o
empacotamento dos dados, e nas linhas 28, 32 e 36o envio desses dados empacotados para os blocos de
memria. Nas linhas 39, 42 e 45 ocorrer o recebimento dos dados e posteriormente o desempacotamento
( linhas 40, 43 e 45 ). A impresso do resulta do ser nas linhas 52, 53 e 54. As tarefas so desassociadas
da mquina virtual ( linha 56 ).
03
04 #define TAM 10
05
06 void main()
07 {
08 int pid, v[TAM], maior, i;
09
10 pvm_mytid();
12
15
16 maior=v[0];
17
19
20
if(maior<v[i])
21
maior=v[i];
22
23
24 pvm_initsend(0);
25 pvm_pkint(&maior,1, 1);
27
28 pvm_exit();
29 exit(0);
30 }
Figura 4.7 Implementao em PVM do processo filho maior
O programa filho maior na linha 10 registra o processo na mquina virtual e obtm a respectiva
identificao, na linha 11 ocorre a identificao da tarefa que lanou a tarefa atual na mquina virtual. A
linha 13 ocorre o recebimento dos dados, e na linha 14 ocorre o desempacotamento dos dados. Entre as
linhas 18 e 22 feita a seleo do maior elemento do vetor. Na linha 24 feita a inicializao de um
bloco de memria, na linha 25 ocorre o empacotamento dos dados e na linha 26 o envio dos dados. A
03
04 #define TAM 10
05
06 void main()
07 {
08 int pid, v[TAM], menor, i;
09
10 pvm_mytid();
12
15
16 menor=v[0];
18
19
if(menor>v[i])
20
menor=v[i];
21
22 pvm_initsend(0);
23 pvm_pkint(&menor,1, 1);
25 pvm_exit();
26 exit(0);
27 }
Figura 4.8 Implementao em PVM do processo filho menor
O programa filho menor na linha 10 registra o processo na mquina virtual e obtm a respectiva
linhas 17 e 21 feita a seleo do menor elemento do vetor. Na linha 22 feita a inicializao de um
03
04 #define TAM 10
05
06 void main()
07 {
08 int pid, v[TAM], i;
09 int media=0;
10
11 pvm_mytid();
13
16
18
19
media=media+v[i];
20
21 media=media/TAM;
22
23 pvm_initsend(0);
24 pvm_pkint(&media,1, 1);
26 pvm_exit();
27 exit(0);
28 }
Figura 4.9 Implementao em PVM do processo filho mdia
O programa filho mdia na linha 11 registra o processo na mquina virtual e obtm a respectiva
linhas 17 e 20 feito o clculo da mdia dos elementos do vetor. Na linha 23 feita a inicializao de um
4.2.2 Implementao utilizando RMI
Na implementao com RMI sero necessrios sete programas, sendo: o programa pai , o
programa filho maior, o programa filho menor, o programa filho mdia e as trs definies das interfaces
dos servidores. Na definio da interface do servidor filho maior declarada apenas uma funo maior
que retorna um inteiro, na definio da do servidor filho menor declaradaa a funo menor que retorna
um inteiro e na definio da interface do servido filho mdia declarada a funo mdia que retorna um
inteiro. No programa pai ser inicializado o vetor e ocorrer a instanciao dos objetos filhos, chamando
assim seus mtodos. No programa filho maior ser feita a seleo do maior elemento do vetor, no
programa filho menor ser feito a seleo do menor elemento do vetor e no programa filho mdia ser
calculada a mdia dos elementos do vetor.
02
03 public interface FilhoMaior extends Remote
04 {
05
public int Maior(int g[], int tam) throws RemoteException;
06 }
Figura 4.10 Implementao em RMI da interface filho maior
A interface FilhoMaior descreve o mtodo que o cliente ( pai ), chamar para interagir com o
objeto remoto. A interface Filho estende a interface Remote na linha 03. Caso ocorra algum tipo de erro
com a comunicao durante uma chamada do mtodo remoto, um mtodo remoto dispara uma
RemoteException, linha 05.
02
03 public interface FilhoMenor extends Remote
04 {
05
public int Menor(int g[], int tam) throws RemoteException;
06 }
Figura 4.11 Implementao em RMI da interface filho menor
A interface FilhoMenor descreve o mtodo que o cliente ( pai ), chamar para interagir com o
02
03 public interface FilhoMedia extends Remote
04 {
05
public int Media(int g[], int tam) throws RemoteException;
06 }
Figura 4.12 Implementao em RMI da interface filho mdia
A interface FilhoMdia descreve o mtodo que o cliente ( pai ), chamar para interagir com o
06
07 public class FilhoMaiorImp extends UnicastRemoteObject implements FilhoMaior
08 {
09
int maior;
10
11
public FilhoMaiorImp() throws RemoteException
12
13
super();
14
15
public int Maior(int g[], int tam) throws RemoteException
16
17
maior=g[0];
18
for (int y=0;y<tam;y++)
19
20
if (maior<g[y])
21
22
maior = g[y];
23
24
25
return maior;
26
27
28
29
System.out.println("Servidor Maior inicializado!");
30
FilhoMaiorImp rsimaior = new FilhoMaiorImp();
31
32
Naming.rebind("//localhost/ServidorMaior", rsimaior);
33
35
36 }
Figura 4.13 Implementao em RMI da classe filho maior
A classe FilhoMaiorImp implementa a interface Remote FilhoMaior ( linha 07 ). A classe

FilhoMaiorImp estende a classe UnicastRemoteObject, na linha 07. As linhas 16 a 26 definem o mtodo
maior, que seleciona o maior elemento do vetor. O mtodo main ( linhas 27 a 35 ) inicia o objeto
FilhoMaiorImp remoto que aceita chamadas de mtodos remotas de clientes e retorna o maior valor dos
elementos do vetor para o cliente. A linha 30 cria um objeto FilhoMaiorImp e automaticamente chama
seu mtodo construtor. O nome do objeto servidor definido na linha 32, esse nome o cliente fornecer
para localizar o objeto servidor.
06
07 public class FilhoMenorImp extends UnicastRemoteObject implements FilhoMenor
08 {
09
int menor;
10
11
public FilhoMenorImp() throws RemoteException
12
13
super();
14
15
public int Menor(int g[], int tam) throws RemoteException
16
17
menor=g[0];
18
19
20
if (menor>g[y])
21
22
menor = g[y];
23
24
}
}
25
return menor;
26
27
28
29
System.out.println("Servidor Menor inicializado!");
30
FilhoMenorImp rsimenor = new FilhoMenorImp();
31
32
Naming.rebind("//localhost/ServidorMenor", rsimenor);
33
34
35 }
Figura 4.14 Implementao em RMI da classe filho menor
A classe FilhoMenorImp implementa a interface Remote FilhoMenor ( linha 07 ). A classe

FilhoMenorImp estende a classe UnicastRemoteObject, na linha 07. As linhas 15 a 26 definem o mtodo
menor, que seleciona o menor elemento do vetor. O mtodo main ( linhas 27 a 34 ) inicia o objeto
FilhoMenorImp remoto que aceita chamadas de mtodos remotas de clientes e retorna o menor valor dos
elementos do vetor para o cliente. A linha 30 cria um objeto FilhoMenorImp e automaticamente chama
seu mtodo construtor. O nome do objeto servidor definido na linha 33.
06
07 public class FilhoMediaImp extends UnicastRemoteObject implements FilhoMedia
08 {
09
int media;
10
11
public FilhoMediaImp() throws RemoteException
12
13
super();
14
15
public int Media(int g[], int tam) throws RemoteException
16
17
media=0;
18
19
20
media = media + g[y];
21
22
return (media/tam);
23
24
25
26
System.out.println("Servidor Media inicializado!");
27
FilhoMediaImp rsimedia = new FilhoMediaImp();
28
29
Naming.rebind("//localhost/ServidorMedia", rsimedia);
30
31
32 }
Figura 4.15 Implementao em RMI da classe filho media
A classe FilhoMediaImp implementa a interface Remote FilhoMedia ( linha 07 ). A classe

FilhoMediaImp estende a classe UnicastRemoteObject, na linha 07. As linhas 15 a 23 definem o mtodo
mdia, que calcula a mdia entre os elementos do vetor. O mtodo main ( linhas 24 a 31 ) inicia o objeto
FilhoMediaImp remoto que aceita chamadas de mtodos remotas de clientes e retorna a mdia dos
elementos do vetor para o cliente. A linha 27 cria um objeto FilhoMenorImp e automaticamente chama
seu mtodo construtor. O nome do objeto servidor definido na linha 29.
03 import java.lang.*;
04
05 public class Pai extends Thread
06 {
07
08

int tam;
09
10
public Pai(int a)
11
12
tam = a;
13
14
public void run()
15
16
for (int j=0;j<tam;j++)
17
18
vet[j]=j+1;
19
20
21
try
22
23
24
25
26
27
FilhoMaior maiorReg = (FilhoMaior) Naming.lookup("//localhost/ServidorMaior");

System.out.println("Maior = " + maiorReg.Maior(vet,tam));
28
FilhoMenor menorReg = (FilhoMenor) Naming.lookup("//localhost/ServidorMenor");
29
System.out.println("Menor = " + menorReg.Menor(vet,tam));
30
31
FilhoMedia mediaReg = (FilhoMedia) Naming.lookup("//localhost/ServidorMedia");
32
System.out.println("Media = " + mediaReg.Media(vet,tam));
33
34
35
36
37
38
39
40
41
catch (Exception e)
42
43
44
System.exit(1);
45
46
}
}
47
48

{
49
Pai rc = new Pai(10000);
50
Pai rc2 = new Pai(5000);
51
rc.start();
52
rc2.start();
53
}
A classe Pai define o aplicativo de cliente que chama os mtodo remotos das classes
FilhoMaiorImp, FilhoMenorImp e FilhoMediaImp. A classe Pai estende a classe Thread ( linha 05 ). Esta
classe Pai implementada de forma que o processamento dos dados feito de forma paralela. Como a
classe estende a classe Thread foi feito overload do mtodo run, visando assim ajust-lo para o problema.
4.3 Terceiro caso
Algoritmo do terceiro caso: Verificar qual o maior elemento, menor elemento e a mdia de um
vetor dado. Mas todas as trs verificaes devem ser feitas em uma mesma mquina, ou seja, uma
mquina faz todas as verificaes e retorna para outra mquina. As mquinas devem retornar um inteiro.
Para fazer todas as verificaes na mesma mquina deve ser utilizado um flag indicando o tipo da
verificao (maior, menor e mdia).
4.3.1 Implementao utilizando PVM
A implementao deste problema ser preciso de um processo filho e um processo pai. O

processo pai vai definir os elementos do vetor com valores fixos e depois inicializar o processo filho, o
qual vai receber um flag indicando a operao a fazer. O processo pai vai ficar em espera at que o
processo filho retorne os resultados. O processo filho vai receber os dados do vetor e um flag, processar a
busca ou o calculo da mdia e retornar o resultado para o processo pai, posteriormente retornar o
processamento ao processo pai.
03
04 #define TAM 10
05 #define NTASK 3
06
07 void main()
08 {
09 int info, tid[NTASK], v[TAM], i,flag=1,max[NTASK];

10
12
v[i]=i+1;
13
14 i=0;
15
16 pvm_mytid();
17
18 info=pvm_spawn("/home/computacao/g100020798/au6/filho",(char **)0,0,"",NTASK,tid);
19
20
21 if(info==NTASK)
22
23
24
25
26
pvm_initsend(0);
27
pvm_pkint(v,TAM,1);
28
29
30
pvm_initsend(0);
31
pvm_pkint(&flag,1,1);
32
33
34
flag++;
35
36
37
38
{
39
pvm_recv(tid[i],63);
40
pvm_upkint(&max[i],1,1);
41
42
43
44
45 else
46
47
48 printf("maior = %d",max[0]);
49 printf("\nmenor = %d",max[1]);
50 printf("\nmedia = %d\n",max[2]);
51
52 pvm_exit();
53 exit(0);
54 }
No programa pai faz a inicializao do vetor e seu envio para o processo filho, passando um flag,
que indica a operao, caso o flag seja: 1 indica operao de seleo do maior elemento, 2 operao de
seleo do menor elemento e 3 operao de clculo da mdia do vetor.
03
04 #define TAM 10
05
06 void main()
07 {
08 int pid, v[TAM], m, i,flag,media;
09
10 pvm_mytid();
12
15
17 pvm_upkint(&flag,1,1);
18
19
20 m=v[0];
21 if(flag == 1)
22
23
for(i=1;i<TAM;i++)
24
25
if(m<v[i])
26
m=v[i];
27
28
pvm_initsend(0);
29
pvm_pkint(&m,1, 1);
30
pvm_send(pid, 63);
31
pvm_exit();
32
33 if(flag == 2)
34
35
for(i=1;i<TAM;i++)
36
37
if(m>v[i])
38
m=v[i];
39
40
pvm_initsend(0);
41
pvm_pkint(&m,1, 1);
42
pvm_send(pid, 63);
43
pvm_exit();
44
45
46 if(flag == 3)
47
48
media=0;
49
for(i=0;i<TAM;i++)
50
51
media=media+v[i];
52
53
media=media/TAM;
54
pvm_initsend(0);
55
pvm_pkint(&media,1, 1);
56
pvm_send(pid, 63);
57
pvm_exit();
58
59
60 exit(0);
61 }
Figura 4.18 Implementao em PVM do processo filho
No programa filho recebe o vetor do programa pai e um flag, o programa testa o flag para saber
qual a operao e a processa, retornando o resultado ao programa pai.
4.3.2 Implementao utilizando RMI
A implementao com RMI sero necessrios trs programas, sendo: o programa pai, o programa
filho e a definio da interface do servidor. Na definio da interface do servidor filho declarada apenas
uma funo operao que retorna um inteiro. No programa pai vai ser inicializado o vetor e ocorrer a
instanciao do objeto filho, chamando assim a sua repectiva funo. O programa filho receber o vetor e
um flag indicando a operao, depois da operao efetivada o programa filho retorna um inteiro para o
programa pai.
02
03 public interface Filho extends Remote
04 {
05
public int Operacao(int g[], int flag) throws RemoteException;
06 }
Figura 4.19 Implementao em RMI da interface filho
A interface Filho descreve o mtodo Operao que o cliente ( pai ), chamar para interagir com o
objeto remoto.
06
07 public class FilhoImp extends UnicastRemoteObject implements Filho
08 {
09
int tmp;
10
11
public FilhoImp() throws RemoteException
12
13
super();
14
15
public int Operacao(int g[],int flag) throws RemoteException
16
17
tmp = g[0];
18
if (flag == 1)
19
20
21
22
if (tmp<g[i])
23
24
tmp=g[i];
25
26
27
28
if (flag == 2)
29
30
for (int j=0;j<10;j++)
31
32
if (tmp>g[j])
33
34
35
tmp=g[j];
}
36
37
38
if (flag == 3)
39
40
for (int k=0;k<10;k++)
41
42
tmp = tmp +g[k];
43
44
tmp = tmp / 10;
45
46
return tmp;
47
48
49
50
System.out.println("Servidor inicializado!");
51
FilhoImp rsi = new FilhoImp();
52
53
Naming.rebind("//localhost/Servidor", rsi);
54
55
56
57 }
Figura 4.20 Implementao em RMI da classe filho
A classe FilhoImp cria o servidor e implementa o mtodo Operao, o qual vai receber um vetor
e um flag indicando a operao.
03
04 public class Pai
05 {
06
int tmp[] = new int[3];
07
08
09
public Pai()
10
11
for (int y=0;y<10;y++)
12
13
vet[y] = (y+1);
14
15
16
try
17
18
19
Filho meuReg = (Filho) Naming.lookup("//localhost/Servidor");
20
21
22
meuReg.Operacao(vet,(i+1));
tmp[i] =
23
24
System.out.println("maior = " + tmp[0]);
25
System.out.println("menor = " + tmp[1]);
26
System.out.println("media = " + tmp[2]);
27
System.exit(0);
28
29
30
31
32
33
catch (Exception e)
34
35
36
System.exit(1);
37
38
}
}
39
40
41
42
43
Pai rc = new Pai();

}
44 }
Na classe pai feita a inicializao do vetor e a instanciaco de um objeto da classe FilhoImp

que receber o verto e um flag, que indica a operao, caso o flag seja: 1 indica operao de seleo do
maior elemento, 2 operao de seleo do menor elemento e 3 operao de clculo da mdia do vetor.
4.4 Concluso
Apesar que a metodologia RMI no implementar sistemas distribudos com paralelismo inerente,
pode-se, utilizando de RMI com Thread, obter implementao de sistemas distribudos paralelos. J o
PVM implementa todos os seus sistemas de modo paralelo. As duas ferramentas so alternativas para
implementao de sistemas distribudos, cada qual em sua linguagem especfica, o PVM implementado
em C/C++ e o RMI em Java, dando assim ao programador duas opes de escolha. Os estudos de casos
deste captulo visaram ilustrar todo o funcionamento das ferramentas, no dando nfase ao problema, ou
seja, os problemas propostos foram de cunho didtico. Todas as implementaes foram testadas para
comprovar o funcionamento das ferramentas. As implementaes em PVM foram testadas utilizando o
sistema operacional Linux, j as implementaes em RMI utilizaram o sistema operacional Windows.

Mesmo sendo implementado em Linux temos o PVM para Windows, e quanto ao RMI tambm temos
para Linux. A idia de utilizao dos dois sistemas operacionais visa dar uma maior gama de escolha. O
PVM ganha muito em processamento em relao ao RMI devido JVM ( JavaVirtual Machine ) que faz
com que ele perca em performance, mas tem todas as funcionalidades da linguagem Java, dando ao
programador caractersticas de orientao a objetos bem teis, como: reutilizao de cdigo, herana.
Ambos so uma tima alternativa para implementao de sistemas distribudos.
5 - Concluso
Todo o estudo elaborado neste trabalho visa dar maior conhecimento terico dos sistemas
distribudos, ilustrando a utilizao com duas ferramentas distintas.
As utilizaes destes sistemas esto se tornando inevitveis, sendo assim o trabalho mostra
formas de se utilizar esses conceitos. Como as linguagens de programao preferidas so Java e C\C++,
o estudo visa, no coloc-las como concorrentes, mas sim como diferentes formas de se implementar
sistemas distribudos.
As duas ferramentas PVM e RMI no so concorrentes devido ao fato que o RMI, se aplica mais
a sistemas onde se quer usar todos os conceitos de objetos, como herana, reutilizao de cdigo,
porlimorfismo, etc. J na utilizao do PVM se aplica mais a sistemas de respostas rpidas, como os
sistemas de tempo real, isso devido ao fato que o PVM e paralelo, com essa capacidade ele consegue ter
altssima performance.
Para aplicaes comerciais, as quais no sejam necessrio a utilizao de tempo real o RMI se
encaixa perfeitamente, j as aplicaes onde o tempo e o grande problema, como as aplicaes cientificas
(matemtica, fsicas e qumicas), o PVM mais adequado.
As aplicaes foram desenvolvidas e testadas visando dar exemplos mais concretos e uma viso
prtica para os leitores. A didtica das aplicaes comprovada. As aplicaes no tm como objetivo a
soluo de problemas, mas sim a exemplificao das ferramentas e sua utilizao.
O trabalho visa ajudar todos os programadores que queiram ter noo das ferramentas, e auxililos na sua utilizao. Tem o trabalho o intuito tambm de esclarecer leigos no assunto e estudantes da
rea.
Referncias Bibliografia:
DEITEL, H. M. e DEITEL Como Programar, P. J. Java,. 3 Edio, Porto Alegre: Editora

Bookman, 2001
DEITEL, Harvey M. Operating System. 2 Edio, Framingham: Editora Bookman, 1990
DIAS, Alex. Notas de aula na disciplina de Redes, UNIT Centro Universitrio do Triangulo:
2001
JAVA.RMI.http://java.sun.com/j2se/1.3/docs/api/java/rmi/package-summary.html.
Ano
de
publicao: 2000. Acesso em 29/10/2000
PVM. http://www.cos.ufrj.br/~xexeo/INFO/INTERNET/pvm/pvm.html. Ano de publicao: 2001.

Acesso em 08/10/2001
PVM-BOOK A Userss Guide and Tutorial for Networked Parallel Computing. 1 Edio,
Londres, 1994.
RICARTE, IVAN L. M.. Programao Orientada a Objetos: Uma Abordagem com Java. 1
Edio, Campinas: Editora FEEC/UNICAMP,2001.
TANENBAUM, Andrew S. Sistemas Operacionais Modernos. 3 Edio, So Paulo: Editora

Campus,1992.

Processamento Distribuído PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Processamento Distribuído PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Sistemas Distribudos usando PVM e RMI

Vincius Passos Montes

Sistemas Distribudos usando PVM e RMI

Vincius Passos Montes

Monografia apresentada ao Curso de Cincia da Computao do

Vincius Passos Montes

3.1.2.6. As Rotinas de Comunicao............................................................................................ 20

A programao de sistemas distribudos est se tornando uma realidade devido as grandes

Da evoluo do processamento distribudo, as suas vantagens, desvantagens e caractersticas,

2.1 Introduo a Sistemas Distribudos

integrao de sistemas computacionais autnomos combinados de forma a atingir um objetivo comum, ou

Figura 2.1 sistema distribudo

2.2 Vantagens dos Sistemas Distribudos

Os microprocessadores oferecem uma melhor

Um sistema distribudo pode ter um poder de

Algumas aplicaes envolvem mquinas separadas

Se uma mquina sair do ar, o sistema como um

O poder computacional pode crescer em doses

Com a idia de reduo de despesas pode-se pensar assim: Se os microprocessadores so

Tabela 2.2 Vantagens dos sistemas distribudos sobre os PCs independentes[TANENBAUM,1992]

Permite que mais de um usurio acesse uma base

Permite que mais de um usurio possa ter acesso a

perifricos muitos caros.

Torna muito mais simples a comunicao pessoa a

Espalha a carga de trabalho por todas as mquinas

2.3 Desvantagens dos Sistemas Distribudos

Na atual fase dos softwares para sistemas distribudos os programadores e analistas no tm

2.4 Caractersticas dos Sistemas Distribudos

Abaixo sero descritas as caractersticas bsicas dos sistemas distribudos.[DEITEL,1990].

Confiabilidade: O grande objetivo da construo de sistemas distribudos era faz-los mais

Tabela 2.4 Tipos de Transparncia

Acesso sem o conhecimento da localizao.

Usurios podem compartilhar os recursos.

Mltiplas instancias de uma entidade pode ser usada para

Permite o deslocamento das entidades sem afetar a

operao dos usurios ou programadores.

Permite ao sistema ser reconfigurado.

Permite ao sistema e as aplicaes serem expandidos sem

Podem ocorre atividades paralelas sem que os usurios

2.5 Arquitetura dos Sistemas Distribudos

Figura 2.2 Arquitetura de um sistema centralizado

Em um sistema centralizado o sistema operacional a principal camada de software. Ele

Figura 2.3 Arquitetura de um sistema distribudo

Nos sistemas distribudos o papel do kernel do sistema operacional restrito ao gerenciamento

2.6 Comunicao nos Sistemas Distribudos

A grande diferena entre sistemas distribudos e centralizados est na comunicao entre

Em sistemas distribudos no existem nenhuma forma de compartilhamento, de tal maneira que

Figura 2.4 Nveis, interfaces e protocolos no modelo OSI da ISO

Definies das camadas do modelo OSI da ISO [DIAS,2000]:

A camada de aplicao na verdade os processos (programas), como o servidor de DNS, SMTP,

Uma das formas mais comuns de se implementar a comunicao em sistemas distribudos

Nenhuma operao de troca de mensagem ou de entrada/sada deve ser visvel ao programador

Mascarar as diferenas de representao de dados

3 Tcnicas de Processamento Distribudo

Existem diferentes ferramentas para a implementao de sistemas distribudos, neste captulo

O processamento distribudo e paralelo um mtodo emergente nas novas tecnologias de

3.1.1 Uma Viso do PVM

O PVM utiliza o modelo de passagem de mensagens como plataforma para utilizao da

O PVM cria um enquadramento computacional uniforme que favorece o desenvolvimento rpido

Programao simples uma aplicao uma coleo de tarefas cooperativas;

Desenvolvimento de aplicaes construtores apropriados do PVM escritos na linguagem de

Interface normalizada para pedir recursos mquina virtual;

Bibliotecas de rotinas - para iniciar e terminar tarefas atravs da rede;