O que é Gerenciamento de Memória?

Função do Sistema Operacional:

• Alocar e gerenciar a memória para processos.
• Garantir que cada processo receba a quantidade necessária de memória para execução.
• Proteger a memória de um processo contra acessos indevidos de outros.

Objetivos:

• Maximizar a utilização da memória.
• Minimizar o tempo de acesso à memória.
• Evitar fragmentação e desperdício.

Hierarquia:

Conceitos Básicos

Endereço Lógico: Gerado pelo processador durante a execução de um programa; reflete a visão do programa.

Endereço Físico: Local real na memória RAM, definido após a tradução pela MMU.

MMU (Memory Management Unit): Hardware responsável por converter endereços lógicos em físicos, usando registradores de relocação.

Estrutura Típica

• TEXT: Código executável – fixo, somente leitura. contém o código a ser executado pelo processo, gerado durante a compilação e a ligação com as bibliotecas. Esta área tem tamanho fixo, calculado durante a compilação, e normalmente só deve estar acessível para leitura e execução.
• DATA: Variáveis globais e estáticas – leitura e escrita. Esta área contém os dados estáticos usados pelo programa, ou seja, suas variáveis globais e as variáveis locais estáticas. Como o tamanho dessas variáveis pode ser determinado durante a compilação, esta área tem tamanho fixo; deve estar acessível para leituras e escritas, mas não para execução.
• HEAP: Memória alocada dinamicamente – tamanho variável, suscetível a fragmentação. Área usada para armazenar dados através de alocação dinâmica, usando operadores como malloc e free ou similares. Esta área tem tamanho variável, podendo aumentar/diminuir conforme as alocações/liberações de memória feitas pelo processo. Ao longo do uso, esta área pode se tornar fragmentada, ou seja, pode conter lacunas entre os blocos de memória alocados. São necessários então algoritmos de alocação que minimizem sua fragmentação.
• STACK: Pilha de execução – usada para chamadas de função e variáveis locais. Área usada para manter a pilha de execução do processo, ou seja, a estrutura responsável por gerenciar o fluxo de execução nas chamadas de função e também para armazenar os parâmetros, variáveis locais e o valor de retorno das funções. Geralmente a pilha cresce “para baixo”, ou seja, inicia em endereços elevados e cresce em direção aos endereços menores da memória. No caso de programas com múltiplas threads, esta área contém somente a pilha do programa principal. Como threads podem ser criadas e destruídas dinamicamente, a pilha de cada thread é mantida em uma área própria, geralmente alocada no heap.

Principais Técnicas

• Partições Fixas: Memória dividida em blocos estáticos. Ex.: OS/360.
• Segmentação: Divisão da memória em segmentos lógicos (código, dados, pilha).
• Paginada: Memória dividida em páginas fixas (ex.: 4 KB) com mapeamento via tabela de páginas.
• Memória Virtual: Abstração que permite usar mais memória que a fisicamente instalada, através do swap.

Conceito

A técnica de partições fixas consiste em dividir a memória RAM em blocos de tamanho fixo, chamados de partições. Cada processo é carregado em uma dessas partições, e não pode usar mais memória do que a capacidade da partição que lhe foi atribuída.

Exemplo: Suponha que um processo queira acessar o endereço lógico 14.257. Ele está carregado na partição 3, cujo endereço inicial na memória física é 110.000. O hardware (MMU) soma esses valores:

Endereço físico = endereço base + endereço lógico = 110.000 + 14.257 = 124.257.

Esse é o endereço real que será acessado na RAM.

Vantagem: É uma técnica simples de implementar, pois não exige estruturas complexas de gerenciamento.

Desvantagem: Pode causar fragmentação interna — ou seja, sobras de memória dentro da partição que não são utilizadas, desperdiçando espaço.

Conceito

Na segmentação, a memória é organizada de forma lógica, refletindo a estrutura dos programas. Em vez de dividir a memória em blocos fixos (como na paginação), ela é separada em segmentos, como:

• código (instruções do programa)
• dados (variáveis globais, vetores, buffers)
• pilha (funções, chamadas recursivas, parâmetros)

Cada segmento possui dois parâmetros:

• Base: endereço inicial do segmento na memória física
• Limite: tamanho máximo do segmento

O processador utiliza essas informações para verificar se o acesso está dentro dos limites válidos.

Vantagem: Maior flexibilidade e permite compartilhamento de código entre processos, como bibliotecas.

