SOII_Materia_Parte02

Prévia do material em texto

SISTEMA OPERACIONAL II – PARTE 2 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 1 
 
4) COMO CONSEGUIR EXECUTAR UM PROCESSO EM UM ENDEREÇO QUALQUER 
DE MEMÓRIA? 
 
5) Correção de endereços em tempo de carga 
6) Registrador de base 
7) Uso de endereçamento relativo a instancia atual 
8) Segmentação 
9) Paginação 
 
5) O USO DE ENDEREÇO RELATIVO 
 
A INTEL tem Registrador de base e Endereçamento relativo a instancia atual. Ela tem estes tipos de 
endereçamento somente para alguns tipos de instruções. Precisamos saber: O que a memória contém? 
O que é armazenado na memória? 
 
A memória possui dois tipos de coisas: Código executável que está na memória e Variáveis Globais, 
Locais e Dinâmicas. A CPU só executa coisas que estão na memória. Cada processo tem códigos 
executáveis e variáveis. Esta é a divisão básica. 
 
6) ÁREAS DE MEMÓRIA DE UM PROCESSO (INTRODUÇÃO À SEGMENTAÇÃO) 
 
As variáveis mudam de valor. Não existem processos que não usem variáveis. Embora o código 
executável não tenha muita diferença entre eles. As variáveis possuem uma divisão importante dentro 
delas. 
 
Existem diversas formas de se usar uma variável em um programa de linguagem de auto nível como 
Delfi ou C. As formas de se usar a variável determinam como elas serão armazenadas dentro da área 
de código do processo. 
 
Existem três formas de se armazenar a variável dentro da área de código do processo: Global, Local e 
Dinâmica. 
 
Áreas de Um Processo: Código, Dados (variáveis locais) e área de pilha (cada processo tem a sua). A 
amarração das variáveis locais é feita em tempo de execução. 
 
7) VARIÁVEIS GLOBAIS 
 
As variáveis Globais existem o tempo todo no processo que está em execução e geralmente qualquer 
parte do processo consegue usar, alterar e consultar esta variável. Quando o programa começa ela 
passa existir e quando o programa termina ela deixa de existir. 
 
Durante a compilação do programa o compilador verifica quantas variáveis Globais existem e qual o 
tamanho de cada uma delas. E coloca no cabeçalho do arquivo executável para informar ao processo 
durante sua execução a quantidade de KB necessários para as variáveis Globais. 
 
8) VARIÁVEIS LOCAIS 
 
As variáveis Locais só podem ser usadas dentro de uma sub-rotina. Elas são declaradas em uma sub-
rotina, por exemplo, uma função. O problema maior que ocorre com as variáveis Locais está dentro 
de funções recursivas, como mostra o exemplo abaixo: 
SISTEMA OPERACIONAL II – PARTE 2 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 2 
 
 
function FAT(n: integer): integer; 
 begin 
 if n = 1 then 
 FAT := 1 
 else FAT := n * FAT(n-1); 
 end; 
 
 program principal; 
 var FAT: integer; 
 begin 
 FAT := 1; 
 for i := 1 to n do 
 FAT := FAT * i; 
 End. 
 
A remoção é a complicação desta alocação de variável local em uma função recursiva, pois não existe 
uma única variável n na memória existem vários n. Para resolver este problema é utilizada uma pilha 
de execução. Na pilha de execução temos o seguinte funcionamento, supondo n = 4: 
 
 Aloca-se no sentido de cima para baixo a variável n. Assim existem quatro variáveis de 
nome n na memória, criada a cada chamada da função recursiva: n = 4, n = 3, n = 2, n = 1; 
 
 Quando desaloca na ordem inversa da alocação, de baixo para cima, é que serão feitos os 
cálculos do fatorial: n = 1, n = 2, n = 3, n = 4. 
 
 
 
 
 
 
As variáveis Locais possuem algumas particularidades e se assemelha muito ao parâmetro de uma 
função. Por exemplo, a função FAT (N: Integer) dos exemplos 2 e 3 abaixo, calcula o fatorial de um 
número. O parâmetro também se assemelha muito a variável local porque só é usado em um 
determinado local. 
 
Exemplo 1 
 
Procedure P; 
Var I = Integer 
Begin 
For I=1 to 10 Do 
 Begin 
 … 
 End; 
End; 
 
 
Exemplo 2 - Delfi 
 
Function 
FAT(N:Integer); 
Var A, I:Integer 
Begin 
A:=1; 
For I:=1 to N Do 
A:=A*I; 
End; 
FAT:=A //Return A 
End; 
Exemplo 3 - Pascal 
 
Function 
FAT(N:Integer); 
Begin 
If N>1 Then 
 Return FAT(N-1)*N 
Else 
 Return 1 
End; 
 
4 
3 
2 
1 
 
alocando desaloca 
Pilha 
SISTEMA OPERACIONAL II – PARTE 2 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 3 
 
Análise da variável N na memória: A variável N é um parametro, ou seja, uma variável local. Ela 
tem particularidades. Que particularidades são estas? A memória contém ao mesmo tempo vários N 
diferentes. 
 
Digamos que chamamos a subrotina, ou seja, a função: J:=FAT(3). O que vai acontecer? Em alguma 
parte da memória temos a variável N que é um parametro com o valor inicial 3. 
 
n 3 fat (3) = fat ( 3 ) * 3 = 6 
 
n 2 fat (2) = fat ( 1 ) * 2 = 2 
 
 → n * 20 fat (1) = 1 
 
O último "n" será sempre o ativo, marcado por um indicador. Qualquer nova atribuição do valor será 
feito na última. 
 
Entra na subrotina FAT(N:Integer) e verifica que 3 > 1. O then da função chama recursivamente a 
função FAT, mas agora o parametro mudou para N=2. Não podemos simplismente trocar o N que 
está com o valor 3 pelo valor 2. 
 
Por que não podemos fazer isto? Porque depois que calcula o fatorial de 2 falta multiplicar por N 
cujo o valor original era 3. O valor original de N não pode mudar o valor do parametro N. 
 
O que acontece? Na memória é criado outro N com o valor 2. Como a função sabe qual N utilizar? 
Ela sabe porque tem indicação externa que diz qual é o N válido naquele momento. Neste caso, o 
N=2. Executa-se mais uma vez a função FAT, mas agora o valor de N=1. 
Memória 
N = 3 
 
N = 2 
 
N = 1 
 
 
FAT(3) = FAT(2)*3 = 6 
FAT(2) = FAT(1)*2 = 2 
FAT(1) = 1 
 
Quando for fazer o cálculo do fatorial de 3 ao criar o N a seta vai descendo ao utilizar o N no cálculo a 
seta vai subindo. Este é o jeito de persistir na memória vários valores do N, pois só assim é possível 
fazer o cálculo. 
 
