Apostila de Projeto de Sistemas Operacionais

Prévia do material em texto

Universidade Estadual Paulista
Instituto de Biociências, Letras e Ciências Exatas
Departamento de Ciência da Computação e Estatística
 
 
 
 
 
 
 
 
 
Apostila de 
Projeto de Sistemas Operacionais 
 
 
 
 
 
 
 
 
 
 
 
Prof. Dr. Norian Marranghello 
Outubro de 2001 
norian@dcce.ibilce.unesp.br 
 
Rua Cirstóvão Colombo, 2265 – São José do Rio Preto, SP 
C.E.P.15054-000; Tel: +17 221 2215; Fax: +17 221 2203 
 
 
 2
Índice 
 
Índice..................................................................................................................................... 2 
Sistemas Distribuídos ........................................................................................................... 4 
Sistemas Centralizados.................................................................................................................5 
Sistema em Rede ...........................................................................................................................7 
Sistemas Distribuídos ...................................................................................................................8 
Sistemas Autônomos Cooperativos .............................................................................................9 
Algoritmos Distribuídos .............................................................................................................10 
Projeto de Sistema Operacional ......................................................................................... 10 
Eficiência ................................................................................................................................................ 10 
Flexibilidade ........................................................................................................................................... 11 
Consistência ............................................................................................................................................ 12 
Robustez ................................................................................................................................................. 12 
Transparência.......................................................................................................................................... 13 
Serviços ............................................................................................................................... 14 
Modelos de Arquiteturas .................................................................................................... 16 
Comunicação ...................................................................................................................... 18 
O modelo de referência da ISO .................................................................................................19 
O modelo TCP/IP do DoD..........................................................................................................21 
Aspectos de projeto ............................................................................................................. 23 
Modelo Cliente/Servidor..................................................................................................... 25 
Serviços de Tempo .............................................................................................................. 27 
Ramificações no Fluxo de Controle de Processos ............................................................ 30 
Mecanismos de Linguagem para Sincronização............................................................... 33 
Comunicação entre Processos....................................................................................................36 
Passagem de Mensagens ......................................................................................................................... 37 
Chamadas a Procedimentos Remotos ..................................................................................................... 40 
Transações .......................................................................................................................... 44 
Protocolo de aceitação em duas fases........................................................................................44 
Coordenação Distribuída ...........................................................................................................45 
Por disputa .............................................................................................................................................. 45 
Controlada............................................................................................................................................... 46 
Algoritmos de Eleição......................................................................................................... 48 
Acordo Distribuído ............................................................................................................. 49 
Falhas Bizantinas ............................................................................................................... 49 
Impossibilidade de Consenso .....................................................................................................51 
Consenso Distribuído Aleatório.................................................................................................51 
Escalonamento de Processos.............................................................................................. 53 
Modelos........................................................................................................................................53 
 3
Escalonamento Estático..............................................................................................................54 
Modelo de Precedência...............................................................................................................55 
Modelo de Comunicação ............................................................................................................57 
Custo de Computação.................................................................................................................57 
Custo de Comunicação ...............................................................................................................58 
Escalonamento Dinâmico...........................................................................................................58 
Algoritmos Genéticos ............................................................................................................................. 60 
Compartilhamento de Memórias Distribuídas ........................................................................61 
Arquiteturas NUMA ............................................................................................................................... 63 
Alocação, Migração e Cópia de dados ......................................................................................65 
Modelos de Consistência de Memória.......................................................................................66 
Sistemas de Memória Cache em Multiprocessadores..............................................................68 
Estruturas de Memórias Cache.................................................................................................69 
Protocolos de Coerência .............................................................................................................70 
Algoritmos de Gerenciamento de MCDs ..................................................................................71 
Localização de Dados .................................................................................................................72 
Sistemas de ArquivosDistribuídos............................................................................................73 
Implementação de Sistemas de Arquivos Distribuídos ...........................................................74 
Compartilhamento de Arquivos................................................................................................75 
Réplicas de Arquivos e Dados....................................................................................................77 
Operações de Leitura .................................................................................................................78 
Operações de Escrita ..................................................................................................................78 
Bibliografia ......................................................................................................................... 79 
 4
 
Sistemas Distribuídos 
 
Segundo Tanenbaum (tradução, página 261), um sistema distribuído é aquele que roda em um 
conjunto de máquinas sem memória compartilhada, máquinas essas que mesmo assim aparecem 
como único computador para seus usuários. 
 
Por outro lado, Chow e Johnson [1 - página 27] definem um sistema operacional (SO) distribuído 
como uma integração de serviços, apresentando uma visão transparente de um sistema com vários 
computadores, com controle e recursos distribuídos. 
 
Este curso tratará de sistemas operacionais distribuídos, cujo desenvolvimento tem sido motivado 
pela: 
- crescente necessidade de compartilhar recursos e informações; 
- redução rápida do custo de estações de trabalho; 
- proliferação do uso de redes; e 
- maturação das tecnologias de software 
 
Inicialmente será feita uma breve revisão de alguns conceitos importantes sobre sistemas 
operacionais. A seguir, serão mostradas as diferenças conceituais de quatro categorias de sistemas 
operacionais. Posteriormente, diversos aspectos de projeto de Sistemas operacionais distribuídos 
serão analisados individualmente. 
 
Um sistema operacional é um conjunto de programas que fazem a interface entre o hardware da 
máquina e seus usuários, com o objetivo de tornar seu uso mais eficiente, fácil e seguro. 
 
O hardware funciona à base de sinais elétricos, os quais são trazidos para uma simbologia binária 
de modo a facilitar o trabalho dos projetistas dos circuitos lógicos. Esta linguagem de máquinas é 
usada para escrever alguns programas, que executam certas funções básicas, as quais tornam mais 
eficiente a manipulação do hardware. Tais funções são utilizadas pelos próprios projetistas de 
sistemas operacionais para criar outras funções, um pouco mais complexas, que além de facilitar e 
tornar mais eficiente o trabalho de seus usuários, garantem que o acesso destes ao sistema não 
comprometa sua segurança, nem a dos demais usuários do sistema. 
 
As funções tratadas pelo sistema operacional são o escalonamento dos processos nos 
processadores, a coordenação da interação entre tais processos, o gerenciamento dos recursos do 
sistema, o controle de acesso a esses recursos (portanto sua proteção), a recuperação de erros e a 
interface com os usuários do sistema. 
 
Para suprir tais funções o sistema operacional fornece dois tipos de serviços, quais sejam, serviços 
de núcleo e os de sistema. Os serviços de núcleo correspondem às funções essenciais, dependentes 
da arquitetura da máquina. Os serviços do sistema correspondem às funções de alto nível 
percebidas pelos programas de aplicação. 
 
Essas funções do sistema operacional, por um lado, visam ajudar os administradores do sistema a 
gerenciarem os seus recursos, por outro lado, visam apresentar aos usuários uma máquina estendida 
mais fácil de lidar. 
 
A ênfase dos sistemas operacionais tradicionais era no aspecto administrativo, ou seja, em gerir os 
meios necessários ao uso da máquina. Já, os sistemas operacionais modernos enfatizam seus 
objetivos, isto é, visam fornecer facilidades para sua utilização. 
 
Os sistemas operacionais modernos podem ser classificados de acordo com seu grau de 
acoplamento em: centralizados, distribuídos, em rede e autônomos. Para classificá-los levam-se em 
consideração as três características seguintes: 
 5
- interoperabilidade: que é a capacidade do sistema facilitar a troca de informação entre 
componentes heterogêneos; 
- transparência: que é a capacidade do sistema fornecer uma visão lógica única ao usuário, 
independente do sistema físico disponível; e 
- autonomia: que é a capacidade dos elementos do sistema processarem tarefas 
independentemente uns dos outros, ao mesmo tempo que cooperam entre si para a 
solução de um problema. 
 
Sistemas Centralizados 
 
Os sistemas operacionais tradicionais, utilizados tanto em arquiteturas com vários processadores 
como em monoprocessadas, são centralizados. Estes sistemas são fortemente acoplados e a 
comunicação entre seus processos é feita pelo compartilhamento de memória ou por interrupções. 
Nas fases iniciais, o projeto desses sistemas visavam o controle das interfaces com os usuários e do 
sistema de entrada e saída, através de interrupções e de um conjunto de acionadores de 
dispositivos. Frente à necessidade de aumentar a eficiência do sistema de entrada e saída surgiram 
os conceitos de entrada e saída virtual e de spooling. Este correspondendo ao armazenamento 
temporário, em disco, de operações de entrada e saída, permitindo assim a minimização das 
diferenças de velocidades de processamento entre a UCP e os periféricos; e aquele correspondendo 
à abstração dos dispositivos de entrada e saída de modo que o sistema operacional possa apressá-
los como se fossem arquivos, deixando a tarefa “conversar” diretamente com os dispositivos para 
os respectivos acionadores. Com o passar do tempo a necessidade de tratar programas grandes deu 
origem ao conceito de memória virtual, o que permite o tratamento de programas, que utilizem 
espaço de endereçamento maior do que o disponível na memória real, através das técnicas de 
paginação e segmentação. A contínua necessidade de otimizar o uso dos sistemas deu origem a 
vários outros conceitos, que possibilitaram o acesso de diversos usuários simultaneamente. Tais 
conceitos incluem a multi-programação, o compartilhamento de tempo, o necessário escalonamento 
de processos, o controle de concorrência, o controle de acesso aos arquivos do sistema e a proteção 
aos arquivos compartilhados. Associado ao acesso de vários usuários está a necessidade de tratar 
diversas tarefas o que originou uma série de técnicas para viabilizar seu processamento 
concorrente, incluindo a sincronização de processos, a recuperação do sistema após bloqueios fatais 
e a comunicação entre os processos concorrentes. 
 
