Sistemas Operacionais

Prévia do material em texto

1 
Arquitetura de Sistemas Operacionais 
 
 
1. Histórico ............................................................................................................ 3 
 
2. Tipos de Sistemas Operacionais ..................................................................... 4 
2.1 Sistemas Monoprogramáveis ..................................................................... 4 
2.2 Sistemas Multiprogramáveis ..................................................................... 5 
2.2.1 Sistemas Batch ..................................................................... 6 
2.2.2 Sistemas de Tempo Compartilhado ........................................ 7 
2.2.3 Sistemas de Tempo Real ........................................................... 7 
2.3 Sistemas Multiprocessados ..................................................................... 8 
 
3. Sistemas Multiprogramáveis ............................................................................... 10 
3.1 Tratamento de Interrupções e Exceções .................................................. 11 
3.2 Buffer ................................................................................................... 12 
3.3 Spool ................................................................................................... 12 
3.4 Reentrância ......................................................................................... 13 
3.5 Segurança e Proteção do Sistema ............................................................ 14 
3.6 Operações de E/S ................................................................................ 17 
 
4. Estrutura do Sistema Operacional ...................................................................... 17 
4.1 Estrutura do Sistema ................................................................................ 17 
4.2 Funções do Sistema ................................................................................ 18 
4.3 System Calls .......................................................................................... 19 
4.4 Modos de Acesso ................................................................................ 20 
4.5 Arquiteturas: Sistemas monolíticos, em camadas e microkernel ...................... 21 
 
5. PROCESSO .................................................................................................... 24 
5.1 Componentes do processo ....................................................................... 24 
5.2 Estados do processo ................................................................................. 26 
5.3 Mudanças de estado ................................................................................. 27 
 5.4 Tipos de processo ................................................................................. 28 
 
6. Gerência do Processador ........................................................................................ 29 
6.1 Funções ............................................................................................................. 29 
6.2 Critérios de Escalonamento ............................................................................. 29 
6.3 Escalonamentos Não-Preemptivos e Preemptivos ................................... 30 
 
7. Gerência de Memória / Memória Virtual ................................................................... 34 
7.1 Introdução ................................................................................................... 34 
7.2 Funções .............................................................................................................. 34 
7.3 Alocação Contígua Simples .............................................................................. 34 
7.4 Segmentação de programas .............................................................................. 35 
 2 
7.5 Alocação Particionada Estática Absoluta e Relocável .................................... 36 
7.6 Alocação Particionada Dinâmica ................................................................... 38 
7.7 Estratégias de Alocação de Partição ........................................................ 39 
7.8 Swapping ................................................................................................... 39 
7.9 Memória Virtual ................................................................................................... 40 
7.10 Algoritmos de substituição de páginas ........................................................ 43 
 
8. Gerência de sistemas de Arquivos .............................................................................. 45 
8.1 Estrutura de diretórios ......................................................................................... 45 
8.2 Sistemas de alocação de arquivos .................................................................... 45 
8.3 Gerência de espaço livre ............................................................................... 46 
8.4 Proteção de acesso .......................................................................................... 47 
 
9. BIBLIOGRAFIA ............................................................................................................... 48 
 
 
 
 3 
1. Histórico 
 
Antes da década de 50, os computadores eram muito difíceis de serem programados. Era 
necessário conhecer totalmente sua arquitetura, e tal operação era efetuada em painéis com 
cerca de 6.000 conectores, em linguagem de máquina. Nesta fase os computadores não 
possuíam ainda dispositivos para interagir com o usuário, como teclados e monitores. 
 
Na década de 50, já com a utilização de transistores, sucedeu-se um grande avanço 
tecnológico, melhorando a velocidade dos processadores e a capacidade dos meios de 
armazenamento, em especial a memória e os discos magnéticos. 
 
Por volta de 1953 foi introduzido o primeiro sistema operacional, um programa de 
controle que permitia uma interação, mesmo que limitada, entre o operador e a máquina, 
otimizando a execução das tarefas. Em 1959 foi criada uma versão de sistema operacional que 
já implementava conceitos de memória virtual, conceito este largamente utilizado nos sistemas 
atuais. 
 
Na década de 60, a partir do surgimento dos circuitos integrados, foi possível difundir u 
uso de sistemas computacionais em empresas, com diminuição de custos e tamanho dos 
equipamentos. Além disso, esta década presenciou inúmeras inovações na área de sistemas 
operacionais, presentes até hoje, como os ambientes de multitarefa, multiprogramação, 
multiprocessamento e time-sharing, tendo o desenvolvimento destas técnicas avançado até o 
meado da década de 70, onde também foram implementadas as tecnologias baseadas em 
arquitetura VLSI (chips), as primeiras redes de computadores, e o desenvolvimento de diversas 
linguagens de programação de alto nível. 
 
A década de 80 foi marcada pela criação dos microcomputadores, baseados em 
microprocessadores de uso pessoal. Liderados pela IBM, diversos fabricantes seguiram por essa 
linha, porém alguns deles não abandonando a fabricação dos computadores de grande porte, 
como foi o caso da própria IBM. 
 
Nota-se que, a partir do meado da década de 80, acontece uma divisão de águas, com a 
indústria passando a produzir equipamentos de grande porte e muitos modelos de 
microcomputadores, que também precisavam de sistemas operacionais bastante evoluídos. 
Foram, então, utilizadas as técnicas modernas já existentes nos ambientes de grande porte na 
implementação de sistemas operacionais para os microcomputadores, com versões diversas, 
todas inicialmente monousuário/monotarefa (devido à baixa capacidade de armazenamento dos 
micros, naquela época). Com o avanço da tecnologia, os micros ganharam discos rígidos e 
outros periféricos, possibilitando a criação de sistemas operacionais mais evoluídos nesta 
categoriade computadores, quando surgiram os sistemas monousuário/multitarefa, que 
executam até hoje. 
 
 
 
 4 
Cronologia 
 
Grande porte (mainframes) 
 
 1990 
 
 1950 1960 1970 1980 
 
 
 
 
 
 
 Microcomputadores 
 
 
 
 
2. Tipos de Sistemas Operacionais 
 
 
 Tipos de 
Sistemas Operacionais 
 
 
 
Sistemas 
Monoprogramáveis/ 
Monotarefa 
 Sistemas 
Multiprogramáveis/ 
Multitarefa 
 Sistemas 
Com Múltiplos 
Processadores 
 
 
2.1 Sistemas Monoprogramáveis/Monotarefa 
 
 Os primeiros sistemas operacionais eram voltados tipicamente para a execução de um 
único programa. Qualquer outra aplicação, para ser executada, deveria aguardar o término do 
programa corrente. Neste tipo de sistema, o processador, a memória e os periféricos 
permanecem exclusivamente dedicados à execução de um único programa. 
 
 Os sistemas monoprogramáveis estão diretamente ligados ao surgimento, na década de 
50/60, dos primeiros computadores. Embora os sistemas operacionais já tivessem evoluído com 
as tecnologias de multitarefa e multiprogramáveis, os sistemas monoprogramáveis voltaram a 
ser utilizados na plataforma de microcomputadores pessoais e estações de trabalho devido à 
baixa capacidade de armazenamento destas máquinas, na época. 
 
1º Sistema 
Operacional 
Monoprogramável 
Monotarefa 
Introduzido o 
conceito de 
Memória Virtual 
Sistemas 
Multitarefa 
Sistemas 
Multiprogramáveis 
Multitarefa 
 5 
 Era muito clara a desvantagem deste tipo de sistema, no que diz respeito à limitação de 
tarefas (uma de cada vez), o que provocava um grande desperdício de recursos de hardware. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Sistema Monoprogramável/Monotarefa 
 
 
 Comparados a outros sistemas, os monoprogramáveis são de simples implementação, 
não existindo muita preocupação com problemas decorrentes do compartilhamento de recursos 
como memória, processador e dispositivos de E/S. 
 
2.2 Sistemas Multiprogramáveis/Multitarefa 
 
 Constituindo-se uma evolução dos sistemas monoprogramáveis, neste tipo de sistema os 
recursos computacionais são compartilhados entre os diversos usuários e aplicações: enquanto 
um programa espera por um evento, outros programas podem estar processando neste mesmo 
intervalo de tempo. Neste caso, podemos observar o compartilhamento da memória e do 
processador. O sistema operacional se incumbe de gerenciar o acesso concorrente aos seus 
diversos recursos, como processador, memória e periféricos, de forma ordenada e protegida, 
entre os diversos programas. 
 
 As vantagens do uso deste tipo de sistema são a redução do tempo de resposta das 
aplicações, além dos custos reduzidos devido ao compartilhamento dos recursos do sistema 
entre as diferentes aplicações. Apesar de mais eficientes que os monoprogramáveis, os sistemas 
multiprogramáveis são de implementação muito mais complexa. 
 
 
 
 
 
CPU 
Memória 
Principal 
_______
_______
_______
_______
_______ 
Programa/Tarefa 
Dispositivos 
E/S 
 6 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Sistema Multiprogramável/Multitarefa 
 
 
Os sistemas multiprogramáveis/multitarefa podem ser classificados de acordo com a 
forma com que suas aplicações são gerenciadas, podendo ser divididos em sistemas batch, de 
tempo compartilhado e de tempo real, de acordo com a figura abaixo. 
 
 Sistemas 