Desvantagem: Pode causar fragmentação externa, já que os segmentos têm tamanhos diferentes e são alocados dinamicamente.

🧮

Exemplo de Cálculo

• Segmento requisitado: 2
• Offset dentro do segmento: 300
• Tabela de Segmentos: Segmento 2 tem base 5.000 e limite 1.000
• Verificação: 300 < 1.000 → Acesso válido
• Endereço físico = 5.000 + 300 = 5.300

Exemplos de processadores que utilizam a alocação por segmentos incluem o 80.386 e seus sucessores (486, Pentium, Athlon e processadores correlatos).

Conceito

No modelo de alocação paginada, tanto o espaço de endereços lógicos (gerado pelo processo) quanto a memória física (RAM) são divididos em blocos de tamanho fixo:

• Páginas: blocos do endereço lógico (geralmente de 4 KB = 4.096 bytes)
• Quadros (frames): blocos equivalentes na memória física

O mapeamento entre as páginas de um processo e os quadros disponíveis na memória física é feito por meio de uma tabela de páginas, que fica associada a cada processo. O processador localiza essa tabela usando o registrador chamado PTBR (Page Table Base Register).

Vantagens: evita a fragmentação externa e simplifica a alocação da memória.

Exemplo de Cálculo

• Endereço lógico: 20.000
• Tamanho da página: 4.096 bytes
• Divisão: 20.000 ÷ 4.096 → Página 4, com resto 784 (offset)
• Tabela de páginas: Página 4 mapeada para o Quadro 7
• Endereço físico: (7 × 4.096) + 784 = 28.656

A divisão do espaço de endereçamento lógico de um processo em páginas pode ser feita de forma muito simples: como as páginas sempre têm 2n bytes de tamanho (por exemplo, 212 bytes para páginas de 4 KBytes) os n bits menos significativos de cada endereço lógico definem a posição daquele endereço dentro da página (deslocamento ou offset), enquanto os bits restantes (mais significativos) são usados para definir o número da página. Por exemplo, o processador Intel 80.386 usa endereços lógicos de 32 bits e páginas com 4 KBytes; um endereço lógico de 32 bits é decomposto em um offset de 12 bits, que representa uma posição entre 0 e 4.095 dentro da página, e um número de página com 20 bits. Dessa forma, podem ser endereçadas 220 páginas com 212 bytes cada (1.048.576 páginas com 4.096 bytes cada).

🔍

Como a MMU traduz um endereço lógico

Como as páginas têm tamanho fixo (geralmente uma potência de 2, como 2¹² = 4.096), a divisão do endereço lógico é simples:

• Bits menos significativos: representam o offset (posição dentro da página)
• Bits mais significativos: representam o número da página

Por exemplo, com endereços lógicos de 32 bits:

• 12 bits para o offset (0 a 4.095)
• 20 bits para o número da página (total de 1.048.576 páginas)

🧭

Etapas da tradução (resumo)

1. Separar o endereço lógico em número da página e offset
2. Buscar o número da página na tabela de páginas → obter número do quadro
3. Construir o endereço físico: quadro × tamanho da página + offset
4. Se a página não estiver carregada, ocorre um page fault
5. O sistema operacional carrega a página da memória secundária (swap/disco)

A Memory Management Unit (MMU) é um componente essencial dos sistemas operacionais, responsável por converter endereços lógicos em endereços físicos na memória RAM. Esse processo de tradução é realizado dinamicamente e envolve o uso de tabelas de páginas e, frequentemente, de uma TLB (Translation Lookaside Buffer) para acelerar as buscas. Se a página não estiver na RAM, ocorre um "page fault".

Como Funciona?

1. Divisão do Endereço: O endereço lógico é dividido em duas partes:
   • Número da Página: Os bits superiores identificam a página.
   • Offset: Os bits inferiores indicam a posição dentro da página.
   Por exemplo, com endereços de 32 bits e páginas de 4 KB (2¹² bytes), os 20 bits superiores representam o número da página e os 12 bits inferiores o offset.
2. Consulta na Tabela de Páginas: A MMU utiliza o número da página para procurar o quadro de memória correspondente na tabela de páginas. Se a página estiver presente na RAM, ela retorna o número do quadro; caso contrário, ocorre um page fault.
3. Cálculo do Endereço Físico: O endereço físico é calculado combinando o número do quadro com o offset. Se o quadro for, por exemplo, 7 e o tamanho da página 4.096 bytes, o endereço físico é dado por:
   (7 × 4096) + offset.

