Existem diferentes tipos de memória que auxiliam na execução das aplicações.

Por exemplo, a
memória cache é rápida e é utilizada juntamente com o processador, elevando assim o
desempenho do computador. Quando uma página é acessada constantemente num navegador, ao
invés do processador fazer uma busca das informações na memória RAM, ela busca as
informações na memória cache. Neste caso, as informações acessadas são copiadas para essa
memória, agilizando a recuperação da página desejada. O controle de todas é de responsabilidade
do gerenciador de memória, que realiza a gestão de quais partes estão sendo usadas e quais não
estão.
na maioria dos computadores existe o conceito de hierarquia de memória, combinando uma
pequena quantidade de memória cache (rápida, alto custo e volátil – guardam a informação
temporariamente), uma grande quantidade de memória principal (RAM – volátil, possui um médio
custo) e uma memória secundária (baixo custo, alto armazenamento das informações, não volátil,
com as informações armazenadas em disco)

desde os primeiros sistemas operacionais a memória do computador era considerada como um

recurso caro e escasso. Mesmo com a redução de custo e aumento da capacidade de
armazenamento das memórias, gerenciar o seu uso é fundamental e complexo.

o gerenciamento de memória permite que vários

processos sejam executados ao mesmo tempo, mantendo um bom desempenho do sistema
1) Sistemas que durante o processamento levam e trazem a informação da memória para o disco
(troca de processos e paginação)

2) Sistemas que não o fazem. A troca de processos (swapping) carrega todo o programa para a
memória principal, o executa por um determinado tempo e depois o mesmo retorna para o disco.

Por exemplo, imagine que um programa tenha três módulos: um principal, um de cadastramento e
outro de impressão. Os módulos de cadastramento e impressão são independentes. Assim,
quando o módulo de cadastramento estiver em execução na memória, o módulo de impressão não
precisa estar presente. O modulo principal é comum aos módulos de cadastramento e impressão, e
deve estar na memória durante o tempo de execução do programa (MACHADO; MAIA, 2007).
• O sistema operacional está utilizando o espaço de endereçamento em RAM (Figura 4.2 (a)),
modelo aplicado aos mainframes e minicomputadores
. • O sistema operacional está utilizando o espaço de endereçamento em ROM somente para a
leitura (Figura 4.2 (b)), usado em alguns computadores de mão e em sistemas embarcados.
• Os drives de dispositivos estão em ROM e os programas do usuário e o sistema operacional está
em RAM (Figura 4.2 (c)) – modelo utilizado nos primeiros computadores pessoais (MS-DOS).
A Figura 4.3(a) apresenta filas de entrada separadas para cada partição. Por exemplo, na partição
4 existem dois processos na fila, sendo que estes podem ter um tamanho de até 100 k para utilizar.

A desvantagem deste método é que podem existir muitos processos aguardando para serem
executados em algumas partições (como nas partições 1 e 4) e em outras filas não exista nenhum
processo (como na partição 3).

Uma solução é implementar uma fila única, assim, gerando um processo mais próximo do início da
fila e que caiba na partição para ser carregado e executado (Figura 4.3 (b)).

Para evitar desperdício de espaço não utilizado em uma partição, poder-se ia percorrer a fila a
procura do maior processo que comporte na partição. Porém, processos pequenos não seriam
selecionados para executar. Uma solução seria implementar uma partição pequena e definir que
um processo não poderia aguardar para receber uma partição mais do que n vezes.

Problemas da Multiprogramação: relocação e proteção

Segundo Tanenbaum (2003), a multiprogramação apresenta dois problemas essenciais: relocação

e proteção. A relocação é a transferência de um código de um local para outro de forma que um
programa não escreva na área de outro programa. A relocação é necessária uma vez que
processos executam em diferentes endereços na memória física.
Como exemplo, podemos relatar o problema de relocação entre dois programas: quando o
programa 1 está executando no endereço de memória entre 0 e 20. Após a finalização do
programa 1, o programa 2 também foi alocado no endereço de memória entre 0 e 20, ambos com
as suas instruções (ADD, MOV, JMP, dentre outras).
Os programas 1 e 2, ao serem relocados, foram alterados os seus endereços iniciais de memória.
Ao iniciarem a execução de suas instruções com novos endereços, o programa 2, que possui uma
instrução de saltar para o endereço 20, invade a área de memória do programa 1.

