SOII_Materia_Parte05

Prévia do material em texto

SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 1 
 
31) RESUMO 
 
1) Segmentação 
 
 Tipicamente 1 área de processo = 1 segmento 
 Linguagem de máquina utiliza endereços bidimensionais 
 Numero do segmento, deslocamento 
 Tabela de segmentos por processo: inicio do segmento, tamanho, executável, alterável, 
proteção de memória. 
 
2) Paginação 
 
 Memória ilusória lógica 
 Memória verdade física 
 Ambas compostas por páginas de tamanho igual 
 Diferenças : 
 Páginas estão em outra ordem 
 Páginas lógicas sem conteúdo não existem na memória física 
 Problema de fragmentação interna. 
 
32) CONVERSÃO DO ENDEREÇO LÓGICO EM ENDEREÇO FÍSICO 
 
O processo vai usar o endereço da memória lógica, pois ele acha que a memória lógica é a memória 
verdadeira. Conforme mostra a Figura 1. Por exemplo, alterar o conteúdo do endereço 8200 o valor 
está no registrador que já tenha um dado calculado. 
 
Instrução do processo 1  Mov [8200] AH 
 
O endereço 8200 é um endereço lógico. Então, devemos fazer a conversão do Endereço Lógico no 
Endereço Físico. Ao fazer isto vamos alterar tudo o que o processo está vendo. 
 
 
Figura 1 
 
 
 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 2 
 
Conversão do endereço lógico em endereço físico. 
 
Como a conversão é feita? A primeira coisa é: 
 
32.1) “QUEBRA” DE ENDEREÇO LÓGICO EM DUAS PARTES: NÚMERO DA PÁGINA 
LÓGICA E DESLOCAMENTO NA PÁGINA 
 
 Num_pag_logica = Int (EndLogico / Tam_pagina) 
 Deslocamento = EndLogico % Tam_pagina 
 
Onde % é o resto da divisão inteira 
 
Uma coisa mais intuitiva é olhar na memória. A página da memória Intel é de 4 kb. Então a primeira 
página que é a página lógica zero começa em 0 e vai até 4095. A partir de 4096 começa o endereço 
da segunda página lógica. A página lógica 1 começa no endereço 4096 e vai até 8191. A página 
lógica 2 começa no endereço 8192 e vai até 12288. Então o endereço 8200 está obviamente na 
página lógica 2. E o deslocamento que a distancia do início da página é 8. 
 
Encontramos os mesmos valores fazendo a conta: 
 
 Num_pag_logica = Int(8200/4096) = 2 
 Deslocamento = 8200%(4096*2) = 8 
 
A segunda coisa a ser feita é a conversão do Número da página lógica para o Número da página 
Física: 
 
32.2) CONVERSÃO NUM_PAG_LOGICA  NUM_PAG_FISICA 
 
Olhando a Figura 1 fica fácil de descobrir esta correspondência, mas o computador não tem a Figura 
1. Como ele sabe esta correspondência? Através da Tabela de Páginas do Processo 1. Conforme 
mostra a Figura 2. Cada processo tem a sua tabela de páginas. A tabela é preenchida pelo Sistema 
Operacional. 
 
Quais são os campos da tabela de páginas? O mais importante que é o número da página física. O 
que é o index da tabela de páginas? É o número da página lógica. Que não é um campo, mas sim o 
index. É onde se guarda o valor do número da página física. 
 
A Figura 2 representa a Tabela de Páginas do Processo 1 mostrado na Figura 1. Como são 
informadas as páginas lógicas que possuem conteúdo e as que não possuem conteúdo? Tem outro 
campo na Tabela de Páginas de um bit que informa se a página existe ou não. O nome desse campo é 
Válido. Se o valor dele for 0 informa que a página lógica está vazia, logo não existe na página física. 
Se o valor for 1 informa que a página lógica tem conteúdo, logo existe na página física. Conforme 
mostra a Figura 2. 
 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 3 
 
 
Figura 2 
 
 
A tabela de páginas do processo é preenchida pelo Sistema Operacional quando o processo é 
iniciado. Fica na memória do Sistema Operacional. E o HW MMU vai consultar esta tabela para 
fazer a conversão do endereço da página lógica para o endereço da página física. 
 
Então nesse caso específico, o endereço da página lógica é o 2. O HW MMU vai na tabela de 
páginas do processo 1. Verifica se a página 2 é válida. Que de fato é. E vê que o número da página 
física é 0. 
 
Num_pag_logica  Num_pag_fisica 
 2  0 
 
O terceiro passo é a união do Número da página Física com o Deslocamento 
 
32.3) EndFisico = (Num_pag_fisica* Tam_pagina) + Deslocamento 
 
Logo, EndFisico = (0*4096) + 8 = 8 
 
Conclusão: Nesse exemplo, quando o processo tenta usar o endereço lógico 8200 o endereço físico 
na memória que vai ser executada de fato é 8. O processo sempre vai utilizar o endereço lógico, o 
endereço que ele acha ser verdadeiro. E o HW MMU faz a conversão do endereço lógico no 
endereço físico. 
 
OBSERVAÇÃO 
 
O computador trabalha com contas binárias. Estas contas são diferentes da apresentada acima. O 
tamanho da página é sempre potencia de 2, por exemplo, 4096 = 212. 
 
