Sistemas Operacionais

Aula 16: Memória virtual: Linux

Referências:

Capítulo 22: 22.6
Linux Kernel Internals: capítulo 4

Gerência de Memória Física

Como o usuário aloca memória ?

Através do sistema de memória virtual

Como o núcleo aloca memória ?

Por exemplo, para uso interno ou como o sistema de memória virtual aloca memória ?
Como fazer para identificar blocos de memória disponíveis com tamanhos variáveis ? Através de um buddy heap.

Buddy Heap

Páginas (ou conjuntos de páginas) são agrupados em blocos de 2:

Truque: uma lista encadeada para cada tamanho de blocos.

Quando se quiser alocar bloco de tamanho i, busca-se um elemento na lista de tamanho imediatamente superior a i.
Não pode esquecer de atualizar os blocos ``ascendentes'' ao escolhido.

Caches do Núcleo

Dois tipos de cache são mantidos no núcleo:

Buffer caches
- Guardam dados que vêm de dispositivos de bloco tais como discos;
- Assim quando os dados chegarem ao sistema eles podem ser guardados imediatamente (e.g., através de DMA), não é necessário esperar o escalonador escolher o processo destino dos dados.
Page caches
- Guardam páginas lidas do disco antes de elas serem movidas ao seu destino final.

Caches X Memória Virtual

A interação entre estes caches é estreita:

Por exemplo, um page fault (vindo da MV) se transforma em uma requisição para um page cache.
Mas como esta página vem de um dispositivo de bloco, ela será colocada antes em um buffer cache.

Para evitar redundância de espaço e cópias as páginas físicas são compartilhadas.

Mas isto não causa confusão ?
Como saber quando uma página já foi usada e pode ser liberada ou se ainda existe alguém que precisa dele ?

Contadores de Referência

Cria-se um contador c = 0 (que surpresa...);
A cada vez que uma entidade é criada, c++
- entidades aqui são páginas;
- criar aqui é a criação da página por cada subsistema;
A cada vez que a entidade é destruída, c--
- uma página é destruída quando o subsistema não precisa mais dela
Quando c == 0, dealoca-se a entidade.
Simples e eficiente! Usado em 99.5% de todos os programas de computador.
Quem ainda não aprendeu a usar ?
- Microsoft, claro! Já tentaram desinstalar um programa no windows95 ?

Mapeamento Endereço Virtual -> Real

Paginação de 3 níveis:

Motivo: É necessário por causa do espaço de endereçamento no Alpha - muito grande.

Problema: Os x86 só permitem paginação de 2 níveis.

Solução: Reduzir o nível do meio a um elemento só.

Diversos Sabores de Páginas

Páginas da memória virtual podem ser:

Sem pistolão -- zero filled: O primeiro acesso à página deve retornar uma página vazia.
Com pistolão -- backed: Um arquivo é o ``padrinho'' da página. Acessos à página retornam páginas deste arquivo:
- Arquivos mapeados em memória
- Código

Outra classificação:

Discretas -- private: acesso por um único processo.
Promíscuas -- shared: acesso por vários processos.
- Implementação: permitir várias referências à mesma página; Usar Reference count.

Compartilhamento de Memória

Como fazer um fork ?

Método ineficiente:

Criar um novo espaço de endereçamento -- nova tarefa;
Copiar todas as páginas na memória para a nova tarefa.

Que horrível!... E se as duas tarefas compartilhassem as páginas ?

Não dá, porque quando um processo modificar a memória esta mudança seria visível ao outro.

Funciona para threads, por isto eles foram implementados.

Copy on Write

E que tal se a gente compartilhasse a página somente na leitura ?

As páginas marcadas como copy-on-write são:

Compartilhadas;
Mas quando há uma escrita na página ela é copiada e marcada como private.

Ou seja, um fork é feito simplesmente compartilhando as páginas:

basta copiar a tabela de páginas.
Escritas são tratadas de maneira automática.

O efeito é de compartilhamento máximo, tudo que pode ser compartilhado será:

Economia de memória e tempo (de cópia).

Compartilhar é Preciso

Copy-on-write compartilha por exemplo:

Código e dados de programas semelhantes quando são ``startados'' hierarquicamente.
Ou quando o mesmo código (ou dados) é usado múltiplas vezes:
- Pois o ``backing store'' é o mesmo.

Mas não compartilha quando por exemplo:

Diversos programas usam subrotinas em comum.

ELF X a.out

O formato de binário a.out é antigo e usado por diversos Unix.

Mas o código é ``linkado'' estaticamente, ou seja, todas as subrotinas têm que estar presentes no binário.

O formato ELF usado por versões mais modernas do Linux é linkado dinamicamente:

Na hora da execução o SO checa prá ver se todas as subrotinas estão disponíveis e as carrega sob demanda.
Isto permite que se implemente shared libs, ou seja, se a subrotina estiver na memória o SO não carrega outra cópia.

Shared Libraries

Cuidado a ser tomado:

Nenhuma shared lib pode fazer referência a endereços absolutos.

Porque ? Isto não tinha sido resolvido muito antes com paginação e segmentação ?

Não, naquele caso os endereços podiam ser absolutos dentro de um processo, pois o processo via a memória de forma contígua.
Com shared libs o mesmo código que está sendo executado pode ser visto por cada processo como estando em endereços virtuais diferentes.
Por isto a shared lib tem que endereçar-se sempre de forma relativa.

Compartilhar é Necessário

Compartilhamento de memória permite um ganho significativo na performance.

No Linux podemos identificar compartilhamento de memória:

Entre buffers de bloco e página;
Entre páginas através de copy-on-write;
Entre subrotinas sendo executadas.