Multiprogramáveis/ 
Multitarefa 
 
 
 
Sistemas BATCH 
 Sistemas de 
Tempo Compartilhado 
 Sistemas de 
Tempo Real 
 
 
2.2.1 Sistemas BATCH 
 
Foram os primeiros sistemas multiprogramáveis a serem implementados na década de 
60. Nesta modalidade, os programas eram submetidos para execução através de cartões 
perfurados e armazenados em disco ou fita, para posterior execução. Vem daí o nome batch 
(lote de cartões). O processamento em batch tem como característica não exigir interação do 
usuário com o sistema ou com a aplicação. Todas as entradas ou saídas são implementadas por 
meio de algum tipo de memória secundária, geralmente disco ou fita. Aplicações deste tipo 
eram utilizadas em cálculo numérico, compilações, back-ups, etc. 
 
CPU 
Memória 
Principal 
 _______
_______
_______
_______
_______ 
 
Dispositivos E/S 
 _______
_______
_______
_______
_______ 
 
 _______
_______
_______
_______
_______ 
 
 _______
_______
_______
_______
_______ 
 
Programa/Tarefa 
Programa/Tarefa 
Programa/Tarefa Programa/Tarefa 
 7 
Estes sistemas, se bem projetados, podem ser bastante eficientes devido à melhor 
utilização do processador, mas podem oferecer tempos de resposta bastante longos. 
Atualmente, os sistemas operacionais simulam este tipo de processamento, não havendo 
sistemas dedicados a este tipo de execução. 
 
2.2.2 Sistemas de Tempo Compartilhado 
 
Também chamados sistemas de time-sharing, permitem que diversos programas sejam 
executados a partir da divisão de tempo do processador em pequenos intervalos, denominados 
fatia de tempo (ou time-slice). Caso a fatia de tempo não seja suficiente para a conclusão do 
programa, este é interrompido pelo sistema operacional e substituído no processador por outro, 
enquanto aguarda nova fatia de tempo. Neste tipo de processamento, cada usuário tem a 
impressão de que a máquina está dedicada ao seu programa, como se ele fosse o único usuário 
a se utilizar do sistema. 
 
 Geralmente permitem interação do usuário com a aplicação através de terminais 
compostos por monitor, teclado e mouse. Estes sistemas possuem uma linguagem de controle 
que permite ao usuário interagir com o sistema operacional através de comandos. Assim, é 
possível verificar arquivos armazenados em disco ou cancelar execução de programas. 
Normalmente, o sistema responde em apenas alguns segundos à maioria destes comandos, o 
que se levou a chamá-los também de sistemas on-line. 
 
A maioria das aplicações comerciais atualmente é processada em ambiente de tempo 
compartilhado, que oferece tempos baixos de respostas a seus usuários e menores custos, em 
função do alto grau de compartilhamento dos diversos recursos do sistema. 
 
2.2.3 Sistemas de Tempo Real 
 
Este tipo de sistema é implementado de forma bastante semelhante ao de tempo 
compartilhado. O que caracteriza a diferença entre eles é o tempo exigido no processamento 
das aplicações. 
 
Enquanto nos sistemas de tempo compartilhado o tempo de processamento pode variar 
sem comprometer as aplicações em execução, nos sistemas de tempo real os tempos de 
execução devem estar dentro de limites rígidos, que devem ser obedecidos, caso contrário 
poderão ocorrer problemas irreparáveis. 
 
No sistema de tempo real não existe a idéia de fatia de tempo como nos sistemas de 
tempo compartilhado. Um programa ocupa o processador o tempo que for necessário ou até 
que apareça um outro com um nível de prioridade maior. Esta prioridade de execução é definida 
pela própria aplicação e não pelo sistema operacional, como nos sistemas de tempo 
compartilhado. 
 
 8 
Estes sistemas são utilizados em aplicações de controle de processos, como 
monitoramento de refinarias de petróleo, controle de tráfego aéreo, de usinas, ou em qualquer 
aplicação onde o tempo de processamento é fator fundamental. 
 
 
2.3 Sistemas com Múltiplos Processadores 
 
Os sistemas com múltiplos processadores caracterizam-se por possuir duas ou mais CPUs 
interligadas e trabalhando em conjunto. A vantagem deste tipo de sistema é permitir que 
vários programas sejam executados ao mesmo tempo ou que um mesmo programa seja 
subdividido em várias partespara serem executadas simultaneamente em mais de um 
processador. 
 
Esta técnica permitiu a criação de sistemas computacionais voltados para processamento 
científico, prospecção de petróleo, simulações, processamento de imagens e CAD. 
 
 Um fator chave no desenvolvimento dos sistemas multiprocessados é a forma de 
comunicação entre as CPUs e o grau de compartilhamento da memória e dos dispositivos de 
E/S. Em função destes fatores, podemos classificar os sistemas multiprocessados de acordo com 
a figura a seguir: 
 
 
 
 
Sistemas 
 com 
Múltiplos 
Processadores 
 
 
 
 
Sistemas 
Fortemente 
Acoplados 
 
Sistemas 
Fracamente 
Acoplados 
 
 
 
Simétricos Assimétricos Redes Distribuídos 
 
Tipos de Sistemas com Múltiplos Processadores 
 
 
 
Na figura podemos perceber a divisão dos sistemas multiprocessados em duas categorias 
iniciais: sistemas fortemente acoplados e fracamente acoplados. A grande diferença entre 
estas duas categorias é que nos sistemas fortemente acoplados existe apenas uma memória 
 9 
a ser compartilhada pelos processadores do conjunto, enquanto que nos fracamente 
acoplados cada sistema tem sua própria memória individual. A taxa de transferência entre 
processadores e memória em sistemas fortemente acoplados é muito maior que nos 
fracamente acoplados. 
 
Nos sistemas fortemente acoplados a memória principal e os dispositivos de E/S são 
gerenciados por um único sistema operacional. Quando todos os processadores na 
arquitetura são iguais, diz-se que o sistema é simétrico. No entanto, quando os 
processadores são diferentes, dá-se à arquitetura a denominação assimétrica. 
 
Nos sistemas fracamente acoplados, como os processadores estão em arquiteturas 
diferentes, somente interligados por cabos de interconexão, cada CPU constitui uma 
máquina independente, com memória própria, dispositivos de E/S e sistemas operacionais 
independentes. 
 
Nesta subdivisão, temos como exemplo as redes e os sistemas distribuídos. 
 
No ambiente de rede, existem dois ou mais sistemas independentes (hosts), interligados 
por linhas telefônicas, que oferecem algum tipo de serviço aos demais, permitindo que um 
host compartilhe seus recursos, como impressora e diretórios, com os outros hosts da rede. 
 
Enquanto nos sistemas em rede os usuários têm conhecimento dos hosts e seus serviços, 
nos sistemas distribuídos os sistema operacional esconde os detalhes dos hosts individuais e 
passa a tratá-los como um conjunto único, como se fosse um sistema só, fortemente 
acoplado. Os sistemas distribuídos permitem, por exemplo, que uma aplicação seja dividida 
em partes e que cada parte seja executada por hosts diferentes na rede. Para os usuários e 
suas aplicações é como se não existisse a rede, mas um único sistema centralizado. 
 
Outros exemplos de sistemas distribuídos são os clusters. Em um cluster podem existir 
dois ou mais servidores ligados por algum tipo de conexão de alto desempenho, e o usuário 
não conhece os nomes dos membros do cluster e nem quantos são. Quando é necessário 
algum serviço, basta solicitar ao cluster para obtê-lo, sem se preocupar com quem vai dispor 
e oferecer tal serviço. Clusters são muito utilizados em servidores de bancos de dados e 
Web. 
 10 
 
3. Sistemas Multiprogramáveis 
 
 
Um Sistema Operacional pode ser visto como um conjunto de rotinas que executam 
concorrentemente de forma ordenada. A possibilidade de um processador executar instruções 
em paralelo com operações de entrada e saída permite que diversas tarefas sejam executadas 
concorrentemente. É este conceito de concorrência o princípio fundamental para o projeto e 
implementação de sistemas multiprogramáveis. 
 
Os sistemas multiprogramáveis surgiram a partir das limitações dos sistemas 
monoprogramáveis onde os recursos computacionais como processador, memória e dispositivos 
de E/S eram utilizados de maneira muito pouco eficiente, limitando seu desempenho, com 
muitos destes recursos permanecendo ociosos por longos períodos de tempo. 
 
Nos sistemas monoprogramáveis somente um programa pode estar em execução de cada 
vez, permanecendo o processador dedicado exclusivamente a uma tarefa, ficando ocioso 
enquanto uma operação de leitura em disco é realizada. O tempo de espera é relativamente 
longo, já que as operações de E/S são muito lentas se comparadas à velocidade de operação do 
processador. 
 
Outro aspecto a ser considerado é a sub-utilização da memória principal, onde um programa 
nem sempre ocupa todo o espaço disponível, ficando o restante inutilizado. Nos sistemas 
multiprogramáveis vários programas podem ser alocados na memória, concorrendo pelo uso do 
processador. Dessa forma, quando um programa solicita uma operação de E/S, outros 
programas poderão utilizar o processador, deixando a CPU menos ociosa e tornando o uso da 
memória mais eficiente, pois existem vários residentes e se revezando na utilização do 
processador. 
 