537 onde 5 é a divisão por 100 e 37 é o resto da divisão. Conforme mostra a Figura 3. 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 4 
 
 
Figura 3 
 
100 é 102 , então ando duas casas para esquerda e faço um corte conforme mostra a Figura 3 o lado 
esquerdo do corte tem a Divisão por 100 e o lado direito do corte tem o Resto da divisão. Na base 10 
é muito fácil dividir por 100, por 1000, por 10000 etc.. 
 
Int(537/100) = 5 (Esquerda) 
 
537%100 = 37 (Direita) 
 
537 = 5*102 + 3*101 + 7*100 
 
Agora estou na base 2 e quero dividir 8200 por 4096 que é 2 12. 
 
 
8200  
 
= 1*213 + 1*23 = 8192 + 8 = 8200 
 
Onde a 1ª Parte é a divisão por 2 12 e pode ser alterada. E a 2ª Parte é o resto da divisão por 2 12 que 
não pode ser alterada, ou seja, se mantem. 
 
Como faço a divisão? 
Faço o corte na 12ª casa, pois 4096 é igual 2 12 . O número de casas que deve ficar no lado direito do 
corte tem que ser igual ao número da potência, ou seja, igual ao expoente do número que estou 
dividindo. Neste caso é o 12. 
 
O Num_pag_fisica muda, ou seja, a 1ª Parte do corte da divisão. Mas, o Deslocamento não muda, ou 
seja, a 2ª Parte do corte da divisão. 
 
Então precisamos converter a 1ª Parte para zero. Logo, o endereço físico é igual a: 
EndFisico = 
 
O Deslocamento é igual à quantidade de bits que o endereço tem. 
 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 5 
 
Este exemplo é um caso que a conversão dá certo. Mas existem casos que a conversão na dá certo. 
Por exemplo, MOV [22000], BH . Onde 22000 é o endereço lógico. 
 
Num_pag_logica = Int(EndLogico/ Tam_pagina) = Int(22000/4096) = 5 
 
Caso 1 
Ao tentar converter o Num_pag_logica para Num_pag_fisica o HW MMU verifica que na Tabela de 
páginas do processo 1 o bit válido da página lógica 5 é 0. Então o HW MMU gera uma interrupção, 
pois não corresponde a uma página verdadeira (não existe esta página). Uma rotina do SO vai tratar 
esta interrupção. 
 
Cada interrupção tem um número que é o index de um vetor no SO. Neste index existe um ponteiro 
para o endereço onde está o código que tratará a interrupção. 
 
A Tabela de Páginas do Processo é preenchida pelo SO no momento que o processo é criado. Ela 
fica dentro do PCB do processo. O HW MMU consulta para esta tabela para fazer a conversão do 
endereço lógico no endereço físico. 
 
O SO vê no arquivo executado do processo o tamanho do código, o tamanho inicial de dados, o 
tamanho inicial da pilha e vai escolher paginas físicas livres para guardar esse conteúdo em qualquer 
lugar da memória física e colocará a correspondência no campo Num_pag_fisica da Tabela de 
Páginas do Processo. 
 
Caso 2 
Como coloco o valor de um ponteiro em um registrador? Digamos que endereço do ponteiro é 9000. 
Então, 1) MOV EAX, [9000]  Copia para o reg EAX o valor do ponteiro. 
2) MOV EBX, [EAX]  Copia para o reg EBX o valor do ponteiro EAX. 
 
A 2 instrução é mais fácil de gerar erro se o valor, pois basta o valor do ponteiro estar errado que 
gera interrupção. 
 
Da mesma forma que a Segmentação controla o tipo de uso que o processo faz no seu segmento, a 
Paginação também controla o tipo de uso que o processofaz das suas páginas. A Tabela de páginas 
ela tem campos que vão controlar se aquilo que o processo quer fazer naquela página está correto ou 
errado. Os campos são os mesmos que a Segmentação: bit Executável e Alterável. Estes campos 
também são preenchidos pelo SO de acordo com o tipo de área. Conforme mostra a Figura 4. 
 
Então se a área é uma área de código. É uma área que tem suas páginas com um conteúdo executável 
e não alterável. Se for uma área que contem variáveis, então é uma área que o conteúdo não pode ser 
executado, mas pode ser alterado. Isto em uma área típica. 
 
O SO preenche dessa forma a tabela de páginas e o HW vai utilizar também para fazer validação. 
Então, por exemplo, MOV [4300], BH. Onde 4300 é o endereço lógico. Tem que fazer a conversão 
para o endereço físico. Mas, primeiro encontrar a Num_pag_logica. 
 
Num_pag_logica = Int (EndLogico/Tam_pag) = Int(4300/4096) = 1 
 
O que a instrução MOV [4300], BH tem que fazer? Pegar o valor contido no BH e copiar para o 
endereço 4300. 
 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 6 
 
Logo, estou querendo alterar o valor contido no endereço 4300 que é uma página lógica válida. Só 
que tem o seguinte na página lógica 1 não permite a alteração do conteúdo. Conforme mostra a 
Figura 4. 
 
Por que? Porque o SO preencheu o bit alterável igual a 0 porque na página contém código. Código 
não é para ser alterado na execução do processo. Então dá erro. O HW MMU gera interrupção, pois a 
instrução está tentando alterar o conteúdo da pagina lógica 1, mas na tabela de página do processo a 
página lógica 1 tem o bit alterável igual a 0. 
 
 
Figura 4 
 