O sistema operacional é um sistema grande, podendo chegar a milhões de linhas de código. Este 
programa deve ser estruturado em módulos divididos vertical e horizontalmente. Cada módulo 
pode ser entendido como um conjunto de instruções necessárias para executar determinado serviço 
do sistema. Os módulos são agrupados (horizontalmente) para formar componentes funcionais. Por 
outro lado, eles são agrupados (verticalmente) em várias camadas, estrutura na qual só é permitida 
a interação entre módulos de camadas adjacentes. 
 
Todos os recursos do sistema inclusive arquivos e processos, podem ser abstraídos como objetos de 
dados sendo sua representação física “escondida” por uma estrutura de dados abstrata. 
 
O modelo de orientação a objetos possibilita uma uniformidade dos mecanismos de acesso e 
proteção de módulos do sistema. Devido, a esta uniformidade sua alteração é mais fácil, o que 
melhora a portabilidade do sistema. 
 
Contudo, os sistemas operacionais tradicionais são do tipo monolítico, nos quais não há 
particionamento do núcleo, fora a modularidade normal do código. Nos sistema monolíticos os 
serviçosdo sistema e do núcleo fazem parte de um mesmo programa. 
 
Todavia, em sistemas operacionais modernos a preocupação com a eficiência e a portabilidade é 
maior. O núcleo deve ser mínimo, restrito apenas a serviços dependentes do hardware ou àqueles 
cujo oferecimento fora do núcleo seja muito caro ou difícil. Dentre tais serviços estão os ligados ao 
 6
tratamento de interrupções, ao acionamento de dispositivos e algumas primitivas básicas para a 
sincronização e a comunicação entre processos. Módulos estes que, por serem dependentes do 
hardware, não podem ser transportados de uma máquina a outra sem serem recodificados. 
 
Serviços que tipicamente são incluídos em um núcleo mínimo são: 
- mecanismos para a comunicação entre processos; 
- algumas funções básicas para o gerenciamento de memória; 
- algumas primitivas para o gerenciamento e o escalonamento de processos em baixo nível; e 
- primitivas para o tratamento de E/S em baixo nível. 
 
As funções de um sistema operacional podem ser divididas em quatro categorias, conforme os 
recursos que gerenciam; são elas: processos e processadores, memória, entrada e saída, e dados ou 
arquivos. 
 
As funções para o gerenciamento de processos e processadores tem por finalidade básica definir 
que processos devem ser executados em cada processador do sistema e quando a execução deve 
iniciar. Elas são chamadas, respectivamente, de alocação e escalonamento. 
 
Definir quais processos devem ser executados, quando os recursos do sistema estiverem 
disponíveis e/ou certas condições forem atingidas, tem por objetivos minimizar o tempo de resposta 
dos processos e maximizar a vazão do sistema. Esta definição pode ser feita de forma estática 
levando-se em consideração as relações de precedência entre os processos, que indicam como os 
processos devem ser sincronizados. A definição pode também ser feita de forma dinâmica 
considerando-se as relações de dependência entre processos, que indicam as interações entre elas. 
 
Para permitir a coexistência de vários usuários e diversas tarefas no sistema, outras funções são 
necessárias. Há as que viabilizam a multiprogramação, responsáveis pela multiplexação espacial da 
memória onde residem os processos. Há as que viabilizam o compartilhamento do tempo, 
responsáveis pela multiplexação temporal do processador onde os processos são executados. A 
interação entre os processos necessita ainda de mecanismos para as suas comunicação e 
sincronização, o que pode ser obtido através da exclusão mútua, por exemplo. A exclusão mútua 
pode ser obtida fazendo-se chamadas ao sistema e acionando operações sobre variáveis especiais, 
chamadas semáforos, capazes de bloquear processos interativos, permitindo coordenar seu 
funcionamento. 
 
Uma forma muito usual de tratar a comunicação entre processos é por meio do compartilhamento 
de áreas de memória. Todavia, processos são geralmente assíncronos e, via de regra, não 
compartilham espaço de endereçamento. Consequentemente, a alternativa natural é a troca de 
mensagens, o que pressupõe algum tipo de sincronização. 
 
As funções para o gerenciamento de entrada e saída geralmente são fornecidas pelo sistema 
operacional via uma interface genérica, deixando para os fabricantes de periféricos o projeto dos 
acionadores e controladores desses dispositivos. Portanto, o sistema operacional enxerga 
dispositivos virtuais (arquivos lógicos) sobre os quais ele pode fazer operações apenas de escrita, 
como no caso das impressoras, apenas de leitura, como no caso dos teclados, ou de leitura e escrita, 
como no caso dos discos. 
 
As funções para o gerenciamento de memória respondem pela alocação e desalocação de memória 
para mapear o espaço lógico de endereçamento dos programas na memória física. Para tanto é 
criado um espaço de endereçamento virtual o qual permite que o tamanho do programa, mais seus 
dados e a pilha, seja maior que a memória física disponível. Isto é conseguido pela divisão do 
espaço de endereçamento lógico em páginas ou segmentos e o mapeamento destas entidades 
(páginas/segmentos) em blocos da memória física. Este mecanismo serve também para resolver 
discrepâncias entre memória em disco (geralmente de grande capacidade, mas lenta) e a principal 
(usualmente de capacidade reduzida, mas rápida). Como o compartilhamento de memória é uma 
 7
solução relativamente fácil para sincronização entre processos, muitos algoritmos foram 
desenvolvidos para este fim. Para aproveitar tais algoritmos vários autores procuram simular a 
existência de uma memória compartilhada em sistemas distribuídos, o que levanta questões como a 
consistência dos dados compartilhados e o desempenho do sistema assim estruturado. 
 
As funções para o gerenciamento de arquivos têm dois enfoques fundamentais, quais sejam, o 
acesso e o compartilhamento. De maneira genérica qualquer computação pode ser vista como 
processos operando sobre arquivos. Estes são entidades lógicas que agrupam dados e devem ser 
estruturadas e implementadas em algum dispositivo antes de serem manipuladas. 
 
As funções para manipulação de arquivos devem implementar mecanismos que garantam o acesso 
aos dados contidos no arquivo apenas a usuários autorizados protegendo-os contra uso indevido. 
Mecanismos para disciplinar o acesso garantem a integridade dos dados contidos nos arquivos são 
necessários para a sua segurança. Mecanismos de sincronização são necessários para controlar o 
acesso correspondente ao conteúdo dos arquivos, permitindo o compartilhamento dos respectivos 
dados. 
 
Sistema em Rede 
 
É um multicomputador fracamente acoplado no qual não existe qualquer tipo de controle direto de 
uma máquina sobre as outras e no qual a comunicação entre as outras máquinas é bem mais lenta 
que dentro de uma dada máquina. 
 
O objetivo principal de sistemas em rede é possibilitar o compartilhamento de seus recursos. Para 
tanto, as máquinas que compõem o sistema trocam informações via um canal de comunicação, que 
as interconecta. A principal característica explorada nestes sistemas é a sua interoperabilidade, para 
o que são necessários alguns mecanismos de suporte, tais como: protocolos de comunicação 
devidamente padronizados e interfaces comuns para sistemas de arquivos e bases de dados. Nos 
sistemas em rede a troca de informações é dividida em níveis, por exemplo: no nível de hardware 
trocam-se sinais físicos via a rede de comunicação, no de sistema operacional tem-se os serviços de 
transporte de dados que trocam grupos de bits entre si, e no nível dos usuários são trocadas as 
mensagens através de processos de alto nível que implementam a comunicação fim-a-fim orientada 
a aplicações. Os principais modelos em camada, que serão estudados mais adiante, são o RM-OSI 
da ISO e o TCP/IP do DoD. 
 
Na origem dos sistemas operacionais em rede temos o conceito de sistemas abertos, que é um 
sistema preparado para se comunicar com qualquer outro sistema aberto utilizando regras padrão 
que governam o formato, o conteúdo e o significado das mensagens enviadas ou recebidas. 
 