A variável local é diferente da variável Global. A variável Global só tem uma para o programa inteiro. A 
local não para a mesma sub-rotina tem várias variáveis na memória com valores diferentes. 
 
No entanto, em um determinado momento de tempo somente uma variável estará sendo utilizada. É 
diferente a forma de se guardar as variáveis Globais e Locais. 
 
Variáveis Locais tem mais de uma a medida que necessite, por exemplo, se o N for igual a 100. Quantas 
variáveis Locais teríamos na memória? 100. Então não se sabe a priori quantas variáveis locais serão 
necessárias. Este número é descoberto na execução. 
 
A variável Global é criada no início do programa e a variável Local é criada durante a execução do 
programa. Enquanto que a variável Local é criada dinamicamente depois que a rotina acaba as variáveis 
são destruídas dinamicamente deixando de ocupar espaço na memória. 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 4 
 
Antes de se chamar a sub-rotina função FAT, não existe N na memória ao chamar a FAT passa a alocar 
o 1º N na memória o 2º N e o 3º N. Ao retornar o valor do 3º N ele é apagado. Assim sucessivamente até 
o 1º N. 
 
A primeira variável local a ser destruída e a última que foi criada e a última a ser destruída é a primeira 
que foi criada. A variável local é criada e destruída no momento da execução. A variável local ativa é 
sempre a última da execução no momento. 
Memória 
N = 3 
 
N = 2 
 
N = 1 
 
O N=1 está ativo ao executar a função FAT do código a seguir: 
 
Function FAT (N:Integer); 
Begin 
If N>1 
 Then 
 Return FAT(N-1)*N 
 Else Begin 
 N:=33; 
 Return 1; 
 End; 
End; 
 
Ao entrar no Else a primeira coisa que é feita é atribuir 33 ao N. O N ativo que era igual a 1 mudou para 
33. Mudou o valor do N=2? Não, pois ele não estava ativo no momento da execução. Vai mudar? Não, 
pois quando o N for igual a 2 não se tem a atribuição deN:= 33. A variável local alterada é sempre a 
que está ativa no momento. 
 
A pilha é a estrutura de dados perfeita para lógica de criação e destruição de variáveis locais. A última 
coisa a empilhar é a primeira a desempilhar. A primeira coisa a empilhar é a última a desempilhar. 
 
A área de dados das variáveis locais é uma pilha. Existe uma parte da memória que é a parte da pilha e 
dentro da pilha tem uma área da pilha. Tem um pedaço com as variáveis já criadas, abaixo é área livre e 
no meio tem o topo da pilha conforme mostra a Figura 1. 
 
Quando uma sub-rotina começa a executar é criada uma variável nova. Então o topo da pilha é 
decrementado de forma a colocar na pilha um novo conjunto de variáveis locais e parâmetros. Por 
exemplo, as variáveis locais N=3, N=2 e N=1. Conforme mostra a Figura 2. 
 
Quando a sub-rotina acabar de executar o que vai acontecer? Desalocação das variáveis locais da sub-
rotina Função FAT, ou seja, o topo é incrementado e volta a ser como era antes da execução dessa sub-
rotina. Onde estavam as variáveis locais N volta a ser área livre da memória da pilha. Conforme mostra 
a Figura 3. 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 5 
 
 
Assim é alocar e desalocar na pilha. Você aloca decrementando o topo e desaloca incrementando o topo. 
A ideia de pilha para o processo poder executar é uma coisa tão importante e fundamental para as 
variáveis locais que as CPUs tem instruções especificas para trabalhar com as pilhas isto por causa das 
variáveis locais. 
 
A Intel tem instruções para o uso da pilha. Push EAX empilha o valor do registrador EAX 
decrementando o topo da pilha. Pop EBX pega o valor do topo da pilha, coloca no registrador EBX e 
incrementa o topo da pilha. Existem mais instruções para lidar com a pilha. Estas são as mais básicas de 
todas. EAX e EBX são registradores. Isto acontece na passagem de parâmetros. 
 
Mov EAX, 3 
Push EAX Exemplo 1 de Linguagem de Máquina 
Call 500 
 
Mov EAX, [1000] (Endereço da variável X) 
Push EAX Exemplo 2 de Linguagem de Máquina 
Call 500 Endereço da Função FAT 
 
No caso da função FAT o EAX será o N. Então a variável local fica em uma área de memória que é 
chamada de área de pilha que é diferente da área das variáveis Globais que é uma área separada. Uma 
parte do processo é o código executável, as variáveis Globais, as variáveis Locais e as variáveis 
dinâmicas. 
 
9) VARIAVEIS DINAMICAS 
 
As variáveis Dinâmicas são criadas pela “vontade” do programador. Ele escreve um comando na 
linguagem para criar a variável. Só depois que este comando é executado que se pode utilizar a variável 
criada. 
 
São alocadas utilizando a instrução NEW em Pascal e MALLOC em C. São variáveis alocadas de 
acordo com a programação feita utilizando as instruções descritas acima. O fato de o programador ficar 
com esta responsabilidade, cria complicações, pois, o compilador não sabe quando essas variáveis serão 
alocadas e desalocadas. 
 
Na memória das áreas ocupadas pelo processo têm a seguinte subdivisão: área de dados, para as 
variáveis globais e dinâmicas, área de pilha, reservada para variáveis locais e área de código. 
 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 6 
 
Um processo contém: CÓDIGO, DADOS (variáveis GLOBAIS, variáveis LOCAIS e variáveis 
DINÂMICA). Códigos, dados, variáveis globais são alocados quando o processo começa a executar, 
dados locais que é usado na pilha, vai alocando os dados conforme o programa executa, quando 
começam a executar são alocados na pilha e variáveis dinâmicas. 
 
 Procedure X 
Var P,Q,R : ^real; 
Begin I := 5; new(P); new (Q); new (R); p^=3,8; 
 
Onde: P, Q e R não são as variáveis dinâmicas, são os ponteiros que apontam para as variáveis 
dinâmicas. A variável dinâmica só passa a existir depois que é feito o loop. P, Q e R são variáveis locais, 
portanto estão na pilha de execução. Nesse programa, existem 4 variáveis locais I, P, Q e R, começando 
a pilha de execução: 
 
5 
 
 
 
 
 
 
Quando fazemos new P : O que pode acontecer? 
1) É alocado um espaço real na heap; 
2) É feito com que P aponte para esse espaço; 
 
 
Nota: 
Heap: local onde são armazenadas as variáveis dinâmicas. A mesma coisa acontece com Q e R, quando 
faz newQ e newR. 
 