Exemplo Prático

Considere o seguinte exemplo:

• Endereço lógico: 0x12345 (hexadecimal)
• Tamanho da página: 4 KB (0x1000 bytes)
• Cálculo:
  • Número da página: 0x12345 >> 12 = 0x12 (18 em decimal)
  • Offset: 0x12345 & 0xFFF = 0x345 (837 em decimal)
  • Suponha que a tabela de páginas mapeie a página 18 para o quadro 7.
  • Endereço físico: (7 × 4096) + 837 = 28685 (0x6F35 em hexadecimal)

Animação

A animação abaixo ilustra esse processo de tradução de endereços:

Referências

• Silberschatz, A., Galvin, P. B., & Gagne, G. Fundamentos de Sistemas Operacionais, 8ª ed., LTC, 2010 (Capítulos 8 e 9).
• Tanenbaum, A. Sistemas Operacionais Modernos, 3ª ed., Prentice Hall, 2009 (Capítulo 3).
• Maziero, C. SOCM – Gestão da Memória, Parte IV: Gestão da Memória. Link.

O que é Memória Virtual?

A memória virtual é uma técnica que permite que processos utilizem mais memória do que a fisicamente disponível no sistema. Ela divide a memória em páginas e transfere páginas não utilizadas para o disco (swap), liberando espaço na memória RAM.

Algoritmos de Substituição de Páginas

• FIFO (First-In, First-Out): Substitui a página que está na memória há mais tempo.
• LRU (Least Recently Used): Substitui a página que não foi usada há mais tempo.
• NRU (Not Recently Used): Substitui uma página que não foi referenciada recentemente. (NRU precisa de informações do hardware (baseado em bits de controle mantidos pelo hardware: Bit R (Referenciado): indica se a página foi acessada recentemente. Bit M (Modificado): indica se a página foi escrita (alterada).), que mudam dinamicamente conforme os acessos. Como não temos acesso a esses bits em um exemplo estático, só podemos estimar seu comportamento.)
• Ótimo: Substitui a página que será usada no futuro mais distante (ideal, mas não implementável na prática).

💡

Funcionamento da Memória Virtual

A memória virtual é uma técnica que permite que os processos usem mais memória do que a quantidade física instalada (RAM). Para isso, o sistema operacional armazena temporariamente páginas de memória em um espaço no disco, chamado swap.

Quando um processo acessa uma página que não está na RAM, ocorre uma falta de página (page fault). Nesse momento:

1. O sistema operacional localiza a página no disco (área de swap).
2. Se houver espaço na RAM, ela é carregada diretamente.
3. Se não houver espaço, o sistema escolhe uma página existente para remover (usando um algoritmo de substituição).
4. A nova página é então carregada na RAM, e a execução do processo continua.

Esse processo é transparente para o programa, mas afeta diretamente o desempenho — quanto mais page faults, maior o tempo de espera.

🧮

Exemplo de Cálculo de Page Faults (FIFO)

Considere um sistema com 3 frames disponíveis na RAM e a seguinte sequência de referências a páginas:

1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

Utilizando o algoritmo FIFO (First-In, First-Out), temos:

1. Página 1 → Page Fault (Frames: [1])
2. Página 2 → Page Fault (Frames: [1, 2])
3. Página 3 → Page Fault (Frames: [1, 2, 3])
4. Página 4 → Page Fault (remove 1) → (Frames: [4, 2, 3])
5. Página 1 → Page Fault (remove 2) → (Frames: [4, 1, 3])
6. Página 2 → Page Fault (remove 3) → (Frames: [4, 1, 2])
7. Página 5 → Page Fault (remove 4) → (Frames: [5, 1, 2])
8. Página 1 → Já na memória (Frames: [5, 1, 2])
9. Página 2 → Já na memória (Frames: [5, 1, 2])
10. Página 3 → Page Fault (remove 5) → (Frames: [3, 1, 2])
11. Página 4 → Page Fault (remove 1) → (Frames: [3, 4, 2])
12. Página 5 → Page Fault (remove 2) → (Frames: [3, 4, 5])

Total de Page Faults: 9

🔁

Exemplo de Cálculo de Page Faults (LRU)

O algoritmo LRU (Least Recently Used) substitui a página que está na memória há mais tempo sem ser usada. Ele tenta prever que páginas não serão utilizadas em breve, com base no uso passado.

