SOII_Materia_Parte07

Prévia do material em texto

SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 1 
 
Onde fica o Sistema Operacional na paginação? O SO tem que ocupar de alguma forma a memória 
verdadeira. Mas, na memória lógica onde ele fica? Como ele vai ocupa-la? 
 
1ª abordagem para tratar esta questão: 
 
37) O SO ESTAR NA SUA PRÓPRIA MEMÓRIA LÓGICA 
 
Quando o SO executa ele executa a memória logica dele. Esta estrutura não é muito utilizada porque 
ela tem um problema na maior parte de HW de desempenho que tem haver com a TLB. A Figura 1 
mostra a disposição do SO na sua memória lógica e a sua ocupação na memória física. 
 
 
Figura 1 
 
Vimos anteriormente que a TLB é uma estrutura da Tabela de Paginas. Ela guarda o numero da 
pagina logica. A Figura 2 mostra a TLB do SO. 
 
 
Figura 2 
 
Quando o processo começa a rodar a TLB não tem dado nenhum e é preenchida conforme as paginas 
logicas vão sendo acessadas. Digamos que o processo 1 mostrado na Figura 1 tenha rodado um 
pouco e o HW já preencheu a TLB com alguma informação do processo 1. Por exemplo, a pagina 
logica 0 está na página física 2 (executável e não alterável). A pagina logica 2 está na pagina física 4 
(não executável e alterável). E assim por diante. Assim a conversão pode ser feita via TLB que é 
mais rápido. 
 
Quando o código do processo esta rodando o HW faz as conversões na tabela de paginas do processo 
e os dados de conversão são colocados na TLB. A questão é a seguinte de tempos em tempos 
ocorrem interrupções. Tem interrupções motivadas por eventos de HW e também o SO entra em 
execução não só para tratar a interrupção, mas também porque o processo faz chamadas ao SO. 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 2 
 
Nesse caso em que o SO tem a memória logica só dele quando ele entra em execução seja porque 
ocorreu uma interrupção sela porque um processo fez uma chamada ao SO. O SO precisa rodar o 
código dele e acessar a memoria logica dele. Só que a memoria logica dele tem outra memória física. 
A pagina logica 0 do Processo 1 está na pagina física 2 e a pagina logica 0 do SO está na pagina 
física 1. 
 
Então as conversões que se encontram na TLB elas são validas enquanto o código do processo 1 
estiver executando. Se entrar em execução o código do SO as conversões que se encontram na TLB 
não vão mais para o local correto estão erradas, pois não valem para o SO. 
 
O que é feito nesse caso? Quando tem que executar código da memória logica do SO o HW tem 
também que esvaziar o conteúdo que está na TLB porque ele não é valido para a memoria logica do 
SO. Este conteúdo era valido somente para o processo 1. 
 
Conclusão quando ocorre uma interrupção ou quando um processo chama o SO o HW precisa limpar 
o conteúdo da TLB. Este tipo de TLB tem que ser limpa ao trocar o processo ser executado. E as 
conversões do outro processo, nesse caso, do SO são colocadas na TLB. 
 
Qual é o problema dessa solução? O problema é que toda vez que é preciso esvaziar a TLB. As 
conversões seguintes são feitas usando a Tabela de paginas daquele momento. Isto também acontece 
quando o processo em execução é trocado. 
 
Como cada processo tem a sua memoria logica diferente quando o SO escalona outro processo é 
necessário esvaziar a TLB. Quando outro processo entrar em execução primeiramente as conversões 
são feitas via Tabela de paginas e só depois e preenchida a TLB que passa ser usada pelo HW para 
realizar as conversões. 
 
A memoria logica do SO e independente da memoria logica do Processo. Quando ocorre uma 
chamada ao SO ou quando ocorre uma interrupção o SO passa a executar mais devagar, pois as 
conversões de pagina logica para pagina física tem que ser feitas via Tabela de Páginas. 
 
É muito mais frequente o SO entrar em execução do que outro processo. Tipicamente o que acontece 
para outro processo entrar em execução? O processo fica bloqueado ou acaba o time sline. Que é 
uma coisa que não ocorre muitas vezes por segundo ocorre algumas vezes. Já as interrupções e 
chamadas ao SO podem ocorrer centenas por segundo. É um numero muito maior. 
 
Só um tipo de interrupção que é a interrupção chamada de relógio ela ocorre 100 por segundo. Esta 
interrupção existe para tratar as coisas que tem haver com o tempo. Por exemplo, a manutenção da 
hora atual, o time line. 
 
Existe também outro relógio na maquina, mas ele é consultado só quando a maquina dá o boot 
depois disso quem controla a hora e sabe que horas são é a interrupção de relógio. 
 
Aconteceram 10 interrupções de relógio em um segundo e é o mesmo processo que esta em execução 
então ele é retirado da CPU e outro processo é escalonado para executar. 
 
 
É muito mais frequente o código do SO entrar em execução do que o código do processo. O processo 
pode fazer varias chamadas ao SO. A cada chamada ao SO tem que rodar o código do SO. Nessa 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 3 
 
execução vai ter que fazer o que a cada chamada ao SO? O HW vai ter que limpar o conteúdo da 
TLB. O HW ao executar o código do SO tem que fazer as conversões de paginas e colocar na TLB. 
 
Alguns HW tem outro tipo de TLB nomeada TLB com o Nº do Processo. 
 
 
Figura 4 
 
Então além destes campos convencionais que a TLB tinha agora tem outro o Nº do Processo. O 
processo 1 começou a executar agora e a TLB está fazia. Então o HW faz as conversões via Tabela 
de páginas e preenche a TLB aos poucos com as conversões do processo 1. A Figura 4 contém as 
conversões realizadas pelo HW MMU do processo1. Ocorreu uma interrupção ou uma chamada do 
SO. Então tem que executar o código do Sistema Operacional. Tem que mudar a memoria logica 
típica. Só que neste tipo de TLB não precisa limpar o conteúdo que está na TLB. 
 
Nesse tipo de TLB como tem o campo Nº do Processo que diz de que tabela veio a conversão não 
precisa limpar o conteúdo que está na TLB. Quando ocorre uma interrupção ou é feita uma chamada 
ao SO e ele tem que executar. Como não tem que limpar a TLB é só executar o conteúdo do SO. A 
Figura 4 mostra as conversões do SO cujo Nº do Processo é o zero. 
 
Acaba a interrupção e a próxima vez que ocorrer uma interrupção e estiver que entrar em execução o 
SO é possível e muito provável que ainda tenha na TLB dados de conversão a respeito do SO. Então 
é provável quando o SO voltar a executar o HW pode usar conversões que ainda estão na TLB. 
Logo, o SO volta a executar de forma mais rápida, pois o HW encontra as conversões na TLB. A 
execução posterior do SO é mais rápida. Não precisa fazer conversões usando tabela de paginas que 
é mais lenta. 
 
Esta solução de ter o SO na memoria logica dele é uma solução que tem perda de desempenho caso o 
seja o HW uma TLB do tipo convencional. Mas se o HW tiver uma TLB que tem dois processos 
tudo bem não é uma coisa que seja ruim porque quando o SO entra em execução (por interrupção ou 
chamada ao SO) a TLB não tem que ser esvaziada. Ela é capaz de ter conversões das duas memorias 
logicas do processo e do SO. 
 