Se (ponteiro)P = 3,8, P está referenciando o ponteiro e está usando o valor 3,8 na variável dinâmica 
apontada por P. Quando acabar acontecerá que o programador poderá desalocar as variáveis em 
qualquer ordem, ele não precisa fazer isso na mesma ordem que alocou. 
 
A variável dinâmica normalmente é usada em linguagens de programação mais sofisticadas. Em 
linguagem orientada a objetos tipicamente um objeto é uma variável dinâmica. Exemplo, uma lista 
encadeada de empregados. A seguir o código 1: 
 
Type 
Emp = Relor 
 Matricula: Integer; 
 Nome: String; 
 Prox: ^Emp; //Ponteiro para o próximo registro de Empregado 
 Emp 
 
Procedure 
Var 
P:^ Emp; // Criação de um ponteiro para P 
Begin 
New(P); //Cria a variável dinâmica do tipo Emp e a variável local P passa a apontar para 
3,8 
HEAP I 
P 
Q 
R 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 7 
 
 Esta variável dinâmica criada. 
 
P^.Matricula = 123; 
P^.Nome = „João‟ 
 
As vezes se confundi variável dinâmica com variável ponteiro. P é variável ponteiro ele aponta. P 
dinâmico ele é local fica na pilha. O comando new cria a variável dinâmica que não está na pilha e faz a 
variável local que é o P apontar para a dinâmica. O que é apontar? É guardar o endereço de memória da 
variável. 
 
Temos a memória e dentro da memória temos o processo. Dentro do processo temos a área de pilha e 
tem outro pedaço que é área da variável dinâmica que se chama Heap. 
 
 
 
Conforme mostra a Figura 4 o P é uma variável local por ser local ele fica onde? Na Pilha. Em algum 
lugar na Pilha tem o valor de P. Qual é o valor de P? O endereço. Quando executar o comando o que 
acontece? Na Heap onde ficam as variáveis dinâmicas é alocado em um pedaço dela uma variável 
dinâmica do tipo Empregado. 
 
Digamos que na Pilha a variável local P guarde o endereço 2000. O comando New não apenas reserva 
uma área da memória do Heap para variável dinâmica do tipo Emp, mas também atribui o valor desta 
variável ao ponteiro P. O que é atribuir o valor da variável ao ponteiro? O que é apontar para 
empregado? É colocar o endereço para variável empregado. Isto é apontar. 
 
O comando New faz duas coisas: primeiro aloca um pedaço da Heap para a variável dinâmica e em 
seguida coloca na variável ponteiro o endereço onde foi alocada a variável dinâmica. Então é assim que 
é criada a variável dinâmica. 
 
Além da variável ponteiro e a variável local tem outra variável que fica na Heap que é a variável 
dinâmica. A variável dinâmica não tem nome. O ponteiro é que aponta para esta variável dinâmica que 
tem nome. Para se usar um campo do Empregado tem fazer isto com o a variável ponteiro P. 
 
Em P.Matricula e P.Nome estou atribuindo valores a variável dinâmica. Como ela não tem nome temos 
que usar o ponteiro para os campos da variável dinâmica. No caso de linguagens orientadas a objetos. O 
objeto é uma variável dinâmica, mas é mais escondido. 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 8 
 
 
As variáveis dinâmicas não têm nome, e são armazenadas numa área chamada HEAP. Ao utilizar um 
comando de alocação de memória, uma variável local (p) aponta para uma variável dinâmica contida na 
área de HEAP. P é uma variável local armazenada na pilha. 
 
A área de HEAP seria a quarta área de um processo em muitos SO, como o Win 3.1. No UNIX, há 
somente3 áreas: Variáveis globais, HEAP (locais e dinâmicas) e código. 
 
As áreas de um processo podem estar aglutinadas num só bloco numa área de memória, ou separadas e 
espalhadas na memória. A área de código de um processo não muda, pois foi carregado totalmente e 
compilado na memória. Porém, na área de dados há alterações em valores de endereços, pois as 
variáveis precisam ser amarradas. 
 
Na área de pilha, o topo vai consumindo espaços livres para armazenar dados, até chegar ao limite 
inferior da área de pilha. Quando isto acontece, o HW gera uma interrupção, e podem ocorrer 2 eventos 
de acordo com o SO. 
 
Abortamento do processo ou/e deixar o topo continuar descendo para expansão da área de pilha. Essa 
expansão só é possível se, abaixo da área de pilha, houver área livre. A pilha, na CPU Intel, cresce para 
baixo. 
 
Uma outra alternativa para expansão da área de pilha, seria a copia da área de pilha para uma área livre, 
mas dependerá se o HW terá essa capacidade. Isso acarreta uma re-amarração dos endereços em tempo 
de execução, e é essa a ponte que depende do HW. 
 
É possível fazer essa re-amarração alterando-se o valor dos registradores base, como na CPU Intel para 
que as instruções passem a acessar os novos endereços, sem que o processo seja incomodado. A HEAP 
aloca as variáveis a execução de comandos do tipo NEW, mas só desloca aos comandos DISPODE. 
Logo, é possível que haja espaços livres na heap, no meio da heap alocada. 
 
O código do comando de alocação é quem percebe que a heap está cheia. No Pascal, quando se tenta 
alocar uma variável na heap cheia, a rotina de alocação percebe a exaustão da heap e aborta o processo. 
No Unix, quando a heap esta cheia ou com espaços muito pequenos para alocação de processos, o 
processo faz uma chamada ao sistema para aumentar a área de dados. A área de heap cresce para cima, 
ela não cresce invadindo a área de variáveis globais. 
 
No Windows 3.1, se a heap está cheia pode-se alocar outra área de dados para servir como uma segunda 
heap. Os dados na heap são alocados numa certa seqüência, porém, nem sempre as variáveis ficam 
alocadas seqüencialmente. 
 
As áreas de código contem uma parte resultante do código-fonte do processo e uma parte que já é 
pronta, que contem as rotinas das bibliotecas do compilador. A parte que vem da biblioteca não vai toda 
para a área de código, somente as partes da biblioteca utilizadas pelo processo. 
 
Ao se carregar o programa na memória, não se sabe onde ficarão as áreas de códigos dos processos, nem 
a área de código da biblioteca compartilhada. A partir do momento em que se sabe a posição do código 
da biblioteca, se faz a correção dos endereços das chamadas as rotinas da biblioteca. A correção desses 
endereços de biblioteca é diferente da correção de código comum. As instruções que contem referencias 
a rotinas da biblioteca são marcadas pelo executável para correção de endereço, e tem marcado o 
numero da rotina sendo chamado na biblioteca. Ao carregar a biblioteca na memória, o linker passa a 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 9 
 