Neste sentido, os sistemas operacionais em rede são extensões dos sistemas centralizados que 
facilitam o compartilhamento de recursos implementando serviços de transporte para interfacear os 
processos aplicativos e a rede de comunicação. A maioria dos sistemas operacionais em rede usam 
interfaces de aplicação de alto nível, tais como soquetes ou chamadas a procedimentos remotos, 
para que o serviço de transporte possa sustentar a comunicação entre sistemas em domínios de rede 
diversos. Algumas classes de aplicações de rede são: 
- login remoto: é a capacidade do sistema permitir que um usuário use uma máquina como 
terminal de outra conectada à rede, para poder utilizar o processador e outros recursos 
associados à máquina hospedeira. Para poder fornecer este serviço a máquina hospedeira 
deve ser capaz de compreenderpacotes de dados vindos do teclado da máquina remota e 
de enviar pacotes de dados compreensíveis para o seu monitor. Esta comunicação requer 
um protocolo de redes, sendo o mais comum o telnet. 
- transferência de arquivos: é a capacidade do sistema transferir dados estruturados na 
forma de arquivos, juntamente com seus atributos, entre máquinas do sistema. Como 
parte da operação de transferência de arquivos há a necessidade do intercâmbio e da 
 8
validação de informações, tais como: atributos do arquivo, formato e fluxo dos dados e, 
controle de acesso ao arquivo. Este serviço é suportado por protocolos de transferência 
de arquivos, como o ftp. 
- mensagens: é a capacidade do sistema transferir mensagens, incluindo documentos e 
arquivos, sem a necessidade de estabelecer uma conexão em tempo real. Ao contrário da 
transferência de arquivos, as mensagens são empacotadas e somente umas poucas 
informações de controle são consideradas. Neste caso há serviços para atender 
transações comerciais em formatos específicos entre computadores com sistemas 
operacionais diversos (EDI - eletronic data interchange) e para troca de mensagens entre 
usuários de rede (correio eletrônico) que se servem de padrões como o X.400 do CCITT 
e o SMTP do DoD. 
- pesquisas em redes: é um serviço que permite a busca e a apresentação de documentos 
distribuídos entre máquinas participantes da rede. O modelo de varredura mais comum é 
o cliente/servidor, no qual um programa cliente busca objetos em sistemas servidores de 
arquivos remotos. O programa cliente mais popular é o netscape. O sistema mais usado 
é o www (world wide web) que é um modelo de dados para a ligação de documentos 
hipermídia usando apontadores (URL - universal resource locators). A comunicação 
principal com o servidor se dá através do hyper text transport protocol (http); em 
algumas ocasiões são usados também o telnet e o ftp. Os documentos são tipicamente 
escritos usando-se a hyper text markup language (html). 
- Execução remota: é a capacidade do sistema enviar mensagens para pedir a execução de 
programas em máquinas remotas. A execução remota se dá, em geral, através da 
interpretação de scripts e não pela compilação de programas, devido a dependência da 
arquitetura da máquina. Este serviço costuma ser restrito a aplicações nas quais a 
segurança do sistema não seja comprometida pela violação de proteções. Aplicações 
deste serviço incluem o uso de linguagens intermediárias para a transmissão de imagens 
compactadas. Talvez uma aplicação mais popular atualmente seja JAVA, que é uma 
linguagem orientada a objetos, derivada da C++, incorporando protocolos tais como o 
http e o ftp. Ela produz instruções compactas e independentes de máquinas, os applets, 
que são objetos que tanto podem conter URL (para apontarem/ativarem outros applets) 
como podem ser apontados por URL. 
 
 
Sistemas Distribuídos 
 
Os sistemas distribuídos representam um passo além daqueles em rede, pois, além de 
possibilitarem o compartilhamento de recursos eles viabilizam a coordenação de atividades 
distribuídas. 
 
Os recursos físicos costumam ser distribuídos geograficamente dentro das empresas, entre outras 
razões por questões como eficiência no uso de certos recursos e segurança do sistema como um 
todo. Por outro lado, os recursos lógicos estão, por sua natureza, dispersos na empresa, pois 
representam as informações que as pessoas possuem. 
 
A função de um sistema operacional distribuído é gerenciar as atividades e os recursos distribuídos, 
possibilitando um processamento descentralizado e melhorando o desempenho do sistema. 
 
A principal diferença de um sistema distribuído para um sistema em rede é sua característica de 
transparência, isto é, enquanto num sistema em rede o usuário deve manipular operações remotas 
explicitamente, o usuário de um sistema distribuído tem a impressão de estar trabalhando em um 
sistema centralizado de bom desempenho. 
 
A transparência pode ser notada em vários aspectos, alguns dos quais são exemplificados a seguir. 
 9
- transparência de concorrência é quando os usuários não têm consciência do 
compartilhamento de tempo com outros; 
- transparência de localização de programas é quando o mapeamento do programa em 
memórias e processadores é escondido do usuário; 
- transparência de acesso a arquivos é quando os arquivos podem ser armazenados em 
qualquer lugar do sistema e por ele movido sempre que conveniente sendo o acesso ao 
arquivo feito via um caminho lógico para o usuário; e 
- transparência de desempenho é quando os processos podem ser executados em qualquer 
processador e movidos dentro do sistema de acordo com suas necessidades, sem que o 
usuário perceba diferença de desempenho significativa. 
 
Para atingir estes e outros aspectos, um sistema digital deve incluir mecanismos para tratar da 
coordenação das atividades de processos distribuídos, gerenciando adequadamente o uso dos 
recursos dispersos pelo sistema, através da implementação de algoritmos distribuídos, como será 
visto mais adiante no curso. 
 
Sistemas Autônomos Cooperativos 
 
Estes sistemas mantêm as noções de transparência e interoperabilidade existentes nos sistemas 
distribuídos, mas para permitir a existência de processos autônomos capazes de exportar e solicitar 
serviços, interagindo independentemente, abolem a necessidade de passar a impressão da existência 
de um único usuário no sistema. 
 
Então, grupos de atividades podem resultar em serviços de nível mais elevado, através de 
composição de serviços mais simples. Desta forma, pode-se formar qualquer sistema de software 
integrando vários serviços por meio de certas estruturas pré-estabelecidas. 
 
Um exemplo interessante de um sistema autônomo cooperativo pode ser emprestado da robótica 
evolutiva. Neste caso, um conjunto de robôs usam técnicas de algoritmos genéticos para 
interagirem e criarem soluções para problemas propostos. Os processos devem ser distribuídos 
pelos robôs, autônomos e assíncronos. Três classes de serviços são implementadas em cada robô do 
sistema, quais sejam: auto-avaliação, seleção e reprodução. 
 
Auto avaliação consiste em métricas para medida de desempenho do algoritmo executado no 
respectivo robô. Estas métricas devem ser baseadas em parâmetros que não dependem de agentes 
ou observadores externos. Por exemplo, deve medir a energia gasta para executar certa tarefa, o que 
pode ser materializado pelo tempo necessário ou pelo número de operações necessárias. 
 
A seleção visa reconhecer indivíduos mais bem ajustados, para executar a tarefa em questão, os 
quais fornecerão genes (isto é, assumirão o papel de pais) para os menos ajustados. Estes, por sua 
vez, receberão os genes e se modificarão gerando novos entes (isto é, filhos). 
 
No processo de reprodução não há reestruturação física dos robôs, mas somente a troca de código 
do programa de controle. 
 
Para colocar em prática estes procedimentos cada um dos robôs determina o seu nível virtual de 
energia, ou seja, seu desempenho na execução da tarefa a ele atribuída. Então irradia sua 
informação genética em uma freqüência proporcional ao seu nível de energia. Esta informação 
genética contém um gene escolhido aleatoriamente do seu genoma e que passou por um processo 
de mutação. Os demais robôs podem ou não aceitar o gene irradiado. Os que aceitarem 
sobrescrevem seu gene correspondente com o gene recebido, caso contrário o gene recebido é 
simplesmente descartado. A receptividade de cada robô do sistema é inversamente proporcional ao 
seu nível de energia. 
 
 10
Robôs com nível de energia maior (melhor desempenho) tendem a disseminar mais seus genes e 
resistem mais a tentativas de reprodução dos outros. Todavia, este processo é probabilístico e não 
garante que robôs mais ajustados transfiram todos os seus genes para os menos ajustados.Algoritmos Distribuídos 
 
O principal objetivo do desenvolvimento de algoritmos distribuídos é fornecer mecanismos que 
possibilitem contornar a falta de informação global sobre o estado de um sistema distribuído. 
 
Cada processador de um sistema distribuído possui o seu relógio interno, que não é sincronizado 
com os relógios dos demais processadores, causando problemas de interação entre eles. Mesmo que 
se use um relógio global, centralizado, a propagação desta informação para os processadores do 
sistema está sujeita a atrasos diversos. Portanto, a tarefa de ordenar os eventos no sistema não é 
trivial. 
 
Além dos atrasos na comunicação, há falhas que podem tornar certas fontes de informação 
inexistentes, ou não confiáveis. O sistema necessita de algoritmos capazes de identificar e 
contornar todos os tipos de falhas, evitando situações que levem à inoperância do sistema ou, o que 
é mais grave, à sua operação defectiva. 
 