A mesma coisa aconteceria se tentar executar uma instrução com o endereço que está nas páginas 
lógicas 2 e 3, não vai dá certo, vai gerar interrupção, pois o conteúdo que está nestas páginas lógicas 
não são executáveis. 
 
Então, nestes dois casos que acabamos de vê tipicamente a rotina do SO que trata este tipo de 
interrupção aborta o processo. 
 
Atualmente todas as CPU’s usam paginação. 
 
2º PROBLEMA: TAMANHO DA TABELA DE PÁGINAS 
 
Depende do chip que tenha na Placa mãe, poderá ser colocado 500MB ou 1GB, depende de quanto o 
usuário decidiu colocar em sua máquina. 
 
Mas, o espaço de endereçamento lógico não é real ele é virtual, então existem páginas de espaço 
lógico que não tem correspondentes no mundo real. Como no exemplo abaixo, somente 3 páginas 
têm correspondentes no mundo real, então se o programador faz um acesso a uma das páginas que 
não tem correspondentes no mundo real, por exemplo, um acesso a página lógica 6 e não houver 
informação, então quando o hardware tentar fazer a conversão do endereço lógico para o endereço 
físico ele terá antes que testar se a conversão pode ser feita ou não, ou seja, o hardware verifica se o 
bit é válido, se não for válido ele não fará a conversão e gerará uma interrupção abortando o 
programa em seguida. 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 7 
 
 
Já que é assim não terá um limite do tamanho do espaço lógico, já que eu posso ter muitas páginas 
que não tem correspondentes, o que acontece é que normalmente o tamanho do espaço lógico é o 
tamanho máximo que a máquina permite. E qual é o tamanho máximo? É o maior endereço que ela 
pode usar. 
 
Por exemplo, na CPU Intel o maior endereço que ela pode usar é 32 bits, ou seja, 2³²-1 = 4GB. É o 
caso em que todos os bits são 1, já que não tem limite para o tamanho do espaço lógico, então os 
Sistemas Operacionais podem escolher que o espaço lógico é 4GB, geralmente é isso que acontece, 
por exemplo, no Windows o espaço de endereçamento virtual de um processo qualquer é de 4GB. 
No interior da CPU poderá ter um outro valor de tamanho máximo que pode ser usado, o valor de 
32bits pode ser 64bits, por isso, vai ser muito maior o tamanho do espaço lógico. 
 
Se o espaço de endereçamento lógico é 4GB, não terá problemas colocar código de dados na parte de 
baixo e colocar a pilha em cima, neste espaço terá milhares de páginas. Então o SO poderá ter pilha 
para baixo e código para cima à vontade. Assim, digamos que a página lógica 0 seja mapeada pela 
página física 1 e a página lógica 1 seja pela 3, o SO preencherá na tabela de páginas como descrito 
acima, enquanto houver memória real para ser usada, podendo aumentar o tamanho da pilha. É 
interessante que o espaço seja grande, pois não existirá problema de dados para cima e pilha para 
baixo, enquanto existir memória física. Se o dado crescer e bater na pilha, aí tem que abortar o 
processo mesmo que exista memória física. É vantagem colocar bem longe essas áreas para evitar o 
encontro delas. Acaba com o problema da fragmentação em que não poderia usar a memória porque 
estavam separados. Afinal, desde que exista uma página física livre não importando onde esteja pode 
ser mapeado uma página lógica. Obs.: A pilha nunca bate no código, porque é muito grande. 
 
Quantas página lógicas de 4KB existe em um espaço lógico de 4 GB? 1M (1 milhão). 
Nº de páginas lógicos = tamanho do espaço lógico / tamanho da página. 
Exemplo: Nº de páginas lógicos = 4GB/4Kb = 1M (1 milhão) 
Onde fica a Tabela de Páginas? Resposta: Na memória. 
 
Espaço de Endereçamento lógico Espaço de Endereçamento Físico 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Qualquer página do espaço de endereçamento lógico, o programa pode tentar usar, erradamente, 
então o hardware tem condição de perceber isso e gerar uma interrupção e abortar o processo. Para o 
Nº da página física 
 
 
 
 
 
 
 
 
3 
2 
1 
0 
Pilha 
Dados 
Código 
4GB
G 
 
 
 
 
 
 
 
 
 
 
 
4 
3 
2 
1 
0 
 
11 
10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
Tabela de Páginas 
válido 
 0 
 0 
 0 
 0 
 0 
 0 
 0 
 0 
 0 
0 1 
4 1 
2 1 
 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 8 
 
hardware perceber isso, tem que existir na tabela de páginas um número de entradas que é igual ao 
número de página lógica que existe. 
 
Uma página lógica qualquer que é acessada faz com que o hardware olhe na tabela de páginas e veja 
se aquela página pode ser usada ou não. Isso será um problema da paginação, pois, terá 1 milhão de 
entradas, se cada entrada tiver, por exemplo, 4 bytes então a tabela de páginas com 1 milhão de 
entradas, será igual a 4MB por processo, então é um problema complicado pois se fossem 100 
processos seriam 400MB. Esse é o tamanho da tabela de páginas como descrito acima, a tabela de 
páginas seria muito grande e ocuparia muito espaço na memória só para construí-la. 
 