TLB vazia é mais lenta, pois as conversões tem que ser feitas via Tabela de Pagina. Este tipo de TLB 
é melhor do que a outra, pois não tem perda de desempenho. Não é comum ter TLB desse tipo. Mas 
existe outra solução que é mais simples de implementar. 
 
38) NA MEMÓRIA LÓGICA DE TODOS OS PROCESSOS 
 
Conforme mostra a Figura 5 o SO não tem um memoria logica só para ele. Ele está em todos os 
processos. Nessa configuração acontece o seguinte é que cada processo não ocupa todo o intervalo 
da memoria logica. A ideia que se tinha de que a memoria era todo do processo nesse caso não 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 4 
 
existe. O SO coloca as áreas do processo na região da Figura 5. Na estrutura existe um limite para 
colocar as áreas do processo, pois na parte de cima vai ficar o SO. 
 
O SO fica nessa parte em qualquer processo conforme mostra a Figura5. É o mesmo SO em ambos 
os processos. Isso é possível porque as paginas logicas que estão nos processos apontam para as 
mesmas pagina físicas do SO. 
 
 
Figura 5 
Nesse exemplo, o limite para ter conteúdo do processo na memória lógica é a página lógica 7. 
 
Por exemplo, o dados do SO da pagina logica 9 do processo 1 estão na memoria física 10. Os dados 
do SO processo 2 também estão no mesmo lugar. Desse jeito apesar do SO está presente em n 
memórias logicas distintas não se gasta memoria física em todos esses casos. Pois em toda memoria 
logica de todo processo a parte cima que está o SO referencia as mesmas paginas físicas. Conclusão 
o SO da memória lógica de P1 e P2 está no mesmo lugar físico. 
 
Este é um artificio que se faz para dar a impressão que o SO esta presente em toda memoria logica. 
Na memoria verdadeira que é a memoria física o SO está somente em três paginas. 
 
Esse é o mesmo mecanismo que é utilizado na DLL na compactação. Biblioteca compartilhada. O 
mecanismo diz você ter a biblioteca compartilhada em um processo e em outro processo. Em ambos 
o SO faz referencia as mesmas paginas físicas. Então esse é o mesmo mecanismo só que agora esta 
sendo no próprio sistema operacional. 
 
 Com este mecanismo isso funciona. Essa solução do SO está na memoria logica do Processo 
funciona bem até com a TLB mais simples que é a sem o campo Nº do Processo. 
 
O SO executa o processo 1 então guarda na TLB as conversões do processo 1. Conforme mostra a 
Figura 6. 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 5 
 
 
Figura 6 
 
A TLB da Figura 6 é preenchida de acordo com a execução do processo 1. Este processo faz uma 
chamada ao Sistema Operacional. É preciso esvaziar a TLB para colocar o código do SO? Não, pois 
o SO está na memória do processo. A memória lógica não muda quando ocorre uma chamada ao SO 
ou uma interrupção. Quando acabar a interrupção vai precisar mudar a TLB não, pois o processo é o 
mesmo e seus dados estão na TLB. 
 
Com este mecanismo não é necessário limpar a TLB. Esta solução é a mais utilizada. A maior parte 
dos SOs trabalham assim. Windows e o Linux trabalham com esta opção, pois não gera perda de 
desempenho. A Intel trabalha assim. A TLB só é esvaziada quando troca o processo ativo e a 
memória lógica muda. 
 
39) PAGINAÇÃO COM USO DO DISCO OU PAGINAÇÃO SOB DEMANDA OU 
MEMÓRIA VIRTUAL 
 
A paginação em disco ocorre quando a memória física fica cheia. Conforme mostra a Figura 7 todas 
às paginas físicas estão em uso. Não tem pagina física livre na memoria verdadeira. Se precisar 
colocar um novo processo na memória física não será possível porque a memoria física está cheia. 
Ou se precisar criar uma nova pagina na memoria logica do processo 1 por uma razão qualquer, por 
exemplo, crescer a área de pilha do processo 1 ou criar uma Biblioteca compartilhada não será 
possível, pois não existe pagina física livre. 
 
Na pilha existe o topo (é um registrador) tudo que está acima do topo está ocupado e o que está 
abaixo do topo está livre. Conforme as variáveis são empilhadas o topo abaixa. Pode acontecer de o 
topo bater no limite inferior da pilha. Nesse caso o HW gera interrupção e pagina abaixo da área de 
pilha é válida. Conforme mostra Figura 7. Essa interrupção é especial e o SO vai tentar aumentar o 
topo da pilha, mas só será possível aumentar o tamanho da pilha se tiver memoria física livre. 
 
Nesse caso especifico não existe memoria física livre. Logo, não é possível de forma simples 
aumentar o tamanho da pilha do processo 1. Vai dar erro no processo o SO não conseguiu aumentar 
o tamanho da área de pilha. Para resolver esse problema a paginação precisa fazer o uso do disco. 
 
Então quando a memoria física está cheia e se precisa de mais paginas físicas livres. Entra em ação 
um mecanismo do SO de tirar paginas da memoria física e salvar em disco. Isto libera paginas 
físicas. 
 
O topo da pilha precisa crescer. Então gera uma interrupção. O SO vai tentar aumentar o tamanho da 
pilha, mas não consegue porque a memoria física está cheia. O SO aciona o mecanismo para salvar 
um pagina física no disco e com isso liberar pagina física na memoria. 
 
A página vitima é a pagina física escolhida para ser colocada em disco. 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 6 
 
 
 
Figura 7 
 
Conforme mostra a Figura 7 digamos que o SO escolha a pagina física 4 para ser salva no disco. O 
conteúdo desta pagina é a pagina logica 2 do processo 1. Assim área que a pagina física 4 ocupava na 
memoria física passa a ficar livre. 
 
A Figura 8 mostra a Tabela de Páginas do Processo 1 antes de dar o problema de estouro da Pilha. 
 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 7 
 
Figura 8 
A página logica 2 do processo 1 estava na pagina física 4 e o bit válido era 1. Quando acontece 
estouro da pilha. O SO tenta aumentar o topo da pilha e não consegue. Então ele escolhe uma página 
vitima para salvar em disco. Nesse exemplo, a pagina física 4. Ao salvar esta pagina física no disco 
ela não está mais valida. Então o campo bit Valido é alterado para 0 conforme mostra a Figura 8. 
 
Assim o SO consegue arrumar um espaço na memoria física para aumentar a pilha do processo 1. 
Conforme mostra a Figura 9. 
 
 
Figura 9 
 
Esta mesma solução é aplicada para resolver o problema de criação de um processo novo. Nesse caso 
pode ser necessário salvar mais de uma pagina física no disco para liberar espaço na memoria física e 
colocar as paginas logicas do novo processo na memória física. 
 
A Figura 10 mostra a Tabela de Páginas do Processo 1 com a nova pagina logica da pilha que foi 
salva na pagina física 4 cujo conteúdo foi salvo em disco. Observe que o bit valido da pagina logica 
6 está ativo e o bit valido pagina logica 2 está inativo. 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 8 
 
Figura 10 
O problema da falta de pagina física aconteceu. Foi resolvido pelo SO. E não deu erro em nenhum 
momento para o usuário. Só tem uma questão a pagina logica 2 do processo não está mais na 
memoria física. Neste momento ela é uma pagina invalida. Tem um problema caso o processo 
queira usar esta pagina logica. 
 
