Sistemas Operativos Funcionamento da Memória Virtual
Rui Magalhães 22917 1
Índice Princípio Geral de Funcionamento................................................................................................ 3 Algoritmos de Substituição de Páginas ......................................................................................... 4 Algoritmo de substituição de páginas FIFO ........................................................................... 4 Algoritmo de substituição de páginas LRU............................................................................ 4 Algoritmo de substituição de páginas Ótimo ........................................................................ 5 Algoritmo de substituição de páginas MRU .......................................................................... 5 Algoritmo de substituição de páginas CLOCK ....................................................................... 5 Algoritmo de substituição de páginas NRU ........................................................................... 5 Algoritmo de substituição de páginas LFU ............................................................................ 6 Algoritmo de substituição de páginas MFU .......................................................................... 6 Algoritmo de substituição de páginas WS............................................................................. 6 Segmentação ................................................................................................................................. 7 -Objectivos ............................................................................................................................ 7 -Mecanismos de tradução de endereços .............................................................................. 7 -Optimização do Mecanismo de Tradução de Endereços..................................................... 8 - Fragmentação ..................................................................................................................... 9 -Protecção ............................................................................................................................. 9 Paginação .................................................................................................................................... 10 -Objectivos .......................................................................................................................... 10 -Mecanismos de tradução de endereços ............................................................................ 10 -Tabela de tradução de endereços(TLB) ............................................................................. 11 -Fragmentação .................................................................................................................... 13 -Protecção ........................................................................................................................... 13 -Partilha de memória entre processos ................................................................................ 13 -Dimensão das páginas........................................................................................................ 13 Memória Segmentada/Paginada ................................................................................................ 14 Conclusão .................................................................................................................................... 15
2
Princípio Geral de F ncionamento
A memória virtual baseia-se num espaço de endereços, dito virtual , que é acessível idealmente a um program em linguagem máquina, conforme a defini ção dos campos de endereços e dos mo os de endereçamento das instruções d referência de memória de um dado pr cessador. A figura 1 ilustra a relação ent e os mapas de memória virtual de divers os processos e a sua localização nas unida es de memória física do computador: me ória central (RAM) e memória secundária ( isco).
igura 1: Memória virtual
A memória virtual é um c nceito que garante uma memória dedicad a à execução de cada programa, contendo, portanto, regiões lógicas de código, dados e pilha, que são geridas pelo SO, de form transparente ao processo utilizador. Isto significa que o espaço de endereços v irtuais de cada processo tem um ta anho máximo independente da capacid ade de memória real disponível num da o computador. Significa também que o p rograma pode ignorar a localização física as suas regiões lógica de código, dados e p ilha, pois o SO e o hardware de transformação de endereços encarregam-se de, a cada eferência gerada pelo programa, localizar a correspondente célula, em memória centr al ou em disco. Por outro lado, este meca ismo garante a separação lógica e física - protecção - entre os espaços de end reçamento dos diferentes processos conc rrentes.
3
Algoritmos de Substituição de Páginas Os algoritmos de substituição de páginas são políticas definidas para escolher qual(is) página(s) da memória dará lugar a página que foi solicitada e que precisa ser carregada. Isso é necessário quando não há espaço disponível para armazenar a nova página. Devemos ressaltar que se a página a ser removida sofreu alterações enquanto esteve na memória, a cópia virtual existente em disco deverá ser atualizada. Por outro lado, se a página não foi modificada significa que sua cópia está atualizada e, portanto, não é necessário reescrevê-la. Políticas de substituição de páginas devem ser utilizadas em sistemas que fazem uso de memória virtual paginada com o objetivo de melhorar o desempenho do sistema computacional. Os algoritmos de substituição de páginas podem ser classificados, basicamente, em: algoritmos com espaço fixo e algoritmos com espaço variável. A diferença entre estes dois tipos de algoritmos é que o de espaço fixo trabalha sobre uma área de memória sempre constante, enquanto que os de espaço variável podem modificar o tamanho da memória alocada dinamicamente [CAS03]. Algoritmo de substituição de páginas FIFO O FIFO (First-in, First-out ) é um algoritmo de substituição de páginas de baixo custo e de fácil implementação que consiste em substituir a página que foi carregada há mais tempo na memória (a primeira página a entrar é a primeira a sair ). Esta escolha não leva em consideração se a página está sendo muito utilizada ou não, o que não é muito adequado pois pode prejudicar o desempenho do sistema. Por este motivo, o FIFO apresenta uma deficiência denominada anomalia de Belady : a quantidade de falta de páginas pode aumentar quando o tamanho da memória também aumenta. Por estas razões, o algoritmo FIFO puro é muito pouco utilizado. Contudo, sua principal vantagem é a facilidade de implementação: uma lista de páginas ordenada pela “idade”. Dessa forma, na ocorrência de uma falta de página a primeira página da lista será substituída e a nova será acrescentada ao final da lista. Algoritmo de substituição de páginas LRU O LRU (Least Recently Used ) é um algoritmo de substituição de página que apresenta um bom desempenho substituindo a página menos recentemente usada . Esta política foi definida baseada na seguinte observação: se a página está sendo intensamente referenciada pelas instruções é muito provável que ela seja novamente referenciada pelas instruções seguintes e, de modo oposto, aquelas que não foram acessadas nas últimas instruções também é provável que não sejam acessadas nas próximas. Apesar de o LRU apresentar um bom desempenho ele também possui algumas deficiências quando o padrão de acesso é sequencial (em estruturas de dados do tipo vetor, lista, árvore), dentro de loops, etc. Diante dessas deficiências foram propostas algumas variações do LRU, dentre eles destacamos o LRU-K. Este algoritmo não substitui aquela que foi referenciada há mais tempo e sim quando ocorreu seu k-último acesso. Por exemplo, LRU-2 substituirá a página que teve seu penúltimo acesso feito há mais tempo e LRU-3 observará o antepenúltimo e assim por diante. 4
A implementação do LRU também pode ser feita através de uma lista, mantendo as páginas mais referenciadas no início (cabeça) e a menos referenciadas no final da lista. Portanto, ao substituir retira-se a página que está no final da lista. O maior problema com esta organização é que a lista deve ser atualizada a cada nova referência efetuada sobre as páginas, o que torna alto o custo dessa manutenção. Algoritmo de substituição de páginas Ótimo O algoritmo ótimo, proposto por Belady em 1966, é o que apresenta o melhor desempenho computacional e o que minimiza o número de faltas de páginas. No entanto, sua implementação é praticamente impossível. A idéia do algoritmo é retirar da memória a página que vai demorar mais tempo para ser referenciada novamente. Para isso, o algoritmo precisaria saber, antecipadamente, todos os acessos à memória realizados pela aplicação, o que é impossível em um caso real. Por estes motivos, o algoritmo ótimo só é utilizado em simulações para se estabelecer o valor ótimo e analisar a eficiência de outras propostas elaboradas. Algoritmo de substituição de páginas MRU O algoritmo MRU (Most Recently Used ) faz a substituição da última página acessada. Este algoritmo também apresenta algumas variações, semelhante ao LRU. Por exemplo, o MRU-n escolhe a n-última página acessada para ser substituída. Dessa forma, é possível explorar com mais eficiência o princípio de localidade temporal apresentada pelos acessos. Algoritmo de substituição de páginas CLOCK Este algoritmo mantém todas as páginas em uma lista circular (em forma de relógio). A ordem mantida segue a seqüência em que elas foram carregadas em memória. Além disso, é adicionado um bit de uso que indica se a página foi referenciada novamente depois de ter sido carregada. Ao precisar substituir uma página o algoritmo verifica se a página mais antiga está com o bit zerado (o que significa que a página não foi mais referenciada) para ser substituída. Se ela não estiver o bit é zerado e a próxima página da fila mais antiga será verificada. Esse processo continua até que uma página antiga com o bit zerado seja encontrada para ser substituída. Algoritmo de substituição de páginas NRU O algoritmo NRU (Not Recently Used ) procura por páginas que não foram referenciadas nos últimos acessos para serem substituídas. Tal informação é mantida através de um bit. Este algoritmo também verifica, através de um bit de modificação, se a página teve seu conteúdo alterado durante sua permanência em memória. Esta informação também vai ajudar a direcionar a escolha da página. As substituições das páginas seguem a seguinte prioridade: páginas não referenciadas e não modificadas, páginas não referenciadas, páginas não modificadas e páginas referenciadas e modificadas.
5
Algoritmo de substituição de páginas LFU O LFU (Least Frequently Used ) escolhe a página que foi menos acessada dentre todas as que estão carregas em memória. Para isso, é mantido um contador de acessos associado a cada página (hit ) para que se possa realizar esta verificação. Esta informação é zerada cada vez que a página deixa a memória. Portanto, o problema desse algoritmo é que ele prejudica as páginas recém-carregadas, uma vez que por estarem com o contador de acessos zerado a probabilidade de serem substituídas é maior. Qual uma possível solução para este problema? (Estabelecer um tempo de carência) Só páginas fora desse tempo é que podem ser substituídas. Tal estratégia deu origem ao algoritmo FBR (Frequency-Based Replacement ). Algoritmo de substituição de páginas MFU O MFU (Most Frequently Used ) substitui a página que tem sido mais referenciada, portanto, o oposto do LFU. O controle também é feito através de contadores de acesso. O maior problema deste algoritmo é que ele ignora o princípio de localidade temporal . Algoritmo de substituição de páginas WS
O algoritmo WS (Working Set ) possui a mesma política do LRU. No entanto, este algoritmo não realiza apenas a substituição de páginas ele também estabelece um tempo máximo que cada página pode permanecer ativa na memória. Assim, toda página que tem seu tempo de permanência esgotado ela é retirada da memória. Portanto, o número de páginas ativas é variável. O WS assegura que as páginas pertencentes ao working set processo permanecerão ativas em memória. Os algoritmos apresentados são alguns dos disponíveis na literatura.
6
Segmentação -Objectivos
O objectivo da segmentação é a divisão dos programas em segmentos lógicos que reflictam a sua subdivisão funcional. Por exemplo, cada rotina ou cada módulo corresponderá a um segmento.O principal objectivo deste método é tentar suportar directamente na gestão de memória as abstracções comuns nas linguagens de programação, nomeadamente: •
•
•
Carregamento em memória. O segmento é a unidade mínima a carregar em memória. Considera-se que todas as palavras dentro do segmento têm a mesma probabilidade de virem a ser acedidas. Como não sabemos qual das instruções de uma certa rotina vai ser ou não executadas, temos de as ter todas em memória. Protecção A protecção da memória é feita em termos de blocos lógicos, quem pode aceder a parte do bloco pode aceder ao bloco todo e vice-versa. Eficiência O princípio da localidade de referência diz-nos que, se acedermos a um endereço de um segmento lógico com grande probabilidade os próximos acessos serão a endereços situados no mesmo segmento. Esta constatação na análise dos programas permite optimizar os acessos dentro do segmento, perdendo-se menos tempo na tradução de endereços.
-Mecanismos de tradução de endereços Um endereço virtual tem a seguinte forma (segmento, deslocamento) segmento contém o número do segmento e deslocamento indica o deslocamento dentro do segmento. O mecanismo de tradução está representado na fig. 4.5. Existe uma tabela de segmentos composta pelo descritor de cada segmento. Cada descritor contém o endereço físico do segmento (endereço base do segmento), a sua dimensão, informação respeitante à protecção e à utilização do segmento. Dois registos da unidade de gestão de memória, chamados registo Base da Tabela de Segmentos (BTS) e registo Limite da Tabela de Segmentos (LTS), contêm respectivamente o endereço real de início da tabela e a sua dimensão. Quando o programa gera um endereço, o número do segmento é comparado com o registo LTS. Se for inferior, é somado com o registo BTS obtendo-se a entrada na tabela de segmentos correspondente a este segmento. De seguida, os bits de protecção são testados para verificar se o acesso pretendido é legal. Habitualmente, estes bits indicam se se pode ler, escrever ou executar o segmento. Por fim, é verificado se o deslocamento pretendido é inferior ou igual à dimensão do segmento. Se o endereço for válido, o deslocamento é somado ao endereço físico do início do segmento, obtendo-se o endereço físico pretendido. Se algum dos testes anteriores falhar, isso significa que o endereço é inválido. O hardware interrompe a tradução do endereço e gera uma excepção, que será tratada pelo sistema operativo. O mecanismo descrito é executado pelo hardware. A função do sistema operativo é a de programar os vários registos, preencher a tabela de 7
segmentos e tratar as excepções quando estes são desencadeados. Quando se dá uma mudança de contexto, os registos base e limite têm de ser carregados, com o endereço e dimensão da tabela de segmentos do novo processo. A dimensão máxima de um segmento está associada à arquitectura da máquina, não podendo nunca ser alterada porque determina quantos bits do endereço são necessários para especificar o deslocamento e conter a dimensão do segmento.
-Optimização do Mecanismo de Tradução de Endereços A tabela de segmentos está em memória física. Se o hardware tiver de lhe aceder de cada vez que o programa gera um endereço, o custo do acesso a uma posição de memória duplica, visto que são necessários dois acessos a memória por cada um pretendido pelo programa. Este facto é particularmente importante, porque na moderna tecnologia a velocidade de um computador está em grande parte limitada pelos acessos à memória. Em arquitecturas segmentadas a solução habitual para este problema é guardar em registos, de acesso muito rápido, as entradas da tabela de segmentos correspondentes aos segmentos em utilização. Um programa pode ter mais que um segmento de código ou dados. Da primeira vez que um segmento é acedido, o seu descritor é lido da tabela de segmentos e é guardado no registo apropriado. Por exemplo, a instrução de chamada a uma rotina noutro segmento, da forma far call segmento: deslocamento, provoca o carregamento do descritor relativo a segmento no registo associado ao segmento de código (CSR). Nos acessos seguintes a endereços dentro do mesmo segmento, a tradução é feita internamente ao processador usando o registo CSR, o que é muito rápido. A operação demorada, que é ler o descritor da tabela de segmentos, só é efectuada da primeira vez que o segmento for acedido. Se o programa aceder a outro segmento diferente de código, esse descritor será carregado em CSR, destruindo o que lá estava, Estes registos funcionam pois como uma cache de direcção unitária. Certos processadores têm tabelas genéricas, que guardam os descritores dos últimos segmentos acedidos pelo programa.
8
- Fragmentação A segmentação gera fragmentação externa a medida que os segmentos são alocados e libertados. Uma maneira de a resolver é copiar todos os segmentos para um dos extremos da memória, como no caso das partições variáveis. Outra solução, usada principalmente quando um segmento cresce, é copiar o segmento para memória secundária, libertar o seu espaço em memória física, alocar um segmento da dimensão pretendida (eventualmente esperando que outros processos terminem e libertem memória) e, copiar o segmento novamente para memória primária. Ambas as soluções exigem que o processamento seja interrompido. A segunda solução é incremental, o que implica paragens menores e necessita de menos memória livre para operar. -Protecção Numa arquitectura segmentada a unidade de protecção é o segmento. A protecção associada ao segmento está especificada no descritor do segmento e é feita a vários níveis: •
•
•
Como processos diferentes têm tabelas de segmentos diferentes, os espaços de endereçamento virtual são distintos, não havendo forma de um processo poder referendar zonas de memória de outro. O deslocamento dentro do segmento é verificado comparando-o com a dimensão do segmento residente no descritor. tipo de acesso ao segmento é verificado impedindo, por exemplo, que um programa escreva no segmento de código. As protecções habituais são leitura, escrita e execução.
-Partilha de memória entre processos
Partilhar um segmento entre dois ou mais processos é externamente simples: basta ter nas varias tabelas de segmentos uma entrada contendo o mesmo endereço físico e dimensão. Desta forma, dois processos podem aceder por endereços virtuais (eventualmente diferentes) à mesma memória física.
9
Paginação Objectivos O principal objectivo da arquitectura de memória paginada é oferecer ao programador um espaço de endereçamento (virtual) linear, em geral bastante maior que a dimensão da memória física da máquina. A ideia subjacente é fazer com que o programador não precise de se preocupar com a gestão de memória quando escreve um programa. Mecanismos de tradução de endereços A memória é dividida em blocos todos do mesmo tamanho, chamados páginas sem preocupações com a estrutura lógica do programa. Um endereço tem a forma (página, deslocamento) página contém o número da página e deslocamento indica o deslocamento dentro da página. O mecanismo de tradução está representado na fig. 4.6, sendo semelhante ao apresentado para a memória segmentada. Existe uma tabela de páginas composta pelo descritor de cada página, em geral chamado PTE (de Page Table Eníry). Cada descritor contém o endereço físico da página, um bit de presença e informação respeitante à protecção e à utilização da página. Não é
necessário guardar a dimensão das páginas, pois elas têm todas o mesmo tamanho. Dois registos do hardware de tradução de endereços, chamados Base da Tabela de Páginas (BTP) e Limite da Tabela de Páginas (LTP), contêm respectivamente o endereço real de início da tabela de páginas e a dimensão desta. Quando o programa gera um endereço, o número da página é comparado com registo LTP. Se for inferior, é somado com o registo BTP, obtendo-se a entrada na tabela de páginas correspondente a esta página. De seguida, os bits de protecção são testados para verificar se o acesso pretendido é legal, estes bits indicam se se pode ler, escrever ou executar a página. Se o endereço for válido, o deslocamento é somado ao endereço físico do início da página, obtendo-se o endereço físico pretendido. Se n for o número de bits do 10
deslocamento, o endereço físico do início da página terá sempre os n bits de menor peso a zero, sendo a soma idêntica a uma concatenação. Como no caso da segmentarão, se algum dos testes anteriores falhar, isso significa que o endereço é inválido, sendo gerada urna excepção que será tratada pelo sistema operativo. Existe uma (ou mais) tabela(s) de páginas, por processo. Quando se dá uma mudança de contexto, os (vários) registos base e limite têm de ser carregados com o endereço e dimensão da(s) tabela(s) de paginas do novo processo. A divisão das páginas está definida na arquitectura da máquina, não podendo nunca ser alterado o espaço de endereçamento virtual. Tabela de tradução de endereços (TLB) A tabela de páginas reside em memória física. Tal como na segmentarão, o mecanismo de tradução obriga a um acesso suplementar à memória, o que duplicaria o tempo de acesso à informação, tornando indispensável a existência de uma tabela interna à unidade de gestão de memória que guarde as PTE das, ultimas páginas acedidas. No entanto, neste caso não podemos ter registos que memorizem os descritores de alguns blocos lógicos do programa, como na segmentarão. As páginas subdividem o programa aleatoriamente, sem terem em conta blocos lógicos, pelo que nunca é possível saber se a palavra a que queremos aceder está ou não dentro da página actual. A solução comum consiste em guardar numa memória associativa de acesso muito rápido chamada TLB (Translation Lookaside Buffer) os, descritores das últimas n páginas, acedidas pelo programa. Quando o programa gera um endereço, a memória associativa consulta simultaneamente todas a suas posições, pesquisando se tem uma entrada cujo número de página seja igual ao número de página gerado pelo programa. O acesso é feito em paralelo a todas as posições da memória associativa. Se for encontrada a entrada pretendida ela é colocada na saída, se não for encontrada isso é assinalado ao hardware de gestão de memória. Em processadores onde a TLB é gerida pelo hardware, a pesquisa na TLB é lançada em paralelo com o acesso à tabela de páginas. Se o descritor for encontrado na TLB, é interrompido o acesso à tabela de páginas. Se não for encontrado, a tabela de páginas, é acedida como foi descrito anteriormente, e o descritor é introduzido na TLB, geralmente segundo uma disciplina FIFO, de forma a que acessos subsequentes à mesma página sejam aí resolvidos. Outros processadores, sobretudo processadores R,ISC, gerem a TLB por software. Se o descritor da página não for encontrado na TLB é gerada uma excepção, tendo o sistema operativo que preencher a entrada na TLB com o valor adequado. Este mecanismo está representado na fig. 4.7. O ideal seria guardar na TLB não as últimas, mas as próximas páginas a que o programa irá aceder. Como isso é impossível de prever, toma-se o funcionamento recente do programa como uma boa previsão para o que ele fará no futuro próximo. Concretamente, se um programa acedeu a uma página, é expectável que os próximos acessos sejam dentro da mesma página. A dimensão destas, tabelas é pequena, em geral (64, 128 entradas), pois o seu custo é elevado.
11
O objectivo central da paginação é oferecer ao programador um espaço de endereçamento virtual maior que a memória física do computador. Isto é conseguido mantendo em memória física apenas algumas páginas do programa e carregando da memória secundária as outras páginas, quando isso for necessário. A PTE tem um bit de presença (bit P) que indica se a página está ou não em memória primária. Na descrição feita anteriormente, considerou-se que o bit P estava a 1. Se o bit P estiver a O, o hardware de gestão de memória gera uma excepção que interrompe a instrução a meio. Diz-se então que houve uma falta de página. O sistema operativo analisa a causa da excepção, determina que foi uma falta de página e começa o processamento adequado. Em primeiro lugar, terá de alocar uma página livre em memória primária (segundo os algoritmos a analisar no capítulo seguinte) e de seguida verifica qual o tipo da pagina. Se é uma página nova (resultante do crescimento da pilha, ou uma pagina de dados não inicializados), basta preenche-la com zeros; se existe uma cópia da pagina em memória secundária, é necessário lê-la do disco. Quando o acesso ao disco terminar, o sistema operativo preenche a PTE com o endereço da página, posiciona o bit P a I e coloca o processo na fila dos executáveis. Quando o processo se voltar a executar, irá completar (ou mesmo repetir, em certas arquitecturas ; a instrução que tinha sido interrompida a meio. O acesso à memória será repetido e completar-se-á correctamente pois PTF já tem o bit P a 1. As excepções provocadas pela UGN têm uma diferença importante em relação às instruções que interrompem o processador no fim de uma instrução. As excepções da gestão de memória têm de interromper a instrução a meio e o processador tem de ser capaz de, mais tarde, completar a instrução que foi interrompida. O programa é seccionado em páginas aleatoriamente, podendo acontecer que uma instrução seja composta por mais de um octeto fique partida entre duas páginas se a primeira página estiver presente e a segunda não, haverá uma falta de página a da instrução. Se o processador não fosse capaz de interromper a instrução a meio e depois completa-la, aquela instrução ficaria perdida, e o programa não funcionaria correctamente. Diz-se que as instruções tem de ser recomeçáveis (de restartable ). Em memória segmentada é também possível ter o mesmo mecanismo de falta de 12
segmento. Se o bit P do descritor de segmento estiver a zero haverá uma falta de segmento. A diferença importante é que, no caso da segmentação, só as instruções que carregam um novo segmento podem originar uma falta de segmento. As instruções que endereçam memória dentro do segmento não obrigam ao carregamento de um novo segmento, portanto, nunca podem originar uma falta de segmento. Estas instruções não necessitam não necessitam de ser recomeçáveis, o que representa uma simplificação considerável no hardware do processador. Na paginação, como se viu, todas as instruções tem de ser recomeçáveis. -Fragmentação Um bloco lógico de programa (em geral, código, dados e pilha) corresponde a um conjunto de páginas, havendo fragmentação interna na última página de cada bloco. O desperdício de memória torna-se muito importante se as páginas forem grandes e houver muitos processos carregados em memória. -Protecção A protecção em memória paginada faz-se da mesma forma que em memória segmentada: processos distintos têm tabelas de páginas diferentes e cada página contém os modos de acesso permitidos (leitura, escrita e execução ). No entanto, a grande particularidade da protecção é a página. Para proteger um bloco lógico de um programa é necessário estabelecer essa protecção nas várias páginas que compõem o bloco, o que é mais complicado e menos elegante que na segmentação. Se o bloco a proteger for menor que a dimensão da página, a única solução é atribuir uma página inteira a esse bloco, o que provoca fragmentação interna à página. -Partilha de memória entre processos Para partilhar uma zona de memória entre vários processos basta ter, nas tabelas de páginas dos processos em causa, um conjunto de PTE indicando o mesmo endereço físico. Como para a protecção, este mecanismo é mais complicado e menos elegante na memória paginada que na segmentada. -Dimensão das páginas Páginas pequenas têm a vantagem de diminuir a fragmentação interna, mas aumentam o número de faltas de páginas, a dimensão das tabelas de página 3 e a dimensão das listas de páginas mantidas pelo sistema operativo. Páginas grandes têm as vantagens recíprocas: tabelas de páginas menores, menos faltas de páginas, listas mais curtas, logo mais rápidas de pesquisar. Em contrapartida, aumenta o desperdício de memória e o tempo de transferência entre memória e disco.
13
Memória Segmentada/Paginada
A Segmentação sege uma aproximação lógica, cada segmento é subdividido em paginas. O mecanismo de tradução de endereços está representado na figura. O numero de segmento é usado para obter o endereço físico do inicio da tabela de paginas do segmento, sendo a tradução do par (pagina,eslocamento) feita como anteriormente. As TLB do segmento e paginas são igualmente usadas como atras foi descrito. A protecção e partilha de segmentos é feita como na Segmentação pura. A partilha de apenas parte das paginas de um segmento é possível, embora seja um pouco mais difícil de gerir. Um endereço virtual tem 48 bits. Os 16 bits mais significativos determinam o segmento, cuja dimensão máxima é 232 octetos. Cada segmento é subdividido em paginas de 4 Koctetos. A utilização normal desta arquitectura é fazer corresponder um segmento para cada um dos segmentos lógicos de um programa, que são código, dados e pilha, e dados do sistema relativos ao processo, sendo cada um destes segmentos paginado. Desta forma, ultrapassa-se a principal limitação da memória segmentada, que é a dimensão máxima dos segmentos.
14
Conclusão Memória virtual
é uma forma de contornar o problema de falta de memória RAM num
computador utilizando a própria memória interna do HD (disco rígido) através da criação virtual de memória estendida que funciona da mesma maneira que a RAM embora muito mais lentamente, uma vez que isto acontece ao nível do HD e, como se sabe, a velocidade dos discos rígidos ainda é muito inferior à de um pente de memória RAM normal. A memória virtual é feita deixando um espaço do HD reservado para que seja possível a sua utilização como memória virtual.
15
