DeadLock..........................................................................................................................

1
Estágios para Tratar o problema de deadlock................................................................2
Prevenir...............................................................................................................................2
Evitar...................................................................................................................................2
Detectar e Recuperar............................................................................................................2
Gerência de Memória......................................................................................................3
1) Sistema Monoprogramado........................................................................................3
Alocação Contígua e Inteira.................................................................................................3
2) Sistema Multiprogramado (Princípio de Alocação Inteira e Contígua )...................4
2.1) Partições Fixas..............................................................................................................4
2.2) Partições Variáveis.......................................................................................................4
Swapping.......................................................................................................................5
Processos que sofreram Swapping.......................................................................................6
Multiprogramação com Swapping.......................................................................................6
2.3) Sistema Multiprogramado (Alocação não Inteira e Não Contígua)..............................7
2.4) Paginação.....................................................................................................................8
Mecanismo de Tradução de endereços.................................................................................8
TLB...................................................................................................................................10
O que tem em uma entrada da tabela de páginas?..............................................................11
Paginação por Demanda....................................................................................................12
Técnica de Prefect..............................................................................................................12
Fragmentação de uso.........................................................................................................12
2.5) Segmentação...............................................................................................................13
Mecanismo de Tradução de Endereços..............................................................................14
O que tem em uma entrada da tabela de segmentos?.........................................................15
Paginação x Segmentação..................................................................................................15
2.6) Segmentação Paginada...............................................................................................16

DeadLock
Erro de sincronia de threads, processos.

Os processos vão se bloquear eternamente.

P1 pede à fita pra imprimir

Bloqueado esperando P2 fita

P1 P2
Fecha o
ciclo
Não pode acontecer

P2 pede a impressora,
bloqueado na fila esperando
impressora P1

1
Dos recursos (ex.: impressora) que não são compartilháveis, o SO tem que alocar o
recurso se vc pedir um que já está sendo alocado. O SO coloca na fila.

Neste caso, não é reeo de programação. Não sei que outro processo pediu impressora.
Este tipo de deadlock o SO tem que tratar.

Estágios para Tratar o problema de deadlock

• Prevenir: Tomar medidas a priori que garantam que o deadlock não ocorra
nunca.
• Evitar
• Detectar e recuperar

Prevenir
Ciclo de segura e espera: garantir que nunca aconteça.
1. Se eu estiver segurando um recurso, e precisar de outro, libero o 1º.
2. Espero por todos os recursos. Quando todos estiverem liberados, aí eu seguro.
(mais ineficiente)

Evitar
Não posso segurar um recurso de ordem menor pra não deixar o ciclo fechar.

R0

R6
R1

R5
R2

R4
R3

Detectar e Recuperar
De tempos em tempos rodo um algorítmo para ver se houve deadlocks.
1ª Opção: matar o processo
2ª Opção: desalocar todos os recursos de um processo

O que pode acontecer (1ª Opção)?

Ex.: Escrevendo um arquivo
- Arquivo inconsistente
Rollback
Se matei P2, voltar atrás tudo que p2 fez.
SO mantém um histórico de coisas que não podem
ficar inconsistentes.

2
Gerência de Memória
Outro módulo do SO que gerencia a memória principal.

O que é para o SO gerenciar o recurso Mem. Principal?

1) Sistema Monoprogramado
Como é o gerenciamento de memória?
Quase não tem, muito simples. A memória é toda do programa, tirando a área do
SO.

Espaço reservado pro SO

SO

P1 Código e dados do único

processo

Preciso de um mecanismo de proteção de memória para garantir que o processo não vai
acessar a área do SO.

Ex.: DOS – monoprogramado. Pedia 1 coisa de cada vez.

Alocação Contígua e Inteira

• Todo código numa área única e contígua.
• Toda área de dados numa área única e contígua.

Por quê todo código numa área única e contígua?

Por causa do incremento do PC

E a área de dados?

Se o programa não cabe na memória:

