SistemaOperacional Material de Apoio

Prévia do material em texto

CENTRO UNIVERSITÁRIO INTERNACIONAL – UNINTER 
CST EM ANALISE E DESENVOLVIMENTO DE SISTEMAS 
 
 
 
 
 
 
 
 
 
 
 
MATERIAL DE APOIO 
SISTEMAS OPERACIONAIS 
 
 
 
 
 
 
 
 
 
 
 
CURITIBA 
2015 
SUMÁRIO 
 
1 CONCEITOS .................................................................................................................... 3 
1.1 PROCESSAMENTO DE DADOS .......................................................................................... 3 
1.2 SISTEMA COMPUTACIONAL ............................................................................................. 3 
1.3 SISTEMA OPERACIONAL ................................................................................................. 3 
2 HISTÓRIA DOS SISTEMAS OPERACIONAIS ................................................................ 3 
3 TIPO DE SISTEMAS OPERACIONAIS ............................................................................ 4 
4 O CONCEITO DE CONCORRÊNCIA EM SISTEMAS OPERACIONAIS ........................ 6 
5 GERÊNCIA DE PROCESSOS ......................................................................................... 7 
5.1 THREADS ...................................................................................................................... 8 
5.1.1 CONCEITOS PARA GERENCIA DE THREADS .................................................................... 8 
5.1.2 PROBLEMA DE COMUNICAÇÃO ENTRE PROCESSOS OU THREADS ..................................... 9 
5.1.3 SEQÜÊNCIA LÓGICA PARA QUE PROCESSOS UTILIZEM RECURSOS DO SISTEMA ............... 10 
6 GERÊNCIA DO PROCESSADOR ................................................................................. 12 
6.1 CRITÉRIOS DE ESCALONAMENTO .................................................................................. 12 
6.2 TIPOS DE ESCALONAMENTOS ....................................................................................... 12 
7 GERÊNCIA DE MEMÓRIA ............................................................................................. 14 
7.1 TIPOS DE ALOCAÇÃO ................................................................................................... 14 
7.2 ESTRATÉGIAS DE ALOCAÇÃO DE PARTIÇÃO ................................................................... 15 
8 MEMÓRIA VIRTUAL ..................................................................................................... 15 
8 .1 MAPEAMENTO ............................................................................................................ 15 
8.2 TIPOS DE MEMÓRIA VIRTUAL ......................................................................................... 15 
8.3 MECANISMO DE TRADUÇÃO .......................................................................................... 16 
8.4 POLÍTICAS DE BUSCA DE PÁGINAS ................................................................................. 16 
8.5 POLÍTICAS DE ALOCAÇÃO DE PÁGINAS ........................................................................... 16 
8.6 POLÍTICAS DE SUBSTITUIÇÃO DE PÁGINAS ...................................................................... 16 
8.7 ALGORITMOS DE SUBSTITUIÇÃO DE PÁGINAS .................................................................. 17 
8.8 PRINCIPAIS ALGORITMOS DE SUBSTITUIÇÃO DE PÁGINAS ................................................. 17 
8.8 PROTEÇÃO DE MEMÓRIA .............................................................................................. 19 
8.9 COMPARTILHAMENTO DE MEMÓRIA ............................................................................... 19 
REFERÊNCIA ................................................................................................................... 20 
1 CONCEITOS 
 
1.1 PROCESSAMENTO DE DADOS 
 
O conceito de processamento de dados é definido como conceito fundamental 
em operação de computadores, consiste na entrada de dados por algum dispositivo 
(teclado, mouse) o processamento desses dados (unidade central de processamento – 
UCP) e a saída de uma resposta (monitor, impressora e etc). 
1.2 SISTEMA COMPUTACIONAL 
 
Um sistema computacional é composto por hardware e software. O hardware é 
composto de dispositivos de entrada, processamento e saída de dados, em essência 
são os componentes físicos da máquina, placa mãe, processadores, placas de vídeo, 
rede, áudio e os dispositivos de armazenamento. O software são os programas do 
computador, são classificados como software básico que são os programas de 
operação ou sistemas operacionais, software aplicativos que são os software de uso 
diversos, as ferramentas e as linguagens de programação. 
1.3 SISTEMA OPERACIONAL 
 
Um sistema operacional é um conjunto de elementos (programas) capazes de 
fazer um todo (computador) funcionar. É uma camada de software colocada entre o 
hardware e os programas que executam tarefas dos usuários. Seus principais 
objetivos são: tornar a utilização do computador mais eficiente e conveniente; 
distribuição dos recursos de memória, processador e dispositivos pelos programas; 
esconder os detalhes de baixo nível; prover recursos em alto nível para acesso a 
periféricos; 
 