Por exemplo, consulta a instrução do processo 1  MOV AH, [8200] onde 8200 é o endereço lógico 
da memória lógica do P1. 
 
 
Figura 11 
 
Primeiro o que o HW vai fazer converte o endereço logico no endereço físico. Conforme mostra a 
Figura 11. Ao tentar fazer esta conversão o HW consulta a TLB se não encontrar na TLB ele 
consulta a Tabela de Páginas, mas dará erro, pois a página lógica 2 não está na memória física. Então 
nesse momento o HW gera interrupção, pois a página lógica está com o bit válido igual 0 na tabela 
de páginas, ou seja, não está na memoria física. 
 
A mesma interrupção é gerada se o processo tentar usar a pagina logica 4, pois não é uma pagina 
logica válida. Conforme mostra a Figura 10. Só que um caso é diferente do outro. Tentar usar a 
pagina logica 4 é um erro do processo, pois não tem nenhum conteúdo e tem que abortar o processo. 
Já por ouro lado ao tentar utilizar a pagina logica 2 não é um erro. Tem conteúdo nela. O processo 
não está errado. Não tem que abortar. Esta pagina só está invalida porque foi salva em disco. 
 
No entanto, a pagina logica 2 está em disco. O SO não aborta o processo. O tratamento da 
interrupção é para trazer a página lógica para memória física. 
 
A Figura 12 mostra onde começa é termina cada área do processo. O SO consulta esta tabela para 
saber as páginas lógicas que estão em disco. 
 
 
Figura 12 
 
Ao consultar esta tabela o SO sabe que a pagina logica 2 pertence a área de dados do processo 1. 
Então o acesso a pagina logica 4 o tratamento da interrupção é para abortar o processo. Já o acesso a 
pagina logica 2 não, pois ela pertence a área de dados do processo 1. Então o trabalho do SOao tratar 
a interrupção é colocar de novo na memoria a pagina logica 2. 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 9 
 
No entanto, a memoria física continua cheia. E para trazer a pagina logica 2 para memoria física tem 
que ser feito o mesmo mecanismo de escolher uma outra pagina vitima, salvar em disco e trazer a 
pagina logica 2 para o lugar da pagina vitima que foi salvo em disco. 
 
Figura 13 
 
Digamos agora que o SO escolha a pagina física 8 que contém o conteúdo da pagina logica 7 do 
processo 1. Conforme mostra a Figura 13. O SO altera na Tabela de Paginas do Processo 1 o bit 
valido da pagina logica 7 para 0. Conforme mostra a Figura 14. E a pagina física 8 fica livre e o SO 
consegue trazer para memória a pagina logica 2. 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 10 
 
 
Figura 14 
A pagina física 8 agora está com o conteúdo da pagina logica 2. O SO ajusta na tabela de paginas o 
novo numero da pagina física da pagina logica 2 e altera o bit invalido para valido dessa pagina. 
 
 
Figura 15 
 
A Figura 15 mostra o resumo do que aconteceu. Primeiro foi preciso aumentar a área de pilha e ao 
tratar a interrupção gerada o SO salvou a pagina logica 2 de P1 no disco. Segundo o SO precisou 
1 
3 
2 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 11 
 
trazer para memória esta pagina logica. Então o SO escolheu outra pagina vitima para salvar em 
disco. Terceiro trouxe para a pagina física da pagina física a pagina logica 2 de P1. 
 
Durante o tratamento da interrupção o SO coloca a pagina logica 2 de volta na memória física 
quando o tratamento da interrupção termina. A instrução gerou a interrupção é reiniciada. Dessa vez, 
a conversão do endereço logico no endereço físico é realizada com sucesso. Tudo isso ocorreu sem 
dá erro para o usuário, pois funciona com transparência. 
 
 
Figura 16 
 
Enquanto a memoria física fica cheia ocorre uma troca de páginas. Este mecanismo também é 
chamado de SWAP de páginas. Ele é parecido com o SWAP de processos a diferença do SWAP de 
páginas para o SWAP de processos é o que vai para o disco não é o processo inteiro, mas sim uma 
pagina logica do processo. 
 
40) VANTAGENS DESSE TIPO DE PAGINAÇÃO 
 
Qual a vantagem de levar uma pagina só para o disco? É mais rápida. E se uma pagina do processo 
for salva em disco impedi do processo continuar executando. No SWAP de processo quando um 
processo é salvo em disco muda o estado dele. No SWAP de paginas ao salvar uma pagina no disco 
não muda o estado do processo. O processo só não entrara em execução se tentar executar uma 
pagina que foi salva em disco. Mas, enquanto executar paginas validas funciona normalmente. Esta 
é uma vantagem importante do SWAP de paginas. 
 
Outra vantagem é em relação ao tamanho. Na paginação como todas paginas tem o mesmo tamanho 
se precisou liberar espaço na memória física pode escolher qualquer um pagina física para ser salva 
em disco que está bom, pois tem o mesmo tamanho da pagina logica. 
 
No SWAP de processos se um usuário quer usar em certo processo que está em disco. O processo 
tem um tamanho e não é necessariamente igual a outro processo na memória. Então as vezes para 
trazer um processo para memoria é necessário talvez salvar três processos em disco. 
 
No exemplo citado acima do estouro de pilha no momento que o SO trata a interrupção gerada na 
execução do processo 1. O processo 1 para de executar. A interrupção desse exemplo fez duas coisas 
salvou a pagina vitima (pagina logica 7) e depois teve que mandar lê página logica 2. Então fez dois 
acesso ao disco durante o tratamento dessa interrupção. 
 
O acesso ao disco é uma coisa meio lento. O tempo que demora para ler o conteúdo do disco nesse 
tempo dá para executar milhões de instruções. É importante não desperdiçar a CPU enquanto o disco 
lê o conteúdo. Nesse exemplo é interessante que o SO escalone outro processo para executar e isso é 
feito. 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 12 
 
Quando o processo manda lê um arquivo no disco o SO bloqueia o processo e coloca outro processo 
em execução. No exemplo como tem que lê do disco a pagina logica 2 e o disco é lento. O SO 
bloqueia o processo e escalona outro para executar. 
 
41) CAPACIDADE DO SO DE SALVAR PÁGINAS EM DISCO QUANDO FALTA ESPAÇO 
NA MEMÓRIA. 
 
Digamos que a memória física está completamente cheia, isto é, todas as páginas físicas estão 
ocupadas. Se o SO precisar de mais uma página física, por exemplo, para a pilha de um processo. ele 
escolherá uma determinada página física e salva o seu conteúdo em disco, atualiza a Tabela de 
Página mudando o bit de validade de 1 para 0, isto é, indicando que há uma página física livre e 
escolhe qual página lógica será espelhada na página física disponível, atualizando a Tabela de 
Páginas, colocando na entrada da página lógica o valor da página física correspondente e atualizando 
o bit de validade de 0 para 1, indicando que a página física é válida e portanto, não está livre. 
 
Digamos que logo depois o HW precisa da página física que foi colocada em disco. O HW vai 
consultar a Tabela de Páginas e vai ver se a página lógica que ele precisa está na memória. Se não 
estiver, o HW gerará uma interrupção (falta de página) e o SO tratará essa interrupção, retirando a 
página lógica a ser substituída e colocando-a em disco, pegando do disco e carregando a página 
solicitada no EEL e na memória, e atualizando a tabela de página com a referida correspondência 
Página Lógica x Página Física. 
 
Se uma mesma página é usada por dois ou mais processos e a mesma é transferida para o disco, as 
tabelas de páginas dos processos que a usam precisam ser atualizadas mudando o bit de validade 
dessa página de 1 para 0. 
 
Se há uma falta de página para um processo, o processo é bloqueado e outro processo é escolhido 
para ser executado. 
 
Quando há falta de página na memória física, é necessário fazer dois acessos ao disco: uma para 
transferir uma página para o disco e outro para transferir uma página do disco para a memória. 
 
42) OTIMIZAÇÕES 
 
1 – Quando uma página lógica que contém código é escolhida para ser transferida para o disco 
(página física), ela não é salva no disco pois o disco já contém o código-fonte e como o código não 
pode ser modificado enquanto está na memória, é exatamente uma cópia do que está em disco. Logo, 
evita-se o desperdício de espaço. 
 
2 – Os SOs nunca deixam que a memória fique completamente cheia, evitando ao máximo que o SO 
acesse duas vezes o disco para transferir/buscar uma página. 
 
3 – Se uma página lógica é transferida várias vezes da memória para o disco e vice-versa e o SO 
precisar liberar espaço na memória para outra página, essa página substituída não será salva 
novamente em disco somente se a página não sofreu alterações enquanto esteve na memória. O SO 
verifica se a página sofreu alteração ou não na memória consultando o bit “Alterado?” presente na 
tabela de páginas do processo. 
 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 13 
 
 
43) CÁLCULO DO TEMPO GASTO NA OCORRÊNCIA DE FALTA DE PÁGINAS 
 
Tempo de acesso à memória = 100 ns 
Tempo de acesso ao disco = 10 ms = 10.000.000 ns 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Devido ao grande tempo de acesso ao disco, a falta de página não pode ocorrer com freqüência. 
 
Se a probabilidade de ocorrer falta de página for de 0,0001%, 
 
(10.000.000 * 0,000001) + 100 ( 1 – 0,000001) = 100 + 99,9999 ≈ 200 ns 
 
Portanto, o SO precisa escolher bem qual página deverá ser colocada em disco (página vítima) de 
forma que esta não seja usada brevemente pelo processo e, conseqüentemente, não gaste mais tempo 
fazendo as trocas de páginas entre memória e disco. 
 
O SO olha o que ocorreu para prever o que poderá acontecer, usando o Princípio daLocalidade: os 
processos tendem a usar a mesma página ou as vizinhas num futuro próximo. 
 
Ex: WHILE X < 10 THEN 
X:= X + 0,01; 
 
Existem três algoritmos para reduzir a falta de páginas: 
 
1 – ALGORITMO FIFO (FIRST IN, FIRST OUT) - USADO PELO NT4 COM MAIS DE 1 
CPU 
 
A página que entrou primeiro (mais antiga) é a primeira a sair. Digamos que um processo usa as 
seguintes páginas lógicas ao longo do tempo, sendo apresentado embaixo a imagem da memória que 
tem 3 posições. 
Tempo 
de 
acesso 
ao disco 
Probabil. de 
ocorrer falta 
de página 
Tempo de 
acesso à 
memória 
Probabil. de não 
ocorrer falta de 
página ( acesso 
somente à 
memória) 
(10.000.000 * p ) + 100 * ( 1 - p ) 
 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 14 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
No tempo T1 as três posições encontram-se vazias. Como do T1 ao T4 há espaço para mais uma 
página, elas vão sendo alocadas no primeiro espaço livre encontrado. No tempo T5 a página 2 
precisa ser alocada mas não há espaço livre na memória. Utilizando o algoritmo FIFO, a página que 
dará vez à página 2 será a página 7 pois é a que estava há mais tempo na memória. Em T7 a página 0 
é substituída pela 3 mas essa não é uma boa escolha porque no tempo seguinte (T8) a página 0 
precisa ser usada e deverá voltar à memória. Essa mesma situação acontece novamente em outros 
momentos. No final de 21 u.t., ocorre 12 faltas de páginas. 
 
2 – ALGORITMO ÓTIMO 
 
Esse algoritmo olha o futuro e vê qual a página que só será usada muito mais tarde e que deverá ser 
substituída a seguir. Infelizmente esse algoritmo não pode ser usado pelos SOs porque simplesmente 
eles não podem adivinhar o futuro. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7 
7 
 
 
0 
7 
0 
 
1
7 
7 
0 
1 
2 
2 
0 
1 
3 
4 
2 
3 
2 
4 
2 
0 
4 
4 
3 
0 
0 
2 
3 
0 
3 
2 
3 
1 
0 
2 
0 
1 
0 
0 
2 
3 
3 
0 
2 
3 
2 
0 
2 
3 
1 
0 
1 
3 
2 
0 
1 
2 
1 
7 
0 
1 
0 
7 
0 
2 
7 
7 
1 
2 
1 
0 
1 
2 
0 
0 
1 
2 
T=1 T=2 T=3 T=4 T=5 T=6 T=7 T=8 T=9 T=10 T=11 
T=12 T=13 T=14 T=15 T=16 T=17 T=18 T=19 T=20 T=21 
 
 
 
 
7 
7 
 
 
0 
7 
0 
 
1
7 
7 
0 
1 
2 
2 
0 
1 
3 
2 
4 
3 
2 
2 
4 
3 
4 
2 
4 
3 
0 
2 
0 
3 
3 
2 
0 
3 
0 
2 
0 
1 
0 
2 
0 
3 
3 
2 
0 
3 
2 
2 
0 
3 
1 
2 
0 
1 
2 
2 
0 
1 
1 
7 
0 
1 
0 
7 
0 
1 
7 
7 
0 
1 
1 
2 
0 
1 
0 
2 
0 
1 
T=1 T=2 T=3 T=4 T=5 T=6 T=7 T=8 T=9 T=10 T=11 
T=12 T=13 T=14 T=15 T=16 T=17 T=18 T=19 T=20 T=21 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 15 
 
No tempo T1 as três posições encontram-se vazias. Como do T1 ao T4 há espaço para mais uma 
página, elas vão sendo alocadas no primeiro espaço livre encontrado. No tempo T5 a página 2 
precisa ser alocada mas não há espaço livre na memória. Utilizando o algoritmo ótimo, a página que 
dará vez à página 2 será a página 7 pois só será usada novamente no tempo 19 ao contrário das 
demais que serão novamente usadas muito antes. 
 
Usando esse algoritmo elimina-se o problema de uma página que foi substituída e que logo depois 
precisa ser usada novamente. Com isso, usando o algoritmo ótimo, o número de falta de páginas cai 
para 6. 
 
3 – ALGORITMO LRU (LEAST RECENTLY USED – MENOS USADA RECENTEMENTE) 
 
Já que os SOs não podem olhar o futuro, eles olham o passado pra tentar prever o futuro, usando o 
algoritmo LRU que substitui as páginas que foram usadas há mais tempo. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
No tempo T1 as três posições encontram-se vazias. Como do T1 ao T4 há espaço para mais uma 
página, elas vão sendo alocadas no primeiro espaço livre encontrado. No tempo T5 a página 2 
precisa ser alocada mas não há espaço livre na memória. Utilizando o algoritmo LRU, a página que 
dará vez à página 2 será a página 7 pois foi usada há mais tempo. No tempo 9, a página 2 dá vez à 
página 4 pois a página 2 foi usada há mais tempo que as páginas 0 e 3. 
 
O algoritmo LRU em geral é melhor que o algoritmo FIFO mas é pior que o algoritmo ótimo. No 
exemplo, ocorre 9 faltas de página. 
 
44) PAGINAÇÃO SOB DEMANDA: 
 
Permite uma forma melhor de evitar a falta de memória física. É também chamada de memória 
virtual, mas a memória virtual já existia antes deste mecanismo. 
 
Digamos que faltou memória física para carregar um novo processo, então o so pode escolher uma 
página física já alocada em memória e colocá-la em disco e carregar o processo novo nesta página 
que ficou disponível. 
 
 
 
 
7 
7 
 
 
0 
7 
0 
 
1
7 
7 
0 
1 
2 
2 
0 
1 
3 
4 
3 
2 
2 
4 
0 
2 
4 
4 
0 
3 
0 
2 
0 
3 
3 
2 
0 
3 
0 
2 
0 
1 
0 
0 
3 
2 
3 
0 
3 
2 
2 
0 
3 
2 
1 
1 
3 
2 
2 
1 
3 
2 
1 
1 
0 
7 
0 
1 
0 
7 
7 
1 
0 
7 
1 
1 
0 
2 
0 
1 
0 
2 
T=1 T=2 T=3 T=4 T=5 T=6 T=7 T=8 T=9 T=10 T=11 
T=12 T=13 T=14 T=15 T=16 T=17 T=18 T=19 T=20 T=21 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 16 
 
Por exemplo: Encheu a página física, o sistema operacional pega a página real número 2 e pode 
salvar esta página em disco e dizer que esta página agora está inválida. Assim, conseguiu abrir 
espaço na memória física. A página disponível será alocada com o novo processo. Se esses mesmo 
processo precisar de uma parte que está na página lógica 4, o hardware vai tentar converter e 
verificar que esta está inválida e vai gerar uma interrupção, o so verifica que esta página lógica 4 é 
válida, mas ele acabou de salvar em disco, então o so tem que trazer esta página de volta para 
memória. Então se a memória esta cheia, ele escolhe uma outra página para salvar em disco, por 
exemplo, a página física 7, e o so carrega a página lógica 4 na página física 7 
 
Esse mecanismo possui três momentos: 
1) O so abre espaço na memória salvando a código correspondente da página física 2 
em disco; 
2) O processo precisa desta página, o so escolhe uma outra página para salvar em 
disco, por exemplo, a página física 7; 
3) Por último, o so carrega o código correspondente da página 2 na página 7 que 
estava em disco. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A página escolhida para ser retirada da memória é chamada de página vítima, no exemplo anterior é 
página de número 2 e 7. É importante que o so escolha bem as páginas vítimas de forma que elas não 
sejam usadas no futuro pelo processo, essa seria a escolha ideal. 
lógica física Válido 
15 0 
14 0 
13 0 
12 0 
11 0 
10 0 
9 0 
8 0 
7 0 
6 0 
5 0 
4 2=>7 1 
3 0 
2 3 1 
1 0 
0 0 1 
 
15 
14 
13 
12 
11 
10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
 
Espaço de Endereçamento 
Físico 
 
Tabela de Paginas 
Disco 
 
 
1 
3 
2 
O fato da página está 
inválida chama-se 
falta de página. 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 17 
 
A troca constante de disco para a memória pode deixar a máquina lenta, sendo que hoje esse 
mecanismo funciona bem. Esse mecanismo é transparente tanto para o usuário quanto para o próprio 
processo. 
 
Outro Exemplo: A partir do seguinte cenário, temos: 
 Dois processos alocados P1 e P2. 
 No P1 é alocado a página lógica 0 e 1 para código correspondente a 
página física 1 e 3, 2 para dados correspondendo a página física 0 e por 
último 5 e 6 para pilha correspondendo a página física 5 e 7. 
 No P2 é alocado a página lógica 0 para código correspondendo a página 
física 2, 1 e 2 para dados correspondendo a página física 4 e 6 e por 
último 7 e 8 correspondendo a página física 8 e 9. 
Segue abaixo os passos seguidos pelo so ao detectar falta de página: 
 
1º Passo) O processo P2 obteve um aumentona área de dados, como não tem 
mais página física, pois as 9 páginas existente neste exemplo já foram 
alocadas. O so salva em disco a página física 3 que corresponde a página 
lógica 1 do P1. Na tabela de página do processo P1 a página física 3 de 
inválida (1) passa para válida (0) e na tabela de página do processo P2, é 
adicionado a página física 3 correspondente a página lógica 3. 
2º Passo) A página física 3 correspondendo a página lógica 3 do processo P2 
fica inválida (1), ou seja, indisponível. 
3º Passo) A página colocada em disco, página lógica 1 de P1 foi solicitada por 
outra parte do processo P1, assim o so salva outra página em disco, e foi 
escolhida a página lógica 7 correspondendo a página física 9 do processo P2 
para liberar espaço na memória física. Na tabela de página a página lógica 7 
correspondente a página física 9 fica válida(0), disponível para ser ocupada. 
4º Passo) O so pega a página física 1 de P1 e coloca na página física 9 que 
está disponível, e em seguida, na tabela de página ele coloca esta página como 
inválida(1). 
 
Veja o que foi descrito acima no esquema abaixo: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9 
8 
7 
6 pilha 
5 
4 
3 
2 dados 
1 código 
0 
 
Espaço de Endereçamento 
Lógico ou virtual – P1 
 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
 
Memória Real 
9 
8 pilha 
7 
6 
5 
4 
3 
2 dados 
1 
0 código 
 
Espaço de Endereçamento 
Lógico ou virtual – P2 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 18 
 
1º Passo) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
lógica física Válido 
2 0 1 
1 3 1 => 0 
0 1 1 
 
Tabela de Páginas P1 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
 
Memória Real 
lógica física Válido 
3 0 -> 3 0 
2 0 1 
1 3 1 
0 1 1 
 
Tabela de Páginas P2 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 19 
 
 
 
2º Passo) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3º Passo) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
 
Memória Real 
9 
8 pilha 
7 
6 
5 
4 
3 
2 dados 
1 
0 código 
 
Espaço de Endereçamento 
Lógico ou virtual – P2 
 
lógica física Válido 
3 0 -> 3 0->1 
2 0 1 
1 3 1 
0 1 1 
 
Tabela de Páginas P2 
Memória Real 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
 
lógica física Válido 
 
7 0 
 
 
 
Tabela de Páginas P2 
Página lógica 1 de P1 
Página lógica 7 de P2 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 20 
 
4º Passo) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Otimizações: 
1) Não salvar páginas de código: quando a página vítima for uma página de código, ela não 
é salva em disco, quando da sua retirada da memória física, pois ela já está no programa 
executável (em disco); 
2) O SO mantém um número mínimo de páginas livres: O SO ao identificar que vai ocorrer 
a falta de página ele pré-salva a página vítima liberando espaço na memória. Se uma 
página vítima, por exemplo página lógica 7 de P2 foi salva em disco e em outro momento 
ela for escolhida novamente, desde que não houve alteração então o SO não salva esta 
novamente em disco, pois a mesma já está salva; 
Exemplo: (1) O so salva pela primeira vez a página vítima 7; (2) A página vítima 7 voltou 
para memória agora em outra página memória física 5; (3) O so não salva a página vítima 7, 
pois a mesma não foi alterada. Como mostra a seqüência no esquema abaixo: 
 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
 
lógica física Válido 
 
1 9 1 
 
 
 
Tabela de Páginas P2 
Memória Real 
Página lógica 1 de P1 
Página lógica 7 de P2 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 21 
 
 
(1) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
(2) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
 
lógica física Válido 
 
7 0 
 
 
 
Tabela de Páginas P2 
Memória Real 
9 
8 pilha 
7 
6 
5 
4 
3 
2 dados 
1 
0 código 
 
Espaço de Endereçamento 
Lógico ou virtual – P2 
 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
 
9 
8 pilha 
7 
6 
5 
4 
3 
2 dados 
1 
0 código 
 
Espaço de Endereçamento 
Lógico ou virtual – P2 
 
Memória Real 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 22 
 
 
(3) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3) Não salvar páginas que já foram vítimas e não foram alteradas 
 
 
 
Tempo de Acesso a Memória = 100 ns 
Tempo de Acesso a Disco = 10 ms 
Tempo Médio de Acesso a Memória = 10ms p + 100ns(1-p) 
 ≈ 10 000 000 ns p + 100 (1-p) 
 ≈ 100 + 10 000 000 p; onde: p = 0,000001 
 ≈ 100 + 10 = 110 
p = probabilidade de ocorrência de falta de página. 
 
A escolha ideal para a página vítima pelo so é a página vítima que não será usada no futuro. 
Isso vai gerar pouca falta de páginas. A idéia básica é olhar o passado para tentar prever o 
futuro. 
 
Princípio da Localidade: os processos tendem a usar as mesmas páginas em um determinado 
instante de tempo. Explicado pela estrutura em que o código é montado (rotinas com suas 
variáveis locais). Assim, o so tenta manter em memória as páginas usadas a pouco tempo no 
passado,pois a tendência de se usar estas páginas é maior do que aquelas usadas num passado 
distante. 
 
- Passos percorridos pelo SO para utilização de um dos algoritmos descritos acima: 
1) O HW tenta fazer a conversão de página lógica para página física, mas a página não é 
válida. HW gera interrupção; 
2) SO identifica se a página pertence a alguma das áreas do processo; 
3) O SO encontra uma página física livre; 
4) O SO envia ordem ao disco para ler a página; 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
 
Memória Real 
lógica física Válido Alterada 
(ou “sujo”) 
 
7 5 1 0 
 
 
 
Tabela de Páginas P2 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 23 
 
5) O SO bloqueia o processo que gerou a falta e escalona outro processo (o que causou o 
bloqueio do processo? Tentar usar uma variável que está numa página que não está na 
memória. Esse é um tipo de bloqueio que não existia); 
6) Quando a página for lida do disco gera interrupção; 
7) O SO muda o estado do processo para pronto; 
 
 
- Alocação de páginas físicas: 
 
 - Global (Unix); 
- Local (Alocar um nº de páginas físicas maior ou igual do que tem o Working Set do 
processo – NT); 
 
A alocação de páginas físicas pode ser global ou local. Na Alocação global, não existe número de 
páginas por processo, qualquer página de qualquer processo pode ser escolhida como vítima, o 
processo pode receber páginas físicas de outros processos que foram escolhidas como vítima. 
 
Já na alocação local, existe um número de páginas por processo, ou seja, cada processo só pode 
receber como página vítima, páginas entre aquelas que foram destinadas a ele. Falta de páginas de 
um processo que necessite de página vítima, a página vítima tem que ser entre as destinadas a esse 
processo. 
 
O Windows NT tem um número mínimo e um número máximo de páginas, o processo não pode ter 
menos que o mínimo e mais que o máximo. 
 
A dificuldade do algoritmo é para saber o número de páginas físicas que devem ser alocadas para 
cada processo. Este número tem que ser maior ou igual ao working set do processo, número de 
páginas físicas que o processo está usando em um certo instante de tempo. 
 
Se o SO conseguir alocar um número de páginas maior ou igual ao workingset do processo, a falta de 
página quase não vai existir, vai existir falta de página quando trocar o workingset do processo. 
 
Se o número de páginas físicas for menor que o workingset do processo, vai ocorrer falta de página o 
tempo todo, pois uma página que foi escolhida comovítima deverá ser usada logo em seguida, como 
não está na memória vai gerar falta de página. Não tem como o SO saber o workingset do processo, 
o que ele faz é observar o número de falta de página do processo, se esse número for grande, ele fica 
sabendo que o workingset do processo é maior que o número de páginas físicas que o processo tem. 
Para resolver isso, ele aumenta o número de páginas físicas desse processo. Com isso, enquanto esse 
workingset não mudar e se já estiver todo na memória, não vai ocorrer falta de página para esse 
processo. A falta de página só ocorre quando trocar o workingset. Por outro lado, se o SO observar 
que o processo tem mais páginas físicas que o workinkset, ele pode diminuir o número de páginas 
físicas alocadas ao processo. 
 
O SO acompanha o número de falta de página dos processos. Exemplo: Tamanho do working set = 5 
páginas lógicas, o so tem que alocar mais que isso: Páginas do working set = {3,4,8,9,12} 
 
 
 
 
 
3 
8 
9 
4 
12 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 24 
 
Como resolver a falta de página desse processo? 
Resposta: Aumentar o nº de páginas física. 
 
Como saber o tamanho do working set ? 
Resposta: O so acompanha o nº de páginas usadas por este processo. 
 
O que pode acontecer é a máquina ficar muito lenta devido o nº muito grande de 
falta de página. O que fazer? 
Resposta: Usar o Swap de Processos. Ele baixa o número de processo na memória. 
Um exemplo disso é um processo comedor de memória, ou seja, um processo que 
aloque muita memória. Este tipo de processo acaba roubando páginas físicas de outros 
processos. Isso é chamado de trashing. 
 
Uma causa do trashing é o processo comedor de memória, como descrito 
anteriormente, outra causa é quando tem muitos processos (obs: 1% de falta de página 
já é um número muito grande e o suficiente para acontecer isso). 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Na alocação global, as páginas dele acabam roubando páginas de outros processos, já que não tem 
número de páginas de memória física reservada a cada processo.Como conseqüência, vai acontecer 
dos outros processos gerar falta de página também. Esta situação da máquina ficar lenta devido à 
falta de página é chamada de thrash, como descrito acima, as causas disso também já foram descritas 
acima: sendo a primeira quando um processo que necessita de muita memória, ou seja, o processo 
comedor de memória. A segunda são muitos processos em execução, tendo muitos processos que 
alocam e usam, acaba acontecendo de ocupar toda a memória da máquina. 
 
Processos típicos não usam a CPU o tempo todo (trocam de estado entre executando e bloqueado), 
quanto mais processos em execução, mais vai ocupar a CPU, até chegar a 100% do uso da CPU com 
o aumento do número de processos. O descrito acima não se aplica a processos que ocupam a CPU o 
tempo todo, neste caso basta um processo para usar a CPU 100%.Isso ocorre se não considerar a 
existência de falta de página. Com a ocorrência de falta de página, existe um número máximo de 
processos em execução, passando desse número, como a memória não é grande o suficiente, os 
Uso de 
CPU 
 