1ª opção: Não roda
2ª opção: OVERLAY – Se o código for extremamente estruturado, pode ser
dividido em áreas independentes e dizer para o SO que são independentes.
Não é possível fazer isso com todos os programas, depende do programador e do
compilador conseguirem dividir o código assim.
O SO carrega colocando um por cima do outro quando o outro acabar.
Fica mais lento: mas o problema não é desempenho aqui, pois o programa não
caberia na memória. Quem determina as partes é o compilador, quem faz é o SO.

3
2) Sistema Multiprogramado (Princípio de Alocação Inteira e Contígua )
Programa vai para a memória de maneira inteira e contígua por ausa do modo de
endereçamento que a CPU tem.

Objetivo principal de implementar uma técnica de Ger. de Memória: Diminuir o

desperdício de memória para, com isso, aumentar o throughput.

2.1) Partições Fixas

Cada partição – 1 programa
1 programa – 1 partição

Faz em cada partição, o que fazia no monoprogramado.

Posso ter mais de 4 processos: reentrância e criação dinâmica de processos.

Problemas: Desperdício de memória  Limita, prejudica P1

Throughput (quantidade de trabalho por unidade de tempo).

Problemas de: P2
Fragmentação de memória
Interna (espaço que sobra dentro da partição)
P3
Externa (sobra uma fragmentação inteira) –
exemplo: programas querendo rodar mas não
cabem.
P4

2.2) Partições Variáveis

Cada programa ocupa espaço igual ao tamanho dele.
P1
Problema: Programas entram e saem com tamanhos
diferentes. A memória vai ficar cheia de fragmentos (no
caso, toda externa). P2

Para Amenizar:
1. Compactação (como desfragmentação no disco)
Empurra tudo.
Problema: Overhead muito grande, caro, muito P3
deslocamento, muita E/S.

2. Algorítmo de alocação P4

4
 P1 First-fit – primeiro que encaixar (mais
10K rápido, mais usado). Tende a deixar áreas
livres para alocar mais em cima ou mais
embaixo.
P4
5K
Best-Fit – o que tiver tamanho mais
P2 parecido (gera fragmentos tão pequenos
6K que não cabe ninguém)

Worst-fit – no maior espaço.

P3
20K

(info) Acesso à Memória

Quando falamos de acesso á memória, trata-se de uma hierarquia de acesso a diversos
módulos de memória, desde acesso à cache L1 até o disco.

A gerência das caches é realizada pelo Hardware. Não é o SO.

A função do SO é gerenciar o que entra e sai na Mem. Principal e no Disco. No Disco é

completamente diferente que na memória principal. No disco o SO gerencia os
arquivos. Por isso, a parte do SO que gerencia o disco é o gerente de E/S e o sistema
acoplado ao sistema de arquivos (os diretórios, onde os arquivos estão localizados).

Quando um código de um programa vai do disco pra memória?

Na hora que um processo foi criado. Quando pede pra ser criado um processo.

Quando um código de um programa sai da memória?

Obs.: Sair da memória é marcar a área como livre, e não apagar os bits.
Quando todos os processos que utilizam aquele código terminam.

Swapping
O que acontece quando todos os processos estão bloqueados? (por exemplo,
esperando P1 terminar de usar a impressora)
Fica todo mundo bloqueado na fila para impressora.
P1 está usando entrada e saída, não está usando a CPU.
A memória acabou, não tem espaço pra mais ninguém. Pra evitar esse tipo de problema
o SO criou o conceito de swapping: O processo temporariamente saiu da memória
(área dele foi liberada), e nessa área livre pode ser carregado outro programa.
Ex.: Tirar P4 temporariamente e colocar P5 pra rodar.

O processo referente a esse código que saiu da memória pode continuar ativo?
Ou seja, o processo pode estar bloqueado, pronto e em execução; se o processo estava
bloqueado, depois de sofrer um swapping, ele pode continuar bloqueado? Não.

5
Quais processos não podem sofrer swapping?
Em execução, se estiver fazendo E/S, pois há uma comunicação entre a área do processo
na memória e o dispositivo.

Processos que sofreram Swapping