2 HISTÓRIA DOS SISTEMAS OPERACIONAIS 
 
O primeiro computador digital foi desenvolvido por Charles Babbage, também 
chamado de motor analítico. A partir da década de 40 é possível observar uma 
evolução muito rápida dos computadores que no início se resumiam a grandes 
máquinas de calcular. 
Das máquinas construídas por meio de válvulas e reles, operadas 
exclusivamente pelos próprios engenheiros que participavam de sua construção, 
surgiram equipamentos menores baseados nos circuitos eletrônicos cada vez mais 
miniaturizados devido à evolução da indústria da microeletrônica. 
O primeiro sistema operacional, chamado monitor por sua 
simplicidade, foi desenvolvido em 1953 pelos usuários do 
computador IBM 701 do Centro de Pesquisas da Gereral Motors, 
justamente para tentar automatizar as tarefas manuais até então 
utilizadas. Posteriomente, este sistema seria reescrito para um 
computador IBM 704 pelo grupo de usuários da IBM (Weizer, 1981). 
Os sistemas operacionais foram desenvolvidos para automatizar a execução de 
programas (JOBS) e facilitar a vida de usuários e programadores. 
De programas pouco interativos baseados em terminais de comando, os 
sistemas operacionais foram evoluindo juntamente com o hardware e se tornando 
cada vez mais eficientes, interativos e cumprindo uma de suas principais funções, 
abstrair o hardware e disponibilizar os recursos de processamento para aplicativos e 
usuários. 
A medida que os computadores foram evoluindo, ganhando cada vez mais 
capacidade de processamento e armazenamento de dados, os sistemas operacionais 
foram implementando conceitos, de gerência de memória, processador, processos e 
outros dispositivos que permitem otimizar os recursos da máquina. 
 
3 TIPO DE SISTEMAS OPERACIONAIS 
Os sistemas operacionais são classificados quanto ao tempo de resposta e 
entrada de dados em sistema operacional em lote (batch), Interativos, tempo real, 
Híbridos. 
Sistema de processamento batch, não exige interação com usuário a entrada 
de dados feita por meio de um dispositivo, geralmente arquivos em disco, 
processamento de cálculos, compilações, ordenações, backups. Os sistemas 
interativos, também conhecidos como sistemas de tempo compartilhado, geralmente 
permitem a interação com usuário por meio de terminais, vídeo, teclado e mouse. 
Sistemas de processamento em tempo real, implementados para responder 100% 
das respostas em tempo real, o tempo de resposta é o fator principal do sistema, 
utilizado em monitoramentos, controle de tráfegoaéreo, de usinas nucleares. Os 
sistemas híbridos é uma combinação de sistema batch com sistemas interativos. 
Quanto a execução de tarefas os sistemas operacionais são classificados como 
sistemas monotarefas, multitarefas e multiprocessamento. 
Os sistemas monotarefas são caracterizados por executarem uma única 
aplicação de cada vez, já nos sistemas multitarefas, varias programas concorrem 
pelos recursos de processamento. Os sistemas multiprocessados, possuem duas ou 
mais CPUs interligas trabalhando em conjunto fortemente acoplados ou fracamenta 
acoplados. 
Os sistemas com multiprocessadores fortemente acoplados são aqueles que 
possuem duas ou mais CPUs que compartilham uma única memória e são controladas 
por um único sistema operacional. Os fracamente acoplados, possuem duas ou mais 
CPUs cada uma com a sua memória e controladas por sistemas operacionais 
independentes. 
Quanto a estrutura, os sistemas operacionais são classificados como 
Monolíticos, em camadas, máquinas virtuais e cliente servidor. 
Os sistemas operacionais ainda são classificados como sistemas operacionais 
de computadores de grande porte, servidores, computadores pessoais e sistemas 
operacionais embarcados. Os embarcados são sistemas que controlam dispositivos 
móveis ou que não são computadores, como exemplo, microondas, geladeiras os 
IPads, Iphone, PDAs e etc. 
Os sistemas operacionais modernos são dividos em várias camadas, onde cada 
camada prove serviços a camada superior mais próxima e oferece proteção a camada 
mais inferior, o núcleo do sistema ou Kernel do sistema operacional. 
O acesso ao recursos do Kernel é feito por meio de chamada de sistemas 
(system calls) de forma protegida para evitar dano ao sistema. As instruções que têm 
o poder de comprometer o sistema são conhecidas como instruções privilegiadas 
(modo kernel), enquanto as instruções não-privilegiadas são as que não oferecem 
perigo ao sistema. 
As chamadas de sistemas são os comandos de acesso as funções do SO, e 
podem ser dividas em chamadas para Gerenciamento de Processos, para sinalização, 
para gerencia de arquivos, para manipulação de diretórios, para proteção e para 
gerenciamento de tempo. 
4 O CONCEITO DE CONCORRÊNCIA EM SISTEMAS OPERACIONAIS 
 