A arquitetura do sistema influi na implementação desses algoritmos. A topologia da rede (se 
completa, regular, fixa ou irregular, etc.) e o tipo de comunicação (se ponto-a-ponto ou multiponto) 
influem na sua implementação. Do ponto de vista do software a reprodução de cópias dos dados 
introduz o problema da coerência e da consistência dessas cópias, que também influi no algoritmo 
distribuído. 
 
Projeto de Sistema Operacional 
 
Ao projetar um sistema operacional distribuído deseja-se que a execução de aplicativos no sistema 
resultante tenha um retorno melhor do que em sistemas monoprocessados centralizados, que o 
sistema distribuído seja capaz de se adaptar a variações tecnológicas e a necessidades de seus 
usuários, que seu comportamento seja, uniforme e previsível, que ele seja, confiável, tolerante a 
falhas e devidamente protegido contra ações nocivas, e que os detalhes de sua implementação 
sejam escondidos do usuário final. Desta forma, pode-se dizer que os projetistas de sistemas 
operacionais distribuídos têm cinco objetivos principais, como explicados a seguir. 
 
Eficiência 
 
A resposta de um sistema operacional distribuído, ao executar um aplicativo, deve ser melhor que a 
resposta de um sistema centralizado, ou não seria razoável investir em um sistema mais caro e 
complexo, cujo desempenho fosse inferior. 
 
O desempenho de um sistema operacional distribuído pode ser medido por diversos parâmetros, 
tais como: tempo de resposta do sistema, sua vazão (o número de trabalhos executados por unidade 
de tempo), a taxa de uso do sistema (seus processadores) e de seus recursos. No caso de sistemas 
distribuídos a questão da eficiência é mais complexa que nos sistemas centralizados, em especial, 
devido aos atrasos na comunicação. 
 
Em sistemas distribuídos geograficamente o tempo para a troca de mensagens pode superar o limiar 
dos segundos. Entretanto, mesmo em sistemas fisicamente próximos, não é possível eliminar os 
atrasos na propagação dos dados. Estes atrasos podem ser agravados por eventuais sobrecargas dos 
protocolos de comunicação e pela distribuição de carga no sistema. 
 11
 
O tempo gasto na propagação dos dados (na troca de mensagens) depende fortemente do protocolo 
de comunicação utilizado, motivo pelo qual ele deve ser bem projetado, com base em primitivas de 
comunicação (tanto da linguagem quanto do sistema operacional) eficientes. 
 
O balanceamento de carga deve ser cuidadosamente calculado para se evitar gargalos e 
congestionamentos no sistema de comunicação. Sempre que possível deve-se cuidar para estruturar 
os processos distribuídos para que haja uma sobreposição de cômputos e comunicação no nível das 
aplicações visando melhorar a eficiência do sistema. 
 
A granulosidade das tarefas concorre para tal balanceamento. Processos com muitas tarefas e 
processamento interno curto, ditos de granulosidade fina, requerem muita comunicação. Processos 
com tarefas relativamente grandes, que requerem bastante processamento interno, são ditos de 
granulosidade grossa, e requerem pouca comunicação. Portanto, quanto mais fina a granulosidade 
dos processos, menores as tarefas. Com tarefas menores torna-se mais fácil a distribuição de carga 
entre os processadores. Quanto mais bem distribuída a carga de processamento, melhor a taxa de 
uso do sistema e de seus recursos. Desta forma, pode-se dizer que quanto mais fina a granulosidade 
dos processos, melhor o desempenho do sistema. Paradoxalmente, quanto mais processos 
distribuídos no sistema, maior o número de mensagens trocadas entre eles. Quanto maior o fluxo de 
mensagens, maior o tempo gasto com comunicação no sistema. Conseqüentemente, menor a vazão 
e maior o tempo que o sistema requer para produzir as respostas desejadas. Por conseguinte pode-
se inferir que quanto mais fina a granulosidade dos processos, pior o desempenho do sistema. O 
resultado disto é que a granulosidade dos processos deve ser ajustada de forma a tornar o sistema o 
mais eficiente possível. 
 
Outra questão que afeta a eficiência de um sistema operacional distribuído é sua tolerância a falhas. 
É desejável que um sistema operacional distribuído mantenha todos os processos em execução, 
ainda que algum(s) de seus componentes falhem. Para tanto, quando uma tarefa é atribuída a um 
processador ele deve comunicar isto a outro(s) processador(es) do sistema para que, caso o 
processador principal falhe, o outro possa continuar a execução da tarefa. Entretanto, isto envolve 
comunicação sem utilidade para a computação, o que reduz o desempenho geral do sistema. 
 
Flexibilidade 
 
Um sistema operacional distribuído deve ser capaz de evoluir e migar, para se adaptar a variações 
tecnológicas. Deve ser possível adicionar serviços inexistentes e remover serviços obsoletos, 
preferencialmente sem a necessidade de recompilar e reinstalar o sistema, ou seja, o sistema deve 
ser modular e escalonável. Conforme mudam as plataformas de trabalho (o hardware) é desejável 
que se possa migrar o sistema a um baixo custo, isto é, re-escrevendo e recompilando o menor 
número possível de rotinas. Para atingir esta portabilidade o núcleo do sistema deve ser o menor 
possível. Além disto, o sistema deve ter interfaces comuns para suas bases de dados e seu sistema 
de arquivos, bem como deve fazer uso de protocolos de comunicação padronizados, resultando em 
um sistema capaz de administrar um conjunto heterogêneo de máquinas. As quatro propriedades 
recém discutidas, quais sejam, escalabilidade, modularidade, portabilidade e interoperabilidade são 
de crucial importância para garantir a capacidade de adaptação do sistema. 
 
Apesar dos sistemas operacionais com núcleo monolítico reinarem absolutos, suas características 
não favorecem ao requisito de flexibilidade. Estes sistemas são compostos por um sistema 
operacional centralizado, ao qual, são acrescidas funções para operação em rede e integrados 
serviços para operação remota. Os principais exemplos são os sistemas operacionais distribuídos 
derivados do UNIX. 
 
Por isto, a maioria dos sistemas operacionais distribuídos projetados desde o início, sem utilizar 
partes de sistemas pré-existentes, adota o modelo de micronúcleo, já que este, por não fazer quase 
 12
nada, é mais flexível. Todos os serviços prestados pelo núcleo de um sistema operacional micro-
núcleo está lá por ser muito difícil ou muito caro prestá-lo fora do núcleo. Os sistemas micro-
núcleo fornecem, fundamentalmente, quatro categorias de serviços, quais sejam: 
- mecanismos de comunicação de processos 
- mínimo de funções para gerência de memória 
- mínimo de funções para gerência de processos e escalonamento; e 
- funções de entrada e saída de baixo nível. 
 
As demais funções do sistema são fornecidas fora do núcleo, através de troca de mensagens com 
este. Entre estas funções encontram-se aquelas para gerência completa de processos, as de 
manipulação de chamadas ao sistema,e os sistemas de arquivos e de diretórios. Como praticamente 
todos os serviços são fornecidos a partir de processos clientes em nível de usuário, a alteração ou a 
ampliação de serviços não implica a parada do sistema para a carga de um novo núcleo. Foi 
mostrado que mesmo a aparente vantagem que teriam os sistemas monolíticos, qual seja, a de 
apresentar um melhor desempenho por não trabalhar a base de trocas de mensagens, não existe. 
 
Consistência 
 
A operação de um sistema operacional distribuído envolve várias máquinas, muitas vezes com 
características heterogêneas, o que torna a interação entre os módulos do sistema por vezes, 
bastante complexa. Do ponto de vista do usuário, um sistema consistente deve permitir um uso 
uniforme e ter um comportamento previsível, apesar dessas possíveis características heterogêneas. 
Além disto, para garantir uma boa eficiência no uso do sistema, freqüentemente é necessário 
particionar os dados e fazer várias cópias deles. Isto requer mecanismos que viabilizem o controle 
de uso das diversas cópias, de modo a mantê-las sempre idênticas. A inexistência de informação 
sobre o estado global do sistema, bem como a ausência de um sincronismo geral, requer 
mecanismos especiais para o controle de concorrência, de forma a manter a integridade do sistema. 
Outra possível fonte de inconsistência no sistema é a possibilidade de falhas de seus componentes. 
O principal problema, neste caso, é a dificuldade, quando não a impossibilidade, de identificação 
da falha. Os três problemas mais comuns são: defeito em uma máquina, comprometimento de uma 
conexão e perda de uma mensagem. 
 
Exemplo (do Silberschatz): 
Sejam duas máquinas A e B, diretamente conectadas. Periodicamente elas enviam, uma à 
outra, uma mensagem x, indicando que estão ativas. Se, após um certo período, A não 
recebe a mensagem x de B, ela sabe que ocorreu algo, mas não sabe o que. Se enviar uma 
mensagem y para B, pela mesma conexão, e não receber resposta, continuará sem saber 
qual o erro. (se receber, provavelmente a mensagem x anterior havia se perdido). Se enviar 
a mensagem y por uma conexão alternativa e não receber resposta, novamente não tem 
como saber o que ocorreu. (se receber, provavelmente a conexão usual está com 
problemas). 
 