Se um processo que sofreu swapping não pode ser candidato nem a ganhar dispositivo
de E/S, nem a ganhar a CPU, então preciso criar novos estados para esse processo.
Não podem mais permanecer nem prontos nem bloqueados. Muda a máquina de
estados.

Execução

Pronto Bloqueado

Suspenso Suspenso
Pronto Bloqueado

Máquina de Estados

Por que suspender um processo pronto?

Se a fila de prontos está muito grande, o tempo de resposta fica comprometido. Então o
SO pode suspender alguns para melhorar o tempo de resposta pro grupo, reduzindo a
fila de prontos.

Por que suspender um processo bloqueado?

- Pra melhorar o uso dos recursos do sistema. Ex.: vários processos pediram a
impressora. Trocar os processos pra que eles usem outros recursos.
- Suspender um bloqueado pra trazer um pronto: melhorar o throughput, por exemplo,
se a fila de prontos for muito pequena.

Então o Swapping permite fazer dinamicamente balanceamento de cargas e de recursos.

(2:15:13)

Multiprogramação com Swapping

Forma de gerenciar memória, meio (teórico) de usar o conceito de swapping ao
extremo.

Deixar a memória pra um único programa, o que está rodando. Na hora em que este
programa sai do estado de execução, o SO faz um swap out e um swap in: trocas os
programas na memória.

6
 Swap in
SO
Overhead
muito alto
P1
Swap out

Troca de contexto: quando muda o processo que está rodando. Ocorre uma interrupção
e o SO decide colocar outro, trocando o contexto dos registradores da CPU.

CPU O que é caro numa troca de contexto, qual

o problema de desempenho?
É muito cara porque envolve swap in e swap
L1 out. Maior parte dos dados do processo não
vai estar na L1, vai haver vários miss, e os
L2 dados vão têm que ser trazidos da MP.

Quando P1 está em execução, os dados de P1

L3 estão subindo e ele está usando os dados lá na
L1.
Na hora em que eu troco de contexto, P1 pra
MP
P2, P2 vai sofrer vários misses, até que os
dados dele voltem pra ele.
Ex.: P2 vai acessar o 1º dado dele. Tá na L1?
Tá na L2? 2º dado.. 3º dado...

Qual a vantagem de fazer troca de contexto

entre threads que entre processos?
A área de dados que estão na cache eu
reaproveito, pq os dados são os mesmos.
Embora a thread tenha alguns dados locais,
essa quantidade é pequena. Então eu não tenho
os misses todos que ocorrem na troca de
contexto entre processos.

2.3) Sistema Multiprogramado (Alocação não Inteira e Não Contígua)

O que estava diminuindo o throughput era o fato do código ficar todo na memória.

Quais os benefícios de uma alocação não inteira e não contígua?

• Possível trazer mais programa pra memória (aumentar throughput)
• Swapping mais barato (balancear cargas e recursos do sistema)

7
 • Não limitar o tamanho do programa ao tamanho da memória (benefício pro
programador que não tem mais que se preocupar com o tamanho da área de
dados que ele vai gerar)

Problema? O Hardware. Tiveram que requisitar aos fornecedores de hardware uma

nova forma de endereçar a memória.
• Para alocação não inteira e não contígua, é necessária a criação de um novo
Hardware.
|_ programas eram endereçados por base + deslocamento.

• Por causa do projeto de SO, foi mecessário novo processo de Hardware

|_ Nele os endereços gerados pelo compilador são endereços virtuais
|_ O processador, ajudado pelo SO, tem

Na hora em que eu gero o código eu tenho que gerar dentro do código do programa
onde estão os dados, em que posição eles estão. Mas com o código embaralhado na
memória. Como o compilador vai gerar os endereços se na hora que eles forem pra
memória vão todos embaralhados? Aí surgiu o conceito de Memória Virtual.
O compilador gera endereços que não têm nada a ver com os endereços de MP. São
end. Virtuais. Que em tempo de execução a CPU tem que ser capaz de traduzir um end.
Virtual p/ um end. Real.

2.4) Paginação
Programas são divididos em páginas, de um tamanho determidado. A MP é dividida em
frames (divisão lógica).

Se cada página tem 10 endereços, qual o