Sistemas Operacionais podem ser vistos como um conjunto de rotinas 
executadas de forma concorrente e ordenada. (Pinkert, 1990). A possibilidade de o 
processador executar instruções ao mesmo tempo que outras operações, como, por 
exemplo, operações de E/S, permite que diversas tarefas sejam executadas 
concorrentemente pelo sistema. O conceito de concorrência é o princípio básico para 
o projeto e a implementação dos sistemas multiprogramáveis. 
Nos sistemas multiprogramáveis, vários programas podem estar residentes em 
memória, concorrendo pela utilização do processador. Dessa forma, quando um 
programa solicita uma operação de E/S outros programas poderão utilizar o 
processador. 
Para permitir a concorrência entre programas, o sistema operacional 
implementa vários mecanismos de software e ou de hardware. 
As interrupções é o mecanismo que tornou possível a implementação da 
concorrência nos computadores é sempre gerada por algum evento externo ao 
programa, exemplo uma operação de E/S. A exceção e gerada por um evento 
síncrono direto do programa concorrente. 
Os controladores são mecanismos de hardware que controlam as operações 
de I/o em disco, liberando o processador para executar outras tarefas. O controlador 
sinaliza as interrupções ao processador. 
A técnica de buffering consiste na utilização de uma área na memória principal, 
denominada buffer, para a transferência de dados entre os dispositivos de E/S e a 
memória. Esta técnica permite que em uma operação de leitura o dado seja transferido 
primeiramente para o buffer, liberando imediatamente o dispositivo de entrada para 
realizar nova tarefa. 
A técnica de spooling utiliza uma área em disco como se fosse um grande 
buffer. Neste caso, dados podem ser lidos ou gravados em disco, enquanto programas 
são executados concorrentemente. Todos os sistemas operacionais utilizam esta 
técnica no gerenciamento de impressão. (arquivos de spool). 
A reentrância é a capacidade de um código executável (código reentrante) ser 
compartilhado por diversos usuários, exigindo que apenas uma cópia do programa 
esteja na memória. 
 
5 GERÊNCIA DE PROCESSOS 
 
Um processo pode ser entendido inicialmente como um programa em 
execução, só que seu conceito é mais abrangente. Este conceito torna-se mais claro 
quando pensamos de que forma os sistemas multiprogramáveis (multitarefa) atendem 
os diversos usuários (tarefas) e mantêm informações a respeito dos vários programas 
que estão sendo executados concorrentemente [MACHADO, 1997]. 
Um processo possuí informações do contexto de hardware, software e 
endereçamento de memória. 
O contexto de hardware é fundamental para a implementação dos sistemas 
time-sharing, onde os processos se revezam na utilização do processador, podendo 
ser interrompidos e, posteriormente, restaurados como se nada tivesse acontecido. A 
troca de um processo por outro na CPU, realizada pelo sistema operacional, é 
denominada mudança de contexto (context switching). A mudança de contexto 
consiste em salvar o conteúdo dos registradores da CPU e carregá-los com os valores 
referentes ao do processo que esteja ganhando a utilização do processador. Essa 
operação resume-se, então, em substituir o contexto de hardware de um processo 
pelo de outro. 
O contexto de software especifica características do processo que vão influir 
na execução de um programa, como o número máximo de arquivos abertos 
simultaneamente ou o tamanho do buffer para operações de E/S. Essas 
características são determinadas no momento da criação do processo, mas algumas 
podem ser alteradas durante sua existência. O contexto de software define 
basicamente três grupos de informações de um processo: sua identificação, suas 
quotas e seus privilégios. 
O espaço de endereçamento é a área de memória do processo onde um 
programa poderá ser executado, além do espaço para os dados utilizados por ele. 
Cada processo possui seu próprio espaço de endereçamento, que deve ser protegido 
do acesso dos demais processos. 
Os processos são executados de forma cíclica alternando seu estado. Estado 
de execução (running) quando está sendo processado pela CPU. Estado de pronto, 
(ready) quando apenas aguarda uma oportunidade para executar, ou seja, espera que 
o sistema operacional aloque a CPU para sua execução. Estado de espera (wait) 
quando aguarda algum evento externo ou algum recurso para poder prosseguir seu 
processamento. 
5.1 THREADS 
 
