trabalho memória virtual

5/12/2018 trabalho mem ria virtual - slidepdf.com

http://slidepdf.com/reader/full/trabalho-memoria-virtual 1/15

1

Sistemas Operativos

Funcionamento da Memória Virtual

Rui Magalhães

22917



2

Í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



Princípio Geral de F

A memória virtual baseia-idealmente a um programde endereços e dos momemória de um dado prmemória virtual de diversfísica do computador: me

A memória virtual é um ccada programa, contendo,geridas pelo SO, de formespaço de endereços vindependente da capacidSignifica também que o plógica de código, dados e pencarregam-se de, a cadacélula, em memória centrseparação lógica e físicadiferentes processos conc

ncionamento

se num espaço de endereços, dito virtual ,em linguagem máquina, conforme a definios de endereçamento das instruções dcessador. A figura 1 ilustra a relação ent

os processos e a sua localização nas unidaória central (RAM) e memória secundária (

igura 1: Memória virtual

nceito que garante uma memória dedicadportanto, regiões lógicas de código, dados

transparente ao processo utilizador. Istoirtuais de cada processo tem um taade de memória real disponível num darograma pode ignorar a localização físicailha, pois o SO e o hardware de transformaçeferência gerada pelo programa, localizar a

al ou em disco. Por outro lado, este meca- protecção - entre os espaços de endrrentes.

3

que é acessívelção dos campos

referência dee os mapas dees de memóriaisco).

a à execução dee pilha, que sãosignifica que oanho máximoo computador.as suas regiões

ão de endereçoscorrespondenteismo garante areçamento dos



4

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 novapágina. Devemos ressaltar que se a página a ser removida sofreu alterações enquantoesteve na memória, a cópia virtual existente em disco deverá ser atualizada. Por outrolado, 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 utilizadasem sistemas que fazem uso de memória virtual paginada com o objetivo de melhorar odesempenho 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 estesdois 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 tamanhoda 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 ede fácil implementação que consiste em substituir a página que foi carregada há maistempo na memória (a primeira página a entrar é a primeira a sair ). Esta escolha nãoleva 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 FIFOapresenta uma deficiência denominada anomalia de Belady : a quantidade de falta depá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 principalvantagem é 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 listaserá 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íticafoi definida baseada na seguinte observação: se a página está sendo intensamentereferenciada pelas instruções é muito provável que ela seja novamente referenciadapelas 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. Apesarde o LRU apresentar um bom desempenho ele também possui algumas deficiênciasquando 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 algumasvariações do LRU, dentre eles destacamos o LRU-K. Este algoritmo não substitui aquelaque 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á maistempo e LRU-3 observará o antepenúltimo e assim por diante.



5

A implementação do LRU também pode ser feita através de uma lista, mantendo aspá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 problemacom esta organização é que a lista deve ser atualizada a cada nova referência efetuadasobre 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 melhordesempenho computacional e o que minimiza o número de faltas de páginas. Noentanto, sua implementação é praticamente impossível. A idéia do algoritmo é retirarda 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óriarealizados pela aplicação, o que é impossível em um caso real. Por estes motivos, oalgoritmo ó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. Porexemplo, o MRU-n escolhe a n-última página acessada para ser substituída. Dessaforma, é possível explorar com mais eficiência o princípio de localidade temporalapresentada 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). Aordem mantida segue a seqüência em que elas foram carregadas em memória. Alémdisso, é adicionado um bit de uso que indica se a página foi referenciada novamentedepois de ter sido carregada. Ao precisar substituir uma página o algoritmo verifica sea página mais antiga está com o bit zerado (o que significa que a página não foi maisreferenciada) para ser substituída. Se ela não estiver o bit é zerado e a próxima páginada fila mais antiga será verificada. Esse processo continua até que uma página antigacom 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 foramreferenciadas nos últimos acessos para serem substituídas. Tal informação é mantidaatravé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. Estainformação também vai ajudar a direcionar a escolha da página. As substituições daspá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 emodificadas.