endereço 5 do programa azul?
0
End Virtual = 5
Ando com a vírgula (EV/nºdeEnd) = (5/10)
1 = 0,5
A página é o que está do lado esquerdo =
Página 0
0 A página 0 está no frame 2
Logo, end. Real é 20 + 5 = 25
|_ frame 2 x 10
3 endereços = 20

Mecanismo de Tradução de endereços

O SO monta uma tabela de páginas para

cada processo dizendo para cada página

8
do processo, onde ela está na MP. A partir dessa tabela a CPU pode fazer a tradução
de end. Virtual p/ real.

• A CPU pega o end. Virtual que vem do código do programa. Então a CPU parte
este end. De acordo com o tamanho da página e divide em duas partes: número
da página e deslocamento dessa página (P e D).

• A CPU descobre em que frame está a página p, na tabela de páginas.

• Como a CPU vai saber qual a tabela de páginas de um processo? Ela contém
um registrador (registrador origem), que o SO ao carregar o processo, coloca lá
dentro o endereço (B) da tabela de páginas desse processo.

• A CPU vai na MP a partir do endereço B, e acessa o endereço de memória B +

P, na tabela de páginas, que é onde está a informação da P-ésima página.

• Lá tem o nº do frame (F) onde o SO colocou a página P. A CPU monta o

endereço real pelo nº fo frame (F) mais o deslocamento (D), ou seja, concatena |
F|D|.

E uma página que não está em nenhum frame?

Tá faltando informação na tabela de páginas. A página está ou não na memória? (Bit de
residência)

Se não estiver, interrupção para chamar o SO para ele carregar essa página do disco pra
mem. e atualizar a tabela. (interrupção de falta de página)

Se estiver, forma o endereço real.

Carregar um processo
1º passo) O SO cria uma tabela de páginas com entrada pra cada página do processo.
Todas com o bit de residência zerado. Não jogo nada na memória. E guardo no contexto
do processo onde eu coloquei essa tabela.

O processo foi escolhido pra rodar: Paginação por

1º endereço que ele vai rodar  gera demanda: a
interrupção por falta de páginas página só vem
pra memória
SO pega a página e traz pra memória. qd ela é
necessária
Obs.: O endereço do PC é um endereço
virtual. A CPU traduz para real e joga dentro
do IR. O compilador só gera end. virtuais.

9
TLB
Problema (acima): Aumenta muito (dobra) a quantidade de acesso à memória. Pra
cada endereço que vou acessar, eu acesso a memória antes.

Solução: evitar a ida à memória  colocar essa tabela numa cache, uma cache só pra
tradução de endereços (TLB).

Então a CPU tem que ter dentro dela uma TLB (Translation look-aside Buffer), que é o
buffer onde eu vou procurar informação para a tradução.

É uma mem. cache associativa, não é busca por endereço, é busca por conteúdo.

Conteúdo: procura dentro da TLB se há informações sobre a página P. Se ela estiver na

memória, gero endereço real.

Caso eu não encontre P, falha na TLB, aí eu vou para o outro mecanismo e o hardware
automaticamente atualiza a TLB.

TLB

P 1|F

O acesso à tabela de páginas é feito primeiramente na TLB, onde a CPU vai perguntar
se tem alguma entrada relativa à página P:

1º Cenário (Dado na TLB e página na MP): Se tiver entrada relativa à página P, eu

pego em que frame ela está (se a página P está na MP). Depois basta concatenar o frame
com o deslocamento. Cheguei ao end. real. (Tradução direta)

2º Cenário (Dado na TLB, mas página não está na MP): Se tiver entrada relativa à
página P, e a página P não está na MP, interrupção de falta de página. SO vai tratar
interrupção, carrega a página na memória, e atualiza tabela e carrega mesma informação
na TLB. (interrupção de falta de página).

3º Cenário (Dado não está na TLB e página está na MP): Se não tiver entrada
relativa à página P, miss na TLB, o Hardware trata esse miss como? Pego no registrador
origem onde esta tabela está na memória. Põe no endereço B+P a entrada. (TLB miss)