Em sistemas tradicionais, cada processo tem seu espaço de endereçamento 
individual e apenas um fluxo de controle (thread). No entanto, algumas vezes 
desejamos ter vários fluxos de controle (threads) no mesmo espaço de 
endereçamento simulando uma execução em paralelo, como se cada fluxo fosse visto 
realmente como um processo distinto (exceto pelo fato de compartilharem um único 
espaço de endereçamento). 
Muitos threads podem existir dentro de um único contexto de processo, 
cooperando entre si a fim de realizar um dado cálculo e compartilhando o espaço de 
endereçamento e o restante do contexto desse processo. (multithread). 
Um ambiente multithread se utiliza dos mesmos mecanismos de concorrência 
entre processos, interrupções, exceções e a comunicação entre processos (Inter 
Process Comunication – IPC), essenciais para permitir acesso concorrente a um 
recurso compartilhado. 
5.1.1 CONCEITOS PARA GERENCIA DE THREADS 
 
Região Crítica: Também chamada de SeçãoCrítica. É a parte do sistema que 
permite acesso concorrente entre os processos. Exemplo: spool de impressão, buffer 
de memória, etc.; 
Exclusão Mútua: É uma técnica usada em programação concorrente para 
evitar que dois ou mais processos ou threads tenham acesso simultaneamente a um 
recurso compartilhado do sistema, ou seja, a uma regição crítica; 
Sinais: São interrupções de software que notificam ao processo que um evento 
ocorreu. Os sinais não permitem que processos especifiquem dados para trocar com 
outros processos. São utilizados para sincronização entre processos e S.O, ou seja, 
os sinais só ocorrem entre processos ou entre um processo e o S.O. 
Trap: É o sinal que o processo envia para o S.O solicitando um serviço 
protegido do mesmo (como por exemplo sua entrada em uma região crítica). Um trap 
bloqueia o processo até que o serviço requerido pelo mesmo, ao sistema operacional, 
seja realizado. 
5.1.2 PROBLEMA DE COMUNICAÇÃO ENTRE PROCESSOS OU THREADS 
 
Processos podem solicitar recursos, mesmo que estejam de posse de recursos 
obtidos anteriormente. Caso estes recursos já estejam alocados a outros processos, o 
processo solicitante deve aguardar pela liberação do mesmo. Essa é a condição 
natural do sistema de alocação de recursos, porém, alguns problemas naturalmente 
podem ocorrer, neste caso temos os problemas de comunicação entre processos ou 
threads. 
Condição de Corrida: Também chamada de Corriza de Hazards, é uma das 
conseqüências da sincronização incorreta, gerando a disputa de recursos do sistema 
por múltiplos processos, ou threads, causando o corrompimento dos dados, onde 
parte dos dados são modificados por um processo/thread e parte por outro, ou seja, 
acontece quando dois ou mais processos entram simultaneamente na região crítica. 
Starvation: Também chamado de Livelock, acontece quando 
processos/threads estão em execução, mas nada acontece, isso ocorre geralmente 
quando dois ou mais processos/threads então trabalhando com intenções contrarias, o 
que é feito por um processo/thread é desfeito pela outro. Também ocorre quando um 
processo/thread tenta o acesso a um recurso que está sendo utilizado por outro 
processo/thread, o S.O pede para que o mesmo aguarde sua liberação, porém o 
processo/thread não está preparado para o aguardo, ou seja, ele vai continuar 
solicitando o recurso indefinidamente, mesmo que o recurso seja liberado, pois o 
processo/thread não foi programado para uma “rejeição”. 
Deadlock: É o problema mais terrível e mais estudado em sistemas 
operacionais. É uma situação em que dois ou mais processos/threads estão em 
estado simultâneo de espera, cada um aguardando que um dos demais libere um 
bloqueio para ele poder prosseguir, ou seja, um conjunto de N processos está em 
deadlock quando cada um dos N processos está bloqueado à espera de um recursos 
que somente pode ser liberado por um processo desse conjunto. 
 
Situação de um deadlock no trânsito. 
5.1.3 SEQÜÊNCIA LÓGICA PARA QUE PROCESSOS UTILIZEM RECURSOS DO 
SISTEMA 
 