6

Algoritmo de substituição de páginas LFU

O LFU (Least Frequently Used ) escolhe a página que foi menos acessada dentre todasas que estão carregas em memória. Para isso, é mantido um contador de acessosassociado a cada página (hit ) para que se possa realizar esta verificação. Estainformaçã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 porestarem 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 decarência) Só páginas fora desse tempo é que podem ser substituídas. Tal estratégiadeu 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 localidadetemporal .

Algoritmo de substituição de páginas WS

O algoritmo WS (Working Set ) possui a mesma política do LRU. No entanto, estealgoritmo não realiza apenas a substituição de páginas ele também estabelece umtempo máximo que cada página pode permanecer ativa na memória. Assim, todapá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áginaspertencentes ao working set processo permanecerão ativas em memória. Os algoritmos apresentados são alguns dos disponíveis na literatura.



7

Segmentação

-Objectivos

O objectivo da segmentação é a divisão dos programas em segmentos lógicos quereflictam a sua subdivisão funcional. Por exemplo, cada rotina ou cada módulocorresponderá a um segmento.O principal objectivo deste método é tentar suportardirectamente na gestão de memória as abstracções comuns nas linguagens deprogramação, nomeadamente:

• Carregamento em memória. O segmento é a unidade mínima a carregar emmemória. Considera-se que todas as palavras dentro do segmento têm amesma probabilidade de virem a ser acedidas. Como não sabemos qual dasinstruções de uma certa rotina vai ser ou não executadas, temos de as ter todasem memória.

• ProtecçãoA protecção da memória é feita em termos de blocos lógicos, quem podeaceder a parte do bloco pode aceder ao bloco todo e vice-versa.

• EficiênciaO princípio da localidade de referência diz-nos que, se acedermos a umendereço de um segmento lógico com grande probabilidade os próximosacessos serão a endereços situados no mesmo segmento. Esta constatação naaná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) segmentocontém o número do segmento e deslocamento indica o deslocamento dentro dosegmento. O mecanismo de tradução está representado na fig. 4.5. Existe uma tabelade segmentos composta pelo descritor de cada segmento. Cada descritor contém oendereç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 daunidade 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, onúmero do segmento é comparado com o registo LTS. Se for inferior, é somado com oregisto BTS obtendo-se a entrada na tabela de segmentos correspondente a estesegmento. De seguida, os bits de protecção são testados para verificar se o acessopretendido é legal. Habitualmente, estes bits indicam se se pode ler, escrever ouexecutar o segmento. Por fim, é verificado se o deslocamento pretendido é inferior ouigual à dimensão do segmento. Se o endereço for válido, o deslocamento é somado aoendereço físico do início do segmento, obtendo-se o endereço físico pretendido. Sealgum dos testes anteriores falhar, isso significa que o endereço é inválido. O hardwareinterrompe 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 dosistema operativo é a de programar os vários registos, preencher a tabela de



8

segmentos e tratar as excepções quando estes são desencadeados. Quando se dá umamudança de contexto, os registos base e limite têm de ser carregados, com o endereçoe dimensão da tabela de segmentos do novo processo. A dimensão máxima de umsegmento está associada à arquitectura da máquina, não podendo nunca ser alteradaporque 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 decada vez que o programa gera um endereço, o custo do acesso a uma posição dememória duplica, visto que são necessários dois acessos a memória por cada um

pretendido pelo programa. Este facto é particularmente importante, porque namoderna tecnologia a velocidade de um computador está em grande parte limitadapelos acessos à memória. Em arquitecturas segmentadas a solução habitual para esteproblema é guardar em registos, de acesso muito rápido, as entradas da tabela desegmentos correspondentes aos segmentos em utilização. Um programa pode ter maisque um segmento de código ou dados. Da primeira vez que um segmento é acedido, oseu descritor é lido da tabela de segmentos e é guardado no registo apropriado. Porexemplo, a instrução de chamada a uma rotina noutro segmento, da forma far callsegmento: deslocamento, provoca o carregamento do descritor relativo a segmentono 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 oregisto CSR, o que é muito rápido. A operação demorada, que é ler o descritor databela de segmentos, só é efectuada da primeira vez que o segmento for acedido. Se oprograma aceder a outro segmento diferente de código, esse descritor será carregadoem CSR, destruindo o que lá estava, Estes registos funcionam pois como uma cache dedirecção unitária. Certos processadores têm tabelas genéricas, que guardam osdescritores dos últimos segmentos acedidos pelo programa.



9

- Fragmentação

A segmentação gera fragmentação externa a medida que os segmentos são alocados elibertados. Uma maneira de a resolver é copiar todos os segmentos para um dosextremos 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óriasecundária, libertar o seu espaço em memória física, alocar um segmento da dimensãopretendida (eventualmente esperando que outros processos terminem e libertemmemória) e, copiar o segmento novamente para memória primária. Ambas as soluçõesexigem que o processamento seja interrompido. A segunda solução é incremental, oque 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áriosníveis:

• Como processos diferentes têm tabelas de segmentos diferentes, os espaços deendereçamento virtual são distintos, não havendo forma de um processo poderreferendar zonas de memória de outro.

• O deslocamento dentro do segmento é verificado comparando-o com adimensão do segmento residente no descritor.

• tipo de acesso ao segmento é verificado impedindo, por exemplo, que umprograma 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 ternas varias tabelas de segmentos uma entrada contendo o mesmo endereço físico edimensão. Desta forma, dois processos podem aceder por endereços virtuais(eventualmente diferentes) à mesma memória física.



10

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ãoda memória física da máquina. A ideia subjacente é fazer com que o programador nãoprecise 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 sempreocupaçõ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 odeslocamento dentro da página.

O mecanismo de tradução está representado na fig. 4.6, sendo semelhante aoapresentado para a memória segmentada. Existe uma tabela de páginas compostapelo descritor de cada página, em geral chamado PTE (de Page Table Eníry). Cadadescritor contém o endereço físico da página, um bit de presença e informaçãorespeitante à 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 dePáginas (BTP) e Limite da Tabela de Páginas (LTP), contêm respectivamente o endereçoreal de início da tabela de páginas e a dimensão desta. Quando o programa gera umendereço, o número da página é comparado com registo LTP. Se for inferior, é somadocom o registo BTP, obtendo-se a entrada na tabela de páginas correspondente a estapágina. De seguida, os bits de protecção são testados para verificar se o acessopretendido é 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 dapágina, obtendo-se o endereço físico pretendido. Se n for o número de bits do



11

deslocamento, o endereço físico do início da página terá sempre os n bits de menorpeso 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 queo endereço é inválido, sendo gerada urna excepção que será tratada pelo sistemaoperativo.

Existe uma (ou mais) tabela(s) de páginas, por processo. Quando se dá uma mudançade contexto, os (vários) registos base e limite têm de ser carregados com o endereço edimensã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 nuncaser 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 mecanismode 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. Noentanto, neste caso não podemos ter registos que memorizem os descritores dealguns blocos lógicos do programa, como na segmentarão. As páginas subdividem oprograma 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áginaactual.A solução comum consiste em guardar numa memória associativa de acesso muitorápido chamada TLB (Translation Lookaside Buffer) os, descritores das últimas npá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 umaentrada 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 forencontrada 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 emparalelo 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 processadoresR,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 como 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 programairá aceder. Como isso é impossível de prever, toma-se o funcionamento recente doprograma 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óximosacessos sejam dentro da mesma página. A dimensão destas, tabelas é pequena, emgeral (64, 128 entradas), pois o seu custo é elevado.



12