32.4) DIFICULDADES PARA IMPLEMENTAR A PAGINAÇÃO 
 
1ª) O acesso a tabela de páginas 
 
Isto introduz uma coisa que a máquina sem paginação não tem. A máquina sem paginação que não 
tem endereço lógico tem endereço físico. Quando o processo vai para memória vai para a memória e 
pronto. Não tem que passar pelo processo de conversão de endereço lógico em endereço físico. 
 
Porém, na paginação tem. Esta primeira conversão do endereço lógico no endereço físico gasta um 
tempo. E este tempo na paginação em principio é bem elevado porque para fazer a conversão precisa 
consultar a tabela de paginas que está na memória. Que não é a coisa mais rápida do mundo. 
 
Por que a tabela de paginas esta na memoria? Não podia estar em um registrador físico? Isto não 
funciona, porque embora neste caso a tabela de páginas não seja grande ela tenha apenas 13 
elementos. Na vida real não é assim. Na vida real a tabela de páginas tem milhões de registros. Então 
não dá para usar registrador para guardar esse conteúdo. 
 
Como cada processo tem a sua Tabela de Páginas do Processo. A Figura 5 mostra a Tabela de 
Páginas do Processo 2. 
 
Figura 5 
 
Tem um registrador que aponta para o endereço da Tabela de Páginas do Processo em execução que 
o HW MMU tem que usar. Então o registrador aponta para tabela da Figura5. Ai para o HW fazer a 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 9 
 
conversão vai pegar o registrador vai vê onde está a tabela e vai utilizar os dados para fazer a 
conversão do endereço lógico para o endereço físico. 
 
Quando o Processo 2 é bloqueado e o SO escalona outro processo. Então o SO também tem que 
mudar o valor contido neste registrador. Ele faz com que o registrador aponte para a tabela de 
paginas do processo que está em execução. Então nesse momento o HW passa a utilizar esta tabela. 
 
A Tabela do Processo fica na memória durante a vida do processo só apaga quando ele morre. Se o 
processo for bloqueado, mas depois ele vai voltar a executar. A tabela fica na memória. 
 
Digamos que numa certa máquina que tem este tipo de memória o Tempo de Acesso a Memória 
Física = 100 ns = 100*10-9 s = 10-7 s 
 
Então quando uma máquina sem paginação faz acesso à memória o tempo gasto é de 100 ns. 
 
Quando tenho uma máquina com paginação e que tem uma instrução de acesso a memória, por 
exemplo, Mov [8200], AH. O endereço 8200 é um endereço lógico. Temos que fazer primeiro a 
conversão de endereço lógico para endereço físico. 
 
Então o Tempo de Acesso a Memória Lógica (Memória Fictícia) = Tempo de Conversão de 
Endereço Lógico em Endereço Físico + Tempo de Acesso a Memória Física 
 
Então pela conta percebe-se que uma máquina com paginação vai ser sempre mais lenta do que um 
máquina sem paginação, pois a máquina com paginação tem o tempo de conversão que a maquina 
sem paginação não tem. 
 
O problema é que a conversão do endereço da página lógica para o endereço da página física não é 
rápida. 
 
No exemplo atual a conversão EndLogico em EndFisico acessa a tabela de páginas que está na 
memória física. Sendo assim, temos: 
 
Mov[8200], AH 
 
EndLogico  EndFisico 
 8200  8 
 
Tempo de conversão = Tempo de Acesso a Memória Física (Acesso a Tabela de Página) 
 
Qual é o problema? O problema é que o tempo de acesso a memória lógica é: 
 
Tempo de acesso a Memória Lógica = 100 ns + 100 ns = 200 ns 
 Tempo de Conversão Tempo para acessar o conteúdo propriamente 
dito 
 
Se fosse assim qualquer acesso à memória na paginação vai ser duas vezes mais lento ao que seria o 
acesso em uma máquina sem paginação. Porque o tempo de conversão é o mesmo tempo gasto para 
fazer o acesso. Mas, na verdade não é assim que funciona. Tem uma solução para este problema. 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 10 
 
 
 
32.5) SOLUÇÃO PARA O PROBLEMA DO DESEMPENHO NA MÁQUINA COM 
PAGINAÇÃO 
 
Tabela de conversão: 
A tabela contem uma entrada para cada pagina virtual. Ela é a consultada pelo gerente de memória 
para fazer a conversão. Ela é criada e alterada pelo SO. O nome mais usado para essa tabela é Tabela 
de Páginas. Esta tabela é grande demais para ser guardada pelo gerente de memória, logo, a tabela 
fica alocada na memória e é consultada pelo gerente de memória do HW. Para descobir o endereço 
real de uma variável, há 2 acessos a memória: 1. Consulta a tabela de paginas, 2. Acesso ao 
endereço. Ou seja, a paginação é duas vezes mais lenta que um HW sem paginação. 
 
Para otimizar este processo, o gerente de memória guarda uma tabela pequena e rápida chamada 
TLB. Antes de acessar a tabela de paginas, o gerente de memória acessa primeiro a TLB, o que torna 
mais rápido a conversão, já que a TLB está contida no gerente de memória. Se não estiver contida na 
TLB, o gerente de memória acessa a tabela de paginas, e as paginas de consulta passam a constar na 
TLB também. Se a TLB estiver cheia, o gerenciador de memória, escolhe uma entrada para ser 
sobreposta. 
 