A utilização concorrente da CPU deve ser feita de maneira que, quando um programa perde 
o uso do processador e depois retorna para continuar sua execução, seu estado deve ser 
idêntico ao do momento em que foi interrompido. O programa deverá continuar sua execução 
exatamente na instrução seguinte àquela onde havia parado, aparentando ao usuário que nada 
aconteceu. Em sistemas de tempo compartilhado existe a impressão de que o computador está 
inteiramente dedicado ao usuário, ficando esse mecanismo totalmente transparente aos 
usuários. 
 
Quanto ao uso dos periféricos, é comum nos sistemas monoprogramáveis é comum termos, 
por exemplo, impressoras paradas por um grande período de tempo e discos com acesso 
restrito a um único usuário. Esses problemas são minimizados nos sistemas multiprogramáveis, 
onde é possível compartilhar os dispositivos de E/S, como impressoras e discos, entre diversos 
usuários e aplicativos. 
 
 
 11 
3.1 Interrupção e Exceção 
 
Durante a execução de um programa, alguns eventos inesperados podem ocorrer, 
ocasionando um desvio forçado no seu fluxo normal de execução. Esses eventos são conhecidos 
como interrupção ou exceção, e podem ser resultado de sinalizações de algum dispositivo de 
hardware externo ao ambiente memória/processador. A diferença entre interrupção e exceção é 
dada pelo tipo de evento ocorrido, embora alguns autores e fabricantes não façam tal distinção. 
 
A interrupção é o mecanismo que permitiu a implementação da concorrência nos 
computadores, sendo o fundamento básico dos sistemas multiprogramáveis/multitarefa. 
 
Uma interrupção é sempre gerada por um evento externo ao programa e, sendo assim, 
independe da instrução que está sendo executada. Um exemplo de interrupção é quando um 
dispositivo avisa ao processador que alguma operação de E/S está completa. Neste caso, o 
processador deve interromper o programa para tratar o término da operação. 
 
Ao término de cada instrução a Unidade de Controle (situada dentro do processador) 
verifica a ocorrência de algum tipo de interrupção. Desta forma, o programa em execução é 
interrompido e seu controle é desviado para uma rotina do sistema responsável por tratar o 
evento ocorrido, denominada rotina de tratamento de interrupção. Para que o programa 
interrompido possa retornar posteriormente à sua execução é necessário que, no momento da 
interrupção, um certo conjunto de informações sobre sua execução seja preservado. 
 
Essas informações consistem basicamente no conteúdo dos registradores internos da 
CPU, que deverão ser restaurados para a continuação do programa. 
 
 Programa 
 Salva 
Contexto 
 
 
 
 
 Identifica 
 a origem 
 
 
 
Interrupção 
 Trata a 
Interrupção 
 
Rotinade 
 Restaura 
Contexto 
 
Tratamento 
 
 
Mecanismo de interrupção/exceção 
 
 
 12 
 Para cada tipo de interrupção existe uma rotina de tratamento associada, para onde o 
fluxo do programa é desviado. A identificação do tipo de evento ocorrido é fundamental para 
determinar o endereço da rotina adequada ao tratamento da interrupção. 
 
 As interrupções podem ser geradas: 
 
- Pelo programa do usuário (entrada de dados pela console ou teclado) 
- Pelo hardware (operações de E/S) 
- Pelo sistema operacional (ao término da fatia de tempo do processador destinada ao 
programa) 
 
As interrupções sempre são tratadas pelo Sistema Operacional. 
 
A exceção é um evento semelhante à interrupção, pois também de fato interrompe um 
programa. 
 
A principal diferença é que a exceção é o resultado da execução de uma instrução dentro 
do próprio programa, como a divisão por zero ou a ocorrência de um overflow (estouro de 
capacidade de um campo) numa operação aritmética. 
 
Na maioria das vezes, a exceção provoca um erro fatal no sistema, causando o término 
anormal do programa. Isto se deve ao fato de que a exceção é melhor tratada dentro do 
próprio programa, com instruções escritas pelo programador. 
 
 
3.2 Buffer 
 
A técnica de buffering consiste nua utilização de uma área em memória principal, 
denominada buffer, criada e mantida pelo Sistema Operacional, com a finalidade de auxiliar 
a transferência de dados entre dispositivos de E/S e a memória. O buffer permite minimizar 
a disparidade de velocidade entre o processador e os dispositivos de E/S, e tem como 
objetivo principal manter tanto os dispositivos de E/S como o processador ocupados a maior 
parte do tempo. 
 
A unidade de transferência do mecanismo de buffering é o registro. O buffer deve 
permitir o armazenamento de vários registros, de forma que o processador tenha à sua 
disposição dados suficientes para processar sem ter que interromper o programa a cada 
leitura/gravação no dispositivo de E/S. Enquanto o processador está ocupado processando, 
os dispositivos de E/S estão efetuando operações para outros processos. 
 
3.3 SPOOL 
 
A técnica de spooling foi criada inicialmente para auxiliar a submissão de processos ao 
sistema, sendo os processos gravados em fita para posterior leitura e execução. 
 13 
 
Com o aparecimento dos terminais para acesso ao sistema, esta técnica teve sua função 
adaptada para armazenar o resultado da impressão dos programas em execução. 
 
Isto é conseguido através da criação e manutenção, pelo Sistema Operacional de uma 
grande área em disco, com a finalidade de simular uma impressora. Desta forma, todos os 
usuários e seus programas imprimem, na verdade, para este arquivo em disco, liberando a 
associação dos dispositivos de impressão diretamente aos programas que estão executando. 
 
O usuário consegue visualizar o resultado de seus programas na tela dos terminais, 
gerando assim mais eficiência e economia de papel e fita de impressão. À proporção que vão 
sendo gerados no SPOOL, os relatórios vão sendo liberados para impressão pelo operador do 
sistema, de forma ordenada e seqüencial. Para cada usuário, é como se ele tivesse uma 
impressora associada para si. 
 
3.4 Reentrância 
 
É comum, em sistemas multiprogramáveis, vários usuários utilizarem os mesmos 
aplicativos simultaneamente, como editores de texto, compiladores e outros utilitários. Nesta 
situação, se cada usuário que utilizasse um destes aplicativos trouxesse o código executável 
para a memória, haveria então diversas cópias de um mesmo programa ocupando espaço na 
memória, o que causaria um grande desperdício de espaço. 
 
Reentrância é a capacidade de um código executável (código reentrante) ser 
compartilhado por vários usuários, exigindo apenas uma cópia do programa em memória. A 
reentrância permite que cada usuário esteja executando um trecho diferente do código 
reentrante, manipulando dados próprios, exclusivos de cada usuário. 
 
Normalmente códigos reentrantes são utilizados em utilitários do sistema, como editores, 
compiladores e linkers, promovendo um uso mais eficiente da memória e um desempenho 
maior do sistema. Alguns sistemas operacionais permitem a possibilidade de se implementar 
o conceito de reentrância em aplicações desenvolvidas pelo próprio usuário, mas não é 
comum. 
 
3.5 Segurança e Proteção do Sistema 
 
A eficiência proporcionada por um ambiente multiprogramável implica em maior 
complexidade do sistema operacional, já que alguns problemas de proteção surgem como 
decorrência deste tipo de implementação. 
 
Considerando-se que diversos usuários estão compartilhando os mesmos recursos, 
como memória, processador e dispositivos de E/S, faz-se então necessário existir 
mecanismos de proteção para garantir a confiabilidade e a integridade dos dados e 
programas dos usuários, além do próprio sistema operacional. 
 14 
 
Como vários programas ocupam a memória principal simultaneamente, cada usuário 
possui uma área reservada onde seus programas e dados são armazenados durante o 
processamento. O sistema operacional deve possuir mecanismos de proteção a essas áreas, 
de forma a preservar as informações nela contidas. Caso um programa tente acessar uma 
posição de memória fora de sua área, um erro indicando a violação de acesso deve ocorrer, 
sendo responsabilidade do sistema operacional o controle eficiente do compartilhamento dos 
recursos e a sincronização da comunicação, evitando problemas de consistência. 
 
Semelhante ao compartilhamento da memória, um disco também armazena arquivos 
de diferentes usuários. Novamente o sistema operacional deve garantir a integridade e 
confiabilidade dos dados de cada usuário. 
 
Todo o controle da segurança do sistema é implementado pelo sistema operacional, a 
partir de mecanismos como grupos de usuários, perfis de usuários e direitos de acesso. 
 
A proteção começa geralmente no procedimento de login, quando o usuário faz a 
conexão inicial ao sistema, através de nome do usuário e senha. A partir daí, toda uma 
estrutura de controle é iniciada, em função da identificação do usuário, no sentido de 
proteger as áreas alocadas em memória, em disco, e até mesmo o uso do processador. 
 
A proteção e segurança do sistema pode ser implementada também a nível do 
programa do usuário, com a inserção de rotinas específicas dentro do programa para 
controlar o acesso de usuários ao aplicativo, além de controlar internamente quais telas e 
funções tal usuário pode acessar. 
 
 
3.6 Operações de Entrada e Saída 
 
Nos primeiros sistemas computacionais, a comunicação entre o processador e os 
periféricos era direta, sendo o processador responsável por efetuar as operações de 
leitura/gravação nos dispositivos. 
 
