DeadLock..........................................................................................................................1Estágios para Tratar o problema de deadlock................................................................2

Prevenir..................................................................................................................................2Evitar.....................................................................................................................................2Detectar e Recuperar.............................................................................................................2

Gerência de Memória......................................................................................................31) Sistema Monoprogramado........................................................................................3

Alocação Contígua e Inteira..................................................................................................32) Sistema Multiprogramado (Princípio de Alocação Inteira e Contígua )...................4

2.1) Partições Fixas................................................................................................................42.2) Partições Variáveis.........................................................................................................4

Swapping.......................................................................................................................5Processos que sofreram Swapping........................................................................................6Multiprogramação com Swapping.........................................................................................62.3) Sistema Multiprogramado (Alocação não Inteira e Não Contígua)...............................72.4) Paginação.......................................................................................................................8Mecanismo de Tradução de endereços..................................................................................8TLB........................................................................................................................................9O que tem em uma entrada da tabela de páginas?...............................................................10Paginação por Demanda......................................................................................................11Técnica de Prefect...............................................................................................................11Fragmentação de uso...........................................................................................................122.5) Segmentação.................................................................................................................13Mecanismo de Tradução de Endereços...............................................................................13O que tem em uma entrada da tabela de segmentos?..........................................................142.6) Segmentação Paginada.................................................................................................14

DeadLockErro de sincronia de threads, processos.

Os processos vão se bloquear eternamente.

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.

P1 P2

fita

impressora

P1 pede à fita pra imprimirBloqueado esperando P2

P2 pede a impressora, bloqueado na fila esperando P1

Fecha o ciclo

Não pode acontecer

1

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.

Detectar e Recuperar

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

O que pode acontecer (1ª Opção)?Ex.: Escrevendo um arquivo- Arquivo inconsistente

RollbackSe matei P2, voltar atrás tudo que p2 fez. SO mantém um histórico de coisas que não podem ficar inconsistentes.

R1

R2

R3

R4

R5

R0

R6

2

Gerência de MemóriaOutro 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.

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 roda2ª 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.

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.

SO

P1

Espaço reservado pro SO

Código e dados do único processo

3

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 programa1 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 Throughput (quantidade de trabalho por unidade de tempo).

Problemas de:Fragmentação de memória

Interna (espaço que sobra dentro da partição)

Externa (sobra uma fragmentação inteira) – exemplo: programas querendo rodar mas não cabem.

2.2) Partições Variáveis

Cada programa ocupa espaço igual ao tamanho dele.

Problema: Programas entram e saem com tamanhos diferentes. A memória vai ficar cheia de fragmentos (no caso, toda externa).

Para Amenizar: 1. Compactação (como desfragmentação no

disco) Empurra tudo.Problema: Overhead muito grande, caro, muito deslocamento, muita E/S.

2. Algorítmo de alocação

4

P1

P2

P3

P4

P1

P2

P3

P4

(info) Acesso à MemóriaQuando 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.

P1

P2

P3

10K

6K

20K

P45K

First-fit – primeiro que encaixar (mais rápido, mais usado). Tende a deixar áreas livres para alocar mais em cima ou mais embaixo.

Best-Fit – o que tiver tamanho mais parecido (gera fragmentos tão pequenos que não cabe ninguém)

Worst-fit – no maior espaç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.

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.

Pronto

Execução

Bloqueado

Máquina de Estados

Suspenso Pronto

Suspenso Bloqueado

6

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.

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

Quando P1 está em execução, os dados de P1 estão subindo e ele está usando os dados lá na L1.Na hora em que eu troco de contexto, P1 pra 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) 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.

SO

P1

Swap in

Swap out

Overhead muito alto

7

CPU

L1

L2

L3

MP

|_ 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?

End Virtual = 5Ando com a vírgula (EV/nºdeEnd) = (5/10) = 0,5A página é o que está do lado esquerdo = Página 0A página 0 está no frame 2Logo, end. Real é 20 + 5 = 25

|_ frame 2 x 10 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 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.

8

0

1

0

3

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 processo1º 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:1º endereço que ele vai rodar gera interrupção por falta de páginas

SO pega a página e traz pra memó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.

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.

9

Paginação por demanda: a página só vem pra memória qd ela é necessária

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

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á.

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.

P 1|F

TLB

10

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

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?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.

End. da pág. No disco.

Bit de residência

Nº do frame

Usado pelo SO

M R W E

Bits de controle de acesso

Bit de modificação

11

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

MPSó por causa deste pedacinho carrega as duas páginas para que a rotina 1 fique na memória.

Fragmentação de uso

Divisão Arbitrária

12

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.

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 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

13

1 5

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 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.

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?

S 1|S’|T

TLB

14

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?

Paginação x Segmentação

PaginaçãoVantagens: 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çãoVantagens: 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:

endereço. do seg no disco.

Bit de residência

endereço do segmento na MP

Usado pelo SO

M R W E

Bits de controle de acesso

Bit de modificação

Tamanho

15

Agora tem, pra cada processo uma tabela de segmentosPra 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.

Continua tendo tamanho na tabela de segmentos?

S|P 1|F

TLB

16