Pedido: o processo cria um trap para solicitar um recurso. Se o processo não tiver 
seu pedido atendido, pois o recurso não está livre, ele é bloqueado e ficará 
esperando até ganhar a posse do recurso. 
Uso: tendo posse do recurso ele poderá utilizá-lo. 
Liberação: desalocar o recurso adquirido pelo processo o liberando para outro 
processo. O gerenciamento desses recursos é feito pelo sistema operacional 
através de uma tabela, que registra se cada recurso está livre ou ocupado. Caso o 
recurso esteja ocupado, também é especificado o processo que tem a posse do 
recurso. 
6 GERÊNCIA DO PROCESSADOR 
 
A política de escalonamento de um sistema operacional tem diversas funções 
básicas, como a de manter o processador ocupado a maior parte do tempo, 
balancear o uso da UCP entre processos, privilegiar a execução de aplicações 
críticas, maximizar o throughput do sistema e oferecer tempos de resposta 
razoáveis para usuários interativos. 
Em ambientes que implementam apenas processos, o escalonamento é realizado 
com base nos processos prontos para execução. Em sistemas que implementam 
threads, o escalonamento é realizado considerando os threads no estado de 
pronto, independentemente do processo. 
 
6.1 CRITÉRIOS DE ESCALONAMENTO 
 
As características de cada sistema operacional determinam quais são os principais 
aspectos para a implementação de uma política de escalonamento adequada. Os 
principais critérios são: 
Utilização do processador: Na maioria dos sistemas é desejável que o 
processador permaneça a maior parte do tempo ocupado. 
Throughput: representa o número de processos executados em um determinado 
intervalo de tempo. 
Tempo de Processador /Tempo de UCP: É o tempo que um processo leva no 
estado de execução durante seu processamento. 
Tempo de Espera: É o tempo total que um processo permanece na fila de pronto 
durante seu processamento, aguardando para ser executado. 
Tempo de Turnaround: É o tempo que um processo leva desde a sua criação até 
seu término, levando em consideração todo o tempo gasto na espera para 
alocação de memória, espera na fila de pronto, processamento na UCP e na fila de 
espera, como nas operações de E/S. 
Tempo de Resposta: Tempo decorrido entre uma requisição ao sistema ou à 
aplicação e o instante em que a resposta é exibida. 
 
6.2 TIPOS DE ESCALONAMENTOS 
 
Não-Preemptivos e Preemptivos: As políticas de escalonamento podem ser 
classificadas segundo a possibilidade de o sistema operacional interromper um 
processo em execução e substituí-lo por um outro, atividade esta conhecida como 
preempção. O escalonamento não-preemptivo (sem interrupção) foi o primeiro tipo 
de escalonamento implementado nos sistemas multiprogramáveis, onde 
predominava tipicamente o processamento bath. No escalonamento preemptivo, o 
sistema operacional pode interromper um processo em execução e passá-la para o 
estado de pronto, com o objetivo de alocar outro processo na UCP. 
 
Escalonamento First-in-First-Out (FIFO): O processo que chegar primeiro ao 
estado de pronto é o selecionado para execução. 
Escalonamento Shortest-Job-First (SJF): Seleciona primeiro o processo de 
menor tempo de processador ainda por executar. 
Escalonamento Cooperativo: É uma implementação que busca aumentar o 
grau de multiprogramação em políticas de escalonamentos que não possuam 
menanismos de preempção. Neste caso, um processo em execução pode 
voluntariamente liberar o precessador para outro processo. 
Escalonamento Circular: É um escalonamento do tipo preemptivo, projetado 
especialmente para sistemas de tempo compartilhado. Quando um processo passa 
para o estado de execução existe um tempo-limite para uso contínuo do processador 
denominado fatia de tempo (time slice) ou quantum. 
Escalonamento por Prioridades: É um escalonamento do tipo preemptivo 
realizado com base em um valor associado a cada processo denominado prioridade 
de execução. O processo com maior prioridade no estado de pronto é sempre o 
escolhido para execução, e processos com valores iguais são escalonados seguindo 
critérios de FIFO. 
Escalonamento Circular com Prioridades: Implementa o conceito de fatia de 
tempo e de prioridade de execução associada a cada processo. 
Escalonamento por Múltiplas Filas: Existem diversas filas de processos no 
estado de pronto, cada qual com uma prioridade específica. Os processos são 
associados às filas em função de características próprias, como importância para a 
aplicação , tipo de processamento ou área de memória necessária. 
Escalonamento por Múltiplas Filas com Realimentação: É semelhante ao 
escalonamento por MúltiplasFilas, porém os processos podem trocar de filas durante 
seu processamento. Possibilidade de reorganizar os processos nas filas de acordo 
com o seu comportamento. 
 