Vamos usar a mesma sequência de referências e 3 frames na RAM:

1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

Acompanhe a execução passo a passo:

1. Página 1 → Page Fault (Frames: [1])
2. Página 2 → Page Fault (Frames: [1, 2])
3. Página 3 → Page Fault (Frames: [1, 2, 3])
4. Página 4 → Page Fault → Remove 1 (menos recentemente usada) → (Frames: [4, 2, 3])
5. Página 1 → Page Fault → Remove 2 → (Frames: [4, 1, 3])
6. Página 2 → Page Fault → Remove 3 → (Frames: [4, 1, 2])
7. Página 5 → Page Fault → Remove 4 → (Frames: [5, 1, 2])
8. Página 1 → Já na memória → (Frames: [5, 1, 2])
9. Página 2 → Já na memória → (Frames: [5, 1, 2])
10. Página 3 → Page Fault → Remove 5 → (Frames: [3, 1, 2])
11. Página 4 → Page Fault → Remove 1 → (Frames: [3, 4, 2])
12. Página 5 → Page Fault → Remove 2 → (Frames: [3, 4, 5])

Total de Page Faults: 10

Comparativo de Algoritmos de Substituição de Páginas

Algoritmo	Descrição	Page Faults	Observações
FIFO	Remove a página que está na memória há mais tempo (ordem de chegada).	9	Simples, mas pode remover páginas ainda úteis.
LRU	Remove a página que não é usada há mais tempo.	10	Mais eficiente que FIFO, mas com maior custo de implementação.
NRU	Remove uma página que não foi referenciada recentemente, priorizando páginas não modificadas.	Varia (depende do clock)	Usa bits de referência e modificação; eficiente e comum em sistemas reais.
Ótimo	Remove a página que será usada mais tarde no futuro.	7	Melhor resultado teórico, mas não pode ser implementado na prática.

Swapping

O swapping é o processo de mover páginas de memória RAM para o disco (swap space) e vice-versa. Ele é essencial para sistemas com memória física limitada, mas pode impactar o desempenho devido ao tempo de acesso ao disco.

Exemplo de Cálculo de Tempo de Swapping

Suponha que o tempo de acesso à RAM seja de 100 ns e o tempo de acesso ao disco seja de 10 ms (10.000.000 ns). Se ocorrer um page fault, o tempo total para acessar uma página será:
Tempo de acesso = Tempo de busca no disco + Tempo de carregamento na RAM
Tempo de acesso = 10 ms + 100 ns ≈ 10 ms

Figuras e Diagramas

Figura 1: Diagrama de memória virtual e swapping.

Figura 2: Funcionamento da memória virtual com páginas e frames.

Referências Adicionais

• Tanenbaum, A. S. - Sistemas Operacionais Modernos
• Silberschatz, A. - Fundamentos de Sistemas Operacionais

O que são Algoritmos de Substituição?

Quando a memória RAM está cheia e ocorre um page fault, o sistema operacional precisa decidir qual página remover para liberar espaço. Os algoritmos de substituição determinam essa decisão, impactando diretamente o desempenho do sistema.

Principais Algoritmos

• FIFO (First-In, First-Out): Remove a página que está na memória há mais tempo.
  Exemplo: Sequência de páginas: 1, 2, 3, 4, 1, 2, 5. Com 3 frames, os page faults ocorrem nas páginas 1, 2, 3, 4, 5.
• LRU (Least Recently Used): Remove a página que não foi usada há mais tempo.
  Exemplo: Sequência de páginas: 1, 2, 3, 4, 1, 2, 5. Com 3 frames, os page faults ocorrem nas páginas 1, 2, 3, 4, 5.
• NRU (Not Recently Used): Remove uma página que não foi referenciada recentemente, priorizando páginas não modificadas.
• Ótimo: Remove a página que será usada no futuro mais distante. É teórico e não implementável na prática, mas serve como referência para comparação.

Exemplo Prático

Considere a seguinte sequência de referências a páginas: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5.
Com 3 frames de memória, calcule o número de page faults para cada algoritmo:

• FIFO: 9 page faults.
• LRU: 8 page faults.
• Ótimo: 7 page faults.

Animação com p5.js (FIFO)

Abaixo está uma animação interativa que simula o funcionamento do algoritmo FIFO. Clique no botão para avançar as referências e observe como as páginas são substituídas.

Próximo Passo (FIFO)

Status: Aguardando início...

Figuras e Diagramas

Figura : Substituição de Página.

