1
Gerenciamento de Memória (Paginação e Memória Virtual)
Prof. Alexandre Monteiro
Recife
Contatos
Prof. Guilherme Alexandre Monteiro Reinaldo
Apelido: Alexandre Cordel
E-mail/gtalk: [email protected]
Site: http://www.alexandrecordel.com.br/fbv
Celular: (81) 9801-1878
DO QUE FALAMOS NA AULA PASSADA?
Memória
A memória pode ser vista como um array (vetor) de células de armazenamento (palavras ou bytes), cada célula com seu endereço
0 2
1 31
2 4
3 35
4 26
5 124
6 42
7 12
8 42
Memórias física, lógica e virtual
Memória física • É a memória implementada pelo hardware,
normalmente associada a memória principal - RAM.
Memória lógica de um processo• É a memória endereçada pelas instruções de máquina
do processo.
Memória Virtual• É uma memória implementada pelo SO, com o auxílio
da memória secundária (disco rígido). Comumente, é implementada através de paginação ou segmentação.
• Normalmente, é maior que a memória física do computador.
Gerência de Memória
Rotinas do SO que controlam o uso da memória.• Controle de quais partes da memória
encontram-se livres e quais estão em uso• Alocação da memória de acordo com as
necessidades dos processos• Liberação da memória alocada após o término
de um processo• Transferência do processo, ou parte dele,
entre a memória principal e a memória secundária
Multiprogramação através de Swapping O programa que perde a CPU é copiado p/
disco, enquanto o programa que ganha a CPU é transferido do disco p/ a memória principal
Monitor
Espaço doUsuário
reg. limite
U1
U2
Swap-in
Swap-out
Efeito da Multiprogramação
Utilização da CPU como função do grau de multiprogramação (= número de processos na memória)
Realocação e Proteção
São dois problemas introduzidos pela Multiprogramação:
• Realocação: não se sabe de antemão em qual região de memória o processo vai ser executado
• Proteção: evitar que um processo acesse uma região usada por outro processo
Partições Múltiplas
Com multiprogramação, é conveniente ter vários programas na memória ao mesmo tempo para que a CPU seja rapidamente alternada entre eles.
Solução: dividir a memória em partições (cada partição irá conter um programa)
• partições fixas (normalmente o hw usa registradores limite inferior e limite superior)
• partições variáveis (normalmente o hw usa registradores base e limite)
Memória com Partições Fixas
(a) Filas de entrada separadas: (Por tamanho de Processo x Partição)
(b) Fila única para todas as partições: (Simples de Implementar)
Partições Fixas
Exemplo: memória de 256K
• espaço do SO: 64K• espaço para processos pequenos: 16K• espaço para processos médios: 48K• espaço para processos grandes: 128K
Memória sem Partições
Memória com Partições Fixas, mas de tamanho variável
Pilha de B
Dados de B
Código de B
Pilha de A
Dados de A
Código de A
SO
Espaço para Expansão
Espaço para Expansão
Partições Variáveis
Os tamanhos das partições variam de acordo com a necessidade
Tamanho e número de partições variam dinamicamente
Elimina a fragmentação interna e introduz a fragmentação externa
Mais difícil de implementar
O SO mantém uma lista indicando quais partes da memória estão disponíveis e quais estão ocupadas.
As áreas disponíveis são denominadas lacunas (holes)
Quando um processo chega para ser executado, a lista de lacunas é consultada e é escolhida uma lacuna de tamanho suficiente
Partições Variáveis
monitor
Job 1
0
40K
100K
Job 2
200KJob 3
230K
256K
monitor
Job 1
0
40K
100K
200KJob 3
230K
256K
monitor
Job 1
0
40K
100K
200KJob 3
230K
256K
Job 4
170K
monitor0
40K
100K
200KJob 3
230K
256K
Job 4
170K
monitor0
40K
100K
200KJob 3
230K
256K
Job 4
170K
Job 5
90K
job 2 termina
aloca job 4
job 1 termina aloca job 5
JOB 1 2 3 4 5
Memória 60K 100K 30K 70K 50K
Tempo 10 5 20 8 15
Partições Variáveis: Algoritmos de Alocação de área livre
First Fit – percorre a lista e aloca o primeiro espaço encontrado Next Fit – como first Fit, só que a partir da posição na lista onde
foi feita a alocação anterior Best Fit – percorre toda a lista e aloca o menor possível espaço e
pode deixar fragmentos muito pequenos para alocação para outros processos
Worst Fit – percorre toda a lista e aloca o maior possível espaço.
OBS. Em muitos sistemas, o overhead adicional exigido pelos Best/Worst Fit não valem a pena para obter uma alocação mais efetiva.
Partições Variáveis: Algoritmos de Alocação de área livre
Qualquer um dos algoritmo anteriores é mais eficiente se:• Houverem 2 listas: lista de partições usadas + lista de espaços livres• Listas são mantidas ordenadas por tamanho (nr. de unidades de
alocação)
Problema: há uma complexidade extra quando ocorre uma liberação de memória (precisa-se verificar se há espaços adjacentes livres e inserir o novo espaço na posição correta da lista). Alternativa:
• Quick Fit: mantém listas separadas por tamanho do espaço livre (2K, 4K, 8K, etc.)
• Problema: ao liberar memória, o novo espaço criado precisa ser inserido na fila correspondente (possivelmente, após combinação com áreas vizinhas)
Atividade Valendo NOTA Estude e siga as orientações descritas no material de
aula.
Utilizando Listas ou Vetores, implemente os 5 algoritmos citados anteriormente, de modo que resolvam os problemas de alocação de espaços livres de memória.
Deve-se selecionar o algoritmo e este deve alocar corretamente o espaço de memória mais conveniente de acordo com as regras de funcionamento de cada uma dos algoritmos.
Apresentação ao final do semestre.
SWAPPING
Swapping
Em sistemas com compartilhamento de tempo (timesharing) memória principal pode não ser suficiente para todos os processos (ex. muitos processos interativos de muitos usuários)
Ideia básica: usar espaço em disco como extensão da memória RAM, e colocar lá os processos enquanto estão bloqueados, carregando-os de volta para a memória assim que são desbloqueados
Duas Situações:• Copiar a imagem inteira (Swapping)• Permitir que processo fique parcialmente em
memória, e parcialmente em disco (paginação) -> Memória Virtual
Swapping
Quando um processo é bloqueado (espera por E/S) ele pode ser swapped out, e depois swapped in para memória principal.
Maior número de processos ativos, aumentando a utilização da CPU
OBS 1: Buracos de memória não utilizada de tamanho qualquer (Fragmentação de Memória)
OBS 2: Um mesmo processo pode ocupar diferentes partições ao longo de sua execução
Fragmentação de Memória
São perdas (desperdício) de memória:• fragmentação interna: memória é perdida
dentro da partição alocada (é um desperdício de espaço dentro da partição usada pelo processo)
• fragmentação externa: ocorre quando existe espaço disponível mas este é pequeno demais para os processos que estão à espera (perda de espaço fora das partições alocadas)
Swapping
Principal problema do swapping com partições de tamanho variável:• Manter a informação sobre espaços não utilizados
(livres)• Evitar uma fragmentação externa da memória (=
muitos espaços pequenos não utilizados)
Compactação de memória é muito cara– da ordem de segundos para alguns MBs de RAM.
Swapping
Como lidar com processos que crescem (em demanda de memória)?
• Tentar alocar uma partição vizinha do processo de uma partição não usada (nem sempre é possível)
• Alocar uma partição conjunta para a pilha e o heap, e fazê-los crescer em sentidos opostos.
• Se processo usa todo espaço de memória disponível, fazer um swap out, e um swap in em uma partição maior (mas, se disco de swap está cheio, processo precisa ser terminado)
Gerenciamento de Espaço Livre Divide a memória em unidades de alocação de n bytes
e representa a ocupação (livre/ocupado) de lotes de unidades usando um bit map (b) ou uma lista encadeada (c).
Cada nó contém o endereço inicial e o tamanho de uma partição ocupada ou livre.
Gerenciamento de Espaço Livre Quando o processo é swapped out, a lacuna
correspondente precisa ser combinada com espaços vizinhos livres.
Quando processo é swapped in, percorre-se a lista buscando um espaço livre suficientemente grande (lista geralmente ordenada por endereços de memória)
Quando X é swapped out: quatro combinações de nós na lista
MEMÓRIA VIRTUAL
Memória Virtual É necessária, quando o total de memória necessária para um
conjunto de processos excede o tamanho da memória física. Também aqui, usa-se parte do disco como extensão da memória RAM.
A grande maioria dos SO’s (exceto alguns para tempo real), implementam Memória Virtual.
MV usa a técnica de paginação:• Memória física e espaço de endereçamento lógico de cada
processo são divididos em partições de mesmo tamanho:- Espaço do processo é dividido em páginas- Memória é dividida em molduras de página
• Em vez de fazer o swap in/out de uma imagem inteira de processo, cada página pode ser movida do disco para a memória e vice-versa.
Paginação Requer da existência de suporte por hardware (Memory
Management Unit - MMU)• MMU intercepta qualquer acesso à memória (p/ instruções e
dados)• Mapeia endereços lógicos para endereços físicos (através de
uma Tabela de Página)• Quando a página acessada não está em memória, gera uma
interrupção de falta de página (Page Fault), que causa a interrupção do processo em execução e o seu bloqueio, até que a página tenha sido transferida para a memória.
Paginação
A memória física é dividida em um número de partições de mesmo tamanho, denominadas páginas físicas, quadros ou frames ou molduras.
A memória lógica é dividida em partições do mesmo tamanho, denominadas páginas lógicas (ou, simplesmente, páginas)
Cada página lógica é carregada em uma moldura de página quando o processo é carregado na memória principal.
Nessa ocasião, uma Tabela de Páginas é criada.
Permite que o espaço físico ocupado por um processo seja não contíguo.
Paginação
Exemplo: número de páginas/processo
5D
4C
3B
4A
Processos A, B, C estão prontos
C4
C3
C2
C1
B3
B2
B1
A4
A3
A2
A1
Paginação
C4
C3
C2
C1
A4
A3
A2
A1
B termina
D é submetido
D4
D5
C1
C2
C3
C4
A1
A2
A3
A4
D3
D2
D1
Paginação
Problemas tanto em particionamento fixo quanto dinâmico:
• fixo – fragmentação interna• dinâmico – fragmentação externa e realocação dinâmica
Solução:• Processo é dividido em páginas (blocos de processos)• MP é dividida em quadros de mesmo tamanho
Páginas/quadros/molduras são de pequeno tamanho (ex., 1K): fragmentação interna pequena.
Paginação elimina fragmentação externa.
SO mantém uma Tabela de Páginas por processo.
Paginação
Processo não precisa estar completamente na MP (veremos adiante em Memória Virtual)
Processo não precisa ocupar área contígua em memória
Endereços são gerados dinamicamente em tempo de execução
Somente um registrador então, não é suficiente
Tabela de Páginas
Exemplo em Memória Virtual
Espaço de Endereçamento
Virtual
Espaço de Endereçamento
Físico
Página Virtual
Moldura de Página
Tabela de Páginas
Tabela de Páginas
MMU com 16 páginas de tamanho 4 KB cada.
Endereço lógico: Bits mais significativos =
número da página
Bits menos significativos = deslocamento do endereço dentro de uma página
Paginação Se um processo tem tamanho K, os seus endereços lógicos
(endereços especificados nas suas instruções) vão desde 0 até K-1. Este é o espaço de endereçamento do processo.
Cada endereço lógico é quebrado em duas partes:- número da página p- deslocamento d (offset)
Endereço lógico: composto do par (número-da-página, deslocamento), onde número-página é usado como índice para uma entrada na Tabela de Páginas
Acontece relocação dinâmica, pois cada endereço lógico é traduzido em endereço físico em tempo de execução
Página (p) deslocamento (d)
15 10 9 0
IC - UFF
Realocação
Mapeamento de endereços virtuais em reais
necessário, pois processos são alocados em espaço de MP dinamicamente
Ex.: processo P1
P1:
novo
pronto
bloqueado
executando
P1 em end. de MP 500
P1 passa para suspenso
Ao voltar para MP P1 vai para end. 1024
IC - UFF
Realocação
Mapeamento eficiente• endereço físico só calculado quando acesso a MP• endereços definidos: lógico, relativo, físico
Registradores:• base – armazena o endereço inicial de MP do processo
(quando o processo passa para executando)• limite – armazena endereço final do processo
Acesso ao endereço Z no programaif (Z + base <= limite)
acesse Z+basesenão “trap”
Relocação
PCB
programa
dados
pilha
registrador de base
somador
imagem doprocesso namemória
endereço relativo
registrador limite
comparador
int
endereçoabsoluto
Paginação
Paginação Processo pode ser executado contanto que haja um número mínimo de páginas na memória
(as páginas sendo acessadas)
O espaço de endereçamento lógico é contiguo, o espaço físico equivalente é distribuído/separado.
A tradução é feita de forma transparente pela MMU, que além da TP, mantém um cache das páginas recentemente consultadas.
Em suma Paginação Cada processo P possui a sua Tabela de Páginas, que precisa ser carregada
na MMU a cada troca de contexto.
Para tal, cada entrada Tabela Processos(P) contém um ponteiro para a Tabela de Páginas de P.
O dispatcher é o encarregado de "carregar" a nova tabela de páginas na MMU.
Como qualquer acesso à memória ocorre através do mapeamento pela TP. Isso fornece também automaticamente um mecanismo de proteção...contanto que o preenchimento da tabela de página seja feita em modo privilegiado (supervisor)!!
=> à medida que as páginas vão sendo alocadas, o núcleo preenche as entradas na tabela de página.
Além disto, kernel precisa manter informações sobre o conjunto de molduras livres na memória principal:
Para isso, usa-se uma tabela de molduras (tabela de moldura de páginas), com uma entrada por moldura, informando se o mesmo está alocado, e para qual processo.
Tabela de Páginas – bits de controle
Cada entrada da tabela possui alguns bits adicionais para implementar proteção• um bit para indicar se a página é de apenas leitura (read only)
• um bit para indicar se a página é válida ou inválida
Vejamos:
Controle de Acesso A paginação pode ser facilmente estendida para incorporar
controle de acesso para cada página:• além do endereço do quadro da memória, cada entrada da TP
contém bits para o tipo de acesso permitido, podendo ser: somente-leitura, leitura-e-escrita ou somente-execução
• se uma instrução viola o acesso permitido, a MMU gera outra interrupção (violação de acesso de memória)
• a validade de uma operação sob um endereço lógico pode ser testada em paralelo com a obtenção do endereço físico correspondente.
Além disto, pode-se usar bits valido/inválido para marcar as páginas lógicas que efetivamente compõem o espaço de endereçamento lógico do processo
• é útil para espaços de endereçamentos grandes e utilizados de forma descontínua
• note-se que devido ao problema do não alinhamento de dados com os limites das páginas, esse tipo de controle de acesso não é muito preciso.
Entrada da Tabela de PáginasCache
desabilitadoModificada Presente/Ausente
Referenciada Proteção
Número da moldura de página
Implementação da Tabela de Páginas Conjunto de registradores dedicados
Memória Principal
TLB ou Memória Associativa
Tabela de Páginas em Conjunto de Registradores Dedicados
Na mudança de processo em execução estes registradores são carregados com os valores correspondentes ao novo processo.
TP é mantida em um conjunto de registradores dedicados, que são carregados através de instruções privilegiadas (ex. DEC PDP-11)
Pró: não necessita de MMU e tradução é veloz.
Contra: número de entradas é pequeno (tipicamente, de 16 a 64)
Tabela de Páginas na Memória Principal
Cada descritor de processo contém o endereço de sua respectiva tabela de páginas.
A UCP possui um registrador que aponta para a tabela de páginas atual
Para acessar um dado na memória são necessários dois acessos: um de mapeamento (acesso à tabela) e outro para acessar o dado
TP é mantida em memória principal• mantém-se um registrador com o endereço base da tabela (Process Table Base
Register, PTBR) e entrada na tabela = PTBR + #página_virtual
Prós:• possibilita tabelas de páginas arbitrariamente grandes• a troca de contexto envolve somente PTBR
Contras:• tempo de acesso à memória duplica, devido ao acesso à tabela
Tabela de Páginas em TLB ou Memória Associativa
Memória de alta velocidade (mas hardware caro), onde cada posição possui dois campos (chave = número de página lógica, valor = página física correspondente)
Usa um Translation Look-aside Buffer (TLB, buffer para tradução de endereços) na MMU:
• TLB = vetor associativo que permite comparação paralela com suas entradas (de 8 - 128 entradas; Intel 80486 tem 32 entradas)
• mantém-se apenas as entradas da TabPaginas das páginas recentemente acessadas ( princípio de localidade)
• quando uma página lógica é acessada e seu mapeamento não está no TLB• (TLB miss) então:
- acessa-se a TabPaginas na memória e substitui-se a entrada no TLB- dependendo se a página está em memória ou não, continua-se a
execução, ou gera-se uma interrupção Page-fault• a cada troca de contexto, o TLB precisa ser limpo
Vantagem: tradução rápida
Desvantagem: requer gerenciamento do conteúdo do TLB (substituição de entradas)
TLB - Translation Look-aside Buffer
Funcionamento da MMU com TLB Ao receber um novo nº. de página (np) todas as entradas
do TLB são comparadas em paralelo:• Se np é encontrado e tipo de acesso é válido, então usa-se
a entrada do TLB (endereço do quadro)• Se tipo de acesso é inválido, gera-se uma falha de proteção
(e processo é abortado)• Se np não é encontrado na TLB, (TLB miss), MMU consulta
a TP em memória, obtém o end. do quadro, e copia a entrada completa da TP para o TLB (para agilizar acessos futuros)
• Quando houver acesso p/escrita, copia-se o flag de escrita (Modify bit) de TLB para TP.
Obs: Pode-se aumentar a eficiência da paginação, aumentando-se o tamanho do TLB.
TLB - Translation Look-aside Buffer Possível configuração do TLB para um programa
com:• Um loop cujas instruções internas estão armazenadas
nas páginas 19-21, acessando um vetor nas páginas 129-130. O índice do vetor está na pagina 140 e a pilha em 860-861.
TLB - Translation Look-aside Buffer Em arquiteturas RISC(*), TLB misses são tratados
pelo Sistema Operacional e não pelo hardware (MMU).
Quando a MMU gera um TLB-miss, o núcleo faz o troca da entrada da TLB.
Desvantagem: gerenciamento do TLB é muito mais lento do que se for por hardware
Vantagem: Torna o circuito da MMU bem mais simples, e permite a implementação em muitas arquiteturas;
Problema com Tabela de Páginas
Principal problema é que a própria TP precisa estar em memória.
- Arquitetura de 32 bits.- Tamanho da página= 4K- Offset = 12 bits- Tabela de página = 220 entradas!
E pior, precisa-se manter uma TP por processo em execução.
Então, dependendo do número de entradas de cada TP (que depende do tamanho da página e do número de bits da arquitetura), pode ser inviável manter todas elas na memória do núcleo.
O que fazer?
Tabela de Páginas Multinível
• Resolve o problema de manter grandes tabelas de página na memória (para todos os processos).
• Com TP de 2 níveis, pode-se particionar a TP principal em páginas e manter apenas as páginas da TP cujo mapeamento esteja sendo usado.
• Uma tabela de 1o. nível contém os ponteiros para essas partes da TP.
TP de nível 2
Tabela de Páginas Invertidas
Para arquiteturas de 64 bits, o espaço de endereçamento lógico é 264 bytes!
Exemplo: se o seu tamanho de página for 4KB, isso leva a TPs muito grandes, ex. 252 ≈ alguns Tera Bytes!).
Por isso, em alguns sistemas usa-se uma TP invertida:
Uma entrada para cada moldura de página
Cada entrada contém uma lista de pares: (processID, nº da página)
Desvantagem: a tradução de endereços lógicos para reais fica bem mais lenta. Ex: para cada página p, precisa-se fazer uma varredura pela TP invertida para encontrar a moldura correspondente.
Só é viável, se o TLB for usado para guardar as associações correntes. Somente quando ocorre um TLB miss, a TP invertida precisa ser consultada.
Na maioria dos sistemas, usa-se uma função de hash para indexar as entradas da TP invertida.
Comparação de TP tradicional e TP invertida.
A questão do tamanho das páginas
Tamanho de página pequenos:
• Vantagens• Melhor aproveitamento da memória física: menos fragmentação
interna• Mais programas usando a memória• Melhor alinhamento de segmentos de código e de estruturas de
dado às páginas
• Desvantagens• Programas precisam de mais páginas, tabelas de página maiores,
mais tempo para carregar entradas de tabela nos registradores da MMU.
• Transferência de página menor ou maior de/para disco demanda aproximadamente o mesmo tempo (mas é feito de forma mais frequente)
Referências
Sistemas Operacionais Modernos – 3ª Edição. A. Tanenbaum, 2008.
Modern Operating Systems 3 e. Prentice-Hall, 2008.
Top Related