Esta é uma operação ilegal, uma vez que os processos não podem ler ou escrever endereços que
pertençam a outros processos/usuários. Segundo Tanenbaum (2003), quando um programa é
ligado (combinação do programa principal e procedimentos executados pelo usuário e
procedimentos de biblioteca), o linker – responsável por gerar o código executável – tem que saber
o endereço inicial do programa para relocar todas as instruções que fazem uso de um endereço
relativo de memória quando o programa for executado. Uma solução para o problema de relocação
é alterar as instruções do programa segundo a partição de memória em que ele está carregado.

No caso da relocação dos programas 1 e 2, a instrução contida no endereço 20, seria direcionada
para um endereço de memória dentro da área dos endereços do programa para não comprometer
sua execução.

Assim, o linker deve inserir no código binário uma lista ou um mapa informando quais são os
códigos de operação precisam ser relocados e quais não precisam. Segundo Tanenbaum (2003), a
relocação de um programa durante a carga não resolve a proteção.

Diferentes aplicações não podem acessar dados que não estejam dentro de sua partição. Se não
houvesse esta proteção, caso um programa mal-intencionado insira uma nova instrução, ele
poderá desviar o controle para ela, ocasionando uma falha de proteção.

Tanto os problemas de relocação quanto de proteção podem ser resolvidos fornecendo o

processador com dois registradores (memória localizada no processador): base e limite.

O registrador é uma memória localizada no processador do computador e acelera a execução das

aplicações. Ele está no topo da hierarquia de memória, possuem baixa capacidade de
armazenamento, alta velocidade de processamento, porém são caros.

Quando um processo é escalonado, o registrador-base é carregado com o endereço de início da

partição e o registrador-limite com o tamanho da partição. Os endereços gerados são verificados
no registador limite garantindo que não seja possível endereçar memória fora da região alocada ao
processo durante a execução.
imagine que estamos usando o navegador para pesquisar sobre um determinado assunto e, logo
que encontramos a informação que buscamos, abrimos o editor de texto para inserir essa
informação. Em alguns casos, quando temos vários programas abertos e realizamos essa troca –
no caso do navegador e do editor de texto –, percebemos um pouco de lentidão no computador. Na
verdade, o que ocorre é a troca de processos (swapping), pois o navegador – que estava sendo
executado até então – é tirado da memória e colocado em disco, enquanto o editor de texto, que
estava no disco, por falta de utilização, é trazido para a memória e reativado.

inicialmente, somente o processo A está na memória (Figura 4.4 (a)). O processo B é trazido do
disco para a memória (Figura 4.4 (b)) e em seguida o processo C (Figura 4.4 (c)). O processo A é
retirado da memória e retorna ao disco (Figura 4.4 (d)) e em seguida o processo D é trazido para a
memória (Figura 4.4 (e)) e o processo B retorna para o disco (Figura 4.4 (f)). O processo A é
trazido novamente na memória (Figura 4.4 (g)).
A Figura 4.5 apresenta o mapa de bits e a
memória dividida em unidades de alocação

A Figura 4.5 (a) mostra uma parte da memória

com cinco segmentos alocados a processos (A,
B, C, D e E) e três segmentos de memória livre
(espaços vazios).

A Figura 4.5 (b) apresenta o mapa de bits

correspondente a memória.
Segmento é uma área de memória alocada a um processo ou uma área livre de memória entre
dois processos.

Por exemplo, na primeira partição da memória representada por 8 bits, foi alocado o processo A
com cinco unidades de alocação (bits igual a 1) e três unidades de memória livre (bits igual a 0).

Na partição seguinte, o processo B alocou seis unidades e o processo C somente 2, uma vez que
as partições foram divididas em 8 bits cada e não comportava todo o processo.