O surgimento do controlador de E/S permitiu ao processador agir de maneira 
independente dos dispositivos de E/S. Com esse novo elemento, o processador não mais se 
comunicava diretamente com os periféricos, mas sim via controlador. 
 
Passou a existir então três maneiras básicas de se implementar operações de E/S: 
 
- por programa: o processador sincronizava-se com o periférico e iniciava a 
transferência de dados, ficando permanentemente testando o estado do periférico 
para saber quando a operação chegaria ao seu final. O processador ficava ocupado 
até o término da operação de E/S. 
 
 15 
- por interrupção: evoluindo o processo anterior, após o início da transferência de 
dados o processador passou a ficar livre para realizar outras tarefas. Assim, em 
determinados intervalos de tempo o sistema operacional deveria testar o estado dos 
periféricos para saber se a operação de E/S tinha terminado. Este tipo de operação 
permitiu um certo grau de paralelismo, já que um programa poderia serprocessado 
enquanto uma operação de leitura/gravação em periférico estava sendo efetuada. 
Isto permitiu a implementação dos primeiros sistemas multiprogramáveis. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Dispositivos de E/S 
 
 
- A necessidade de se transmitir cada vez um volume maior de informações trouxe 
uma evolução significativa nas operações de E/S. Em vez de o processador ser 
interrompido várias vezes para interrogar os dispositivos para saber do resultado 
das operações, o que diminuía sua eficiência devido ao excesso de interrupções, foi 
criado um dispositivo de transferência de dados chamado de DMA – Direct Memory 
Access. Esta técnica permite que um bloco de dados seja transferido entre a 
memória e os dispositivos de E/S sem a intervenção do processador, a não ser no 
início (quando a operação é solicitada) e no final da transferência (quando o 
processador é notificado sobre o término da operação). Na figura a seguir, 
podemos ver a implementação do canal de E/S gerenciando vários controladores e, 
ligados a estes, vários periféricos. 
 
CPU 
Memória 
Principal 
Controlador 
 16 
O canal de E/S funciona então como uma interface entre os controladores e a CPU, 
como mostra a figura a seguir: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CPU 
Memória 
Principal 
Controlador Controlador 
Canal de E/S 
 Dispositivos de E/S Dispositivos de E/S 
 17 
4. Estrutura do Sistema Operacional 
 
 
4.1 Estrutura do Sistema 
 
 
USUÁRIO 
 
UTILITÁRIOS 
 
NÚCLEO 
DO SISTEMA 
 
HARDWARE 
 
Hierarquia do Sistema Operacional 
 
O sistema operacional é formado por um conjunto de rotinas que oferecem serviços 
essenciais aos usuários, às suas aplicações, e também ao próprio sistema. A esse conjunto 
de rotinas dá-se o nome de núcleo do sistema ou kernel. 
 
 É fundamental não se confundir o núcleo do sistema com aplicações, utilitários ou o 
interpretador de comandos, que acompanham o sistema operacional. As aplicações são 
utilizadas pelos usuários de maneira transparente, escondendo todos os detalhes da 
interação com o sistema. Os utilitários, como os compiladores, editores de texto e 
interpretadores de comandos permitem aos usuários, desenvolvedores e administradores de 
sistema uma interação amigável com o sistema. 
 
 Existe uma grande dificuldade em compreender a estrutura e o funcionamento do 
sistema operacional, pois ele não é executado como uma aplicação tipicamente seqüencial, 
com início, meio e fim. Os procedimentos do sistema são executados concorrentemente sem 
uma ordem específica ou predefinida, com base em eventos dissociados do tempo. Muitos 
desses eventos estão relacionados ao hardware e a tarefas internas do próprio sistema 
operacional. 
 
 
 
 18 
4.2 Funções do Sistema 
 
 As principais funções do núcleo encontradas na maioria dos sistemas comerciais são as 
seguintes: 
 
- Tratamento de interrupções e exceções: já explicados anteriormente, em detalhes; 
 
- Criação e eliminação de processos: função responsável por alocar em memória todos os 
recursos necessários à execução do processo. É esta função que aloca em memória, além 
do executável, o contexto do processo, o buffer de leitura/gravação (se necessário), além 
de listas e estruturas de controle utilizadas pelo sistema operacional. Nesta função 
também são estabelecidos vínculos físicos a arquivos em disco, fitas e outros periféricos 
que serão usados no processamento. Quando do fim da execução do programa, é esta 
função que desaloca todos os espaços em memória ocupados pelo processo, liberando-os 
para futuras alocações a outros processos; 
 
- Escalonamento e controle de processos: função responsável por organizar a fila de 
acesso ao processador. Utiliza parâmetros do sistema e do perfil do usuário para 
estabelecer a ordem em que os processos permanecerão à espera pela liberação da CPU, 
para então entrarem em execução; 
 
- Gerência de memória: função responsável por fornecer à função de criação/eliminação de 
processos os endereços em memória disponíveis para alocação; 
 
- Gerência de sistemas de arquivos: responsável pelo gerenciamento dos arquivos, bem 
como seu compartilhamento pelos diversos usuários, implementando mecanismos de 
controle da segurança e direitos de acesso às áreas utilizadas pelos usuários nos diversos 
dispositivos; 
 
- Gerência de dispositivos de E/S: responsável por gerenciar os dispositivos, prestando 
auxílio à criação/eliminação de processos e á gerência de sistemas de arquivos no que diz 
respeito ao endereçamento e associação de arquivos em periféricos; 
 
- Suporte a redes e teleprocessamento: é esta função que executa todos os serviços de 
rede, fazendo o empacotamento das mensagens vindas dos terminais para a CPU central 
e vice-versa, além de controlar e confirmar o envio e recebimento de todas as 
mensagens que trafegam pela rede; 
 
- Contabilização de uso do sistema: responsável por contabilizar o uso de todos os 
recursos do sistema consumidos pelos usuários e suas aplicações. São registrados: tempo 
de CPU, tempo corrido, quantidade de área alocada em memória, em disco, linhas 
impressas, páginas de papel, entre outros. Isto se faz necessário para servir de subsídio 
para análise de performance, estatísticas de gastos com material de consumo e também 
para definição de custos de processamento.; 
 19 
- Auditoria e segurança do sistema: função extremamente importante, pois detecta e 
registra (num arquivo especial de LOG) todas as ocorrências de erro e violação de 
direitos de acesso ao sistema, aos arquivos, à memória e a todos os recursos do sistema. 
O arquivo de LOG é usado pela gerência de sistemas, com o intuito de verificar e 
aperfeiçoar os mecanismos de segurança e proteção ao sistema. 
 
A estrutura do sistema, a maneira como ele é organizado e o inter-relacionamento entre 
seus diversos componentes pode variar conforme a concepção do projeto do sistema. 
 
4.3 System Calls 
 
Uma grande preocupação no projeto de sistemas operacionais se refere à implementação de 
mecanismos de proteção ao núcleo do sistema e também o controle de acesso aos serviços 
oferecidos pelo sistema. Caso uma aplicação que tenha acesso ao núcleo realize alguma 
operação que altere sua integridade, todo o sistema poderá ficar comprometido e inoperante. 
 
As system calls podem ser entendidas como uma porta de entrada para acesso ao núcleo do 
sistema e aos seus serviços. Sempre que um usuário ou uma aplicação necessita de algum 
serviço do sistema, é realizada uma chamada a uma de suas rotinas através de uma system call. 
 
Através dos parâmetros fornecidos na system call, a solicitação é processada e uma 
resposta é enviada à aplicação juntamente com um estado de conclusão indicando o sucesso ou 
não da operação. Para cada serviço disponível existe uma system call associada, e cada sistema 
operacional possui seu próprio conjunto de chamadas, com nomes, parâmetros e formas de 
ativação específicos. Isto explica por que uma aplicação desenvolvida utilizando serviços de um 
determinado sistema operacional não pode ser diretamente portada para um outro sistema. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Aplicação 
System Call 
Núcleo do 
Sistema 
Operacional 
Biblioteca Hardware 
 20 
4.4 Modos de Acesso 
 
Existem certas instruções que não podem ser colocadas diretamente à disposição das 
aplicações, pois a sua utilização indevida poderia ocasionar sérios problemas à integridade do 
sistema. Imagine que uma aplicação atualize um arquivo em disco. O programa, por si só, não 
pode especificar diretamente as instruções que acessam seus dados no disco pois, como o discoé um recurso compartilhado, sua utilização deve ser gerenciada unicamente pelo sistema 
operacional. Tal procedimento evita que a aplicação possa ter acesso a qualquer área do disco 
indiscriminadamente, o que poderia comprometer a segurança e a integridade do sistema de 
arquivos. 
 
Assim, fica claro que existem certas instruções que só podem ser executadas pelo sistema 
operacional ou sob sua supervisão. As instruções que têm o poder de comprometer o sistema 
são chamadas de instruções privilegiadas, enquanto as instruções que não comprometem o 
funcionamento do sistema chamam-se instruções não-privilegiadas. 
 
Para que uma aplicação possa executar uma instrução privilegiada, é preciso que haja um 
mecanismo de proteção no processador, chamado modos de acesso. Existem basicamente dois 
modos de acesso ao processador: modo usuário e modo kernel. Quando o processador trabalha 
no modo usuário, somente instruções não-privilegiadas podem ser executadas, tendo assim 
acesso a um número limitado de instruções do processador. Já no modo kernel (ou supervisor), 
a aplicação pode ter acesso ao conjunto total de instruções do processador. 
 