saber a posição das rotinas na memória, então ele checa a posição da rotina sendo chamada e substitui 
na chamada. 
 
10) DIFERENÇA ENTRE VARIÁVEIS LOCAIS E DINÂMICAS 
 
As Variáveis locais tem um seqüenciamento muito claro de alocação e desalocação quando a rotina 
começa a rodar, são alocadas todas as variáveis locais para essa rotina, quando a rotina acaba de rodar, 
são desalocados na mesma ordem em que foram alocadas. 
 
Nas variáveis dinâmicas o programador pode escolher a ordem de desalocação, não seguem a ordem de 
pilha como nas locais. Não dá para usar uma pilha para alocar variáveis dinâmicas. A grande diferença é 
o sequenciamento. 
 
O ponteiro guarda o endereço na memória. A variável é aquilo para qual o ponteiro aponta. O ponteiro 
contém o endereço e esse endereço aponta para a variável dinâmica alocada na heap. A variável 
dinâmica é aquilo que foi alocado na heap. O grande ponto: a heap não é uma pilha. A heap é a 3ª área 
diferente de dados. 
 
11) DIFERENCIAÇÃO ENTRE O PONTEIRO E A VARIÁVEL DINÂMICA EM UMA 
LINGUAGEM OO TRADICIONAL 
 
Type 
L_Emp = Class 
 Public 
 Matricula: Integer; 
 Nome: String; 
Prox: L_Emp 
End; 
 
Procedure X; 
Var 
E: L_Emp; 
Begin 
E:= New L_Emp; // A variável E é um ponteiro para o endereço da variável L_Emp 
E.Matricula:= 123; 
E2:=E; // Neste caso ambas as variáveis estão apontando para o mesmo endereço 2000 
E2.Matricula:= 567; 
 
Na linguagem OO não temos o ponteiro explícito. A linguagem OO esconde o ponteiro. Embora a 
linguagem OO não tenha o ponteiro como uma coisa explícita na linguagem o código na linguagem de 
máquina do código 1 e 2 é o mesmo. Nos dois casos você tem uma variável ponteiro. 
 
Se for criada outra variável, por exemplo E2 e atribuir ao E. Se alterar o valor de E2 altera o valor da 
matricula do próprio E, pois o objeto é um só. E e E2 são ponteiros que apontam para o mesmo 
endereço. 
 
Quando se atribui E ao E2. O que está acontecendo? Estou copiando o valor do E que é 2000 para o E2. 
Ambas as variáveis apontam para o mesmo endereço 2000. Embora a linguagem OO não tenha 
ponteiros explícitos eles estão lá. 
 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 10 
 
Type 
 Emp = Relo 
 Matricula: Integer; 
 Nome: String; 
 Prox:^ Emp; 
 Emp 
 
Procedure X; 
Var 
P1, P2:^ Emp; 
Begin 
New(P); 
P^.Matricula:= 123; 
P^.Nome = „João‟; 
New(P2); 
P2^.Matricula = 567; 
... 
Dispose(P) //Destruindo a variável dinâmica apontada por P 
 
 
Em linguagem de programação mais antiga você tem o comando de alocação/criação que é o New e 
você tem também o comando de destruição da variável dinâmica. O que é destruir a variável dinâmica 
apontada por P? É tornar a área da Heap livre. O que está acontecendo? A Heap é uma coisa diferente da 
Pilha. A Heap pode ter lugres ocupados e lugares livres. 
 
Então, a área da Heap funciona diferente. Você é obrigado ter áreas diferentes para cada uma das 
variáveis. A Heap não tem ordem correta para alocação da variáveis, pois depende do programador. Ele 
vai determinar quando cria e quando destrói a variável dinâmica. Então pode ficar bagunçado? Não. 
Fica uma coisa misturada. 
 
Para as três formas de se usar a variável temos três áreas de memória do processo. Uma para as variáveis 
Globais, uma para as variáveis locais e outra para as variáveis dinâmicas. Esta é a forma mais completa 
do processo. 
 
Temos três áreas distintas à área de código, área de variáveis globais, área das variáveis locais (Pilha) e 
área das variáveis dinâmicas (Heap). No caso do Unix eles simplificam um pouco isto. Então no Unix 
duas variáveis estão condensadas em uma só área. Existe uma área de dados que é igual as variáveis 
globais mais a Heap. 
 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 11 
 
Dá para ajuntar, pois não temos maiores problemas. As globais são bem comportadas. Como fica no 
Unix? Fica conforme mostra a Figura 6, um exemplo de alocação sequencial do processo na memória. 
 
 
 
Então são três áreas: Código, Dados e Pilha. Os dados condensam as Globais e a Heap. Uma coisa 
importante é que dentro dessas áreas além das variáveis alocadas dinamicamente tem as áreas livres. 
Tanto na Heap quanto na Pilha. Você tem dentro delas áreas livres para alocação de variáveis locais (no 
caso a Pilha) e variáveis dinâmicas (no caso a Heap). 
 
Mas, além das áreas livres internas no processo existem as áreas livres externas ao processo. As áreas 
livres externas ao processo servem para alocação de novos processos. As áreas livres internas ao 
processo são para as variáveis locais e dinâmicas que o processovai precisar. Assim é a organização dos 
processos na memória. Este exemplo fala da alocação dos processos de forma continua é a forma mais 
fácil de fazer e mais simples. 
 
As áreas de memória do processo código, Pilha e dados. Elas podem ser alocadas separadamente na 
memoria conforme mostra a Figura 7, pois não precisam estar sequencialmente. Qual a vantagem de 
alocar separadamente? É mais fácil encontrar uma área livre. Se existe uma regra que obrigue as áreas 
do processo serem alocadas juntas isto restringe um pouco a alocação. 
 
Por exemplo, queremos alocar um processo de 300 KB é mais fácil encontrar três pedaços de 100 KB de 
área de memória livre do que um único espaço de 300 KB na memória. Então exigir que as três áreas do 
processo sejam alocadas juntas é uma desvantagem, pois dificulta a alocação de processos. 
 
É uma vantagem alocar separadamente as áreas dos processos. A outra vantagem de alocar dessa forma 
é que se tem mais chance de crescer as áreas do processo quando necessário se tiver área livre. Se for 
profissional o módulo de alocação é separado. Para uma questão didática o modelo junto é mais 
utilizado, pois é mais fácil. 
 
Uma questão que deve ser resolvida pelo Sistema Operacional é a questão de alocação dos novos 
processos. Esta questão existe tanto no caso de alocação do processo junto quanto no caso separado. 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 12 
 
 
 
A alocação não sequencial do processo na memória é melhor do que a alocação sequencial porque é 
mais fácil encontrar áreas livres de memória. 
 