A solução é ter um componente de HW que acelera a conversão. Torna a conversão mais rápida. O 
ideal é a Tabela de Páginas ficar no registrador, mas ela não fica porque é muito grande. Seria mais 
rápido se fosse no registrador. 
 
Como esse componente funciona? O componente se chama TLB. Ele guarda um resumo da Tabela 
de Páginas. Não guarda a Tabela de Páginas toda porque é muito grande. Que resumo é esse? A TLB 
guarda alguns registros da Tabela de Páginas do Processo. Por exemplo, a Tabela de Páginas da 
Figura 5 tem 13 registros a TLB vai guardar 3 registros. 
 
A ideia é se você estiver usando uma página cuja conversão esteja na TLB vai ser mais rápido do que 
na Tabela de Página do Processo. 
 
A TLB tem basicamente os mesmos campos da Tabela de Páginas do Processo, mas o campo 
Num_pag_logica é um campo que não existe na Tabela de Página do Processo. Conforme mostra a 
Figura 6 a seguir: 
 
 
Figura 6 
 
Bits de controle Executável e Alterável. A TLB é um resumo da Tabela de Páginas do Processo. 
Como é um resumo e tem só alguns registros da Tabela de Páginas do Processo (TPP). Eu tenho que 
saber que registro da TPP está na TLB. Então tem um campo a mais na TLB que é o 
Num_pag_logica. Este campo na TPP é um índice e não um campo. Exemplo: 
 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 11 
 
1) Acabou de começar um processo e a primeira instrução é: MOV [8200], AH 
O que acontece? O endereço é quebrado em duas partes e descobre que o número da página lógica é 
igual a 2. Para que serve o Num_pag_logica na TLB? Ele tenta verificar se existe uma página lógica 
2 na tabela de resumo que é a TLB. Como o processo começou a executar agora a TLB está vazia. 
Então não tem registro da página lógica 2. Nesse momento o HW vai ter que consultar a TPP que 
está na memória e é mais lenta. Logo, o HW descobre que a Num_pag_logica = 2  corresponde a 
Num_pag_fisica = 0. Ao mesmo tempo em que o HW faz esta consulta a TPP ele pega os dados da 
TPP referentes a página lógica de consulta e coloca na Tabela Resumo. 
 
Depois tem outra instrução, por exemplo, CALL 500. Olhando a TPP sabemos que neste caso o 
Num_pag_logica = 0  Corresponde a Num_pag_fisica = 2. Primeiro o HW chama a TLB. A TLB 
tem os dados referentes a página lógica 0? Não. Só tem referente a página lógica 2. Então o HW vai 
consulta a TPP da página lógica 0 e ao mesmo tempo preenche a TLB com os dados desta página. 
 
Assim quando tiver outra instrução que por sorte use uma destas duas páginas lógicas cuja conversão 
estão na TLB será mais rápido. 
 
Digamos que agora temos a instrução: MOV BH, [10000]. Nesse caso temos que o Num_pag_logica 
= 2  Já tem na TLB. O HW consulta a TLB. Ela tem o número da página lógica que é igual a 2. 
Então o HW consegue fazer a conversão sem precisar consultar a TPP. Como a TLB é tipo um 
registrador é muito mais rápido fazer a conversão. 
 
Nesse caso descobre que a página lógica 2 corresponde a página física 0 muito mais rapidamente, ou 
seja, consegue fazer isso utilizando a TLB de cada processo que é rápida porque é como se fosse um 
registrador. 
 
A TLB existe para que? Para aumentar a velocidade de conversão do número da página lógica em 
número da página física. Então fica mais rápido executar um processo, pois, se for utilizar somente a 
TPP fica muito lento. Tem casos que vai acontecer de abortar o processo. Por exemplo, se o processo 
for utilizar a página lógica 5 ou 4 que são página inválidas ele será abortado. Então nesse caso que 
vai ser abortado não precisa ir para TLB, pois não faz diferença abortar mais rápido ou mais devagar. 
 
Portanto, páginas lógicas que não são válidas não vão para TLB, pois não tem muita vantagem fazer 
isso. Conforme mostra a Figura 6 o campo bit válido não tem na TLB. Só vão para TLB as páginas 
válidas. A TLB contém as últimas conversões feitas. E em linguagens convencionais tem a tendência 
de reutilizar os endereços que estavam sendo utilizados. Logo, quando a página lógica é colocada na 
TLB é muito provável que esta página será utilizada novamente. Os registros mais antigos são 
retirados da TLB. 
 
Qualquer HW que tenha paginação tem TLB porque sem TLB é muito lento. Inclusive a TLB éuma 
parte que complica muito a paginação. 
 
Digamos que quero fazer um novo acesso ao endereço que está na página lógica 10. Na TPP isso é 
muito trivial porque ela é indexada pelo número da página lógica. Então para fazer a conversão basta 
acessar um único local na TPP, ou seja, faz um único acesso a TPP. A TLB não é assim, logo para 
descobrir qual o endereço da pagina lógica 10 tem que fazer uma procura até encontrar ou não. 
Portanto, isso não é trivial de implementar, mas tem que ser feito para paginação funcionar bem. 
 