A melhor maneira de controlar o acesso às instruções privilegiadas é permitir que apenas o 
sistema operacional tenha acesso a elas. Sempre que uma aplicação necessita executar uma 
instrução privilegiada, a solicitação deve ser feita através de uma system call, que altera o modo 
de acesso ao processador do modo usuário para o modo kernel. Ao término da execução da 
rotina do sistema, o modo de acesso retorna para o modo usuário. 
 21 
4.5 Arquiteturas: Sistemas monolíticos, em camadas e microkernel 
 
- Arquitetura monolítica: é caracterizada por possuir seus módulos compilados 
separadamente mas linkados formando um único e enorme programa executável. Onde 
os módulos podem interagir livremente. Os primeiros sistemas operacionais foram 
desenvolvidos com base nesta arquitetura, o que tornava seu desenvolvimento e, 
principalmente, sua manutenção muito difíceis. Como vantagens desta arquitetura 
podemos citar a rapidez de execução e simplicidade de implementação. Como 
desvantagens, a limitação quanto a inovações futuras e a dificuldade de manutenção. 
 
 
 
 
 
 
 
Modo Usuário 
 
Modo Kernel 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Arquitetura monolítica 
 
 
 
 
 
 
 
 
 
Aplicação 
 
 
Aplicação 
System call 
Hardware 
Núcleo 
do 
Sistema 
 22 
 
- Arquitetura em camadas: com o aumento do tamanho do código dos sistemas 
operacionais, técnicas de programação estruturada e modular foram incorporadas em seu 
projeto.Na arquitetura em camadas, o sistema é dividido em níveis sobrepostos. Cada 
camada oferece um conjunto de funções que podem ser utilizadas somente pelas 
camadas superiores. Neste tipo de implementação as camadas mais internas são mais 
privilegiadas que as camadas mais externas. A vantagem da estruturação em camadas é 
o isolamento das funções do sistema, facilitando sua manutenção. Uma desvantagem é o 
desempenho, comprometido devido às várias mudanças de estado do processador 
provocado pela mudança de camadas. A figura a seguir mostra esta arquitetura. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Arquitetura em camadas 
 
- Arquitetura microkernel (cliente x servidor): uma tendência nos sistemas operacionais 
modernos é tornar o núcleo do sistema o menor e o mais simples possível. Para 
implementar esta idéia, os serviços do sistema são disponibilizados através de processos, 
onde cada um é responsável por oferecer um conjunto específico de funções, como 
gerência de arquivos, gerência de processos, gerência de memória e escalonamento. 
Sempre que uma aplicação deseja algum serviço, é realizada uma solicitação ao processo 
responsável. Neste caso, a aplicação que está solicitando o serviço é chamada de cliente, 
enquanto o processo que responde à solicitação é chamado de servidor. Um cliente, que 
pode ser uma aplicação do usuário ou um outro componente do sistema operacional, 
solicita um serviço enviando uma mensagem para o servidor. O servidor responde ao 
cliente através de uma outra mensagem. A principal função do núcleo é realizar a 
comunicação, ou seja, a troca de mensagens entre o cliente e o servidor. A utilização 
Camada Usuário 
Camada Supervisor 
Camada Executivo 
Kernel 
 23 
deste modelo permite que os servidores operem em modo usuário, não tendo acesso 
direto a certos componentes do sistema. Apenas o núcleo do sistema, responsável pela 
comunicação entre clientes e servidores, executa em modo kernel. Como conseqüência, 
se ocorrer um erro em algum servidor,este poderá parar, mas o sistema não ficará 
inteiramente comprometido, aumentando assim a sua disponibilidade. Como os 
servidores se comunicam através de trocas de mensagens, não importa se os clientes e 
servidores processam em um sistema com um único processador, com vários 
processadores ou ainda em um ambiente de sistema distribuído. A arquitetura 
microkernel permite isolar as funções do sistema operacional por diversos servidores 
pequenos e dedicados a serviços específicos, tornando o núcleo menor, mais fácil de 
depurar (procurar e solucionar erros) e, com isso, aumentando a sua confiabilidade. 
Apesar de todas as vantagens deste modelo, sua implementação é muito difícil. A 
começar pelo desempenho, comprometido devido às várias trocas de modo de acesso a 
cada troca de mensagens entre cliente e servidor. Outro problema é que certas funções 
do sistema operacional, como operações de E/S, exigem acesso direto ao hardware. 
Assim, o núcleo do sistema, além de promover a comunicação entre clientes e servidores, 
passa a incorpora funções críticas do sistema, como escalonamento, tratamento de 
interrupções e gerência de dispositivos. 
 
 
 
 
 
 
 
 
 
 
Modo Usuário 
 
Modo Kernel 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Microkernel 
 
Hardware 
Servidor 
Arquivo 
Servidor 
Process
o 
Servidor 
Memória 
Servidor 
Impressã
o 
Servidor 
Rede 
 24 
5. PROCESSO 
 
O conceito de processo é a base para a implementação de um sistema multiprogramável. O 
processador é projetado apenas para executar instruções, não sendo capaz de distinguir qual 
programa se encontra em execução.A gerência de um ambiente multiprogramável é função 
exclusiva do sistema operacional, que deve controlar a execução dos diversos programas e o 
uso concorrente do processador. 
 
A gerência do processador é uma das principais funções de um sistema operacional. Através 
dos processos, um programa pode alocar recursos, compartilhar dados e trocar informações. 
 
5.1 Componentes do processo 
 
Um processo pode ser entendido inicialmente como um programa em execução, que tem 
suas informações mantidas pelo sistema operacional. 
 
Num sistema multiusuário, cada usuário tem a impressão de possuir o processador e todos 
os demais recursos reservados exclusivamente para si, mas isto não é verdade. Todos os 
recursos estão sendo compartilhados, inclusive a CPU. Neste caso, o processador executa o 
processo do usuário por um intervalo de tempo e, no instante seguinte, poderá estar 
processando um outro programa, do mesmo ou de outro usuário. 
 
Para que a troca de processos possa ser feita sem problemas, é necessário que todas as 
informações do programa que está sendo interrompido sejam guardadas, para que ele possa 
retornar à CPU exatamente do ponto em que parou, não lhe faltando nenhuma informação vital 
à sua continuação. Todas as informações necessárias à execução de um programa fazem parte 
do processo. 
 
Um processo também pode ser definido como o ambiente onde o programa é executado. 
Este ambiente, além das informações sobre a execução, possui também a quantidade de 
recursosdo sistema que o programa pode utilizar,como espaço de endereçamento, tempo do 
processador e área em disco. 
 
Um processo é formado por três partes: contexto de software, contexto de hardware e 
espaço de endereçamento, que juntas mantêm todas as informações necessárias à execução de 
um programa. 
 
 
 
 
 
 
 
 
 25 
 
Estrutura do processo: 
 
 
 
 
 
 
 
 
 
 
 
 
 Contexto de Software: neste contexto são especificadas características e limites dos 
recursos que podem ser alocados pelo processo, como número máximo de arquivos 
abertos, prioridade de execução, número máximo de linhas impressas, etc. Muitas destas 
características são criadas no momento da criação do processo, quando da sua alocação. 
 
O sistema operacional obtém, a partir do cadastro de usuários e do cadastro de 
contas no sistema, as informações e características que valerão para o processo. 
 
O contexto de software é composto por tr?es grupos de informações: 
 
- Identificação: neste grupo são guardadas informações sobre o usuário que criou o 
processo, e, em função disso, suas áreas de atuação no sistema. 
 
- Quotas: são os limites de recursos do sistema que um processo pode alocar, como 
área utilizada em disco, em memória, limite de linhas impressas, número máximo 
de arquivos abertos, número máximo de operações de E/S pendentes, tempo 
limite de CPU, etc. 
 
- Privilégios: diz respeito principalmente às prioridades assumidas pelo processo 
durante sua execução. 
 
 Contexto de Hardware: armazena o conteúdo dos registradores gerais da CPU, além dos 
registradores de uso específico. Quando um processo está em execução, o seu contexto 
de hardware está armazenado nos registradores da CPU. No momento em que o 
processo perde a utilização da CPU, o sistema salva as informações no contexto de 
hardware do processo. 
 
A troca de um processo por outro no processador, comandada pelo sistema 
operacional, é denominada troca de contexto, que consiste em salvar o conteúdo dos 
registradores do processo que está deixando a CPU e carrega-los com os valores 
________
________
________
Programa 
Espaço de 
endereçamento 
Contexto de 
Software 
Contexto de 
Hardware 
 26 
referentes ao do novo processo que irá executar. Essa operação resume-se em substituir 
o contexto de hardware de um processo pelo de outro. 
 
 Espaço de endereçamento: é a área de memória pertencente a um processo onde as 
instruções e os dados do programa são armazenados para execução. Cada processo 
possui seu próprio espaço de endereçamento, que deve ser devidamente protegido do 
acesso dos demais processos. Os contextos de software e de hardware não fazem parte 
do espaço de endereçamento . 
 
 Bloco de controle do processo: é a estrutura de dados que compõe o processo, contendo 
os contextos de software e de hardware e o espaço de endereçamento. O BCP reside em 
memória, numa área reservada ao sistema operacional. 
 
5.2 Estados do processo 
 