12) CONCLUSÃO 
 
Quatro tipos de área diferentes de um processo: 
- Área onde está o código executado; 
- Área onde estão os variáveis globais (que mais são utilizadas); 
- Área de variáveis locais que são alocados dinamicamente; 
- Variáveis dinâmicas. 
 
No caso do UNIX juntou duas e agora são três áreas: 
- Área do código executável; 
- Área de pilha (que contém a pilha e variáveis locais); 
- Área de dados (contém variável global e a heap. Juntou globais e dinâmicas). 
A partir do conceito acima podemos concluir que o processo fica todo contido na memória e podemos 
ter o mesmo processo em várias partes da memória. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SO 
////// 
D1 
P1 
P2 
C2 
C1 
D2 
3 áreas do processo P1 
3 áreas do processo P2 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 13 
 
Como essas áreas sofrem alteração? 
 
Área de Código 
 
Faz sentido ser modificado? Sim, durante a execução do programa. Esses programas geram códigos que 
são incorporados a eles mesmos. Mas isso não é muito comum. 
 
Os programas automodificáveis eles precisam ter alteração na área de código, uma vez que o programa é 
carregado na memória e vira processo essa área vem a ser modificada e é por causa disso que desde que 
o hardware permita, essa área fica inibida, impedindo que o processo faça modificação nessa área e se o 
processo tentar fazer ele é abortado. Então, geralmente, a resposta à pergunta acima é Não. É 
proibida a modificação dessa área. Se o próprio processo ou outro tentar alterar a área de código o SO 
abortará a execução desse processo. 
 
Área de Pilha 
 
Sofre modificação? Sim, pois as varáveis locais podem ser modificadas. A área de pilha é alterável. Não 
apenas isso. Dentro da área de pilha tem um ponteiro que aponta para um lugar dentro da área que esse 
ponteiro se chama topo da pilha e no caso da Intel que tudo que está abaixo dos outros está livre, só a 
parte de cima tem variáveis. 
 
Quando uma rotina se inicia (o que significa alocação? Significa que descer um pouco do topo), quando 
a rotina acaba, é solto o topo da pilha, quer dizer que a rotina acabou. A CPU de 30 anos pra cá, tem 
uma função específica para manipular o topo da pilha (mais básicas: paste e copy). 
 
Nessa área de pilha o valor muda, muda a área total, vai mudar o valor de dentro. Outra coisa é, pode ter 
um programa que tenha um tempo de execução muito grande, ou um programa que tenha variáveis 
locais muito grandes, pode acontecer quando a rotina entra o topo desce, se uma rotina é muito 
recursiva, cada vez que tem uma recursão o topo desce um pouco e assim por diante tem uma hora que o 
topo da pilha vai bater no limite dela, então aborta o processo, isso é o stack overflow. 
 
Nos SO‟s mais sofisticados, antes de abortar um processo o SO tenta aumentar a área da pilha, se 
conseguir crescer não aborta o processo se crescer não tem jeito (ex: Unix). Alterável à medida que são 
incluídas/excluídas/alteradas as variáveis locais nessa pilha. 
 
Se uma rotina tem muita recursão, pode acabar com o espaço na pilha, causando o estouro da pilha (a 
maioria dos SOs abortam o processo – ex.: Windows 3.1). O Unix tenta aumentar o tamanho da pilha ao 
perceber que o espaço disponível da pilha chegou ao fim. 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 14 
 
 
 
 
Visão de uma pilha da arquitetura Intel: 
 
 
 
 
 
 
Tentativa de liberar espaço para pilha: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Área de dados 
 
 
 
 
 
No Unix essa área contém variáveis globais e dinâmicas (heap): Conforme o programa vai sendo 
executado vai sendo alocados e desalocados variáveis dinâmicas, ou seja, será feito o new no Pascal ou 
malloc no C/C++, e “dispose” no Pascal ou free no C/C++ respectivamente. 
 
Se o programa utilizar muitas variáveis dinâmicas, em algum momento, é possível que não tenha mais 
espaço para alocar essas variáveis, nesse caso, pode abortar ou tentar crescer o tamanho da área, ou seja, 
o SO pode tentar crescer a área de pilha. 
 
1) Quem sabe se a heap tem ou não espaço é o processo, o SO não se envolve. 
2) O Windows pode ter mais de uma heap. 
3) Na área de pilha e de dados do Unix, elas são alteráveis (conteúdo) e o tamanho também. 
/////// 
globais 
heap 
Topo 
Variáveis 
 
Área livre 
Topo 
 
Área livre 
Topo Topo 
Variáveis 
 
Área livre 
Topo 
 
Variáveis 
Área livre 
Variáveis 
Topo 
Variáveis 
Nova área 
livre 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 15 
 
 
 
 
2) 
 
 
 
 
 
 
No Unix ao invés de abortar o processo, provocando o erro de stack overflow, ele aumenta a área de 
pilha, caso não consiga ocorre o erro descrito anteriormente. Desse tipo de concepção foi inventada uma 
forma de organizar a memória, a quantidade de áreas que o processo possui. Essa forma de organizar a 
memória é chamada segmentação. Se houver muitas variáveis dinâmicas, pode ser que cause falta de 
espaço na heap. 
 
O que pode acontecer? 
- Aborto do processo 
- Tentativa de expansão da área da heap através de uma solicitação da rotina new (no Pascal) ou malloc 
(no C), que percebem a falta de espaço na heap (Unix). 
 
O Unix pode reservar inicialmente um espaço livre em comum para a pilha e/ou dados usarem à medida 
que elas forem precisando. O processo não se divide na memória. 
 
 
 
 
 
 
 
 
 
 
 
 
Quando um processo chega e precisa de memória, é feita uma busca no conjunto por um bloco que seja 
grande o suficiente para o processo. Se o bloco for grande demais, ele será dividido em dois: uma parte 
é alocada ao processo que chega; a outra é devolvida para o conjunto de blocos. 
 
O problema de alocação de memória dinâmica consiste em como atender a um pedido de tamanho n de 
uma lista de blocos de memórias livres. As estratégias de first-fit, best-fit e worst-fit são as mais 
comumente usadas para selecionar um bloco de memória livre do conjunto de blocos disponíveis.13) FRAGMENTAÇÃO DA MEMÓRIA (PROBLEMA DA ALOCAÇÃO DE MEMÓRIA) 
 
Conforme mostra a Figura 10, os espaços de área livre que sobram ao alocar um processo pelo algoritmo 
de alocação são chamados de Fragmentação. 
P 
//// 
D 
C 
Processo 1 
Pilha P 1 
Área livre para 
Pilha/Dados 
P 1 
Dados P 1 
Código P 1 
Processo 1 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 16 
 
 
 