Mas há um outro mecanismo que otimiza a paginação. É a TLB (Translation Lookaside Buffer) que 
fica na CPU. Ela funciona como uma cache da tabela de páginas. 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 12 
 
 
A TLB tem algumas posições que guardam o número da página lógica e física de um processo e se a 
página física é válida ou não. (bit de validade). 
 
Digamos que um processo precise acessar a página real 4 que é referenciada pela página lógica 2. 
Quando a CPU atualizar o endereço informado na instrução, a CPU atualizará a TLB com a página 
lógica 2, página física 4 e bit de validade 1. 
 
Se a CPU tiver que acessar um outro endereço da mesma página lógica, em vez de acessar a tabela 
de páginas, poderá acessar a TLB que pode ser acessada mais rapidamente e com isso economiza-se 
tempo. 
 
Se a TLB ficar cheia e precisar colocar novos valores (relação página lógica x página física) de um 
mesmo processo, deverá ser escolhida uma linha da TLB a ser sobrescrita. A tabela deverá ser zerada 
caso haja uma troca de processo. 
 
Tempo de Acesso à Memória: 100 ns 
Tempo de Acesso a TLB: 10 ns 
Tempo médio de acesso a memória para instruções similares a MOV reg, [endereço]: 
 
 
 
 
 
 
 
 
 
 
 
 ((10 + 100) * p ) + ( (10 + 100 + 100) * (1 - p)) 
 
 
 
 
 
 
110 p + 210 (1 – p) 
= 110 p + 210 – 210 p 
= 210 – 100 p 
 
Ex.: Se em 90% dos casos a conversão estiver na TLB, o tempo médio gasto será de: 
 
210 – 100 (0,9) = 210 – 90 = 120 ns 
 
Logo, a página traz perda de performance pois se não fosse usada (como está escrito acima, a perda 
foi de 20%) o tempo gasto seria simplesmente de 100 ns. 
 
Seria muito pior se não existisse a TLB, pois haveria sempre 2 acessos à memória, consumindo 200 
ns. 
Tempo 
de 
acesso 
à TLB 
Tempo de 
acesso à 
memória 
(leit./escr.) 
Probabil. da 
conversão 
ser feita 
pela TLB 
Tempo 
de 
acesso 
à TLB 
A conversão 
não foi achada 
na TLB. 
Precisa ver a 
Tab. Página 
(que fica na 
memória) 
Probabil. 
da 
conversão 
não ser 
feita pela 
TLB 
Tempo de 
acesso à 
memória 
(leit./escr.) 
Conversão via TLB Conversão via Tab. Pág 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 13 
 
 
Com o uso da TLB, o tempo reduz consideravelmente. Hoje em dia é preferível usar a paginação 
mesmo com perda de performance. 
 
2º problema: Problema do tamanho da Tabela de Página 
 
O máximo que a EEL pode endereçar é 232 – 1 = 4 GB 
 
Número de páginas lógicas = 4 GB (tamanho da EEL) / 4 KB (tamanho da página lógica) = 1 M 
páginas = 1.048.576 páginas 
 
Se há 1 M páginas lógicas, a tabela de página tem que ter 1 M entradas. 
 
Se cada entrada da Tabela de Páginas tem 4 bytes de tamanho, só a Tabela de Páginas ocuparia 4 * 1 
M = 4 MB, o que já é exagerado. 
 
Se a Tabela de Páginas tem 1 M páginas e a maioria das entradas da Tabela de Página tem o bit 0 
pois não há informação válida nessas entradas, há espaço inútil sendo gasto. 
 
Para resolver esse problema, a Intel usou o conceito da estrutura esparsa. 
 
O que vem a ser estrutura esparsa? 
 
É uma estrutura que utiliza um array que contém ponteiros para um outro array. 
 
Matriz gigante de 100.000 linhas x 100.000 colunas 
 
Linha 
1 
0 9 8 1 0 0 0 0 .
.. 
0 
Linha 
2 
0 0 0 0 0 0 0 0 .
.. 
0 
Linha 
3 
0 0 0 0 0 0 0 0 .
.. 
0 
Linha 
4 
0 0 0 0 0 0 0 0 .
.. 
0 
Linha 
5 
0 0 0 0 0 0 0 0 .
.. 
0 
Linha 
6 
0 0 0 0 0 0 0 0 .
.. 
0 
... .
.. 
.
.. 
.
.. 
.
.. 
.
.. 
.
.. 
.
.. 
.
.. 
.
.. 
.
.. 
Linha 
10000 
0 0 0 0 0 0 0 0 .
.. 
0 
 
Se cada elemento tem 1 byte, a matriz tem 100 MB. 
 
Como nessa matriz a maioria das linhas dessa matriz tem em todas as suas colunas o valor 0, 
utilizamos um array da seguinte forma: 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 14 
 
 
 
Linha 
10000 
 
... 
Linha 6 
Linha 5 
Linha 4 
Linha 3 
Linha 2 
Linha 1 0 9 8 1 0 0 0 0 .
.. 
0 
 
FUNCTION GETITEM (I, J: INTEGER): BYTE; 
BEGIN 
 IF LINHAS [I] = NIL THEN GETITEM:=0; 
 ELSE GETITEM:=LINHAS [I]^[J]; 
END; 
 
 
 
O uso da estrutura esparsa usará pouquíssimo espaço se a maioria das linhas tiver valor 0 em todas as 
colunas. 
 
Aplicando essa estrutura na Tabela de Páginas, divide-se a tabela de páginas em tamanhos iguais. 
 
Só vão existir fisicamente as páginas que tem bit de validade 1. 
 
Ex.: Usa-se o Diretório de Páginas em vez da Estrutura Esparsa que tem 1K entradas de 1 KB cada 
(Intel), formando assim uma Tabela de Páginas Multinível. 
 
As páginas 0 a 999 da Tabela de Páginas corresponde à página 0 do Diretório de Páginas. Só ficará 
no Diretório de Páginas o grupo de 1000 entradas da Tabela de Páginas (0-999, 1000-1999, 2000-
2999 etc.) que tiver pelo menos uma entrada com o bit de validade com valor 1. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tabela de 
Páginas 
2 
3 
4 
5 
 6 
7 
9 
9 
0 
0 
9 
8 
7 
6 
 5 
4 
3 
2 
1 
0 
0 
0 
1 
0 
 0 
1 
0 
1 
1 
0 
 
..
. 
 
 
 
 
 
 
 
9
9
9 
 
7 
6 
 5 
4 
3 
2 
1 
0 
 
..
. 
 
 
 
 
 
 
 
Diretório de 
Páginas 
9
9
9 
... 
7 
6 
 5 
4 
3 
2 
1 
0 
2 
3 
4 
5 
 6 
7 
9 
9 
0 
0 
0 
0 
1 
0 
 0 
1 
0 
1 
1 
0 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 15 
 
 
2 acessos à memória: o 1o acesso ao Diretório de Páginas e o 2o à Tabela de Páginas. 
 
O tempo médio de acesso à memória usando Diretório de Páginas com 90% de hit na TLB. 
 
= (10 + 100) p + (10 + 100 + 100 + 100) (1 - p) 
= 110 p + 310 – 310 p 
= 310 – 200 p 
= 310 – 200 (0,9) 
= 310 – 180 
= 130 ns 
 
Para máquinas que endereçam mais que 232, 264 por exemplo, não é bom usar Tabela de Páginas 
(relação página lógica x página física) pois ficaria gigantesca e usar vários níveis também não é uma 
boa idéia pois seria mais lenta ainda. 
 
Existe um mecanismo que torna o acesso a memória mais rápido que é TLB(Translation Look Aside 
Buffer). 
Translation Look Aside Buffer(TLB) resolve o problema descrito acima, que é uma tabela reduzida 
com as páginas mais acessadas. Esta tabela localiza-se internamente no chip da CPU. 
 
Estrutura da TLB: 
 
Nº da Página Lógica Nº da Página Física Válido 
1 2 1 
2 6 0 1 
 
O hardware antes de fazer a conversão ele vai à TLB buscar o mapeamento caso exista da tabela de 
página. 
 
Exemplo de outras Instruções: 
1) MOV [5000], BX => já está na TLB; 
2) MOV CX, [9000] => não está na TLB, então busca a informação da sua localização e 
atualiza a TLB. Neste caso, o hardware vai à Tabela de Página na memória e busca o mapeamento, 
faz a conversão e guarda na TLB este mapeamento; 
3) MOV [10000], DX => já está na TLB, pois a instrução anterior já havia atualizado a 
mesma. Então o hardware não precisa acessar a Tabela de Página na memória 
 
O sistema operacional ao escalonar outro processo zera a TLB. Tem uma instrução que faz isso. 
 
1º problema : Perda de Velocidade 
Solução : TLB 
 
Vamos fazer um cálculo para saber a perda de performance que a paginação pode ter utilizando a 
TLB: 
Exemplo : 
Tempo de acesso a memória = 100ns 
Tempo de acesso a TLB = 10 ns 
Duas situações podem ocorre para instruções que vai a memória: 
O acesso tem que passar pela tabela de páginas; 
SISTEMAOPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 16 
 
Não precisa da tabela de páginas, pois a informação esta contida na TLB. 
 
 
Tempo de acesso a memória em = (10+100)*p + (10+100+100) 
 
 
 
 
Conversão via TLB: 10ns para consultar a TLB + 100ns para acessar o banco de dados depois de 
convertido, p é a probabilidade de acontecer a conversão via TLB. 
 
Conversão via Tabela de Páginas: dois acessos a Tabela de Páginas (100ns + 100ns) e outro a 
memória para trazer o dado que o programador quer, também se gasta o tempo de acesso da TLB 
(10ns), pois só será sabido que a informação está na TLB, depois do acesso à mesma. 
 
Outra situação: Quando a conversão não está na TLB tem como ocupar a TLB primeiro.Gasta mais 
100ns para consultar a Tabela de Página para fazer a conversão do endereço lógico para o endereço 
físico e depois se gasta mais 100ns para pegar o dado que o programador quer e colocá-lo no 
registrador: 
 
Instrução similar a mov reg [end] = 110p+210 –210p = 210 –100p =210 –90 =120 => perda de 20% 
Onde: p = 0,9. 
 