O processo C utilizou duas unidades de alocação da próxima partição, duas unidades de memória
livre e o processo D utilizou 4 unidades. Na última partição do exemplo, o processo D utilizou duas
unidades de alocação, o processo E três unidades e três unidades de memória livre. Quanto menor
for a unidade de alocação, maior será o mapa bits.

A Figura 4.6(a) mostra uma parte da memória com cinco segmentos alocados a processos (A, B, C,
D e E) e três segmentos de memória livre (espaços vazios).

A Figura 4.6(c) apresenta a lista encadeada e a memória dividida em unidades de alocação. Cada
elemento dessa lista especifica um segmento de memória disponível (H) ou de memória alocada
ao processo (P), o endereço onde se inicia o segmento e um ponteiro para o próximo elemento da
lista.

Por exemplo, o processo A possui memória alocada (P), inicia na posição 0 (zero), tem o tamanho
de cinco unidades de alocação e possui um ponteiro para o próximo elemento. O próximo elemento
é um segmento de memória disponível (H), inicia na posição 5, possui o tamanho de três unidades
e aponta para o próximo segmento.

• First Fit (primeiro que couber): é o algoritmo mais simples e que consome menos recurso do
sistema. O gerenciador de memória procura ao longo da lista por um segmento livre que seja
suficientemente grande para esse processo.
• Next Fit (próximo que couber): este algoritmo é uma variação do First Fit. A posição em que
encontra o segmento de memória disponível é memorizada, não precisando percorrer toda lista
quando se quer alocar.
• Best Fit (melhor que couber): percorre toda lista e escolhe o menor segmento de memória livre
suficiente ao processo. Este algoritmo é mais lento uma vez que procura em toda a lista.
• Worst Fit (pior que couber): sempre é escolhido o maior segmento de memória disponível de
maneira que, quando dividido, o segmento disponível restante fosse suficientemente grande para
ser útil depois. Simulações mostram que este algoritmo não é uma boa ideia a ser usado.
• Quick Fit (mais rápido que couber): É um algoritmo rápido e mantém listas separadas por
tamanhos de segmentos de memória mais solicitados disponível.

A Figura 4.7 exemplifica o funcionamento dos algoritmos Best Fit, Worst Fit e First Fit.

O processo F (com tamanho de 1 kb) está aguardando para ser executado na memória principal.
Na memória principal está em execução os processos C e A e contém três segmentos de memória
livres com os tamanhos de 4 kb, 5 kb e 3 kb, respectivamente.
Antes do processo F iniciar a execução na memória principal, o algoritmo Best Fit seleciona na
lista o menor segmento de memória livre.
Assim, a partição com o tamanho 3 kb foi selecionada para executar o processo, deixando 2 kb de
espaço vazio.

Utilizando o algoritmo Worst Fit que escolhe o maior segmento de memória disponível, a partição
com o tamanho 5 kb foi selecionada para executar o processo, deixando 4 kb de espaço vazio.

Se for utilizado o algoritmo First Fit que procura na lista pelo primeiro segmento livre que seja
suficientemente grande para esse processo, será selecionada a partição com o tamanho 4 kb para
executar o mesmo, deixando 3 kb de espaço vazio.

Nos algoritmos First Fit e Best Fit ocorre a fragmentação externa.

é um espaço reservado no disco rígido do computador para ser utilizado quando a memória RAM
não é suficiente para executar os processos. Neste caso, uma parte dos processos ficam em disco
aguardando a liberação da memória para executar enquanto outros processos estão em execução.

Para entendermos melhor o conceito de memória virtual, observe o seguinte exemplo: suponha
que você quer executar um aplicativo de restauração de imagens que possui um tamanho de 100
MB e um programa de edição de textos com um tamanho de 60 MB, porém a memória RAM do seu
computador tem espaço para comportar programas de até 145 MB.

Neste caso, seria carregado na memória RAM o aplicativo de restauração de imagens (com 100
MB) e uma parte do programa de edição de textos (45 MB) e o restante ficaria em disco para serem
executados posteriormente a medida que a memória fosse liberada.