O First Fit tem esta característica embora ele seja muito rápido ele pode gerar fragmentos. 
 
Tenho uma memória disponível tem que alocar a memória dentro dessa memória disponível e o pedaço 
alocado tem que ficar indisponível. Com isso, cria situações que podem gerar o impedimento do 
surgimento de processos. Se tiver muitas alocações e desalocações o que pode acontecer é que terá 
muitas áreas disponíveis pequenas e separadas umas das outras, se eu precisar alocar uma nova área que 
seja maior que qualquer área dessa eu não vou conseguir, apesar da soma de cada área ser maior do que 
a área que eu quero alocar. Esse problema se chama Fragmentação de Memória. 
 
Se houver muitas alocações/desalocações na memória, pode acabar causando o surgimento de várias 
áreas disponíveis na memória mas pequenas demais para caber os segmentos de um processo apesar da 
soma dessas áreas serem, muitas vezes, maiores que o espaço que um processo precisa. Esse problema é 
chamado de fragmentação. 
 
Como se resolve esse problema? 
1) Utilizar compactação; 
2) Evitar que aconteça. 
 
1ª solução: deslocar as áreas livres e ocupadas de forma que as áreas livres fiquem todas juntas 
(compactação). 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Processo 1 
Problema: A 
movimentação das 
áreas dos processos 
depende do HW. 
 
 
 
 
Na segmentação pode 
ser feita a 
SO 
Área livre 
Processo 2 
Área livre 
Processo 3 
Área livre 
Área livre 
Processo 1 
50000 
 
45000 
 
40000 
 
35000 
 
31000 
 
25000 
 
22000 
 
20000 
 
0 
 
SO 
Processo 3 
Processo 2 
Área livre 
50000 
 
45000 
 
40000 
 
34000 
32000 
 
 
 
 
 
 
 
 
0 
 
Antes da compactação Depois da compactação 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 17 
 
 
2a solução: Tentar evitar que a fragmentação ocorra. 
 
Para isso deve ser usada um algoritmo de alocação de área a um processo de forma que as áreas livres 
sejam poucas e as menores possíveis. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O Algoritmo Worst Fit é o algoritmo que escolhe a maior área disponível. Nesse exemplo, a área livre 
escolhida por esse algoritmo seria a área que começa no endereço 25000 e termina no endereço 31000 
(tamanho 6000). Ao alocar os 3500kb necessários para o processo X, sobraria 2500 Kb para outro 
processo utilizar. 
 
Mas esse algoritmo pode causar o seguinte problema: Se um processo precisar de 6000 kb para ser 
alocado na memória, vai acabar não conseguindo, pois não há uma área desse tamanho para ele. A 
solução seria fazer uma compactação. 
 
O Worst Fit tem uma variação: se existir uma área com o tamanho exato, ela será usada. Se não tiver, 
use a que tem o maior tamanho. 
 
O 3o algoritmo é o First Fit que utiliza a 1a área grande o suficiente para caber o processo. No exemplo 
acima, a área livre que o SO utilizaria para alocar o processo seria a que começa no endereço 5000 (que 
tem um tamanho de 5000). 
 
O First Fit tem uma variação: o Next Fit ou Circular Fit verifica a 1a área livre grande o suficiente para 
alocar o processo a partir da posição de memória alocada para o último processo. 
 
Todos os três algoritmos verifica todas as áreas disponíveis para ver qual área se adequa melhor ao 
algoritmo. A verificação pode demorar se houver muitas áreas livres. O SO mantém uma lista de todos 
Um processo novo precisa de uma área de memória 
de tamanho 3500. 
 
Qual das áreas livres pode ser escolhida? 
 
O algoritmo Best Fit escolhe a área que tem o 
tamanho igual ou um pouco maior do que a área 
necessária para o processo. 
 
Nesse exemplo, a área livre escolhida por esse 
algoritmo seria a área que começa no endereço 35000 
(que tem um tamanho de 4000). 
Note que nesse caso causaria uma fragmentação pois 
utilizando uma área de 3500 na área de tamanho 
4000, vai acabar sobrando 500, área essa 
possivelmente pequena para a inserção de um novo 
processo. 
 
 
 
Processo 4 
Área livre 
Processo 2 
Área livre 
Processo 3 
Área livre 
Área livre 
Processo 1 
50000 
 
45000 
39000 
 
35000 
 
31000 
 
25000 
 
21000 
 
20000 
 
10000 
 
 5000 
 
 2000 
 
 0 
SO 
Área livre 
Processo 5 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 18 
 
as áreas livres disponíveis na memória (ordenado pelo endereço inicial) com seu endereço inicial e 
tamanho. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Se for alocado/desalocado um ou mais espaços livres (por inteiro ou não), o SO deve atualizar a lista dos 
espaços livres para refletir o estado da memória. 
 
Uma solução para o problema da fragmentação externa é a compactação. A meta é trocar de posição o 
conteúdo da memória para reunir toda a memória livre em um grande bloco. Se a relocacao é estática e 
for feita no momento de montagem ou carga, a compactação não poderá ser feita. A compactação só 
será possível se a relocacao for dinâmica e for feita em tempo de execução. Quando a compactação é 
possível, devemos determinar o seu custo. O algoritmo de compactação mais simples consiste em mover 
todos os processos em direção a um lado da memória; todos os blocos livres se movem na outra direção, 
gerando um grande bloco de memória disponível. Outra solução possível para o problema de 
fragmentação externa é permitir que o espaço de endereçamento lógico de um processo seja não 
contíguo, possibilitando que um processo receba memória física onde ela estiver disponível. Solução: 
Paginação e segmentação. 
 
14) ALGORITMO DE ALOCAÇÃO (Para evitar a Fragmentação da Memória) 
 
Então o problema é que tenho mais de uma área livre. Em qual área livre irei usar para alocar o 
processo? Tem vários algoritmos de alocação. Veremos alguns tipos de algoritmos de alocação. 
 
A Figura 8 a seguir mostra os processos 1 de 100 KB, o processo 2 de 200 KB, e o processo 3 de 80 KB, 
o processo 4 de 100 KB e a área livre de 200 KB. Quando o processo acaba sua execução a área de 
memória que ele ocupava fica livre. 
 
0 3000 
4000 1000 
9000 3000 
End. 
Inicial 
da 
Área 
Livre 
Tam. 
da 
Área 
Livre 
Ponteiro 
para a 
próximo 
item da 
lista 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 19 
 
 
 
Digamos que os processos 1 e 3 acabaram sua execução e liberaram a memória. Então temos três áreas 
livres (100 KB, 80 KB e 200 KB). Temos agora um processo 5 com 80 KB. Temos que fazer uma 
escolha. Onde alocar o processo 5? Temos três áreas livres de memória. Esta escolha é feita pelo 
algoritmo de alocação. 
 