100 
1 2 3... N 
Nº DE PROCESSOS EM 
EXECUÇÃO 
Uso de 
CPU 
 
100 
1 2 3 M M+ 1 
Nº DE PROCESSOS EM 
EXECUÇÃO 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 25 
 
processos vão ficar mais tempo paginando e conseqüentemente o uso da CPU cai. Com a falta de 
página a CPU nunca é usada 100%. Nesse ponto que o uso da CPU cai é onde fica caracterizado o 
Thrash, onde a máquina começa a ficar lenta. Nesse ponto, quando coloca mais processo, mais a 
máquina fica lenta, menos CPU é usada. 
 
O thrash pode acontecer nas duas formas de alocação, mas é mais comum na alocação global de 
páginas físicas, pois nesse tipo de alocação, pode acontecer de ter um único processo que use muita 
memória. Se ele usar toda memória física da máquina, os outros processos não vão ter memória e 
vão ocasionar o thash. Com alocação local, isso não acontece tão facilmente, pois cada processo tem 
o seu número de páginas físicas reservado. Cada processo, normalmente, tem o número mínimo e 
máximo de páginas reservadas, se o processo alcançar o máximo, ele fica lento, mas os outros não. 
Com o tempo acaba provocando thrash, pois o SO vai dar mais páginas para esse processo, mas é 
uma coisa mais controlada. O thrash ocorre mais facilmente em alocação global. 
 
O UNIX resolve o problema do thrash com swap de processo, ou seja, ele tira completamente o 
processo da memória, com isso, liberando páginas físicas para os demais processos baixando o 
número de processos da memória, como descrito anteriormente. 
 
Quando se têm n processos, mas nenhum pronto para executar, o uso da CPU não é total. Basta um 
processo estar em execução para o uso da CPU ser total. Para o uso da CPU ser total o ideal é que 
tenha sempre processos prontos para execução. 
 
A falta de página provoca thrash porque bloqueia o processo, poucas faltas não afetam muito, mas se 
as faltas forem muitas podem provocar pouco uso da CPU. 
 
45) SEGMENTAÇÃO SOB DEMANDA: 
 
 
 
 
 
 
 
O hardware passa a ter um novo bit, o bit de válido. Quando ocorre falta de memória, o SO pega um 
segmento e salva em disco deixando ele como inválido. Se o processo tentar usar o segmento 
inválido, o hardware vai gerar uma interrupção para o SO, então, o SO pega o segmento em disco e 
coloca outra vez na memória e seta o bit para válido. É conhecido como primo pobre da paginação, 
pois apesar de salvar em disco, os segmentos são bem maiores que as páginas, logo o tempo para 
salvar em disco e trazer do disco será grande, bem maior que na paginação. Devido a isso é bem 
menos eficiente que a paginação. O Windows 3.1x e o OS2 1.x usam segmentação sobre demanda. 
Início tamanho Válido 
 
 
 
 0 
 
Tabela de Segmentação 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 26 
 
 
46) SEGMENTAÇÃO COM PAGINAÇÃO: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Muito pouca vantagem. A vantagem é poder rodar processos que gaste mais de 
4GBytes de memória lógica. 
 
DESVANTAGEM DESSE TIPO DE PAGINAÇÃO 
 
A paginação embora seja transparente para o usuário. Além de demorar mais ele introduz bloqueios 
no processo em lugares que não se esperava. Uma instrução dessa pode bloquear o processo durante 
um tempo porque a pagina logica pode estar em disco. 
 
Em alguns casos isto pode ser grave. Tem certos tipos de processos que tem a necessidade de 
executar rápido muito importante. Isso ocorre justamente com processos que controlam algo físico, 
por exemplo, uma maquina ou um robô. Se ocorrer uma parada de repente e robô estava andando ele 
pode andar mais do que deveria. Em um processo cujo tempo é critico não é recomendável que você 
use paginação com uso de disco. Porque ele introduz paradas (bloqueios) em momentos que você 
não esperaria que acontecesse. Este é o problema da paginação em disco. 
 
Esses tipos de processos que não é para utilizar paginação em disco são chamados de processos em 
tempo real. 
 
Este mecanismo da paginação em disco é o mais vantajoso para tratar a falta de memória em relação 
aos outros mecanismos. 
 
OBSERVAÇÃO 
 
A TLB existe sempre que existir paginação. Ela é controlada pelo HW e não pelo SO. 
 
O SO escolheu a pagina logica 7 como vitimas. Ele tem que mudar o bit valido da pagina logica e 
atualizar a TLB. Existe uma instrução para controlar a TLB quando uma pagina logica é levada para 
o disco. O SO avisa a TLB através de uma instrução que avisa o seguinte se estiver um registro para 
pagina logica 7 na TLB pode limpar. 
 
 Início tamanho 
0 
1 
2 
3 
 
Tabela de Segmentação 
 
Nº Seg Desloc Seg 
 > + 
Endereço 
 
 Nº da 
Pág 
Física 
 
Desloc na 
Página 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página27 
 
A instrução que o SO manda não sabe se existe ou não a pagina logica que está sendo salva no disco 
na TLB. Se a pagina logica estiver na TLB o HW vai retirá-la. 
 
Nessa solução de se ter o SO na mesma Memória logica do processo. Na memoria logica do processo 
existem paginas validas que são do SO. A Figura 17 mostra a Tabela de Página do Processo 1 
existem páginas logicas que pertencem ao SO e não ao processo. 
 
 
Figura 17 
 
O que impede do processo não alterar a pagina logica do SO que está na mesma memoria logica do 
processo? Esse mecanismo do SO está na mesma memoria logica do processo introduz uma questão 
de estabilidade que é resolvida com a inclusão de um HW adicional que é o bit de controle Núcleo. 
 
No campo Núcleo é preenchido pelo SO com o valor o 1 quando é uma pagina do SO (Modo 
Privilegiado) e com 0 quando é uma pagina do processo (Modo não Privilegiado). Modos de 
operação Privilegiado e Não Privilegiado. Esvaziar a TLB é uma coisa que é feita no modo 
privilegiado. 
 
Quando estiver em execução o código do processo o HW sabe o que é do processo e o que é do SO e 
não permite que o processo altere o código do SO. 
 
As paginas com o bi Núcleo igual a 1 só podem ser executada no Modo Privilegiado e as paginas 
com o bit Núcleo igual a 0 podem ser executadas em qualquer modo de operação. 
 
DESEMPENHO DA PAGINAÇÃO SOB DEMANDA 
 
O problema nesse caso é o acesso a memoria porque a pagina logica acessada pode estar em disco ou 
não. Então temos três casos de acesso a memoria logica: 
 
1) Pagina Lógica válida (Bit válido = 1). 
2) Página Lógica inválida (Bit válido = 0), mas está em disco. 
3) Pagina Logica invalida que não pertence ao processo. Caso de erro o SO aborta o processo. 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 28 
 
 No caso do desempenho o que interessa são os dois casos bem sucessivos são os casos que não 
abortam, ou seja os casos 1 e 2 citados acima. 
 
No caso 1 temos: Tempo Físico é igual a aproximadamente o tempo de acesso a memória que é 
igual aproximadamente a 100 ns = 10-7 s. 
 