Um computador que utiliza memória virtual permite que o volume de informações de um programa
como código dado e pilha ultrapasse a quantidade total de memória física disponível para ele,
mantendo as partes ativas na memória e as demais no disco rígido. A memória virtual é um arquivo
dinâmico e de tamanho variável na maioria dos sistemas operacionais.
A figura acima apresenta o funcionamento do mapeamento de endereços virtuais para endereços
físicos realizado pela MMU. O computador possui uma memória virtual de 64 KB (gerando
endereços virtuais de 16 bits de 0 a 64 K) e uma memória física de 32 KB. Programas podem ser
maiores que o tamanho da memória física, mas não podem ser totalmente carregados nela,
devendo permanecer em disco. O endereço virtual divide-se em unidades conhecidas como
páginas e sua referência na memória física são as molduras de página. As páginas e as molduras
de páginas têm o mesmo tamanho e a movimentação entre disco e memória são sempre
realizadas em unidades de página.

Existem 16 páginas virtuais e oito molduras de página. Quando um programa tenta acessar o
endereço 0, o endereço virtual 0 é enviado a MMU, que o localiza na página virtual (0 a 4 K) e que
corresponde a moldura de página 2 (8 K a 12 K). A MMU então transforma o endereço virtual 0 no
endereço físico 8 K e o envia à memória por meio do barramento. Como existem apenas oito
molduras de página física, somente oito páginas virtuais podem ser mapeadas.
O endereço virtual, 8196 (0010000000000100), é mapeado para o endereço físico 24580
(endereço físico de saída). O endereço virtual de 16 bits (0010000000000100) que chega a MMU é
dividido num número de página de 4 bits (0010) mais significativos e um deslocamento de 12 bits
(000000000100) menos significativos.
O número da página (0010 = 2) é usado como índice para a tabela de páginas.
Se o bit presente/ausente for 1, o número da moldura de página encontrado na tabela será copiado
para os três bits (110) mais significativos concatenados ao deslocamento de 12 bits do endereço
virtual que não sofreu alteração (110000000000100).
O registrador envia para a memória o endereço físico via barramento, conforme apresentado na
Figura acima
• Algoritmo de substituição de página ótimo

Seleciona uma página que não será referenciada no futuro ou aquela que demorará a ser utilizada
novamente. Este algoritmo garante uma menor paginação, porém é impossível de ser
implementado, uma vez que o sistema operacional não consegue prever o futuro das aplicações e
saber quando cada página será referenciada novamente.

• Algoritmo de substituição de página não recentemente utilizada (NUR)

Muitos computadores que utilizam a memória virtual possuem dois bits R (referenciada) e M
(modificada) associados a cada página virtual para identificar quais páginas físicas estão sendo
usadas e quais não estão. No algoritmo NUR, quando um processo é iniciado os bits R e M são
colocados em 0 para todas as páginas.
Periodicamente, o bit R é limpo de modo que diferencie as páginas que não foram referenciadas
recentemente daquelas que foram.
Quando acontece uma falta de página, o sistema operacional verifica todas as páginas e as separa
em quatro categorias, com base nos bits R e M:

• Classe 0: não referenciada, não modificada.

• Classe 1: não referenciada, modificada.
• Classe 2: referenciada, não modificada.
• Classe 3: referenciada, modificada. O algoritmo remove aleatoriamente uma página de classe de
ordem mais baixa que não esteja vazia, ou seja, remove uma página modificada, mas não
referenciada. O algoritmo NUR é simples e de fácil implementação. Por exemplo, suponha que as
páginas virtuais 0, 1, 2 e 3, iniciaram todas com os valores zero. Num determinado momento foram
associados aos bits referenciada e modificada os seguintes valores:

Como o algoritmo retira a página de ordem mais baixa, que esteja vazia e que tenha sido
modificada, mas não referenciada, as páginas 0 e 2 poderiam ser removidas segundo o algoritmo
NUR.

• Algoritmo de substituição de página FIFO

FIFO (first in first out), a primeira página utilizada será a primeira a ser escolhida para ser removida.
As páginas são inseridas em uma fila sendo que as mais antigas estão no início e as mais recentes
no final. É um algoritmo de baixo custo, porém quase não é implementado em função de escolher
páginas antigas que sempre são referenciadas.