4º Cenário (Dado não está na TLB e página não está na MP): (TLB miss +
interrupção de falta de página)

Pode acontecer de estar na TLB mas a página não está na memória. Quando
alguém tirou P de lá.

10
Quando troco de P1 pra P2, a TLB tem que ser esvaziada, dá um flush na TLB pra
começar com a tabela de P2. É como se invalidasse todas as entradas da TLB, qualquer
acesso à TLB vai dar um miss (vai na MP buscar a informação).

Obs.: Alguns sitemas possuem um dispositivo mais rápido que armazena páginas que
estão saindo e entrando na memória. Pra tornar mais eficiente. Alguns reservam uma
área do disco pq não tem o dispositivo. Mas isso não é memória virtual.

O que tem em uma entrada da tabela de páginas?

Bit de End. da pág. No

Nº do frame M R W E
residência disco.

Bits de
Usado pelo SO controle
de acesso
Bit de
modificação
End. da página no disco: (carregado qd monta a tabela de páginas, quando cria o
processo  trilha e setor) Facilita a vida do SO, por exemplo: Ele foi chamado por uma
interrupção de falta de página, e vê onde a página está no disco transfere pra um
determinado frame. Depois que a transferência acabar ele escreve na tab. em que frame
ele colocou e escreve 1 no bit de residência.

Bit de modificação (M): Indica se a página foi ou não modificada, se o processo

alterou o conteúdo da página. Pra quando eu tiro essa página pra voltar pro disco, se o
bit estiver em zero, não preciso copiá-la de volta. Se tiver em 1, sim.
CPU seta o bit, pois o SO não ele não está rodando.

RWE: leitura, escrita e execução. 110, pode ler e escrever, não executar. Útil para
páginas compartilhadas por vários processos. O SO pode dar tipos de acesso
diferenciados a um determinado dado.

O que acontece se vc não tem permissão pra escrita W=0, e vc está tentando
escrever naquela página? Interrupção, erro de execução.

Cluster: Dados compartilhados, replica dados em cada memória. Nos bits de

controle de acesso eu deixo a permissão de escrita zerado. O primeiro processo
que tentar escrever numa página vai gerar uma interrupção. Mas não trata como
erro, chama sistema de gerenciamento de memória, libera a escrita e marca: esse
cara foi lá e alterou essa página. Mais tarde alguém tenta escrever ou ler essa
página, vai sofrer uma interrupção. Chama sistema de ger., ele vê quem foi o
último a escrever e pega o dado e transfere pro outro.

Suponha um Hardware em que a CPU não sete o bit de modificação, como

vc pode resolver esse problema com o SO?

11
 Toda pág. entra na memória com o bit W (write) zerado. A 1ª tentativa de
escrita, em vez de gerar uma interrupção de erro, o SO vai lá, pega o bit de
modificação e libera a escrita na página.

Paginação por Demanda

Página é carregada na memória somente quando é necessária.
Benefício: Não gasta espaço na memória com algo que vc não vai acessar. Não
desperdiça nenhum espaço na memória. Traz pq precisa usar. Ex.: Seu código é
gigantesco, tem 2000 rotinas, mas vc só vai usar meia dúzia delas.
Problema: Se vc precisa acessar uma página e ela não está na memória, em tempo de
execução vc vai ter que sofrer a espera pra que aquela página seja trazida do disco pra
MP. Overhead alto pois envolve transferência do disco pra memória, que é muito lento.
Muita falta de página, custo alto.

Técnica de Prefect
Buscar páginas com antecedência para evitar interrupção de falta de página. Tenta
antecipar, chutar a página que vai precisar antes dela ser necessária, traz pra memória.
Se acertar, evitou interrupção por falta de página. Se errar, perdeu tempo fazendo
operação de E/S, gastou espaço de memória atoa.

A questão é o quanto vc consegue acertar.

Na cache, vc tende a usar as linhas seguintes, então vc traz um bloco de linhas da cache.
Mas com página, essa localidade espacial não é tão forte, pq agora estou trabalhando
com unidades de 4k, 8k, 16k... Não necessariamente o fato de vc estar usando esta
página, vc vai usar a seguinte. Então usar a técnica de localidade espacial não é uma
boa idéia.