Num sistema multiprogramável, um processo não deve alocar a CPU com exclusividade, 
de forma que possa existir um compartilhamento no uso do processador. Os processos 
passam por diferentes estados ao longo do processamento, em função de eventos gerados 
pelo sistema operacional, pelo hardware, ou pelo próprio programa. São estados possíveis 
de um processo: 
 
- Criação: neste estado o processo está sendo alocado na memória, sendo criado no 
sistema. Todos os recursos necessários à execução do processo são reservados 
durante a passagem do processo por este estado, o que acontece uma única vez. 
Vários processos podem estar neste estado, ao mesmo tempo. 
 
- Pronto: é o estado onde os processos, depois de criados ou quando retornam do 
tratamento de uma interrupção, permanecem aguardando a liberação da CPU para 
que possam iniciar ou continuar seu processamento. É como se fosse uma fila, 
gerenciada pelo sistema operacional, que se incumbe de organizar os processos de 
acordo com as informações contidas no contexto de software (identificação, 
quotas e privilégios). Vários processos podem estar neste estado, ao mesmo 
tempo. 
 
- Execução: é onde o processo efetivamente utiliza a CPU. Ele permanece no 
processador até que seja interrompido ou termine sua execução. Neste estado, 
somente um processo pode permanecer de cada vez, já que existe apenas um 
processador. 
 
- Espera: neste estado estão todos os processos que sofreram algum tipo de 
interrupção de E/S, onde permanecem até que a intervenção seja resolvida. Vários 
processos podem estar neste estado, ao mesmo tempo. 
 
 27 
- Saída: é o estado final do processo, quando este termina seu processamento. 
Vários processos podem estar neste estado, ao mesmo tempo. 
 
5.3 Mudanças de estado do processo 
 
Um processo muda de estado diversas vezes durante sua permanência no sistema, 
devido aos eventos ocorridos durante sua execução. São mudanças possíveis: 
 
- Criação Pronto: o processo foi criado, tem seus recursos alocados, e está apto a 
disputar o uso da CPU. 
 
- Pronto  Execução: o processo é o primeiro da fila de pronto e a CPU fica 
disponível. Neste momento o processo passa a ocupar a CPU, permanecendo em 
execução até que seja interrompido ou termine sua execução. 
 
- Execução  Pronto: o processo foi interrompido por fatia de tempo ou por 
prioridade. Ainda precisa de mais tempo na CPU para terminar sua execução, não 
tem nenhuma intervenção pendente, por isso volta à fila de pronto para disputar 
novamente o uso da CPU. 
 
- Execução  Espera: esta transição acontece quando o processo foi interrompido 
por E/S. Significa que deve permanecer no estado de espera até que a interrupção 
seja tratada pelo sistema. Neste estado o processo fica impedido de disputar o uso 
da CPU. 
 
- Espera  Pronto: Após o término do tratamento da interrupção, o processo volta 
à fila de pronto para disputar novamente o uso da CPU. 
 
- Execução  Saída: o processo terminou, e não mais disputará o uso da CPU. 
 
A seguir, a figura mostra as mudanças possíveis de estado de um processo. 
 
 
 
 
 
 
 
 
 
 
 
 
 
Pronto 
Espera 
Execução 
Criação 
Saída 
Mudanças de estado de 
um processo 
 28 
5.4 Tipos de processos 
 
Além dos processos do usuário, a CPU também executa processos do sistema. São aqueles 
que oferecem os serviços do sistema operacional aos usuários, como criação/eliminação de 
processos, tratamento de interrupção e todos aqueles correspondentes às funções do sistema já 
estudadas. Estes executam sempre, com certa prioridade, concorrendo com os processos do 
usuário. 
 
Os processos em execução, do usuário, podem assumir dois tipos diferentes, de acordo com 
suas características de uso de CPU e periféricos: 
 
- Processo CPU-bound: é aquele processo que utiliza muito a CPU. Ele ganha uma fatia de 
tempo e a utiliza por inteiro, sem desperdiçar nenhum tempo. É o caso de programas 
científicos, de cálculo numérico, estatística, matemática, e também na área de simulação. 
Normalmente fazem pouca ou nenhuma entrada de dados, e muito processamento. 
 
- Processo I/O-bound: é o tipo de processo que utiliza muito mais E/S do que CPU. 
Aplicações em Banco de Dados, onde se faz consultas e atualizações constantes em 
arquivos em disco são um bom exemplo deste tipo de processo. De acordo com essas 
características, podemos dizer que este tipo de processo permanece mais tempo em 
espera (tratando interrupções) do que propriamente em execução, ocupando a CPU por 
períodos mínimos de tempo. 
 
 
 29 
6. Gerência do Processador 
 
6.1 Funções 
 
Com o surgimento dos sistemas multiprogramáveis, onde múltiplos processos poderiam 
permanecer na memória e disputar o uso de um único processador, a gerência doprocessador 
tornou-se uma das atividades mais importantes em um sistema operacional. 
 
A partir do momento em que vários processos podem estar no estado de pronto, devem 
ser estabelecidos critérios para definir qual processo será escolhido para fazer uso do 
processador. Tais critérios compõem a política de escalonamento, que é a base da gerência do 
processador e da multiprogramação em um sistema operacional. 
 
Dentre as funções da gerência do processador, podemos citar: manter o processador 
ocupado a maior parte do tempo. balancear o uso da CPU entre processos, privilegiar a 
execução de aplicações críticas, maximizar o throughput e oferecer tempos de resposta 
razoáveis aos usuários interativos. 
 
Cada sistema operacional possui sua política de escalonamento adequada ao seu 
propósito e às suas características. Sistemas de tempo compartilhado, por exemplo, possuem 
requisitos de escalonamento distintos dos sistemas de tempo real. 
 
 
6.2 Critérios de escalonamento 
 
- Utilização do processador: corresponde a uma taxa de utilização, que na maioria dos 
sistemas varia entre 30 e 90%. Uma utilização abaixo dos 30% indicaria um sistema 
ocioso, com carga de processamento baixa, enquanto uma taxa de utilização acima dos 
90% pode indicar um sistema bastante carregado, próximo da sua capacidade máxima 
(em alguns casos tal situação pode levar a um crash – travamento do sistema). 
 
- Throughput: é o número de processos executados em um determinado intervalo de 
tempo. Quanto maior o throughput, maior o número de tarefas executadas em função do 
tempo. A maximização do throughput é desejada na maioria dos sistemas. 
 
- Tempo de Processador: é o tempo que um processo leva no estado de execução, 
durante seu processamento. As políticas de escalonamento não interferem neste 
parâmetro, sendo este tempo função apenas do código executável e da entrada/saída de 
dados. 
 
- Tempo de Espera (pela CPU): é todo o tempo que o processo permanece na fila de 
pronto, aguardando a liberação da CPU para ser executado. A redução deste tempo de 
espera é desejada pela maioria das políticas de escalonamento. 
 
 30 
- Tempo de Turnaround: é o tempo total que o processo permaneceu no sistema, desde 
sua criação até o momento em que é encerrado. São contados os tempos de alocação 
de memória, espera na fila de pronto e interrupção (E/S). 
 
- Tempo de Resposta: é o tempo decorrido entre uma requisição ao sistema e o instante 
em que a resposta começa a ser exibida. Em sistemas interativos, como aplicações on-
line ou acesso à Web, os tempos de resposta devem ser da ordem de apenas poucos 
segundos. 
 
6.3 Escalonamentos Não-Preemptivos e Preemptivos 
 
Escalonamentos do tipo não-preemptivos são aqueles onde o sistema operacional não 
pode interromper o processo em execução para retirá-lo da CPU. Assim sendo, se nenhum 
evento externo ocorresse durante a execução do processo, este permanecia na CPU até 
terminar ou então alguma instrução do próprio programa o desviasse para o estado de espera 
(operação de E/S). 
 
Já os escalonamentos preemptivos são caracterizados pela possibilidade de o sistema 
operacional interromper o processo em execução para retirá-lo da CPU e dar lugar a outro. 
Neste caso o processo retirado da CPU volta ao estado de pronto, onde permanece 
aguardando nova oportunidade de ocupar a CPU. Com o uso da preempção, é possível ao 
sistema priorizar a execução de processos, como no caso de aplicações em tempo real. Outro 
benefício é a possibilidade de implementar políticas de escalonamento que compartilhem o 
processador de uma maneira mais uniforme, balanceando o uso da CPU entre os processos. 
 
São escalonamentos não-preemptivos: 
 
- FIFO: o processo que chegar primeiro à fila de pronto é selecionado para execução, e 
permanece utilizando o processador até terminar sua execução ou ser interrompido por 
E/S. Neste caso, o próximo processo da fila de pronto é selecionado para execução. 
Todo processo que chega à fila de pronto entra no final desta fila, conservando a ordem 
de chegada na fila, até ser escalonado novamente. Apesar de simples, este 
escalonamento apresenta algumas deficiências, principalmente no que diz respeito à 
dificuldade de se prever o início da execução de um processo, já que a ordem de 
chegada á fila de pronto deve ser observada à risca. Outro problema é quanto aos tipos 
de processo, onde os CPU-bound levam vantagem no uso do processador em relação 
aos do tipo I/O-bound, pois o sistema não trata este tipo de diferença. O escalonamento 
FIFO foi inicialmente implementado em sistemas monoprogramáveis, sendo ineficiente 
se aplicado em sistemas interativos de tempo compartilhado. 
 
 
 
 
 
 
 31 