• Algoritmo de substituição de página de segunda chance (SC)

O algoritmo FIFO não leva em consideração a retirada de uma página usada constantemente. Uma alteração simples
evitaria a eliminação de uma página muito usada.
Basta verificar o bit de referência da página mais antiga. Se o bit R for 0, a página não está sendo usada e pode ser
substituída.
Se o bit R for 1 será colocado em 0, e essa página será inserida no final da lista como se ela tivesse acabado de ser
carregada na memória. A Figura 4.11(a) apresenta uma lista com as páginas de A até H ordenadas por ordem de
chegada na memória (a página A chegou no instante 0, a página B no instante 3, a página C no instante 7, e assim por
diante).
Caso ocorra uma falta de página no instante 20, o bit R da página A (que é a mais antiga) é verificado. Se o valor do bit R
for 0 (zero) a página é retirada da memória, caso contrário A será inserida no final da fila no instante 20 (Figura 4.11(a))
e R receberá o valor 0. O algoritmo continua a percorrer a lista a partir da página B para encontrar uma página que
possa ser substituída.

 Algoritmo de substituição de página relógio

Este algoritmo mantêm todas as páginas em uma lista circular em forma de relógio e um ponteiro apontando para a
‘cabeça’ da lista, ou seja, para a página mais antiga. A Figura 4.12 apresenta o funcionamento do algoritmo,
(TANENBAUM, 2003).

Quando ocorre uma falta de página, o ponteiro aponta para a página mais antiga e o bit R é verificado (página C). Se o
valor do bit R for 0 (zero) a página é retirada da memória e o ponteiro avança uma posição. Caso contrário, R receberá
o valor 0 e o ponteiro avançará para a página mais antiga. A diferença entre o algoritmo SC para o algoritmo relógio
está na implementação. O algoritmo SC é implementado através de fila e o relógio através de uma lista circular.

• Algoritmo de substituição de página menos recentemente utilizada (MRU)

Este algoritmo é baseado na observação de que páginas referenciadas intensamente nas últimas
instruções provavelmente serão novamente utilizadas, e páginas que não foram referenciadas não
serão utilizadas na próxima instrução. Este algoritmo aproxima se do desempenho do algoritmo
ótimo e possui uma implementação onerosa, pois mantem uma lista encadeada na memória com
as páginas mais utilizadas no início da lista e as menos utilizadas no final, sendo necessário a sua
atualização a cada referência de memória.

A memória virtual é unidimensional, uma vez que inicia da posição 0 e vai até um endereço
máximo. Em alguns casos isso pode ser um problema. Por exemplo, durante a execução de um
compilador são gerados o texto fonte pré- processado, uma tabela de símbolos, uma tabela de
constantes, uma árvore sintática e uma pilha. O texto fonte, a tabela de símbolos, a tabela de
constantes e a árvore sintática crescem continuamente durante a compilação, enquanto a pilha
varia de tamanho. Se um programa possui um número grande de variáveis, o espaço reservado
para elas na tabela de símbolos pode se esgotar à medida que o compilador é executado e sobrará
espaço nas outras tabelas. Para resolver este problema, basta fornecer ao computador vários
espaços de endereçamento independentes chamados de segmentos.

O segmento é uma unidade lógica que pode ser um vetor ou uma pilha, por exemplo, sendo de
conhecimento do programador. Cada segmento tem um tamanho dinâmico e independente dos
outros (que varia de 0 a um valor máximo),

A segmentação facilita o compartilhamento de procedimentos ou dados entre vários processos, por

exemplo, o uso de uma biblioteca compartilhada, evitando que estas bibliotecas sejam replicadas
em cada endereçamento de cada processo. Segmentos podem ter diferentes proteções, como um
segmento que armazena código pode ser definido apenas para execução, um segmento que
armazena constantes, somente leitura e um segmento de pilha como leitura/escrita. As tentativas
de acesso indevido podem ser capturadas e tratadas pelo hardware ou pelo sistema operacional.