De qualquer forma são necessários procedimentos específicos para, adequadamente, reconhecer a 
falha, tratar os processos de forma a manter o sistema consistente e posteriormente recuperar o 
estado do sistema anterior à ocorrência da falha. 
 
Robustez 
 
Para ser robusto um sistema operacional distribuído deve estar disponível a maior parte do tempo, 
sempre apresentando dados confiáveis. Na teoria, uma das grandes vantagens de um sistema 
operacional distribuído é sua maior disponibilidade, geralmente resultante da redundância de seus 
componentes. Se um processador se mantém operante em 98% do tempo, um sistema com 4 
 13
processadores idênticos a este teria uma probabilidade de falhas de (0,02)4 = 24 x (10-2)4 = 1,6 x 10-7 
~ 0,00002%, o que corresponde a uma disponibilidade em 99,99998% do tempo. Em outras 
palavras, se o monoprocessador falha uma hora para cada 50 horas de funcionamento, o 
quadriprocessador falharia uma hora para cada cinco mil horas de funcionamento, ou seja, estaria 
cem vezes mais disponível. Evidentemente, estes números são fictícios, apenas ilustrativos, para se 
ter uma idéia da possibilidade de uma maior disponibilidade de sistemas distribuídos, em relação a 
um monoprocessador. Esta maior disponibilidade só é conseguida às custas de redundância, como 
já foi dito, o que, por sua vez, aumenta o risco de inconsistências no sistema. Falhas em canais de 
comunicação, em nós de processamento e perdas de mensagens são freqüentes em um sistema 
operacional distribuído. A robustez do sistema do ponto de vista de tolerância a falhas (sua 
confiabilidade) está vinculada à sua capacidade de reinicialização, em um estado no qual sua 
integridade seja preservada e seu desempenho seja pouco degradado. 
 
Se uma máquina falha, o sistema deve: 
- tirar esta máquina de operação; 
- transferir as tarefas que eram realizadas por ela para outra máquina; 
- reconfigurar o sistema sem a máquina falha; e 
- re-integrar a máquina ao sistema, após seu reparo. 
 
Tudo sem que os usuários percebam mais que uma, possivelmente pequena, variação no 
desempenho geral do sistema. 
 
Mesmo sem falhas explícitas, um sistema robusto deve poder tratar situações especiais e erros, tais 
como, mudanças na sua topologia, longos atrasos em mensagens ou a impossibilidade de localizar 
um servidor. Em outras palavras, deve ser capaz de controlar o acesso aos elementos do sistema. 
 
Finalmente, a robustez de um sistema também diz respeito aos mecanismos de proteção existentes, 
isto é, deve poder garantir a segurança das informações nele contidas, resguardando sua 
integridade, bem como a confidencialidade dos dados dos usuários do sistema. 
 
Transparência 
 
Segundo Leslie Lamport: “um sistema distribuído é aquele no qual eu não posso fazer meu 
trabalho, pois, uma máquina que eu não conheço, não sei onde está e sobre a qual nunca ouvi falar, 
encontra-se fora do ar”. 
 
Para evitar este tipo de reação, os projetistas de sistemas operacionais distribuídos enganam a 
todos, fazendo com que um conjunto de máquinas seja visto pelos usuários como se fosse um 
sistema único, de tempo compartilhado. Neste contexto, pode-se dizer que transparência de um 
sistema operacional distribuído é sua capacidade de, por assim dizer, esconder dos usuários 
detalhes da implementação do sistema, em particular aqueles mais complexos (dependentes da 
máquina), na medida do possível apresentando aos usuários um modelo lógico da máquina como 
eles gostariam de operar e não como ela é realmente. 
 
Portanto, através do uso do conceito de transparência deve-se apresentar ao usuário o sistema mais 
simples possível sem, contudo, comprometer sua eficiência. 
 
A idéia de propiciar ao usuário um sistema lógico mais amistoso que o sistema físico, 
minimizando a necessidade dos usuários tomarem ciência do sistema físico, é análoga aos 
conceitos de virtualidade em sistemas convencionais e de abstração em linguagens de 
programação. 
 
Na página 30 do Chow & Johnson há definições de 10 aspectos de transparência, transcritos a 
seguir: 
 14
- Access transparency refers to the ability to access both local and remote system objects 
in a uniform way. The physical separation of system objects is concealed from the user. 
- Location transparency means that users have no awareness of object locations. Objects 
are mapped and referred to by logical names. This is sometimes called name 
transparency. 
- Migration transparency is an added property of location transparency where an object 
is not only referred to by its logical name but can also be moved to a different physical 
location without changing the name. Migration transparency is also called location 
independence. 
- Concurrency transparency allows the sharing of objects without interference. It is 
similar to the time-sharing concept in a broader sense. 
- Replication transparency exhibits consistency of multiple instances (or partitioning) of 
files and data. It is closely related to currency transparency but is treated separately 
since files and data are special objects. 
- Parallelism transparency permits parallel activities without users knowing how. Where, 
and when these activities are carried out by the systems. The parallelism might not be 
explicitly specified by the users. 
- Failure transparency provides fault tolerance such that failures in the system can be 
transformed into graceful system performance degradation rather than disruptions, and 
damage to the users is minimized. 
- Performance transparency attempts to achieve a consistent and predictable (not 
necessaryequal) performance level even with changes of the system structure or load 
distribution. In addition, the users should not experience excessive delays or variations 
in remote operations. 
- Size transparency is related to modularity and scalability. It allows incremental growth 
of a system without the user’s awareness. The size of the system has no effect on the 
user’s perception of the system. 
- Revision transparency refers to the vertical growth of system as opposed to the 
horizontal growth in system size. Software revisions of the system are not visible to 
users. 
 
Objetivos do sistema 
operacional distribuído 
Eficiência Flexibilidade Consistência Robustez 
 
 
Transparências 
 
Concorrência 
Paralelismo 
Desempenho 
Acesso 
Localização 
Migração 
Tamanho 
Revisão 
 
Acesso 
Replicação 
Desempenho 
Falha 
Replicação 
Tamanho 
Revisão 
 
 
Serviços 
 
Um sistema operacional é um provedor de serviços. 
 
Serviços Primitivos: serviços fundamentais, os quais devem ser implementados no núcleo. 
- comunicação: primitivas send/receive (passagem de mensagens) 
- sincronização: semântica de comunicação ou servidor de sincronização. 
- servidor de processos: criação, eliminação e rastreamento de processos, alocando 
recursos tais como memória e tempo. 
 
Os servidores de processos interagem via primitivas de sincronização e comunicação para garantir 
a transparência do sistema. 
 
 15
Serviços de Sistema: serviços que podem ser implementados em qualquer lugar do sistema, mas 
que ainda desempenham funções básica da operação do sistema. 
- Servidor de nomes: mapeamento de nomes lógicos em endereços físicos. Relacionando-
os com usuários, processos e máquinas. 
- Servidor de diretórios: relacionado com arquivos e portas de comunicação. 
- Servidor de rede: traduz e seleciona caminhos e faz roteamento da informação. 
- Servidor de tempo: relógios lógicos ou físicos, necessário para ordenação dos eventos. 
- Servidores de arquivos e de impressão. 
 
Serviços de Valor Agregado: são serviços não essenciais na implementação de um sistema 
distribuído, mas que são úteis no suporte a aplicações distribuídas. 
- servidor de grupos 
- servidor de web 
 
 16
Modelos de Arquiteturas 
 
De forma abstrata os modelos de arquitetura de sistemas distribuídos podem ser definidos com base 
em três entidades que são fundamentais para o seu funcionamento, quais sejam: 
- Arquivos, que são todos os conjuntos de dados que podem sofrer manipulação dentro do 
sistema. 
- Processos, que são todos programas em execução, os quais são responsáveis pela 
mudança de estado do sistema. 
- Portas, que são os caminhos disponíveis para a comunicação de dados entre os diversos 
processos do sistema. 
 
Os arquivos e os processos residem em estações de trabalho e trocam informações através de uma 
rede de comunicação. A forma como as estações de trabalho e a rede de comunicação são 
estruturadas define a arquitetura do sistema distribuído. Todavia, o usuário não se preocupa com o 
sistema físico propriamente dito, salvo com seu custo, com a aparência de alguns de seus 
componentes e com o desempenho geral do sistema, ainda que este nem sempre seja determinado 
pelo seu hardware. 
 
De qualquer forma, tem-se processos no sistema que utilizam serviços fornecidos por outros 
processos. Dependendo de especificidades geográficas ou características de desempenho 
necessárias, algumas estações de trabalho do sistema podem ser dedicadas à prestação de certos 
serviços especiais. As demais estações podem servir preferencialmente para processamento local, 
como um computador de uso exclusivo para determinado usuário, e ocasionalmente interagir, via 
malha de comunicação, com as demais estações que compõem o sistema distribuído. Há também o 
caso de estações sem disco, que servem apenas como terminais de servidores remotos e que 
dependem em tudo dos serviços prestados pela rede, inclusive para inicialização (boot). Este 
modelo é chamado de estação-servidor (wokstation-server) e pode ser esquematizado como 
apresentado na Figura 1. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O caso do modelo estação-servidor apresenta uma série de vantagens, como a possibilidade de 
realizar ao menos parte do processamento localmente. Desta forma, o volume de comunicação 
gerado no sistema é relativamente pequeno e o dimensionamento da malha de comunicação pode 
ser relaxado. Conseqüentemente, o custo do sistema é reduzido neste quesito. Por outro lado, o uso 
Portas de 
Estações 
Servidores 
dedicados 
E
s
t
a
ç
õ
e
s 
 
S
e
r
v
i
d
o
r
a
Figura 1 – Modelo Estação-Servidor 
 17
de processamento localizado faz com que a maioria das estações estejam ociosas ao longo do 
tempo. Uma solução para este problema é concentrar todo o poder de processamento do sistema e 
deixar os usuários apenas com terminais, cuja inteligência se restrinja ao hardware/software 
necessários ao funcionamento eficiente do terminal de vídeo e da interface com a rede de 
comunicação. Neste caso, todo o restante do processamento é fornecido por um conjunto de 
processadores com base na demanda real dos usuários do sistema. Este modelo é dito poço de 
processadores (processor-pool) e pode ser esquematizado como mostrado na Figura 2. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Entretanto, se por um lado a utilização de um reservatório com processadores, no qual é realizado 
todo o processamento do sistema, otimiza o uso dos processadores, por outro lado, aumenta 
consideravelmente a sobrecarga na malha de comunicação. Resultados gerais mais adequados 
talvez possam ser obtidos por intermédio de um modelo híbrido, no qual há estações de trabalho 
com capacidade de processamento local as quais, formam um reservatório de processamento 
distribuído geograficamente. Os processos sendo executados em qualquer dessas estações podem 
migrar para outras estações que estejam ociosas ou com carga de trabalho menor. Esta migração 
deve ser controlada por alguma estratégia de compartilhamento de carga pré-definida para o 
sistema. 
 
Terminais 
Portas de 
Servidores 
dedicados 
Poço de 
processadore
Figura 2 – Modelo Poço de Processadores
 18
Comunicação 
 
Como o desempenho de um sistema distribuído está diretamente ligado à possibilidade de migração 
dos dados, sua rede de comunicação tem papel muito importante. Esta rede engloba elementos 
físicos utilizados na interconexão dos equipamentos e protocolos para disciplinar a comunicação 
entre os processadores. 
 
A Comunicação pode ser feita ponto-a-ponto, quando se estabelece uma ligação direta entre um par 
de processadores, ou multi-ponto, quando um conjunto de processadores é interligado através de 
um barramento ou chaves eletrônicas. 
 
Os barramentos são mais baratos, mas permitem apenas o compartilhamento no tempo. Já, as 
chaves, embora formem um sistema mais caro e complexo, possibilitam não somente a 
multiplexação no tempo como também no espaço. 
 
As redes de comunicação locais são restritas ao âmbito de empresas e geralmente têm um raio de 
abrangência de alguns poucos quilômetros. Estas redes normalmente utilizam a interconexão por 
algum tipo de barramento e fundamentam sua comunicação em protocolos, como o padrão 802.X 
do IEEE, como é o caso das redes Ethernet, token bus, token ring, FDDI (fiber distributed data 
interface) e DQDB (distributed queue dual buses). 
 
Por outro lado, as redes dos serviços públicos de comunicação utilizam a ligação por chaves de 
barramentos cruzados ou de múltiplos estágios. Estas redes, incluem o ISDN (integrated services 
digital network), o SMDS (switched multimegabit data service) e o ATM (asynchronous transfer 
mode). O roteamento que no caso anterior é feito pela análise das mensagensque circulam no 
barramento, neste caso é feito pela programação das chaves que compõem a rede. 
 
A comunicação em sistemas distribuídos se dá em camadas, buscando propiciar a comunicação 
entre entidades de um mesmo nível (peer-to-peer). Por exemplo, usuários do sistema precisam 
trocar mensagens para se comunicar e devem ter a impressão de estarem falando diretamente um 
com o outro. Entretanto, como a distância não permite eles fazem uso do sistema. Para tanto, sem 
que o usuário perceba, o serviço do sistema que o atende passa a mensagem desejada para uma 
máquina hospedeira, a qual estabelecerá um canal de comunicação com uma máquina remota, 
servidora do interlocutor, a qual, por sua vez, providenciará para que a mensagem chegue ao seu 
destino. Contudo, as máquinas também não são capazes de se comunicarem a distância. Para que 
isto ocorra elas devem utilizar portas de comunicação, as quais encapsularão as mensagens das 
máquinas servidoras e estabelecerão uma comunicação ordenada através do sistema físico de 
comunicação. Neste rápido exemplo introdutório pode-se notar que foram estabelecidos três níveis 
(ou camadas) de comunicação, quais sejam: o de troca de mensagens entre os usuários; o de 
comunicação entre as respectivas máquinas hospedeiras; e o de coordenação pelas portas do 
sistema de comunicação. 
 
Mundo real Telefonemas Cartas 
Sistemas de comunicação 
computacional 
Orientando a conexão 
 
Sem conexão 
Exemplo de aplicações Transferência de arquivos Divulgação do estado do 
sistema 
Nível de rede circuito virtual Datagramas 
Nível de hardware Chaveamento de circuito Chaveamento de pacotes 
 
As estruturas em camadas referidas no parágrafo anterior são chamadas de protocolos de 
comunicação. Protocolos de comunicação são conjuntos de regras que regulam a troca de 
mensagens, para prover um fluxo de informação ordenado e confiável, entre os processos 
comunicantes. Nos protocolos, camadas inferiores fornecem serviços usados para comunicação 
 19
entre camadas imediatamente superiores. Os principais protocolos são, como foi dito 
anteriormente, o RM-OSI da ISO e o TPC/IP do DoD. A seguir eles são descritos mais 
detalhadamente. 
 
O modelo de referência da ISO 
 
Em 1977, sentindo a necessidade de padronizar a conexão de sistemas computacionais 
heterogêneos, a International Standards Organization (ISO), através de seu comitê técnico de 
processamento de dados (TC97), criou um subcomitê (SC16), para estudar o problema. No ano 
seguinte, o SC16 apresentou uma proposta, aceita pelo TC97 em 1979. Esta proposta foi chamada 
de reference model for open system interconnection (RM-ISO) e foi aprovado como padrão 
ISO7498 em maio de 1983. Em setembro do ano anterior, o RM-OSI foi adotado como 
recomendação X.200 pelo CCITT. Este modelo é dividido em sete camadas, contemplando 
diversos níveis de abstração de um sistema distribuído, desde o nível físico até o de aplicações 
voltadas para o usuário. A seguir, apresenta-se uma descrição sucinta das sete camadas que 
compõem o RM-OSI. 
 
A camada mais baixa do RM-OSI é a física. Ela é a responsável pela interface entre os nós da rede 
e o meio físico de transmissão. Portanto, nela existe a preocupação com a transferência de bits 
(unidade de dados desta camada) diretamente através de uma conexão física. Desta forma, há um 
interesse especial na definição das características elétricas, mecânicas e funcionais necessárias para 
a transferência adequada de informações. Algumas características elétricas consideradas são a 
amplitude, o período e a freqüência dos sinais, o esquema de modulação e o modo de operação 
usados. Dentre as características mecânicas estão o número de pinos usados nos conectores, o 
tamanho dos conectores e de seus pinos, bem como a distribuição destes naqueles. Já as 
características funcionais têm a ver com os procedimentos necessários para o estabelecimento e o 
encerramento de conexões, por exemplo. Resumindo: Na camada física a preocupação recai sobre 
as características elétricas, mecânicas e funcionais necessárias para ativar, manter e desativar 
conexões físicas para a transmissão de bits entre nós da rede. 
 
A camada seguinte é a de enlace de dados. Uma vez que a camada física trata apenas da 
transmissão de seqüências de bits, a camada de enlace é a primeira do RM-OSI a dar alguma 
atenção ao significado de tais bits. Nesta camada, a unidade de dados é o quadro. Os quadros são 
compostos por conjuntos de bits, normalmente uns poucos milhares. A camada de enlace é a 
principal responsável pela transmissão confiável dos quadros. Para tanto, ela deve ser capaz de 
detectar e possivelmente corrigir erros que aconteçam eventualmente, o que é viabilizado pela 
inclusão de alguns bits de controle nas extremidades dos quadros, os quais permitem a 
identificação de seus limites e o tratamento dos erros. Como existe a possibilidade de perda de 
quadros durante a transferência, esta camada deve oferecer mecanismos que permitam o 
reconhecimento dos quadros corretos e a retransmissão dos incorretos e dos faltantes. Neste caso, 
como é possível a recepção de quadros duplicados, a camada de enlace deve estar apta a identificar 
esta situação. Em resumo: A camada de enlace de dados deve oferecer um serviço de transferência 
confiável de dados entre os nós da rede, suportada pela camada física subjacente. 
 
A camada de rede é a terceira no RM-OSI. A função principal desta camada é controlar o 
funcionamento da malha de comunicação. Ela é responsável pelo estabelecimento e pela 
manutenção do fluxo de pacotes através da rede. Devido a uma falta de consenso no âmbito da 
ISO, foram adotados dois tipos de serviços oferecidos por esta camada, quais sejam: circuitos 
virtuais e datagramas. Como não há necessidade de uma ligação física direta entre os usuários, uma 
tarefa importante desta camada é o roteamento de pacotes. Outras questões relativas ao tráfego são 
o tratamento de congestionamentos, o controle da vazão e a contabilidade dos serviços. 
Congestionamentos ocorrem quando um nó da rede é forçado a trabalhar no seu limite de 
capacidade, causando um engarrafamento das informações que por ela trafegam. O controle de 
vazão refere-se ao controle do desequilíbrio entre as velocidades de transmissão de um nó e de 
 20
recepção de outro. A contabilidade deve-se à necessidade de contagem dos pacotes enviados pelos 
diversos usuários, de maneira a produzir informações que permitam a cobrança dos serviços 
prestados. Em suma: a camada de rede é responsável pelo controle das operações de comunicação 
da rede, incluindo o empacotamento de mensagens, o roteamento dos pacotes e o controle de fluxo. 
 
O RM-OSI tem como quarta camada a de transporte. Esta camada inicia uma mudança de ênfase da 
ISO. Inicialmente, preocupada com as funções de hardware e software necessárias para garantir a 
transmissão adequada de pacotes, quadros e bits, a partir desta camada a ISO passa a dirigir sua 
atenção às funções mais voltadas à garantia de uma transferência de dados entre os usuários finais, 
sem que estes tenham que preocupar com detalhes de operação da rede em níveis mais baixos de 
abstração. A função básica desta camada consiste da eventual necessidade de divisão das 
mensagens oriundas da camada superior em pacotes e do envio destes à rede, garantindo sua 
transmissão adequada e sua chegada correta ao destinatário desejado. Nesta camada a ISO define 
apenas serviços orientados a conexão. Portanto, ela pode ser bastante simples se a camada de rede 
oferecer um serviço de circuitos virtuais, mas será bastante mais complexa se o serviço oferecido 
pela camada de rede for do tipo datagrama. Pode-se usar qualquer dos três tipos de 
correspondências entre as conexões de sessão e de transporte. Entretanto, tudo deve ser feito de 
modo que as camadas superiores fiquem isoladas das trocas inevitáveis na tecnologiade hardware 
subjacente. A camada de transporte é a primeira realmente fim-a-fim, isto é, as camadas inferiores 
têm, digamos, consciência de que suas unidades de dados passam por vários nós intermediários 
antes de chegarem ao seu destino, já, do ponto de vista das camadas superiores, as mensagens vão 
diretamente da fonte ao destino, sem a intervenção de elementos intermediários. Sintetizando: a 
camada de transporte controla a transferência de dados do sistema-fonte ao sitema-destino, através 
do estabelecimento, da manutenção e da liberação de conexões bidirecionais entre um par de 
entidades de sessão, para aliviar as entidades das camadas superiores das tarefas de transporte de 
dados entre elas. 
 
A camada seguinte é a de sessão. Nesta camada há uma maior preocupação com as aplicações 
propriamente ditas, do que com a mera comunicação. Esta camada administra a sessão, unindo e 
desunindo duas entidades para relacionamento. Para isto, verifica a autenticidade das entidades que 
desejam se comunicar. Desta forma, serve de interface entre os usuários e a rede. Controla a troca 
de dados, delimita e sincroniza as operações sobre estes dados e decide sobre o tipo de 
comunicação a ser usado (simplex, semi-duplex ou duplex). Em síntese: a camada de sessão 
organiza e sincroniza o diálogo e gerencia a troca de dados entre duas entidades da camada de 
apresentação. 
 
A próxima camada na hierarquia do RM-OSI é a de apresentação. Esta camada ocupa-se da 
interpretação da sintaxe dos dados, transformando-os e formatando-os sempre que necessário, para 
resolver problemas de diferenças entre as sintaxes dos diversos sistemas interligados. Nesta camada 
são usadas técnicas de compressão de dados, para reduzir o número de bits transmitidos, e de 
criptografia, para aumentar a privacidade na transferência destes. Resumindo: a camada de 
apresentação visa gerenciar as estruturas de dados abstratas (como letras, números e símbolos) 
convertendo-as da representação interna ao computador, para aquela na rede e vice-versa. 
 
A camada de aplicação é a mais alta do RM-OSI. Todas as outras camadas existem para dar suporte 
a esta. Seus serviços são diretamente observados pelos usuários. As entidades desta camada são 
janelas que viabilizam a representação de cada usuário final, dentro da rede. As funções desta 
camada são totalmente dependentes das aplicações. Alguns exemplos clássicos de aplicações são: 
- terminais virtuais: fazem a conversão de informações transferidas entre dois terminais de 
modo a possibilitar sua legibilidade em ambos, independentemente de suas diferenças 
físicas; 
- transferência de arquivos: faz a conversão do conteúdo dos arquivos transferidos entre 
dois equipamentos de forma a compatibilizar as diferenças de representação existentes, 
oferecendo mecanismos básicos para a manipulação de arquivos a distância, como 
abertura, edição e fechamento de arquivos; 
 21
- tratamento de mensagens: permite a preparação, disseminação (remessa e recebimento) e 
o armazenamento de mensagens ou arquivos, entre os usuários, incluindo-se neste 
serviço o correio eletrônico o teletexto e o facsímile; e 
- Submissão remota de tarefas: serviço que permite submeter tarefas a máquinas 
diferentes, utilizando sistemas operacionais distintos, compartilhando recursos e 
capacidade de processamento, de forma transparente. 
 
O modelo TCP/IP do DoD 
 
Em dezembro de 1969 o departamento de defesa (DoD – Department of Defense) norte americano 
colocou em operação a rede Arpanet. Inicialmente consistia de quatro nós, chamados de IMPs 
(Inerface Message Processors). Originalmente, os IMPs eram minicomputadores Honeywell DDP-
516, com memória de 12k palavras de 16 bits. Atualmente, constitui-se de muitos milhares de IMPs 
espalhados pelo mundo todo. Como a Arpanet é anterior ao RM-OSI, ela não segue esta 
padronização. Contudo, ela possui protocolos que correspondem, aproximadamente, às camadas do 
modelo da ISO. Com o passar do tempo e com sua internacionalização, a Arpanet deu origem à 
Internet e os protocolos de comunicação nela utilizados passaram a ser conhecidos pela sigla 
TCP/IP, correspondente às duas camadas principais do conjunto de protocolos da Arpanet, como 
será visto em seguida. 
 
O nível físico não é definido pela Arpanet pois baseia-se em ligações telefônicas alugadas. Vista 
em âmbito da Internet, sua camada física corresponde àquelas das redes locais a ela conectadas. O 
protocolo mais baixo, IMP-IMP, é uma mistura aproximada das camadas dois e três do RM-ISO, 
incluindo um mecanismo de roteamento bastante elaborado e um mecanismo para a verificação da 
recepção pelo IMP-destino, de cada pacote enviado pelo IMP-fonte, o que não existe no ambiente 
da ISO. 
 
A camada de rede é chamada, na Arpanet, de IP (Internet Protocol), sendo um serviço do tipo 
datagrama, projetado para ligar um vasto número de redes locais e de longa distância. À camada de 
transporte corresponde o TCP (Transmission Control Protocol), que embora eqüivalha, 
genericamente, ao modelo da ISO, pouco tem em comum com aquele, no que se refere a formatos e 
demais detalhes. As camadas de sessão e apresentação inexistem na Arpanet, já que sua falta nunca 
foi sentida nestes mais de 30 anos de funcionamento. Também, não existe uma camada de 
aplicação propriamente dita, como entendida no âmbito do RM-OSI. O que existe é uma série de 
serviços oferecidos por meio de vários protocolos bem estabelecidos, tais como: o ftp (file transfer 
protocol) para transferência de arquivos; o SMTP (simple mail transfer protocol) para correio 
eletrônico; e o telnet (terminal emulation) para terminais virtuais. A Figura 3 mostra a arquitetura 
básica do modelo TCP/IP do DoD, em comparação com a RM-OSI/ISO. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 22
 
 
 
 
 
 
 
 
aplicação 
apresentação 
sessão 
transporte 
rede 
enlace 
física IEEE 802 X.25 outros 
IMP 
IP 
TCP 
ftp smtp telnet outras 
RM-OSI da ISO TCP/IP do DoD 
Figura 3 – Comparação entre o RM-OSI da ISO e o TCP/IP do DoD 
 23
Aspectos de projeto 
 
De modo geral, um sistema distribuído pode ser visto como um conjunto de processos que são 
executados de forma concorrente, cada um dos quais acessando um sub-conjunto de recursos do 
sistema por meio de um mecanismo que envolve a troca de mensagens através de uma malha de 
comunicação a qual, nem sempre, é confiável. A partir desta observação pode se identificar uma 
série de aspectos, que devem ser considerados durante o projeto desses sistemas. 
 