Essa é uma solução razoável, porque se não houvesse nada teria uma perda de 100%, se não tivesse a 
TLB para fazer a conversão todo acesso a uma instrução como essa faria dois acessos a memória, 
então ao invés de gastar 100ns, gastará 200ns ia ser uma perda de 200%. Usando a TLB a perda é de 
20%. 
 
Justifica-se então que a TLB é uma solução razoável para perda de velocidade. 
 
Avaliação de perda desempenho TPP x TLB 
 
Uma máquina com paginação tem perda desempenho que uma maquina sem paginação não tem. 
 
Digamos que o Tempo de conversão via TLB = 10 ns. 
 
Temos 2 casos para o tempo de conversão. 
Via TLB = 10 ns 
Via tabela de páginas = 10 ns + 100 ns = 110 ns 
Tempo de conversão via TLB 
 
O tempo de conversão via TPP é mais complicado, pois para saber, por exemplo, a pagina física da 
página lógica 11 do processo o HW verifica primeiro se está página na TLB. Ele gasta tempo para 
fazer esta verificação. Sabemos que esta página não está na TLB, mas gasta-se 10 ns. Em seguida o 
HW vai na TPP. Sabemos que o tempo gasto para ir na memória é de 100 ns. 
 
Supondo que 90% dos casos a conversão seja feita via TLB 
 
Tempo Médio de Conversão = P*(Tempo de conversão via TLB) + (1-P)*(Tempo de conversão via 
Tabela de Páginas) 
Conversão via 
TLB 
Conversão via 
Tabela de Páginas 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 17 
 
 
Tempo Médio de Conversão = 0,9*100 ns + (1-0,9)*110ns = 20 ns 
 
Tempo Médio de Acesso a Memória Lógica = Tempo Médio de Conversão + Tempo de Acesso a 
Memória Física 
 
Tempo Médio de Acesso a Memória Lógica = 20 + 100 = 120 ns 
 
Comparando com o tempo de acesso de uma máquina sem paginação (Tempo de acesso a Memória 
Física = 100 ns). A máquina com paginação tem um tempo 20% maior. O pior caso é se o P for 
menor que 90%. Então é muito importante a TLB conseguir fazer a maior parte das conversões 
porque só assim que não vai ter perda de desempenho. 
 
Temos mais de um processo na memoria. Cada processo tem sua TPP. Quando o processo está em 
execução. O registrador aponta para TPP do processo que está em execução. O processo 1 começou a 
executar o SO aponta para TPP do P1, o HW vai consultar esta tabela mais aos poucos preenche a 
TLB. Depois de certo tempo o HW consegue fazer muitas conversões usando somente a TLB. 
 
Uma hora o processo fica bloqueado e para de executar. E o SO escalona o processo 2. Como o SO 
faz para escalonar outro processo? Ele faz o registrador apontar para a TPP do outro processo dentre 
as outras coisas realizadas. 
 
A TLB guarda as informações do processo atual em execução. Então não faz sentido continuar os 
dados do P1 na TLB. O SO tem que limpar este conteúdo. Isto é feito através do campo Registro em 
uso. 
 
Na hora que é preciso esvaziar a TLB o SO altera o campo Registro em uso para 0 (zero). Conforme 
mostra a Figura 7. Então no momento que o processo entra em execução o SO zera este campo para 
dizer que as informações da linha não são validas. A primeira instrução a ser executada do processo 
P1 vai para TLB e o campo Registro em uso é modificado para 1. Conforme mostra a Figura 7. 
 
 
Figura 7 
 
Nesse tipo de TLB toda vez que o processo entra em execução ou reinicia sua execução ele é um 
pouco mais lento porque as conversões que o HW tem que fazer é todas vias TPP. Pois, a TLB desse 
processo está vazia. A consequência de fazer desta forma é que os tempos de execução fica mais 
lento por causa da TLB que fica vazia. 
 
Existe outro componente de HW que tem TLB “Alternativa”. Esta TLB tem o campo 
Num_Processo. Por exemplo, a TLB estava com os dados do Processo 1 conforme mostra a Figura 8. 
Mas ele foi bloqueado e o SO escolonou o processo 2. Nesse caso não precisa limpar a TLB nem 
invalidar o conteúdo dos campos da TLB porque tem o campo Num_Processo que diz de que tabela 
que veio o dado que está na TLB. Quando o P2 inicia ele de fato pega uma TLB vazia. O processo 2 
SISTEMA OPERACIONAL II – PARTE 5 
 
Elaborado por Luciana SA Amancio Página 18 
 
foi bloqueado e o SO volta a executar o P1. Caso isso ocorra é vantajoso para o P1, pois ele não 
pegou a TLB vazia. O P1 não volta a executar tão devagar, pois já tem dados dele na TLB. 
 
 
Figura 8 
 
Esse tipo de TLB é vantajoso quando tem dados do processo quando ele retorna de um bloqueio. 
 
Na Intel temos 1 milhão de páginas lógicas isto não corresponde a página física sendo utilizadas pelo 
processo, pois temos milhares de páginas lógicas sem uso na memória lógica. Isso não gasta chip de 
memória, porém cria o problema da TPP. Porque se tem 1 milhão de registros na memória lógica tem 
que ter o mesmo valor na TPP. Assim a TPP gasta uma memória razoável não uma mais somando 
todas as TPP de todos os processos, pois temos uma TP por processo. Temos 3 mecanismo para 
evitar que a TP seja muito grande.