14.1) ALGORITMO DE ALOCAÇÃO FIRST FIT 
 
Aloca o bloco na primeira área livre que encontrar. Não procura áreas livres na memória. Assim é mais 
rápido. Porém gera áreas livres de tamanho variado na memória. Começa a procurar no espaço seguinte 
à última alocação. 
 
Utilizando o algoritmo de alocação First Fit ele vai alocar aonde? No primeiro lugar que encontrar de 
área livre que caiba o processo (ou uma das áreas do processo). Então alocará no 100 KB, ou seja, onde 
estava o processo 1. O processo 5 ocupará 80 KB e sobrará 20 KB de área livre que não será utilizada. 
Isto é um desperdício conforme mostra a Figura 9. 
 
 
SISTEMA OPERACIONAL II – REVISÃO PARTE2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 20 
 
 
Alocar uma área e deixar um pedaço livre não é muito interessante, pois muitas vezes o pedaço pequeno 
não é o suficiente para alocar um novo processo. A área que sobra neste caso, 20 KB fica sem uso 
porque nada novo consegue ser alocado nela. 
 
14.2) ALGORITMO BEST FIT 
 
Existe outro algoritmo que é mais sofisticado que se chama Best Fit que tenta alocar na área de tamanho 
mais próximo ao que se quer inserir na memória. 
 
Este algoritmo pesquisa entre as áreas livres de memória o espaço mais adequado para alocar o 
processo. Exemplo, alocar o processo 5 de tamanho 80 KB. Tem um espaço adequado para alocar 80 
KB? Tem. A área de 80 KB ao invés de alocar na área de 100 KB. Conforme mostra a Figura 11. 
 
 
 
Agora digamos que o processo 5 tenha 60 KB. Onde alocar este processo? Este processo será alocado 
onde melhor se adeque, ou seja, na área livre de 80 KB. Conforme mostra a Figura 12. Neste caso, sobra 
20 KB que é um desperdício (fragmento). 
 
 
 
First Fit pesquisa a partir do “zero” da memória e o Next Fit é a partir da última alocação na memória. 
 
 
 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 21 
 
14.3) ALGORITMO WORST FIT 
 
A ideia do Worst Fit é a seguinte aloca-se a área de tamanho exato se existir. Se não existir uma área de 
tamanho exato então ele aloca a maior área encontrada. Este algoritmo tenta alocar na área de tamanho 
mais afastado do que se quer inserir na memória. Faz o worst se não existir espaço de tamanho exato. 
Começa a procurar área livre no início da memória. 
 
Conforme mostra a Figura 13, queremos alocar um processo de 60 KB. Como não existe uma área de 
memória com este tamanho exato. O Worst Fit aloca a maior área livre de memória encontrada que é de 
200 KB sobrando 140 KB de área livre. 
 
 
O Worst Fit não gera fragmento porque quando ele não encontra uma área de memória de um tamanho 
exato ele aloca a maior área e o que sobra é um tamanho grande. Embora ele seja bom ele não é tão bom 
assim. Por quê? Digamos que se tenha um processo 7 de 150 KB. 
 
Ele poderia ser alocado na área livre de 200 KB e sobraria 50 KB, mas como o Worst Fit já matou a área 
livre de 200 KB (a área maior) o processo 7 não poderá ser alocado neste espaço. E o Worst Fit é pior 
para este caso. 
 
Então não dá para dizer de forma eficiente qual destes algoritmos é o melhor. O que dá para dizer é que 
o First Fit é o mais rápido para executar e implementar do que os outros algoritmos Best e Worst. 
 
No caso de alocar o processo por áreas separadas temos o mesmo problema e utiliza-se os mesmos 
algoritmos de alocação. E este mesmo problema existe dentro da área de Heap, pois tem espaço livre e 
alocado. Na Heap é alocado as variáveis dinâmicas, mas temos o mesmo problema de alocar memória só 
que o espaço é menor. 
 
Quem controla o espaço da Heap é a própria linguagem de programação e não o Sistema Operacional. O 
Windows até tem suporte para isto, mas normalmente é a própria linguagem de programação que gera o 
código de alocação executa internamente o algoritmo segundo o fabricante da linguagem escolheu para 
implementar. 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 22 
 
 
 
14.4) CONCLUSÃO 
 
Memória 
 
 
 
 
 
 
 
 
 
 
 
 
 
No esquema acima têm cinco áreas livres, cada uma com os seguintes tamanhos: 3000, 5000, 8000, 
4000, 2000 respectivamente. Se o processo alocar uma área de 4000 na memória não haveria 
fragmentação, pois ele ocuparia a área livre de tamanho 4000. O problema é se tentar alocar um bloco 
de 3500, pois sobrará um espaço de 500, pequeno demais para poder ser alocado por outro bloco, é o 
que o algoritmo Best Fit faz. 
 
O que pode ser feito é tentar alocar em um bloco maior e assim sobrar um pedaço maior para que possa 
ser alocado por outro bloco, por exemplo, alocar no bloco de 8000 sobrando 4500, que é o que o 
algoritmo Worst Fit faz. Mas, agora se quiser alocar um processo de 6000, por exemplo, não tem mais 
área com tamanho maior ou igual para este processo, o que vai ter que fazer é a compactação. Não 
existe um algoritmo prático para alocação. 
 
Pode ser uma coisa custosa procurar o espaço que melhor se adapta. Por isso, existe outro algoritmo que 
coloca o processo no primeiro espaço livre encontrado que couber este processo. Este algoritmo é o 
First Fit. 
 
Dentro do sistema operacional existe uma lista encadeada com os espaços livres da memória para 
controlar esses espaços livres. Como mostra o esquema abaixo: O endereço de início 0 e tamanho 3000 
aponta para o endereço inicial 10000 de tamanho 5000 e este aponta o endereço inicial 25000 de 
tamanho 8000 e este aponta para o endereço inicial 40000 de tamanho 4000 e por último o endereço 
inicial 60000 de tamanho 2000. 
SO 
 
 
 
 
 
 
 
 
 
 
 
3000 
5000 
8000 
4000 
2000 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 23 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Os problemas e as soluções da alocação de memória são utilizados tanto para processos como para 
variáveis dinâmica, onde quem controla isto é o sistema operacional e a biblioteca padrão, e nesta última 
contém as informações sobre o que foi alocados na heap e etc. 
 
15) COMPACTAÇÃO 
 
Deslocamento de todas as áreas para acabar com os buracos; Juntaria todas as áreas e formaria um 
espaço livre maior capaz de ser alocado para um novo processo. Isso é chamado de compactação. 
 