Abaixo, um exemplo de escalonamento utilizando o método FIFO: a ordem de chegada 
dos processos (A, B, C) na fila de pronto foi obedecida, e, não tendo sido interrompidos por 
E/S, os processos executaram inteiramente até terminar, de acordo com seus tempos 
necessários para execução. 
 
0 10 18 27 
 
 
 
 Processo A Processo B Processo C 
 10 u.t. 8 u.t. 9 u.t. 
 
 
 
 
 
- SJF (Shortest Job First): este escalonamento seleciona o processo que tiver o menor 
tempo de processador ainda por executar. Desta forma, o processo que estiver na fila de 
pronto com menor necessidade de tempo de CPU para terminar o seu processamento 
será o escolhido para ocupar a CPU. Funciona com um parâmetro passado ao sistema 
via contexto de software, onde o tempo estimado para o processo é informado 
baseando-se em estatísticas de execuções anteriores. 
 
Como exemplo, vamos utilizar os mesmos processos executados no 
escalonamento FIFO acima, com seus respectivos tempos de execução em u.t. 
(unidades de tempo): processo A com 10 u.t., processo B com 8 u.t, e o processo C com 
9 u.t. Como neste escalonamento o que importa é o tempo de execução, a nova ordem 
de escalonamento para utilização da CPU será B, C e A, como segue: 
 
 0 8 17 27 
 
 
 Processo B Processo C Processo A 
 
 
- Cooperativo: este escalonamento busca aumentar o grau de concorrência no 
processador. Neste caso, um processo em execução pode voluntariamente liberar o 
processador retornando à fila de pronto, possibilitando que um novo processo seja 
escalonado, permitindo melhor distribuição do tempo do processador. A liberação da 
CPU é uma tarefa exclusiva do programa em execução, que de maneira cooperativa 
libera o processador para um outro processo. Neste mecanismo, o processo em 
execução verifica periodicamente uma fila de mensagens para saber se existem outros 
processos na fila de pronto. Porém, como a interrupção do processo não depende do 
sistema operacional, situações indesejáveis podem ocorrer, como por exemplo, se um 
programa em execução não verificar a fila de mensagens, os demais programas não 
 32 
terão chance de executar enquanto a CPU não for liberada. As primeiras versões do 
Windows chegaram a utilizar este tipo de escalonamento. 
 
São escalonamentos preemptivos: 
 
- Circular: é um tipo de escalonamento projetado especialmente para sistemas em tempo 
compartilhado. É muito semelhante ao FIFO (obedece a ordem de chegada á fila de 
PRONTO), mas quando um processo passa para o estado de execução há um limite de 
tempo para o uso contínuo do processador, chamado fatia de tempo (time-slice) ou 
quantum. Assim, toda vez que um processo é selecionado para execução uma nova fatia 
de tempo lhe é concedida. Caso esta fatia de tempo expire, o sistema operacional 
interrompe o processo, salva seu contexto e o direciona para a fila de PRONTO. Este 
mecanismo é conhecido como preempção por tempo. A principal vantagem deste 
escalonamento é não permitir que um processo monopolize aCPU. Outrossim, uma 
desvantagem é que os processos CPU-bound são beneficiados no uso do processador 
em relação aos processos I/O-bound, pois tendem a utilizar totalmente a fatia de tempo 
recebida. A figura a seguir mostra o escalonamento circular com 3 processos, onde a 
fatia de tempo é igual a 2 u.t. No exemplo não estão sendo levados em consideração 
tempos de troca de contexto entre os processos, nem o tempo perdido em operações de 
E/S. Os processos A, B e C, gastam 10 u.t, 6 u.t e 3 u.t., respectivamente. 
 
 
 
 
 
 
 
 
 
 
 
2 4 6 8 10 11 17 
 
 
- Por Prioridades: funciona com base num valor associado a cada processo, denominado 
prioridade de execução. O processo com maior prioridade na fila de PRONTO é sempre 
o escolhido para ocupar o processador, sendo os processos com prioridades iguais 
escalonados pelo critério FIFO. Neste escalonamento o conceito da fatia de tempo não 
existe. Como conseqüência disto, um processo em execução não pode sofrer preempção 
por tempo. Neste escalonamento a perda do uso do processador somente ocorrerá no 
caso de uma mudança voluntária para o estado de espera (interrupção por E/S), ou 
quando um outro processo de prioridade maior passa (ou chega) para o estado de 
pronto. Neste caso o sistema operacional interrompe o processo em execução, salva seu 
contexto e o coloca na fila de pronto, dando lugar na CPU ao processo prioritário. Este 
mecanismo é chamado de preempção por prioridade. A figura a seguir mostra a 
A 
 
 
B 
 
 
C 
u.t. 
 33 
execução dos processos A, B e C, com tempos de execução de 10, 4 e 3 u.t. 
respectivamente, e valores de prioridades de 2, 1 e 3, também respectivamente. Na 
maioria dos sistemas, valores menores correspondem à MAIOR prioridade. Assim, a 
ordem de execução será invertida para B, A e C. 
 
 
A 
 
B 
 
C 
 4 14 17 u.t. 
 
 
 A prioridade de execução faz parte do contexto de software do processo, e pode ser 
estática (quando não pode ser alterada durante a existência do processo) ou dinâmica 
(quando pode ser alterada durante a existência do processo). Este escalonamento é 
muito usado em sistemas de tempo real, com aplicações de controle de processos, 
controle de tráfego (sinais de trânsito, de trens/metrô, aéreo), robótica, entre outros. 
 
 
- Escalonamento Circular com Prioridades: implementa o conceito de fatia de tempo e de 
prioridade de execução associada a cada processo. Neste escalonamento, um processo 
permanece no estado de execução até que termine seu processamento, ou 
voluntariamente passe para o estado de espera (interrupção por E/S), ou sofra uma 
preempção por tempo ou prioridade. A principal vantagem deste escalonamento é 
permitir um melhor balanceamento no uso do processador, com a possibilidade de 
diferenciar o grau de importância dos processos através da prioridade (o Windows utiliza 
este escalonamento). 
 
- Por Múltiplas Filas: Este escalonamento implementa várias filas de pronto, cada uma 
com prioridade específica. Os processos são associados às filas de acordo com 
características próprias, como importância da aplicação, tipo de processamento ou área 
de memória necessária. Assim, não é o processo que detém a prioridade, mas sim a fila. 
O processo em execução sofre preempção caso um outro processo entre em uma fila de 
maior prioridade. O sistema operacional só pode escalonar processos de uma fila 
quando todas as outras filas de maior prioridade estejam vazias. Os processos sempre 
voltam para a mesma fila de onde saíram. 
 
- Por Múltiplas Filas com Realimentação: semelhante ao anterior, porém permitindo ao 
processo voltar para uma outra fila de maior ou menor prioridade, de acordo com seu 
comportamento durante o processamento. O sistema operacional identifica 
dinamicamente o comportamento de cada processo e o redireciona para a fila mais 
conveniente ao longo de seu processamento. É um algoritmo generalista, podendo ser 
implementado na maioria dos sistemas operacionais. 
 34 
7. Gerência de Memória / Memória Virtual 
 
 
7.1 Introdução 
 
 Historicamente, a memória principal sempre foi vista como um recurso escasso e caro. 
Uma das maiores preocupações dos projetistas foi desenvolver sistemas operacionais que não 
ocupassem muito espaço de memória e, ao mesmo tempo, otimizassem a utilização dos 
recursos computacionais. Mesmo atualmente, com a redução do custo e o aumento considerável 
da capacidade da memória principal, seu gerenciamento é dos fatores mais importantes no 
projeto e implementação dos sistemas operacionais. 
 
 Enquanto nos sistemas monoprogramáveis a gerência de memória não é muito complexa, 
nos sistemas multiprogramáveis essa gerência se torna crítica, devido à necessidade de se 
maximizar o número de usuários e aplicações utilizando eficientemente o espaço da memória 
principal. 
 
7.2 Funções 
 
 Geralmente, os programas são armazenados em memórias secundárias, de uso 
permanente e não voláteis, como discos ou fitas. Como o processador somente executa o que 
está na memória principal, o sistema operacional deve sempre transferir programas da memória 
secundária para a principal antes de serem executados.Como o tempo de acesso às memórias 
secundárias é muito superior ao tempo de acesso à memória principal, o sistema operacional 
deve buscar reduzir o número de operações de E/S (acessos à memória secundária) a fim de 
não comprometer o desempenho do sistema. 
 
 A gerência de memória deve tentar manter na memória principal o maior número de 
processos residentes, permitindo maximizar o compartilhamento do processador e demais 
recursos computacionais. Mesmo não havendo espaço livre, o sistema deve permitir que novos 
processos sejam aceitos e executados. Outra preocupação na gerência de memória é permitir a 
execução de programas maiores do que a memória física disponível. 
 
 Em um ambiente de multiprogramação o sistema operacional deve proteger as áreas de 
memória ocupadas por cada processo, além da área onde reside o próprio sistema. Caso um 
programa tente realizar algum acesso indevido à memória, o sistema deve, de alguma forma, 
impedir o acesso. 
 