7 GERÊNCIA DE MEMÓRIA 
 
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. 
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. 
 
7.1 TIPOS DE ALOCAÇÃO 
 
Alocação Contigua Simples: A memória principal é subdivida em duas áreas: 
uma para o sistema operacional e outra para o programa do usuário. 
Técnica de Overlay: A memória é dividida em área do sistema operacional, 
área do módulo principal do programa do usuário e uma área de troca entre os 
módulos secundários do programa do usuário, denominada área de overlay. 
Alocação Particionada Estática ou fixa: A memória era dividida em pedaços 
de tamanho fixo, chamado partições. O tamanho das participações, estabelecido na 
fase de inicialização do sistema, era definido em função do tamanho dos programas 
que executariam no ambiente. Alocação fixa com código absoluto os programas só 
podem ser executados em posições físicas de memória. Alocação fixa com código 
relocável, todas as referências a endereços no programa são relativas ao inicio do 
código, e não a endereços físicos de memória. Nesse tipo de alocação o principal 
problema é a fragmentação interna, os espaços que sobram nas partições quando 
alocado aplicações e tamanho menor que a partição. 
Alocação Particionada Dinâmica: As partições são criadas exatamente de 
acordo com o tamanho dos programas que serão executadas, eliminando problema da 
fragmentação interna. Cada vez que surge um novo programa para ser executado, são 
criadas novas partições, com isso surge um novo problema, a fragmentação externa, 
que são as partições tão pequenas que não suficientes para alocar os programas 
necessários. 
 
7.2 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á carregada para execução. 
Essas estratégias tentam evitar ou diminuir o problema da fragmentação externa. 
Best-fit, a melhor partição é escolhida, ou seja aquela em que o tamanho da 
partição tem o mesmo tamanho do programa. Worst-fit, nesta estratégia a pior 
partição é escolhida, deixando espaços livres maiores permitindo que mais 
programas sejam executados, diminuindo o problema da fragmentação. First-Fit, a 
primeira partição livre de tamanho suficiente para carregar o programa é escolhida. 
 
Swapping: É uma técnica aplicada à gerência de memória para programas que 
esperam por memória livre para serem executadas. Nesta situação, o sistema 
escolhe um processo residente, que é transferido da memória principal para a 
memória secundária (swap out), geralmente em disco. 
 
8 MEMÓRIA VIRTUAL 
 
É uma técnica sofisticada e poderosa de gerência de memória, onde as memórias 
principal e secundária são combinadas dando ao usuário a ilusão de existir uma 
memória muito maior que a capacidade real da memória principal. O conceito de 
memória virtual fundamenta-se em não vincular o endereçamento feito pelo 
programa dos endereços físicos da memória principal. 
 
8 .1 MAPEAMENTO 
 
 O mapeamento é o mecanismo que permite a conversão do endereço virtual 
em endereço real. Nos sistemas modernos a tarefa de tradução dos endereços 
virtuais é realizada por hardware juntamente com o sistema operacional, de forma 
a não comprometer seu desempenho e torná-lo transparente a usuários e 
aplicações. O dispositivo de hardware responsável por esta tradução é conhecido 
como unidade de gerência de memória (Memory Management Unit – MMU), sendo 
acionado sempre que se faz referência a um endereço virtual. 
 
8.2 TIPOS DE MEMÓRIA VIRTUAL 
 
Memória Virtual – Paginação - A memória virtual por paginação é a técnica 
de gerência de memória onde o espaço de endereçamento real são divididos em 
blocos de mesmo tamanho chamado páginas. 
 
Memória Virtual – Segmentação - Memória virtual por segmentação é a 
técnica de gerência de memória onde o espaço de endereçamento virtual é dividido 
em blocos de tamanhos diferentes chamados segmentos. 
 
Enquanto na paginação existe o problema da fragmentação interna, na 
segmentação surge o problema da fragmentação externa. 
 
8.3 MECANISMO DE TRADUÇÃO 
 
Sempre que o processo referencia um endereço virtual, a unidade de 
gerência de memória verifica, através do bit de validade, se a pagina que contém o 
endereço referenciado está ou não na memória principal. Caso a página não 
esteja na memória, dizemos que ocorreu um page fault. Para corrigir o erro o 
sistema deverá transferir a página da memória secundaria para principal. 
 