Exemplo: A memória contém cinco processos (P1, P2, P3, P4 e P5) e entre eles tem uma área livre. A 
compactação vai juntar essas áreas. Na tabela de segmento o início do processo P5, que antes era 40000 
passa a ser 32000, o seu tamanho permanece em 5000, assim como se trata do último processo alocado 
na memória, o endereço inicial da área livre é 37000. 
 
Memória Memória 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
É o hardware que permite a compactação da memória. E esta compactação é acionada quando um 
processo deseja ocupar a memória e não tem área disponível, o SO toma a iniciativa da compactação da 
memória. 
 
Início Tamanho Próximo 
0 3000 
 
Início Tamanho Próximo 
10000 5000 
 
Início Tamanho Próximo 
25000 8000 
 
Início Tamanho Próximo 
40000 4000 
 
Início Tamanho Próximo 
60000 2000 
 
SO 
 
P5 
 
P4 
 
P3 
 
P2 
 
P1 
 
SO 
 
P5 
P4 
P3 
P2 
P1 
 
Compactação 
40000 
45000 
32000 
37000 
Ínicio Tamanho 
40000 5000 
 
Tabela de Segmento antes 
da Compactação 
Ínicio Tamanho 
32000 5000 
 
Tabela de Segmento 
depois da Compactação 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 24 
 
O mesmo problema ocorre para alocação de variáveis dinâmicas dentro de área de heap de um processo. 
E como solução é compactar a memória. Neste caso, para correção dos endereços tem que ser possível 
saber onde estão os ponteiros das variáveis dinâmicas. O Java consegue fazer isto, mas o C, Pascal não 
conseguem. 
 
 
 
 
 
 
 
 
 
 
A vantagem da segmentação é poder fazer a compactação e apenas trocar o endereço inicial do 
segmento na tabela de segmento, pois o deslocamento e o tamanho são os mesmos. Para se chegar ao 
endereço final da posição da memória o hardware tem somar o início do segmento mais deslocamento. 
 
Problemas da compactação: 
1) Mover memória; 
2) Depende de o hardware mover a posição que a área de determinado processo ocupa sem que o 
processo saiba que isso aconteceu, nem sempre é possível de ser feito. No caso de 
segmentação é possível, desde que todas as tabelas de segmentosreflitam a nova posição de 
cada segmento. 
 
A outra forma é tentar evitar (2) que a fragmentação ocorra e para isso existem algoritmos, e cada um 
tem seu objetivo, para a escolha de área livre, que é uma área que minimize a fragmentação. 
 
Conforme mostra a Figura 14. A compactação junta todos os processos e toda área livre na parte de 
baixo da memória e acima junta todas as áreas livres. A compactação tem um problema que é a 
mudança dos endereços dos processos e das suas respectivas áreas. 
 
Digamos que o processo 7 tem uma variável global que estava no endereço 65000 após a compactação 
seu endereço foi modificado. Então a mera compactação simples não vai funcionar. 
 
Figura 14 
 
Pilha 
 
 
 
 
 
Dados 
Código 
 
Heap 
 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 25 
 
Não adianta fazer somente a compactação. Precisamos alterar os ponteiros para os novos endereços de 
memória. A compactação exige que se tenha mecanismos para modificar os endereços, pois senão dará 
problemas. 
 
O sistema operacional tem condição de corrigir o endereço perdido. Uma coisa que ele pode fazer é 
apontar o endereço de carga. Ele pode corrigir a carga e pode corrigir o endereço. O problema é que os 
sistemas operacionais de hoje em dia não sabem dentro da área de memória do processo onde estão as 
variáveis do ponteiro. 
 
O sistema operacional sabe na hora da execução onde estão os endereços. Ele não sabe dentro da área de 
memória dos processos onde estão os ponteiros. Em um esquema como este a compactação não pode ser 
usada, pois o sistema operacional não sabe corrigir a variável de ponteiro. 
 
A compactação nem sempre pode ser implementada. Neste caso não pode. Porém, existe outro caso que 
é o caso do registrador de base. 
 
15.1) COMPACTAÇÃO COM O REGISTRADOR DE BASE 
 
O endereço será feito a partir do registrador de base. Durante a execução o valor de deslocamento e 
somando ao valor do registrador de base gerando o novo endereço. Assim, a compactação vai funcionar, 
ou seja, com o registrador de base é possível compactar sem ele não é possível, pois não consegue 
recuperar o endereço da variável ponteiro. 
 
Para o caso dos processos alocados por áreas? A base não é única. Algumas CPUs permitem várias 
bases. A Intel permite três bases. Uma base para área de código, uma base para área de dados e outra 
base para área de Heap. Tem três registradores de base diferentes um para cada área. 
 
16) FALTA DE MEMÓRIA 
 
Quando o usuário quer executar processos que não cabem na memória da máquina. Isto pode acontecer 
quando: 
 Um processo executado for maior do que a memória da máquina; 
 Ou a soma dos tamanhos de cada processo que se quer executar na máquina é maior que a 
memória desta máquina; 
 O tamanho total dos processos é maior que o tamanho da memória que está disponível. 
 
17) MECANISMOS PARA LIDAR COM A FALTA DE MEMÓRIA 
 
Existem casos que se tem memória livre, mas está separada. Digamos que temos uma memória com 200 
KB livre. Criou um processo novo de 100 KB. Criou um processo de 80 KB. Ficou sobrando 20 KB. 
Cria um processo novo de 100 KB. Não vai dá, pois sobrou só 20 KB. A memória está insuficiente para 
rodar o processo de 100 KB. 
 
Então isto é um problema? Em teoria é. Hoje em dia temos memórias grandes (4 GB). Vai existir um 
caso que os processos na memória a soma seja mais de 4 GB. Hoje em dia isto fica muito improvável de 
acontecer. O problema de memória insuficiente é antigo e hoje em dia acontece muito menos. O 
tratamento das imagens digitais só foi possível a partir do momento que passamos ter mais memória na 
máquina para guardar a imagem na memória. 
 
SISTEMA OPERACIONAL II – REVISÃO PARTE 2 – AULA 13/11/2012 
 
Elaborado por Luciana SA Amancio Merge com material da Soraia – 2013/01 Página 26 
 
Hoje em dia o caso que faz sentido de uso de muita memória é a edição de vídeo. Neste caso a memória 
pode encher e é preciso ter um mecanismo para não dá erro para você. Então, embora isto fosse mais 
comum no passado é importante ter hoje em dia. Isto pode acontecer no computador pessoal e no 
servidor. 
 
Resolve-se o problema de falta de memória através de mecanismos. Usa-se o disco ou gasta menos 
memória.