Ex de técnica usada: compilador ajuda, ele entende perfeitamente o código, então ele
gera dicas pro SO pra quando ele vai fazer prefect. Por exemplo, quando há um loop,
num vetor. Pelo índice que vc está acessando o vetor, vc sabe qual página vc vai
precisar usar na memória. Então se seu programa for bem comportado em termos de
vetor, o compilador sabe adiantar pro sistema qual página ele vai usar em seguida. Por
enquanto melhor forma, mas pouco utilizado.

Fragmentação de uso

12
 Divisão Arbitrária
MP
Só por causa deste
pedacinho carrega as
duas páginas para que
a rotina 1 fique na
memória.

Fragmentação de uso

Não vou usar, mas é um desperdício diferente da fragmentação de memória, que era
uma área vazia que ninguém consegue usar. Na fragmentação de uso, aquela área não
está livre, mas não serve pra nada. E ela vem pra memória por conta da divisão
arbitrária da página. Por exemplo qd a página quebra uma rotina no meio.

Uma outra questão sobre a divisão arbitrária da página é a seguinte: na paginação a

gente tem os bits de controle de acesso, mas não conseguimos fazer um controle de
acesso por estrutura de dados. Supondo, eu tenho no meu programa uma matriz e um
vetor, a matriz eu posso deixar todo mundo ler e escrever, mas o vetor não. Não consigo
fazer isso na paginação, não consigo distinguir por estrutura de dados, pois a paginação
não divide o programa por estrutura de dados, divide por tamanho fixo, vou fazer
sempre por páginas.

2.5) Segmentação
Exatamente por conta dessa divisão arbitrária da paginação, que pode levar ao problema
de fragmentação de uso, e não permite que eu faça carregamentos na memória por
estrutura do programa, seja uma rotina, uma estrutura de dados, surgiu uma outra forma
de organização, baseada no conceito de memória virtual que é chamada de
segmentação.

1 5 Baseado no conceito de
memória virtual, ou seja, o
programa é carregado de
forma não inteiro e não
contíguo na memória. Em
outras palavras, dividido
em partes e as partes
podem ficar em qualquer

13
posição de memória, pq os endereços do programa são desvinculados dos endereços de
memória.

Na paginação, todo mundo é dividido em partes do mesmo tamanho, na segmentação a

divisão em partes reflete na divisão lógica do programa, ou seja, segmentos têm
tamanhos diferentes.

Se os tamanhos são diferentes, não posso deixar a memória pré-dividida em molduras.

Área livre em que os segmentos vão se encaixando em qq área livre em que eles
caibam. (como em partições variáveis).
Resolve problema de fragmentação de uso, mas causa problema de fragmentação de
memória. Pode ser pior de acordo com o tamanho do segmento, como eles entram e
saem da memória.

Só que a diferença é que agora quando eu precisar de uma rotina, vai direto aquela
rotina pra memória. Posso controlar acesso por estrutura de dados. Tenho controle sobre
as estruturas do programa.

Usar as mesmas técnicas para amenizar fragmentação.

- Compactação (em último caso)
- Algoritmos de alocação

Diferença entre partiçoes variáveis e Segmentação: Este último carregamento não

inteiro e não contíguo, o 1º, carregamento inteiro e contíguo.

Segmentação precisa de Hardware para tradução de endereços, pois é baseado em

mem. virtual.

Mecanismo de Tradução de Endereços

Agora a CPU, do endereço virtual, tem que distinguir em que segmento ele está, e
qual o deslocamento dentro do seguimento. Como?
A CPU não tem como distinguir de um endereço o que é segmento e o que é
deslocamento. É o contrário, o compilador já gera os endereços dessa forma. Então o
compilador em vez de gerar os endereços sequencialmente, ele gera o endereço com
dois campos, um com o número do segmento, outra com o deslocamento.

O endereço virtual tem um tamanho fixo, o campo de deslocamento tem o tamanho