8.4 POLÍTICAS DE BUSCA DE PÁGINAS 
 
O mecanismo de memória virtual permite a execução de um programa sem 
que seu código esteja completamente residente na memória principal. A política de 
busca de páginas determina quando uma página dever ser carregada para a 
memória. Paginação por demanda e paginação antecipada. 
 
8.5 POLÍTICAS DE ALOCAÇÃO DE PÁGINAS 
 
A política de alocação de páginas determina quantos frames cada processo 
pode manter na memória principal. 
Alocação fixa: cada processo tem um numero máximo de páginas que 
pode ser utilizado durante sua execução. 
Alocação variável: o numero máximo de páginas alocadas ao processo 
pode variar durante sua execução. 
 
8.6 POLÍTICAS DE SUBSTITUIÇÃO DE PÁGINAS 
 
Consiste na atuação do sistema operacional na substituição páginas (Page 
out e Page in) quando o processo atinge o numero máximo de páginas que foram 
alocadas. 
Working Set: Tem o objetivo de reduzir o problema de thrashing 
(sucessivos page faults e I/O de páginas) e erros de page faults (páginas não 
encontradas na memória). 
 
8.7 ALGORITMOS DE SUBSTITUIÇÃO DE PÁGINAS 
 
Os algoritmos de substituição de páginas tem o objetivo de selecionar os 
frames que tenham as menores chances de serem referenciados em um futuro 
próximo. A partir do princípio da localidade, a maioria dos algoritmos tenta prever o 
comportamento futuro das aplicações em função do comportamento passado, 
avaliando o numero de vezes que uma página foi referenciada, o momento em que 
foi carregada para memória principal e o intervalo de tempo da última referência. 
 
8.8 PRINCIPAIS ALGORITMOS DE SUBSTITUIÇÃO DE PÁGINAS 
 
Ótimo: seleciona para substituição uma página que não será mais referenciada no 
futuro ou aquela que levará o maior intervalo de tempo para ser novamente utilizada. 
 
Aleatório: Todas as páginas alocadas na memória principal têm a mesma chance 
de serem selecionadas, inclusive os frames que são freqüentemente referenciados. 
Consome pouco recurso de memória, mas possui baixa eficiência. 
FIFO: Seleciona para substituição a primeira página que foi utilizada e que está a 
mais tempo na memória. A fila é por ordem de tempo, as primeiras utilizadas são as 
primeiras da fila. 
LFU (least frequently used): A página que possuir o contador com o menor número 
de referências será escolhida, ou seja, o algoritmo evita selecionar páginas que são 
bastante utilizadas. O problema é que justamente as páginas que estão a pouco tempo na 
memória é que podem ser selecionadas. 
 LRU (least recently used): Seleciona a página na memória principalque está há 
mais tempo sem ser referenciada. É necessário que cada página tenha a ela associado o 
momento do último acesso, que deve ser atualizado a cada referência a um frame. 
Quando for necessário substituir uma página, o sistema fará uma busca por um frame que 
esteja há mais tempo sem ser referenciado. Outra maneira de implementar o LRU seria 
através de uma lista encadeada, onde todas as páginas estariam ordenadas pelo 
momento da última referencia. Elevado custo de implementação. 
NRU (not recently used): O algoritmo NRU é bastante semelhante ao LRU, porém 
com menor sofisticação. Para a implementação deste algoritmo é necessário um bit 
adicional, conhecido como bit de referência (BR). O bit indica se a página foi utilizada 
recentemente e está presente em cada entrada da tabela de páginas. 
Quando uma página é carregada para a memória principal, o bit de referência é 
alterado pelo hardware, indicando que a página foi referenciada (BR=1). No momento da 
substituição de uma página, o sistema seleciona um dos frames que não tenha sido 
utilizado recentemente, ou seja, com o bit de referência igual a zero. 
 
Categorias Bits avaliados Resultado 
1 BR = 0 BM = 0 Página não referenciadas e não modificada. 
2 BR = 0 BM = 1 Página não referenciadas e modificada. 
3 BR = 1 BM = 0 Página referenciada e não modificada. 
4 BR = 1 BM = 1 Página referenciada e modificada. 
 