7.3 Alocação Contígua Simples 
 
 Este tipo de alocação foi implementado nos primeiros sistemas operacionais, embora 
ainda nos dias de hoje esteja presente em alguns sistemas monoprogramáveis. Nesse modelo, a 
memória principal é dividida em duas partes, uma para o sistema operacional e a outra para o 
 35 
programa do usuário. Dessa forma, o programador deve desenvolver suas aplicações 
preocupado apenas em não ultrapassar o espaço de memória disponível. 
 
 Neste esquema o usuário tem total controle sobre toda a memória, exceto naquela área 
onde reside o sistema operacional, cujo endereçamento é protegido por um registrador, 
impedindo acesso indevido pelo usuário. 
 
 
 X 
 registrador 
 
 
 
 
 
 
 
Proteção na alocação contígua simples 
 
Apesar de simples implementação e código reduzido, a alocação contígua simples não 
permite a utilização eficiente dos recursos do sistema, pois apenas um usuário pode dispor 
destes recursos. Há inclusive um desperdício de espaço de memória, caso o programa não 
venha a ocupar toda a área reservada para ele. 
 
 
 
 
 
 
 
 
 
 
 
 
 Sub-utilização da memória principal 
 
 
 
7.4 Segmentação de Programas 
 
 Na alocação contígua simples todos os programas estão limitados ao tamanho da 
memória principal disponível para o usuário. Uma solução encontrada para o problema é dividir 
o programa em módulos, de modo que seja possível a execução independente de cada módulo, 
utilizando a mesma área de memória. A esta técnica dá-se o nome de segmentação ou overlay. 
Sistema 
OperacionalÁrea para 
programas 
Sistema 
Operacional 
 
Programa do 
Usuário 
 
Área livre 
 36 
 Consideremos um programa que tenha três módulos: um principal, um de cadastramento 
e outro de impressão, sendo os módulos de cadastramento e impressão independentes. A 
independência significa que quando um módulo estiver na memória para execução, o outro não 
necessariamente precisa estar presente.O módulo principal é comum aos outros dois, logo, 
precisa estar na memória durante todo o tempo da execução do programa. 
 
 Na figura a seguir, a memória é insuficiente para armazenar todo o programa, que 
totaliza 9 KB. A técnica de overlay utiliza uma área de memória comum para armazenar o 
módulo principal do programa e uma outra área na mesma memória, chamada área de overlay, 
que será compartilhada entre os módulos de cadastramento e impressão. Assim, sempre que 
um dos módulos for referenciado no módulo principal, o sistema o carregará da memória 
secundária para a área de overlay, sobrepondo o módulo antigo na memória. 
 
 
 Memória Principal 
 
 
 Cadastramento 
 
 
 
 
 
 Impressão 
 
 
 
 
 
 Técnica de Overlay 
 
 
 A definição das áreas de overlay é função do programador, através de comandos 
específicos da linguagem de programação utilizada. 
 
 A grande vantagem da utilização desta técnica consiste em se poder executar programas 
maiores do que a memória física disponível. 
 
 
7.5 Alocação Particionada Estática 
 
 Os sistemas operacionais evoluíram no sentido de proporcionar melhor aproveitamento 
dos recursos disponíveis. Nos sistemas monoprogramáveis o processador permanece grande 
parte do tempo ocioso e a memória principal é sub-utilizada. Os sistemas multiprogramáveis já 
Sistema 
Operacional 
Módulo 
Principal 
 
Área de 
Overlay 
Área livre 
 
 
 
 
2 KB 
 
3 KB 
 
 
 
4 KB 
 
 
1 KB 
 
4 KB 
 
 
 
 
2 KB 
 
2 KB 
 37 
são muito mais eficientes no uso do processador, necessitando que vários processos estejam na 
memória principal ao mesmo tempo e que novas formas de gerência de memória sejam 
implementadas. 
 
 Nos primeiros sistemas multiprogramáveis a memória era dividida em blocos de tamanho 
fixo, chamados partições.O tamanho dessas partições, estabelecido em tempo de inicialização 
do sistema, era definido em função do tamanho dos programas que executariam no 
ambiente.Sempre que fosse necessária a alteração do tamanho de uma partição, o sistema 
deveria ser inicializado novamente com uma nova configuração. 
 
 
Sistema 
Operacional 
 
Partição 1 2 KB 
Partição 2 5 KB 
Partição 3 8 KB 
 
 Inicialmente, os programas só podiam ser carregados e executados em apenas uma 
partição específica, mesmo que as outras estivessem disponíveis. Esta limitação se devia aos 
compiladores e linkeditores, que geravam apenas código absoluto. No código absoluto, todas as 
referências a endereços no programa são posições físicas na memória, ou seja, o programa só 
poderia ser carregado a partir do endereço de memória especificado no seu próprio código. A 
esse tipo de alocação de memória chamou-se alocação particionada estática absoluta. 
 
 Coma evolução dos compiladores, linkeditores, montadores e loaders, o código gerado 
deixou de ser absoluto e passou a ser relocável . No código relocável, todas as referências a 
endereços no programa são relativas ao início do código e não a endereços fixos na memória. 
Desta forma, os programas puderam ser alocados em qualquer partição livre, independente do 
endereço inicial e da partição para a qual o código foi criado. A esse tipo de alocação deu-se o 
nome de alocação particionada estática relocável. 
 
 Tanto nos sistemas de alocação absoluta como nos de alocação relocável, os programas, 
normalmente, não ocupam totalmente as partições onde são alocados, deixando algum espaço 
livre dentro das partições. Este tipo de problema, decorrente do esquema de alocação fixa de 
partições, é chamado fragmentação interna. 
 
 A figura a seguir mostra um gráfico representando o particionamento estático de uma 
memória e sua fragmentação interna. 
 
 
 
 
 38 
Memória Principal 
 
Sistema 
Operacional 
 
Programa C 
 1 KB 
Programa A 
 
 
 
3 KB 
Programa E 
 5 KB 
 
Alocação particionada estática com fragmentação interna 
 
 
 
7.6 Alocação Particionada Dinâmica 
 
 A alocação particionada estática deixou clara a necessidade de uma nova forma de 
gerência de memória principal, onde o problema da fragmentação interna fosse reduzido e, 
conseqüentemente, o grau de compartilhamento da memória aumentado. 
 
 Na alocação particionada dinâmica, foi eliminado o conceito de partições de tamanho fixo. 
Nesse esquema, cada programa, ao ser carregado, utilizaria o espaço necessário à sua 
execução, tornando esse espaço a sua partição. Assim, como os programas utilizam apenas o 
espaço de que necessitam, no esquema de alocação particionada dinâmica o problema da 
fragmentação interna deixa de existir. 
 
 Porém, com o término de alguns programas e o início de outros, passam a existir na 
memória blocos cada vez menores na memória, não permitindo o ingresso de novos programas. 
A este tipo de problema dá-se o nome de fragmentação externa. 
 
 Para resolver o problema da fragmentação externa, os fabricantes tentaram duas 
soluções: 
- reunião de todos os blocos livres adjacentes, formando uma grande área livre, que se 
transforma em uma nova partição; 
 
- realocação de todas as partições ainda ocupadas para a parte inicial da memória, 
eliminando os blocos livres entre elas, formando uma grande área livre no final da 
Fragmentação 
interna 
 39 
memória, que podia ser distribuída entre os processos ainda por executar. A este tipo 
de compactação de espaços livres foi dado o nome de alocação particionada dinâmica 
com realocação. 
 
Estas soluções ajudaram a diminuir os problemas da fragmentação (tanto interna como 
externa), mas, devido á complexidade dos algoritmos, nem todos os sistemas operacionais 
as utilizaram. 
 
 
7.7 Estratégias de Alocação de Partição 
 
 Os sistemas operacionais implementam basicamente três estratégias para determinar em 
qual área livre um programa será alocado para execução. Essas estratégias tentam evitar ou 
diminuir o problema da fragmentação. 
 
 A melhor estratégia a ser adotada por um sistema depende de uma série de fatores, 
sendo o mais importante o tamanho dos programas executados no ambiente. 
 
 Independentemente do algoritmo utilizado, o sistema possui uma lista das áreas livres, 
com endereço e tamanho de cada área. 
 
 São estratégias de alocação: 
 
- Best-fit: é escolhida a melhor partição, ou seja, aquela que deixa o menor espaço sem 
utilização. Uma grande desvantagem desta estratégia é que, como são alocados 
primeiramente as partições menores, deixando pequenos blocos, a fragmentação 
aparece mais rapidamente. 
 
- Worst-fit: aloca o programa na pior partição, ou seja, aquela que deixa o maior 
espaço livre. Esta técnica, apesar de aproveitar primeiro as partições maiores, acaba 
deixando espaços livres grandes o suficiente para que outros programas utilizem 
esses espaços, permitindo que um número maior de processos se utilizem da 
memória, diminuindo ou retardando a fragmentação. 
 
- First-fit: esta estratégia aloca o programa na primeira partição que o couber, 
independente do espaço livre que vai deixar. Das três estratégias, esta é a mais 
rápida, consumindo menos recursos do sistema. 
 
 
7.8 Swapping 
 
 É uma técnica aplicada à gerência de memória que visa dar maior taxa de utilização à 
memória principal, melhorando seu compartilhamento. Visa também resolver o problema da 
falta de memória principal num sistema. 
 40 
 Toda vez que um programa