No caso 2 é mais complicado. Temos: Tempo é igual aproximadamente o Tempo de leitura da 
página que é igual aproximadamente a 10 ms = 10-2 s. 
 
Observação: 1 ms = 10-3 s e 1 ns = 10-9 s 
 
O tempo de acesso ao disco é 100 mil vezes mais lento do que o tempo de acesso a memória. Isso dá 
uma perda de desempenho brutal quando tem que acessar o disco. Colocando isso em uma formula 
só temos o seguinte: 
 
Tempo Médio de acesso a Memoria Logica (Endereço Lógico) = (Px10-7) + ((1-P)x 10-2) 
 
P = Probabilidade da Pagina Logica estar na memoria física. 
 
Estipulando a perda de desempenho de 20% 
 
Tempo médio é 20% maior que o caso 1 = 1,2 x 10-7 
 
1,2 x 10-7 = (Px10-7) + ((1-P)x 10-2) 
P = 99,9998 % A página lógica tem que estar na memória física 
 
O que podemos mostra é que a perda de desempenho é grande com a paginação sob demanda. Para 
ser pequena a perda de desempenho a gigantesca maioria dos casos 99,9998% a pagina logica tem 
que estar na memória física. E somente 00,0002% dos casos a pagina logica estar no disco. 
 
É muito importante que poucas vezes o SO traga a pagina logica para memória, pois se isto acontecer 
com muita frequência a perda de desempenho será muito grande. O uso do disco quando a memoria 
física está cheia introduz uma perca de desempenho muito grande. Nesse caso só foi considerando o 
tempo de um acesso ao disco que é o acesso de leitura. 
 
No exemplo dado acima temos que considerar o tempo do SO salvar o conteúdo de uma pagina física 
no disco e depois trazer a pagina logica que está no disco para a memória física para então o 
processo utiliza-la. Nesse caso que é o caso 2 o tempo será multiplicado por 2. Sendo duas vezes 
pior. 
 
COMO EVITAR O USO DO DISCO QUANDO NÃO PRECISA 
 
Tem varias ocasiões que não precisa utilizar o disco e o SO vai utiliza-las. 
 
1) Paginas de código quando são paginas vitimas. Não são salvas no disco. Por quê? Porque está 
no disco dentro do arquivo executável. Mas, para isto acontecer não pode apagar o arquivo 
executável. Logo não será permitido apagar o arquivo executável que estiver em execução. 
Tudo é feito para evitar o caso do salvamento. O SO se preocupa muito em não ter o acesso 
de salvamento e fazer somente o acesso de leitura. 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 29 
 
2) O passo 1 da Figura 15 - Páginas alteráveis (tipicamente as que contém variáveis) que foram 
vitimas anteriormente e não foram alteradas desde de então (se forem vitimas novamente) 
não são salvas novamente. Porque o conteúdo é o mesmo. Dificuldade como saber se uma 
pagina foi alterada ou não? 
 
Observação: Outra solução é criar um arquivão de paginas logicas salvas em disco chamado de 
arquivo de SWAP. Este arquivo pode ficar em um arquivo grande ou em uma partição separada. 
Somente o SO tem acesso a este arquivo quem tenta mexer dá erro e não consegue mexer. 
 
Dificuldades da Solução 2 
 
O SO não sabe tudo que está acontecendo. Ele só tem capacidade de fazer coisas quando ele entra 
em execução. O SO entra em execução quando o processo faz uma chamada ao SO ou quando ocorre 
uma interrupção. Se isto não acontecer o SO não sabe de nada. Sendo assim, não é trivial ele saber, 
mas ele pode saber com ajuda do HW. 
 
Como descobrir qual página foi alterada? Com ajuda do HW. Alguns HWs tem mais um campo na 
tabela de paginas do processo que se chama Alterado (Dirty = sujo). Este bit é HW que altera. Todos 
os bits citados até esse momento é o SO que altera e o HW consulta. Este é o SO que consulta. 
 
Por exemplo, a pagina logica 2 foi a pagina vitima escolhida para ser salva no disco e depois voltou 
para memoria física. Depois que ela volta para memoria o SO coloca neste bit (Alterado) o valor 0 
conforme mostra a Figura 18 para dizer que a pagina não foi alterada. E o processo volta a executar. 
Se durante sua execução ele alterar o código dessa pagina logica. O HW automaticamente liga o bit 
Alterado colocando 1. 
 
Então essa ajuda do HW permite que o SO saiba que a pagina logica foi alterada ou não. Se for 0 
não precisa ser salva novamente no disco, pois nada foi alterado. Se for 1 precisa salvar novamente 
no disco, pois o que está no disco está desatualizado. A Intel trabalha com este bit outros fabricantes 
não tem esse bit na tabela de paginas. 
 
 
 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 30 
 
Figura 18 
 
Como que faz os fabricantes que não tem esse bit? Nos casos que o HW não tem esse bit (Alterado 
(Dirty)) na tabela de pagina do processo é possível que o SO faça a simulação desse bit conforme 
mostra a Figura 20. 
 
A Figura 19 é tabela de paginas do processo sem o campo bit Alterado que é fornecido somente pela 
Intel. 
 
 
Figura 19 
Como o SO faz para saber a simulação desse bit? Ele tem uma tabela auxiliar usada somente por ele 
conforme mostra a Figura 20. O SO com esta tabela ele engana o HW colocando uma informação 
falsa na tabela que o HW utiliza. Na tabela da Figura 19 o SO diz que a pagina logica 2 não é 
alterável (coloca 0). A informação verdadeira ele coloca no campo Realmente Alterado da Tabela 
Auxiliar (coloca 1). No campo Alterado da Tabela Auxiliar ele coloca 0 que é o valor que o SO 
alterou o campo Alteravel da tabela de paginas do processo. 
 
Figura 20 
 
SISTEMA OPERACIONAL II – PARTE 7 
 
Elaborado por Luciana SA Amancio Página 31 
 
Desse jeito dá para simular o bit Alterável porque na hora que o processo tentar alterar a pagina 
logica 2. O que o HW vai fazer? Vai dizer que não pode, pois para ele na tabela principal essa pagina 
logica é não alterável. O HW gera uma interrupção e quando o SO for tratar essa interrupção ele vai 
na Tabela Auxiliar para verificar qual é o valor correto desse campo e descobre que é 1. Então essa 
pagina é alterada de verdade foi eu SOque coloquei o valor falso na Tabela de Pagina do Processo. 
O que o SO faz? Utiliza a interrupção para mudar o valor do bit Alterado para 1 conforme mostra a 
Figura 20. Ou seja, coloca o bit Alteravel igual a 1conforme mostra a Figura 19. 
 
Para uma pagina que voltou ao disco nesse caso o que o SO faz quando o HW não tem o campo 
Alterado? Ele faz três coisas: 
 
1) Tabela principal: Bit alterável = 0 (Valor falso) 
Tabela auxiliar: Bit alterável = 1 (Valor correto) e Bit alterado = 0 
 
2) Quando o processo tenta alterar a pagina o HW gera a interrupção. O SO verifica se a pagina 
é realmente alterável na Tabela Auxiliar. Esta interrupção só será gerada quando o processo 
alterar a página. 
 
3) Tabela auxiliar: Bit alterado = 0 
Tabela principal: Bit alterável = 1 (Valor correto)