FIFO com buffer de páginas: O algoritmo FIFO com buffer de páginas combina 
uma lista de páginas alocadas (LPA) com uma lista de páginas livres (LPL). A LPA 
organiza todas as páginas que estão sendo utilizadas na memória principal, podendo ser 
implementada como uma lista única para todos os processos ou uma lista individual para 
cada processo. Independente da política utilizada, a LPA organiza as páginas alocadas há 
mais tempo na memória no início da lista, enquanto as páginas mais recentes no seu 
final. Da mesma forma, a LPL organiza todos os frames livres da memória principal, 
sendo que as páginas livres há mais tempo estão no início e as mais recentes no final. 
Sempre que um processo necessita alocar uma nova página, o sistema utiliza a primeira 
página da LPL, colocando-a no final da LPA (figura 15a). Caso o processo tenha que 
liberar uma página, o mecanismo de substituição seleciona o frame em uso há mais 
tempo na memória, isto é, o primeiro da LPA, colocando-o no final da LPL (figura 15b). 
 
É importante notar que a página selecionada e que entrou na LPL continua 
disponível na memória principal por um determinado intervalo de tempo. Caso esta página 
seja novamente referenciada e ainda não tenha sido alocada, basta retirá-la da LPL e 
devolvê-la ao processo (figura 15c). Nesse caso, a LPL funciona como um buffer de 
páginas, evitando o acesso à memória secundária. Por outro lado, se a página não for 
mais referenciada, com o passar do tempo irá chegar ao início da LPL, quando será 
utilizada para um outro processo. Caso a página seja posteriormente referenciada, o 
sistema terá que carregá-la novamente da memória secundária. 
 
FIFO circular: O algoritmo FIFO circular utiliza como base o FIFO, porém as 
páginas alocadas na memória estão em uma estrutura de lista circular, semelhante a um 
relógio. Este algoritmo é implementado, com pequenas variações na maioria dos sistemas 
Unix. Para a implementação do algoritmo existe um ponteiro que guarda a posição da 
página mais antiga na lista (figura 16a). Cada página possui associado um bit de 
referência, indicando se a página foi recentemente referenciada. Quando é necessário 
substituir uma página, o sistema verifica se o frame apontado tem o bit de referência 
desligado (BR = 0). Nesse caso, a página é selecionada para descarte, pois, além de ser 
a mais antiga, não foi utilizada recentemente. Por outro lado, se a página apontada tem o 
bit de referência ligado (BR = 1), o bit é desligado e o ponteiro incrementado, pois, apesar 
de ser a página mais antiga, foi utilizada recentemente. O processo se repete até ser 
encontrada uma página com bit de referência igual a zero (figura 16b). 
 
Neste algoritmo, existe a possibilidade de todos os frames possuírem o bit de 
referência ligado. Nesse caso, o ponteiro percorrerá toda a lista, desligando o bit de 
referência de cada página. Ao final, a página mais antiga é selecionada. A utilização do bit 
de referência permite conceder a cada página uma segunda chance antes de ser 
substituída. É possível melhorar a eficiência do algoritmo utilizando o bit de modificação, 
juntamente com o bit de referência, como apresentado no esquema NRU. 
 
8.8 PROTEÇÃO DE MEMÓRIA 
 
Em qualquer sistema multiprogramável, onde diversas aplicações compartilham a 
memória principal, devem existir mecanismos para preservar as áreas de memória do 
sistema operacional e dos diversos processos dos usuários. 
Um primeiro nível de proteção é inerente ao próprio mecanismo de memória virtual 
por paginação. Neste esquema, cada processo tem a sua própria tabela de mapeamento 
e a tradução dos endereços é realizada pelo sistema. Desta forma, não é possível a um 
processo acessar áreas de memória de outros processos, a menos que haja 
compartilhamento explícito de páginas entre processos. A proteção de acesso é realizada 
individualmente em cada página da memória principal, utilizando-se as entradas das 
tabelas de mapeamento, onde alguns bits especificam os acessos permitidos. 
 
8.9 COMPARTILHAMENTO DE MEMÓRIA 
 
Em sistemas que implementam memória virtual, é bastante simples a 
implementação da reentrância, possibilitando compartilhamento de código entre os 
diversos processos. Para isso, basta que as entradas das tabelas de mapeamento dos 
processos apontem para os mesmos frames na memória principal, evitando, assim, várias 
cópias de um mesmo programa na memória. Apesar de os processos compartilharem as 
mesmas páginas de código, cada um possui sua própria área de dados em páginas 
independentes. 
 
 
REFERÊNCIA 
 
MACHADO, Francis Berenger e MAIA, Paulo Luiz. Arquitetura de Sistemas 
Operacionais – 4ª edição. LTC, 2007. 
TANENBAUM & WOODHULL. Sistemas Operacionais, Projeto e Implementação – 3ª 
edição. Bookman, 2008.