máximo (nº de bits) que um seguimento pode ter.

• Pelo número do segmento a CPU acessa a TLB. Vai procurar onde o segmento S
está ma MP.
• Supondo que está na TLB, e que o segmento está na MP, a partir do endereço S’.
O endereço real é S’ mais D. Não é concatenado (concatenar era o mesmo que
multiplicar pelo tamanho da página e somar D). Não pode concatenar pq S’ é um
endereço qq de memória.
Obs.: Na paginação era garantido que um deslocamento não podia ficar
fora da página pelo número de bits do campo deslocamento. Na
segmentação isso não é possível, pois o campo deslocamento tem o

14
 número de bits do maior deslocamento possível, então eu posso dentro
daquele deslocamento gerar um nº de bits fora do meu segmento.
Falta proteção de memória:
colocar na tabela de segmentos o tamanho do segmento (T) e,
antes de fazer a soma (S’+D), tenho que comparar se o
deslocamento é menor que o tamanho. Se for, eu somo S’ com D,
senão, erro! Interrupção: vc está tentando acessar uma área que
está fora do segmento.
TLB

S 1|S’|T

Se vc tem um hardware para paginação o SO pode implementar segmentação?

Não. Com aquele mecanismo não dá pra gerar segmentos com tamanhos diferentes.
(frames de mesmo tamanho?)

Um hardware pra Segmentação, eu posso implementar paginação?

Sim. É só as páginas serem segmentos de tamanhos idênticos.

É o hardware quem determina que o sistema vai ser paginado ou segmentado, não o SO.
Como o processador implementou. O SO tem que acompanhar o que o hardware faz.

O que tem em uma entrada da tabela de segmentos?

Bit de endereço do endereço. do seg no

M R W E Tamanho
residência segmento na MP disco.

Bits de
Usado pelo SO controle
de acesso
Bit de
modificação

Paginação x Segmentação
Paginação
Vantagens: a divisão é em páginas de tamanhos fixos, na hora de carregar é muito
simples.
Desvantagem: fragmentação de uso e dificuldade de controlar as estruturas do
programa.

Segmentação

15
Vantagens: não tem fragmentação de uso e é possível controlar as estruturas do
programa.
Desvantagens: carregamento é mais complicado pq segmento têm tamanhos diferentes.
Fragmentação de memória.

2.6) Segmentação Paginada

Tenta unir as vantagens dos dois.
A diferença é como é feita a divisão de partes. Os segmentos são separadamente
paginados.
O que vai entrar e sair da memória são páginas, a MP pode ficar dividida em molduras.

Vantagem: mesma da paginação -> carregamento é simples. Em compensação, agora

vc tem controle sobre as estruturas do programa. Dentro de uma página não tem
informações que não têm relação entre si. Dá pra ter controle de acesso diferenciado.
Outro benefício: às vezes o compilador não faz uma boa divisão em segmentos. Gera
segmentos muito grandes, com isso, perde o benefício da memória virtual, ocupando
muito espaço na MP, baixando throughput, o swapping é mais caro. Paginando o
segmento, resolve esse problema.

Aqui tb tem fragmentação de uso.

Dois níveis de tabelas:

Agora tem, pra cada processo uma tabela de segmentos
Pra cada segmento (entrada da tab. de segmentos), uma tabela de páginas

Do endereço virtual, o compilador gerou dois campos S e D. Esse deslocamento dentro

do segmento é paginado, que vai ser dividido em P e D.
Pro compilador é como gerar endereço virtual para segmentação. Então eu tenho
como extrair P e D do endereço virtual.

Vou procurar na TLB informações sobre segmento S e página P. Na TLB eu não posso
ter 2 níveis de tabela. Pq? Pq eu teria que ter 2 TLB’s, que torna o hnardware
extremamente caro. Como a busca é associativa, eu posso fazer a busca na TLB pelo par
S|P. (na TLB tenho um merge das duas tabelas.)

Descobri que essa página desse segmento tá na memória no frame F. O endereço real é
F concatenado com D.
TLB

S|P 1|F

Continua tendo tamanho na tabela de segmentos?

16
17