O primeiro desses aspectos conduz à questão da identificação e da modelagem dos objetos no 
sistema. Tais objetos são os processos, os arquivos, a memória, os dispositivos periféricos, a rede 
de comunicação e os processadores. A cada objeto do sistema é associado um conjunto de 
operações que possibilita o acesso a ele. Para organizar tal acesso, a cada objeto é associado um 
processo, o qual fica de responsável pela manipulação do objeto. Esses processos que gerenciam o 
acesso aos objetos são as únicas entidades visíveis no sistema digital e são chamados de servidores 
dos respectivos objetos. Eles são ditos as únicas entidades visíveis, porque quando um processo 
qualquer precisa que algum serviço seja executado por outro objeto do sistema ele o solicita 
enviando uma mensagem de requisição ao servidor do objeto. Este recebe as requisições vindas de 
diversos processos do sistema, organiza-as e aciona o objeto adequado no seu devido tempo. Após 
a execução da tarefa solicitada, ele retorna a resposta ao processo que originou o pedido. Portanto, 
em um sistema digital há servidores de processos, servidores de arquivos, servidores de rede, 
servidores de impressão, e assim por diante. 
 
Por outro lado, os objetos podem residir nas mais diferentes partes do sistema e a referência a cada 
um deles deveser inequivocamente distinguida. A identificação dos objetos pode ser feita por 
nome, que é mais fácil e intuitiva, por endereços, que é mais precisa e contém informação 
estrutural embutida, e por serviços, que é pouco usada. 
 
Como foi mencionado anteriormente, do ponto de vista dos elementos do sistema, a rede de 
comunicação pode ser abstraída por suas portas. Estas portas correspondem a endereços lógicos de 
objetos no sistema. Num nível de abstração mais elevado estes endereços lógicos são associados a 
nomes de objetos do sistema distribuído. Ao contrário, num nível de abstração mais baixo os 
endereços lógicos correspondem a endereços físicos dos objetos. Os processos responsáveis pelo 
mapeamento de nomes em endereços lógicos do sistema, e vice-versa, são chamados de servidores 
de nomes e os processos responsáveis pelo mapeamento entre endereços lógicos e físicos são ditos 
servidores de rede. 
 
Outro aspecto relevante do projeto de um sistema distribuído diz respeito ao modo como é feita a 
coordenação da interação entre os objetos do sistema e como eles fazem para se comunicar. Para 
que eles possam interagir é necessário sincronizar o funcionamento dos objetos, caso contrário 
corre-se o risco de solicitar algo a determinado objeto quando ele não é mais capaz de executar a 
tarefa solicitada ou de receber informações de objetos quando esta não faz mais sentido para o 
objeto que a solicitou. O grande problema para a sincronização em sistemas digitais é a ausência de 
conhecimento sobre o estado global do sistema. Portanto, é necessário impor certos requisitos para 
a sincronização, tais como: 
- Barreira de Sincronização: um conjunto de processos deve atingir um ponto de 
sincronização comum antes de continuar. 
- Condição de coordenação: um processo deve esperar por uma condição que outro 
processo iterativo ajustará assincronamente, para manter uma ordem de execução. 
- Exclusão Mútua: processos concorrentes devem ter acesso exclusivo a certos recursos 
compartilhados do sistema. 
 
Além disto, o uso de mecanismos para prevenir e evitar bloqueios fatais, isto é, a ocorrência de 
uma espera circular de processos por objeto do sistema, mesmo atendendo aos requisitos de 
sincronização mencionados, pode não ser praticável. Às vezes, até mesmo a detecção e a 
recuperação do sistema após a ocorrência de um bloqueio fatal não é trivial, devido à falta de 
 24
conhecimento sobre o estado global do sistema. Uma forma de contornar este problema é 
utilizando protocolos de entendimento. Tais protocolos usam algoritmos com troca de mensagens 
contendo informações sobre estados locais do sistema, para atingir um consenso sobre seu estado 
global. 
 
A comunicação no sistema, que em seu nível mais baixo se dá através de mecanismo de troca de 
mensagens, em seus níveis mais altos, para atingir a transparência desejada no sistema distribuído, 
lança mão de modelos como cliente/servidor e chamadas a procedimentos remotos. Estes modelos 
usam o conceito de solicitação de serviços a servidores do sistema em moldes semelhantes aos 
usados para fazer chamadas a rotinas, das quais recebem os resultados. 
 
Resolvida a questão do compartilhamento, ou da multiplicação de cópias dos objetos, vem à baila a 
questão de como gerenciá-los de forma controlada e como distribuir a carga de processamento pelo 
sistema. 
 
Como a memória está distribuída pelos processadores do sistema, deseja-se manter a transparência 
apresentando-a ao usuário como uma grande memória compartilhada sem sobrecarregar o sistema 
de comunicação de forma significativa. Além disto, os protocolos de comunicação utilizados 
devem manter a consistência dos dados compartilhados e a coerência dos dados para os quais 
existam várias cópias no sistema, sempre considerando que há uma migração dos processos pelo 
sistema. Por sua vez, a carga de processamento pode ser distribuída estática ou dinamicamente. 
 
No primeiro caso, a distribuição estática, é dita escalonamento e visa minimizar o tempo necessário 
para completar as tarefas de um conjunto de processos. O principal problema a ser equacionado é 
uma forma de reduzir este tempo, mantendo o mínimo de sobrecarga no sistema de comunicação. 
 
No segundo caso, a distribuição dinâmica, é dita compartilhamento de carga e visa maximizar o 
uso de um conjunto de processadores. O principal desafio aqui é ajustar os mecanismos que 
implementam a estratégia considerada mais adequada para efetuar a migração dos processos. 
 
Finalmente, há o aspecto de como proteger os objetos do sistema e garantir sua segurança. A 
segurança de um sistema distribuído está sempre ameaçada, porque o sistema é aberto, isto é, 
permite o acesso de vários usuários, em certos casos e com certas restrições, mesmo usuários não 
cadastrados podem acessar o sistema. Alguns usuários podem violar intencionalmente a segurança 
do sistema, causando problemas para os demais. Todavia, há também os problemas causados aos 
sistema pelo seu mau uso, não intencional, provocando falhas no sistema. O problema da 
ocorrência de falhas no sistema pode ser amenizado pelo emprego de objetos redundantes no 
sistema. Já a questão da segurança passa pela autenticação e autorização dos usuários do sistema. A 
autenticação requer a identificação correta de clientes, serviços e mensagens que circulam no 
sistema. A autorização tem a ver com o controle de acesso à rede física, controle este que é 
dificultado por lidar com computadores heterogêneos, sujeitos administrações de características 
diversas e, por conseguinte, usando modelos de segurança diferentes. 
 
 25
Modelo Cliente/Servidor 
 
O modelo cliente/servidor é um paradigma de programação, que representa as interações entre 
processos e estruturas do sistema. Este modelo pode ser usado para melhorar a estrutura do sistema 
operacional, movendo-se a maior quantidade possível de funções para níveis mais altos do sistema, 
reduzindo o tamanho do núcleo. 
 
Processos do sistema são chamados de clientes, quando usam serviços, e de servidores, quando 
fornecem serviços. Para pedir um serviço um processo cliente solicita-o a um processo servidor o 
qual, após realizar o serviço solicitado, envia a resposta ao cliente. Desta forma, o núcleo precisa 
apenas gerenciar a comunicação entre clientes e servidores. 
 
Como tudo o que o usuário percebe é a comunicação lógica entre cliente e servidor, este modelo 
facilita a implementação do conceito de transparência. 
 
O modelo cliente/servidor não é baseado no estabelecimento de uma conexão. Portanto, pode ser 
implementado sobre um canal de comunicação real por passagem de mensagens. Tudo que deve ser 
implementado no núcleo são as primitivas de comunicação send e receive, não importando se o 
serviço de transporte utilizado é ou não orientado a conexão, ou se a mensagem é transferida para 
um servidor na mesma máquina ou em uma máquina remota. 
 
A simplicidade deste modelo é tal que, para maior eficiência, pode ser implementado sobre um 
protocolo que corresponde apenas às três camadas inferiores do modelo OSI. Tamanha é a 
simplicidade do modelo que a própria resposta do servidor é usada como confirmação do 
recebimento da solicitação. 
 
As primitivas de comunicação podem ser classificadas segundo três critérios, quais sejam: o estado 
em que ficam os processos durante a transmissão de uma mensagem, a forma como as mensagens 
são disponibilizadas, e a confiabilidade do mecanismo de troca de mensagens. 
 
De acordo com o primeiro critério as primitivas podem ser classificadas em bloqueadoras, quando 
o processo fica paralisado durante a transmissão da mensagem, e não bloqueadoras, quando o 
processo fornece uma cópia da mensagem ao sistema de comunicação, por ocasião da solicitação 
do serviço, e segue seu processamento, enquanto o sistema de comunicação se encarrega de tratar 
da solicitação. 
 
De acordo