O objectivo central da paginação é oferecer ao programador um espaço deendereçamento virtual maior que a memória física do computador. Isto é conseguidomantendo em memória física apenas algumas páginas do programa e carregando damemó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óriaprimária. Na descrição feita anteriormente, considerou-se que o bit P estava a 1. Se obit P estiver a O, o hardware de gestão de memória gera uma excepção queinterrompe 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 ecomeça o processamento adequado. Em primeiro lugar, terá de alocar uma páginalivre em memória primária (segundo os algoritmos a analisar no capítulo seguinte) e deseguida verifica qual o tipo da pagina. Se é uma página nova (resultante docrescimento da pilha, ou uma pagina de dados não inicializados), basta preenche-lacom zeros; se existe uma cópia da pagina em memória secundária, é necessário lê-lado disco. Quando o acesso ao disco terminar, o sistema operativo preenche a PTE como 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 certasarquitecturas ; 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 àsinstruções que interrompem o processador no fim de uma instrução. As excepções dagestão de memória têm de interromper a instrução a meio e o processador tem de sercapaz de, mais tarde, completar a instrução que foi interrompida. O programa éseccionado em páginas aleatoriamente, podendo acontecer que uma instrução sejacomposta por mais de um octeto fique partida entre duas páginas se a primeira páginaestiver presente e a segunda não, haverá uma falta de página a da instrução. Se oprocessador 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



13

segmento. Se o bit P do descritor de segmento estiver a zero haverá uma falta desegmento. A diferença importante é que, no caso da segmentação, só as instruçõesque carregam um novo segmento podem originar uma falta de segmento. Asinstruções que endereçam memória dentro do segmento não obrigam aocarregamento 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 querepresenta uma simplificação considerável no hardware do processador. Napaginaçã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 umconjunto de páginas, havendo fragmentação interna na última página de cada bloco. Odesperdício de memória torna-se muito importante se as páginas forem grandes ehouver muitos processos carregados em memória.

-Protecção

A protecção em memória paginada faz-se da mesma forma que em memóriasegmentada: processos distintos têm tabelas de páginas diferentes e cada páginacontém os modos de acesso permitidos (leitura, escrita e execução ). No entanto, agrande particularidade da protecção é a página. Para proteger um bloco lógico de umprograma é necessário estabelecer essa protecção nas várias páginas que compõem obloco, o que é mais complicado e menos elegante que na segmentação. Se o bloco aproteger 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 depáginas dos processos em causa, um conjunto de PTE indicando o mesmo endereçofísico. Como para a protecção, este mecanismo é mais complicado e menos elegantena memória paginada que na segmentada.

-Dimensão das páginas

Páginas pequenas têm a vantagem de diminuir a fragmentação interna, masaumentam o número de faltas de páginas, a dimensão das tabelas de página 3 e adimensão das listas de páginas mantidas pelo sistema operativo. Páginas grandes têmas vantagens recíprocas: tabelas de páginas menores, menos faltas de páginas, listasmais curtas, logo mais rápidas de pesquisar. Em contrapartida, aumenta o desperdíciode memória e o tempo de transferência entre memória e disco.



14

Memória Segmentada/Paginada

A Segmentação sege uma aproximação lógica, cada segmento é subdividido empaginas. 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 depaginas do segmento, sendo a tradução do par(pagina,eslocamento)feita como anteriormente. As TLB do segmento e paginas são igualmente usadas comoatras foi descrito.A protecção e partilha de segmentos é feita como na Segmentação pura. A partilha deapenas parte das paginas de um segmento é possível, embora seja um pouco maisdifícil de gerir. Um endereço virtual tem 48 bits. Os 16 bits mais significativosdeterminam o segmento, cuja dimensão máxima é 232 octetos. Cada segmento é

subdividido em paginas de 4 Koctetos. A utilização normal desta arquitectura é fazercorresponder um segmento para cada um dos segmentos lógicos de um programa, quesão código, dados e pilha, e dados do sistema relativos ao processo, sendo cada umdestes segmentos paginado. Desta forma, ultrapassa-se a principal limitação damemória segmentada, que é a dimensão máxima dos segmentos.



15

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 maislentamente, 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.

trabalho memória virtual

Documents

Transcript of trabalho memória virtual