Segmentação com Paginação

Essa técnica combina o melhor de dois mundos: a organização lógica da segmentação com o gerenciamento físico eficiente da paginação.

Cada processo é dividido em segmentos lógicos (ex.: código, dados, pilha), e cada segmento é dividido em páginas. O sistema operacional então utiliza uma tabela de segmentos, onde cada entrada aponta para a tabela de páginas do segmento correspondente.

Por que combinar?

• Segmentação facilita a organização lógica e proteção (ex.: separar código de dados).
• Paginação permite o uso eficiente da memória física, evitando fragmentação externa.

Como funciona?

1. O endereço lógico é composto por:
   • Segmento
   • Número da Página dentro do segmento
   • Offset dentro da página
2. A MMU usa o segmento para encontrar a tabela de páginas correspondente.
3. Usa o número da página para encontrar o quadro físico.
4. Calcula o endereço físico combinando o quadro e o offset.

Exemplo Numérico

Endereço lógico: Segmento = 1, Página = 3, Offset = 56

- Tabela de segmentos: Segmento 1 → base = 0x1000 (endereço da tabela de páginas)
- Tabela de páginas do segmento 1: Página 3 → quadro = 7
- Tamanho da página: 256 bytes

Endereço físico = (7 × 256) + 56 = 1792 + 56 = 1848

Uso Real: Arquiteturas Intel

No processador Intel 80386 e sucessores (como Pentium), a segmentação é feita com as tabelas GDT (Global Descriptor Table) e LDT (Local Descriptor Table). Cada entrada contém o base e o limite de um segmento. Ao acessar um segmento, a CPU localiza sua tabela de páginas correspondente.

Resumo

• ⚙️ Organização lógica: Segmentação
• 📦 Gerenciamento eficiente da memória: Paginação
• 💡 Muito usado em sistemas modernos com suporte a virtualização e proteção

Passo a Passo: Cálculos de Alocação

1. Alocação Paginada

Exemplo: Endereço lógico = 8.500; tamanho da página = 4.096 bytes.

1. Cálculo: 8.500 ÷ 4.096 = 2 (página) com resto 108 (offset).
2. Tabela de Páginas: Página 2 mapeada para o Quadro 5.
3. Endereço Físico: (5 × 4.096) + 108 = 20.588.

Página	Quadro
0	3
1	1
2	5

2. Alocação Segmentada

Exemplo: Segmento 1, Offset 200; Base = 10.000, Limite = 1.000.

1. Verificação: 200 < 1.000 → Válido.
2. Endereço Físico: 10.000 + 200 = 10.200.

Segmento	Base	Limite
0	5.000	2.000
1	10.000	1.000
2	15.000	500

Implementação em Sistemas Reais

Linux: Utiliza paginação com tabelas multinível (ex.: 4 níveis em x86_64) e uma abordagem aproximada do LRU.

Windows: Emprega paginação por demanda, gerencia working sets e utiliza um algoritmo de clock modificado.

BSD/FreeBSD: Usa listas de páginas inativas para otimizar a substituição.

Simulações e Estudos

• Emular page faults e comparar desempenho de algoritmos FIFO vs. LRU.
• Analisar a fragmentação em partições fixas versus segmentação versus paginação.

Demonstração Interativa: FIFO vs LRU

- Silberschatz et al., Fundamentos de SOs, 8ª ed., LTC, 2010, Capítulos 8 e 9.
- Tanenbaum, A., Sistemas Operacionais Modernos, 3ª ed., Prentice Hall, 2009, Cap. 3.
- Maziero, C., SOCM – Parte IV: Gestão da Memória (link).
-Link extra (link).

Perguntas para Reflexão

1. Qual a diferença entre endereço lógico e físico?
2. Como a MMU realiza a tradução dos endereços?
3. Quais as vantagens e desvantagens da alocação paginada?
4. Como os algoritmos de substituição de páginas impactam o desempenho?
5. O que é fragmentação e como ela pode ser evitada?

Mostrar Respostas

Resumo

O gerenciamento de memória é vital para o desempenho dos sistemas operacionais. Técnicas como partições fixas, segmentação, paginação e memória virtual otimizam o uso dos recursos, e algoritmos de substituição são essenciais para manter a performance.

Próximos Passos

• Estudo de casos práticos (Linux, Windows, BSD).
• Implementação e simulação de algoritmos (FIFO, LRU, etc.).

Responda as questões abaixo: