Lec 6 | MIT 6.033 Computer System Engineering, Spring 2005

Virtualization and Virtual Memory

View the complete course at: http://ocw.mit.edu/6-033S05

License: Creative Commons BY-NC-SA
More information at http://ocw.mit.edu/terms
More courses at http://ocw.mit.edu

Então no caso você está todo preocupado que você pode não ser no direito

classe, está ainda em 6.033.
Se você está se perguntando o que

aconteceu com o cara de indiano que normalmente palestras,

ele está sentado logo ali.
Nós somos troca fora palestras

em toda a classe.
Eu vou fazer sobre o próximo

oito palestras até spring break, e então será o [Hari?]

Voltar.
Então, meu nome é Sam,

e sinta-se livre para abordar questões sobre a palestra a

me.
Por isso hoje vamos manter

falando sobre este conceito de aplicação de modularidade que nós

começou a falar sobre a última vez.

Então a última vez que vimos como poderíamos usar esta noção da

modelo de serviço do cliente a fim de separar os dois módulos de cada

outros.
Então a idéia foi executando o

cliente e o serviço em máquinas separadas,

nós pode isolar estas duas coisas uns dos outros.

Assim nós podemos o fazer assim, por exemplo,

Quando o cliente quer invocar alguma operação no servidor,

que o servidor pode verificar o pedido que o cliente faz,

e certifique-se de que o cliente não está pedindo para fazer algo

malicioso.
Da mesma forma, então isso é o que nós

vi a última vez que foi este modelo de serviço do cliente.

E assim foi o outro benefício do modelo de serviço de cliente

significava que nós poderia dissociar o cliente do serviço.

Assim que ele quis dizer que quando o cliente emitiu um pedido contra

o serviço, isso não significa necessariamente que o

cliente, se o serviço falhou quando o cliente emitido o

solicitar, não era necessariamente o caso que o cliente

também não.
Assim o servidor pode falhar

executar a solicitação e, em seguida, o cliente receberia um

tempo de espera e seria capaz de repetir.

E da mesma forma, se o cliente falhou,

o servidor poderia continuar solicitações em nome

de outros clientes.
OK, então o que era um bom

separação, a capacidade de dividir o cliente e o servidor distante

uns dos outros.
Isso é uma coisa boa.

Mas o problema com esta abordagem é que tínhamos que ter

duas máquinas separadas.
Foi a maneira que apresentamos este

que o cliente estava executando em um computador,

e o servidor estava funcionando em outro computador.

E se você pensar sobre isso, isso não é exatamente o que nós

quer, certo?
Porque isso significa que,

Suponha que nós queremos construir um sistema de computador grande, complicado

que é composto por vários módulos diferentes.

Se temos de executar cada um desses módulos em separado

computador, que não é realmente muito ideal, certo?

Para construir um grande serviço, nós vamos precisar de muito

de computadores.
E, claramente,

que não é a maneira que o computador sistemas que nós

realmente interagir com o trabalho.
Então, o que vimos até agora é

Esta noção: temos um módulo por computador.

OK, e o que vamos fazer hoje é ver como podemos

generalizar isso assim que, em vez de ter um módulo por

computador, em vez disso temos vários módulos executando dentro

um único computador.
Mas quando fazemos isso,

Nós ainda queremos manter este bom tipo de benefícios de proteção

que tivemos entre o cliente e serviço quando estes dois

as coisas estavam em execução em computadores separados.

OK, então a maneira que nós vamos fazer isso é através da criação de algo

chamamos um computador virtual.
Assim-

O que vamos fazer é o que vamos criar essa noção de

vários computadores virtuais.
Eles estão executando em um

único computador.
E, em seguida, vamos correr

cada um destes módulos dentro de um computador virtual.

OK, e vou falar mais sobre o que quero dizer com uma virtual

computador durante todo o próximo par de palestras.

Mas a idéia é que um computador virtual tem exatamente o mesmo,

para um programa que está sendo executado nele, parece um virtual computadores

como estes cliente ou servidor de computadores podem ter

olhou.
Agora, em particular,

um computador virtual tem o mesmo tipo de abstrações que nós

estudou nas palestras anteriores à sua disposição que um real

computador tem.
Para que um computador virtual tem uma

memória virtual-

- e um processador virtual.
Então, hoje o que nós vamos

é esta noção de uma memória virtual.

E assim que vocês provavelmente já viram o termo virtual

memória 6.004.
Assim, a palavra deve estar familiarizada

para você.
E vamos usar exatamente

a mesma abstração que usamos em 6.004.

Portanto vamos apenas mostrar como essa abstração pode ser usada para

fornecer essa proteção entre o cliente e o servidor que nós

quer.
OK, nós também vamos

apresentar hoje esta noção de algo chamado um kernel.

E um kernel é algo que está no comando,

Basicamente, de gerenciar todas essas diferentes virtual

computadores que estão executando em nosso um computador físico.

Então o kernel vai ser o tipo de sistema que vai

para ser a parte do sistema que realmente sabe que lá

são vários computadores virtuais rodando

Este sistema.
OK, então eu quero começar por

primeiro apenas falando por que queremos uma memória virtualizada,

por que a virtualização de memória é uma coisa boa.

Então eu vou abreviar a memória virtual como VM.

Então por que nós quer virtualizar a memória?

Bem, vamos ver o que pode acontecer de se construir um computador

sistema com vários módulos executando ao mesmo tempo

que não tem uma memória virtualizada.

Assim suponha que nós temos algum microprocessador e nós temos alguns

memória.
E dentro desta memória,

Nós temos o código e dados para um par de módulos diferentes é

armazenados.
Portanto, temos, digamos,

módulo A e módulo B e esta é as coisas como o

código e os dados que estes módulos estão usando atualmente

Execute.
Assim, neste ambiente,

Suponha que o módulo, A, executa algumas instruções.

Então, se você pensar nisso como memória, digamos que esse módulo A

começa no endereço um aqui e o módulo B começa no endereço

B aqui.
Então, suponho que módulo A

executa algumas instruções de como armazenar algum valor,

R1, no endereço de memória, B.

OK, então o módulo A grava memória endereço B aqui.

Assim, esta pode ser uma coisa problemática, direita,

porque se o microprocessador só permite que isso aconteça,

se ele apenas permite A para gravar na memória do módulo B,

em seguida, módulo B não tem como ser isolado do módulo A no

Está bem?
Módulo A pode,

por exemplo, escrever algum tipo de lixo em

a memória do módulo B.
E, em seguida, quando tenta módulo B

ler a partir desse endereço de memória, ele vai

dizer, experimentar e executar uma instrução ilegal, ou ele vai ler em

alguns dados que não fazem qualquer sentido.

Assim perdemos a separação, o isolamento que tivemos

entre se módulo A e módulo B são um cliente e um serviço

tentando interagir uns com os outros.

Nós perdemos esse tipo de habilidade.

Nós perdemos a capacidade de separar e isolar uns dos outros,

isolá-los uns dos outros que tivemos quando eles foram

em execução em computadores separados.
Além disso,

Este tipo de arranjo de memória virtual.

Assim que um problema com isso é um pode substituir a memória do B.

Mas temos outro problema, o que é que este tipo de

arranjo também é muito, muito difícil de depurar.

Assim, esses tipos de erros podem ser muito difícil de rastrear.

E realmente, quando nós estamos construindo sistemas de computador,

Nós gostaríamos de livrar-se deles.
Assim, por exemplo,

Suponha que das lojas na memória do B, substitui um

instrução que em algum lugar uma espécie de arbitrariamente dentro do B

memória.
E então, 10.000 instruções

mais tarde, B tenta carregar em que endereço de memória e executar que

instrução.
E torna-se um ilegal

instrução.
Agora, imagine que você tem que

Depure este programa.
Assim você sorte de está sentado

lá e assim você correr para fora com paciente B, e funciona apenas

muito bem.
E, em seguida, executar A aplicação,

e A substitui parte da memória do B.

E agora, quando programa B é executado às vezes muito tempo depois do programa A,

é talvez, já encerrado, B misteriosamente cai sobre você.

Então, como você vai rastrear o problema?

É muito complicado, e é o tipo de problema

Isso é extremamente difícil de depurar esses tipos de problemas.

Então nós realmente gostaríamos de torná-lo assim que A não é capaz de

simplesmente substitua coisas arbitrárias na memória do B.

Nós gostaríamos de proteger A de B. OK, e isso é o que esta

abstração de memória virtual que vamos falar hoje sobre

vai fazer por nós.
Então, se você pensar sobre como você

pode proteger A de B, a solução que você classificar de

chegar depois pensando nisso e olhando isso

para um pouco é o que você deseja verificar se todos os

acessos de memória que A não é acessos de memória realmente válido

que A deve fazer, assim, por exemplo,

que se referem a objetos que são, na verdade, que A atribuiu ou

que A possui.
OK, então, a fim de fazer isso,

o que vamos precisar fazer é colocar algum tipo de

software entre os acessos de memória que faz de cada módulo,

e o acesso de memória real.
Assim, a idéia é a seguinte.

Portanto, esta é a abstração de memória virtual.

OK, então a idéia é a seguinte.
Para cada um dos nossos módulos,

digamos A e B, vamos criar o que na

conhecido como um espaço de endereço, OK?

E este espaço de endereço vai ser, por exemplo,

em um computador de 32 bits, dois para o 32, menos um, é

vai ser um espaço de memória de 32 bits.

Assim, é o espaço de endereço virtual de, digamos,

um processo, A.
Assim, o processo A pode usar qualquer

Endereço de memória que está sendo este dois para o intervalo de 32 bits,

Razoável?
Mas isso vai ser uma

espaço de endereço virtual.
E o que quero dizer com isto é quando

processo A refere-se a algum endereço no mesmo espaço de memória,

chamá-lo de endereço virtual BA.
Esse endereço vai ser

mapeados pelo sistema de memória virtual em um endereço físico,

Razoável?
Então é este endereço virtual aqui

vai ser mapeado em algum endereço físico-

-em algum lugar dentro a memória física do sistema,

Razoável?
Assim esta memória física da

sistema é também um espaço de 32 bits.
Mas o tipo de mapeamento de

Este endereço virtual na memória para o físico

vai ser manipulado por essa memória virtual espaço de endereço

sistema.
Então, agora a idéia é que cada

coisa que, digamos, um processo A ou B pode querer

referência vai ser mapeado em algum outro local

dentro desta memória.
Assim, por exemplo,

o código de processo A ou de módulo A pode ser mapeado em um

localização e o código do módulo B vai ser mapeado

em um local diferente no espaço de endereço físico.

OK, então temos esta noção de espaços de endereçamento.

Cada módulo que está em execução no sistema em uma memória virtual

sistema vai ser atribuído a um desses espaços de endereço.

Este espaço de endereço vai ser, e este espaço de endereço

virtual no sentido de que esses endereços são válidos em apenas o

contexto deste dado módulo, OK?

E, eles traduzem, cada endereço virtual

espaço traduz-se em algum endereço no espaço físico.

Agora, se você olhar para isso por um minuto, você poderia pensar,

bem, este é tipo de confusão, pois B e um tanto têm agora uma

espaço de endereçamento de 32 bits.
E só o próprio computador

tem um espaço de endereçamento de 32 bits.
Assim, há uma classificação de mais

endereços entre todos os módulos do que o próprio computador

fisicamente tem.
E, se você se lembra de

6.004, a história que nós dissemos-lhe sobre o que foi que,

bem, alguns desses endereços virtuais realmente podem ser mapeado

no disco no computador.
Então, em 6.004,

memória virtual foi apresentada como uma maneira de criar um computador que

parecia ter uma memória mais física do que,

na verdade, fez.
E a maneira que o que foi feito

foi mapear alguns desses endereços para disco.

Assim você pode ter endereços de B mapeado para disco.

E então, quando B tenta fazer referência a um endereço que

mapeado para o disco, o sistema iria carregar dados

de memória, carregar os dados do disco e na memória.

Portanto, não vamos falar sobre esse aspecto do virtual

memória muito hoje.
A coisa a lembrar é apenas

que estas virtual endereço espaços, lá pode ser partes de

Este espaço de endereço virtual em cada um dos módulos que não é

na verdade é mapeado para qualquer espaço de endereço físico.

Portanto, se um destes módulos tenta usar um desses

espaços de endereço virtual não mapeado, não é permitido fazer isso.

Este sistema de memória virtual vai sinalizar um erro quando se tenta

fazer isso.
E no seu computador,

às vezes você verá programas que irão misteriosamente caiu

com as coisas que dizem coisas como, tentei acessar um ilegal

Endereço de memória.
Quando ele faz isso,

Isso é porque o programa tentar acessar algum local de memória

que não foi mapeado pelo sistema de memória virtual.

OK, então vamos mergulhar um pouco mais na verdade como neste virtual

abstração de memória funciona assim podemos tentar entender um pouco

pouco mais sobre o que está acontecendo.
Por isso vai ser uma

hardware simplificado do BM, OK?

Ele é um pouco simplificado mesmo do que você aprendeu sobre

em 6.004.
Assim, a idéia neste simplificado

o hardware é que temos nosso processador.

OK, e então nós vamos ter esse sistema de BM,

que às vezes é chamado uma unidade de gerenciamento de memória,

MMU.
E, isso é um pedaço de

hardware que vai nos ajudar a fazer esse mapeamento destes

endereços lógicos dos módulos lidar com espaços para o

memória física.
E então, nós vamos ter

a memória física, OK?

Agora a idéia é que, quando uma instrução tenta aceder a algumas

Endereço virtual, assim, por exemplo, suponha que nós

executar a instrução load algum endereço virtual,

carregar em R1 algum endereço virtual, OK?

O que vai acontecer quando nós fazemos, ou seja, que o

microprocessador vai enviar este endereço virtual para a VM

sistema.
E, em seguida, o sistema VM vai

para traduzir isso em algum endereço físico que pode ser

resolvidos dentro da própria memória.

OK, na forma que o sistema de memória virtual vai decidir

esse mapeamento entre um endereço virtual e um endereço físico

está usando algo que chamamos de um mapa de página,

Razoável?

OK, então esta tabela é um exemplo.

Assim, este é um mapa de página.
E o que uma página mapa basicamente

tem é apenas uma tabela de endereço virtual para o físico

mapeamentos de endereço.
Portanto, este é o endereço virtual

para o endereço físico.
Então a idéia é que, quando alguns

Endereço virtual vem aqui, o Gerenciador de memória virtual

Olha esse endereço virtual nesse mapa da página,

localiza o endereço físico correspondente,

e, em seguida, procura o endereço físico na memória real.

OK, então agora há mais um detalhe que precisamos,

direito?
Então, o que isso nos dá é nós

ter esta noção de uma página de mapa que é nada para nós.

Mas o que estamos perdendo um detalhe é que, OK, o que queríamos estava para

cada um destes módulos diferentes que está executando o

sistema para ter um espaço de endereço diferente associado

ele.
Então o que nós queremos é o que nós queremos

tem mapas da página separada para cada um destes módulos diferentes,

Assim, para o A e B, OK, vamos ter uma

mapa de página diferente.
E nós estamos indo para ter este

classificação da mesma, podemos ter várias cópias

de um endereço virtual particular em cada um destes página mapas.

E então o que vamos fazer é o que vamos alocar um

registo especial no hardware, no processador.

Vamos adicionar um pequeno cadastro que vai permitir que

-na manter-se a par de que um destes página mapas que estamos atualmente

olhando, OK?
Portanto, essa coisa é chamada a

PMAR ou o registro de endereço de página mapa.

OK, e o endereço da página mapa registrar simplesmente pontos em uma das

Estas página mapas.
OK, então o que acontece é que o

sistema de memória virtual, quando se quer resolver um

Endereço virtual, olha para este endereço de mapa da página

Cadastre-se e usa-os para encontrar um ponteiro para o início da

mapa da página que está atualmente em uso.

E, em seguida, ele usa o mapa da página que está atualmente em uso para

resolver, para obter o endereço físico corresponde a esta

endereço lógico.
OK, então isso é realmente o núcleo

conceito de memória virtual.
Então o que temos agora é que nós temos

Este registo de endereço de mapa de página que pode ser usado para selecionar quais

um desses espaços de endereço que estamos usando atualmente.

OK e então quando nós selecionamos, por exemplo,

o mapa de módulo A páginas e, em seguida, módulo um pode apenas referir-se

endereços virtuais que estão em seu mapa de página.

E esses endereços virtuais podem mapear apenas em certa física

endereços.
Assim, por exemplo,

Suponha que este bloco aqui é o conjunto de endereços virtuais,

o conjunto de endereços físicos que correspondem a virtual

endereços na página mapa.
OK, estas são apenas física

endereços que A falar.
Por isso, se nós, por exemplo,

tenho um bloco diferente de endereços de memória que correspondem

para os endereços virtuais que B pode fazer referência,

podemos ver que não há nenhuma maneira para o módulo A ser capaz de

referência qualquer da memória que B usa.

Assim, somos capazes de separar totalmente a memória física,

pedaços de memória física que A e B podem falar usando

Esse mecanismo de mapa de página que a memória virtual nos dá.

Então, basicamente o que fizemos é que espécie de adicionamos este

camada extra de engano, este sistema de memória virtual,

que obtém para mapear endereços virtuais em físicos

endereços.
Por isso o resto esta palestra é

realmente vai para ser detalhes sobre como podemos fazer este trabalho,

sobre como podemos realmente decidir, como podemos atribuir este PMAR

registo baseado em que um dos módulos é atualmente

execução sobre coisas como o que o formato deste mapa da página

tabela vai parecer, OK?

Assim, este é realmente o conceito-chave.

Então agora o que eu quero fazer é uma espécie de voltar para esta segunda

pergunta que fiz, que é, como funciona essa coisa de mapa da página

realmente funciona?
Como ele realmente é representado?

Portanto, uma representação muito simples de um mapa de página

pode ser que simplesmente é um ponteiro para o mapa de página apenas

diz onde A memória começa no processador,

direito?
Portanto, é apenas um valor.

Ele diz que A memória começa neste local no físico

memória e todos os endereços virtuais devem ser resolvidas

em relação a este local de início da memória.

O problema com essa representação é que não é

muito flexível.
Assim, por exemplo,

Suponha que haja um terceiro módulo, C, que é colocado para fora na memória

ao lado a.
Assim, o seu armazenamento é colocado direito

ao lado de A na memória.
E agora, suponha que A quer

alocar alguma memória adicional que pode usar.

Agora, para isso, se o mapa da página é simplesmente uma

único ponteiro para o início do espaço, de endereço

Estamos tipo de problemas.
Nós apenas não é possível adicionar memória para

parte inferior porque então nós iria se sobrepor C.

Então nós vamos ter que mover toda A memória em torno de

fim de ser capaz de fazer o espaço para isso.

OK, então isso parece como um pouco problemático simplesmente tê-lo

ser um ponteiro.
A outra coisa que podemos fazer é

Suponha que poderia, em vez disso, temos um diferente

opção onde poderíamos dizer, por exemplo,

para cada endereço virtual em um espaço, de endereço

Então, para cada valor de 32 bits que A quer resolver,

pode haver uma entrada na tabela de mapa nesta página,

direito?
Portanto, para cada 32 bits virtual

Endereço, haveria um correspondente físico de 32 bits

Endereço.
E havia apenas um

mapeamento entre todas estas coisas.

Assim, se A poderia fazer referência a 1 milhão de blocos de memória,

haveria 1 milhão entradas nesta tabela de mapa de página.

Então, se você pensar sobre isso por um minuto, que soa como tipo

de uma má idéia, também, porque agora estas tabelas

são totalmente enorme, à direita e na verdade eles são

quase tão grande quanto a memória de si, certo,

porque se eu tenho 1 milhão de entradas, se fazer referência A um

milhões de blocos, então eu vou precisar de um

milhões de entradas na tabela.
Assim, a tabela torna-se apenas como

grande como a própria memória.
Para isso precisamos de alguns entre tipo

híbrido de alternativa entre estes dois extremos.

E a idéia, mais uma vez, é muito simples.

E você viu isso em 6.004.
Então a idéia é aproveitar esta

Endereço virtual de 32 bits.
Assim, suponho que este é o nosso 32 bits

Endereço virtual.
Agora o que vamos fazer é

Vamos dividi-lo em dois pedaços, um número de página e um

deslocamento.
OK, e vamos escolher

alguns tamanho para estas duas coisas.
Por enquanto eu vou apenas arbitrariamente

escolher um número de página 20 bit e um bit 12 deslocamento.

OK, então o que isso vai fazer, então agora o que vamos

fazer é em vez de armazenar uma única palavra de memória em cada

entrada nesta tabela, vamos guardar uma página de

memória em cada entrada na tabela.

Assim-

Então, esta tabela vai olhar como um mapeamento entre uma página,

e um endereço físico.
OK, assim que uma página é,

assim se o número da página é de 20 bits longos, então isso significa que

cada página vai ser dois para os bits 12 grandes,

que é igual a, digamos, 4.096 palavras,

Razoável?
Então a idéia é que nós estamos indo

ter duas páginas XX dentro de cada espaço de endereço,

e cada página vai mapear um destes 4.096 bytes

blocos, OK?
Então, se temos aqui a nossa memória

nesta página, digamos, página vai mapear em

algum endereço físico.
E página dois vai mapear

em alguns outro bloco físico, OK, então cada uma dessas coisas

agora é 4.096 bytes, cada bloco aqui,

Razoável?
E assim é esta,

Vamos apenas expandir isso.
Por isso agora é uma página.

E vai ser usado a fim de procurar esse deslocamento de 12 bits

a palavra que queremos realmente olhar nesta página.

Assim, se o endereço virtual, digamos, por exemplo,

um deslocamento de página zero, o que vai fazer é

Vamos olhar para cima no mapa da página.

Nós vamos encontrar o número de página que corresponde,

Nós vamos encontrar um número de página.

Nós vamos encontrar o físico endereço que

corresponde a ele, nós estamos indo para ir para baixo aqui,

e olhar para este bloco de memória.

E então dentro desta memória 4.096 bloco,

Vamos tomar o endereço zero, a primeira palavra dentro desse

coisa, OK?
Então agora o tamanho destas página

tabelas é muito menor, certo?

Eles já não são dois a 30 bits.

Agora são dois para 20 bits, que é um número pequeno

de megabytes grandes.
Mas nós tenho evitado este problema

que temos.
Temos alguma flexibilidade em

termos de como os mapas de cada página na memória física.

Assim eu pode alocar uma terceira página, a um processo.

E pode mapear que em qualquer bloco de 4.096 bytes que está em

memória que está atualmente não utilizado.
OK, então eu tenho flexibilidade.

Eu não tenho esse problema, dizem, onde A e C foram

colidir uns com os outros.

OK, então este é o tipo de contorno de memória como virtual

obras.
Mas o que eu não tenho ainda

descrevi-lhe é como é que podemos realmente ir

Criando estas diferentes resolver espaços que são alocados para o

módulos diferentes, e como nós pode alternar entre

diferentes módulos usando este registo PMAR.

Então que tipo de descrevi isso como, suponho que esses dados

existem estruturas, agora aqui é como podemos usá-los.

Mas ainda não contei para vocês como essas estruturas de dados, todos se

juntos e criado e definido acima para começar com.

E sugeri isso no início.

Mas para isso, o que vamos precisar é

algum tipo de um módulo de supervisão especial que pode

olhar para a página de mapas para todos estes diferentes,

que é capaz de criar novos mapas de página e olhar para os página de mapas

para todos os módulos diferentes que estão dentro do sistema.

E o módulo de supervisão vai ser capaz de fazer coisas

como adicionar memória nova a um mapa de página ou ser capaz de destruir,

Exclua um módulo específico e seu mapa de página associado.

Por isso precisamos de algum tipo de coisa que pode gerenciar tudo isso

infra-estrutura.
Assim, este módulo de supervisão-

-é chamado o kernel.
OK, e o kernel é realmente,

vai ser a única coisa que vai ser responsável de

gerenciar todas essas estruturas de dados para nós.

Assim-

Então, aqui está nosso microprocessador com seu PMAR Registe-se.

E, o que vamos fazer é o que vamos estender o

microprocessador com uma peça adicional de hardware,

e este é o bit de kernel do usuário, OK?

Assim, este é apenas um pouco especifica se estamos

um módulo de usuário que é apenas um programa em execução no momento que

execução no seu computador, ou se o kernel está

atualmente executado, OK?

E a idéia com este bit kernel é que quando este kernel bit

é definida, o código que está executando o vai ter especial

privilégios.
Ele vai ser capaz de

Manipule coisas especiais sobre o hardware e o processador.

E, em particular, nós vamos ter uma regra que

diz-se que apenas o kernel pode alterar o PMAR,

Razoável?
Assim o PMAR é a coisa que

Especifica qual processo está sendo executado,

e seleciona quais queremos ser usando do espaço de endereçamento.

E o que vamos usar é o que vamos usar,

então o que vamos fazer é ter o kernel a ser a coisa

que é responsável por manipular o valor do registo PMAR

para selecionar qual coisa atualmente está sendo executada.

E queremos e eles ficam para que apenas o kernel pode fazer isso

porque se nós, por exemplo,

permitido um destes outros programas para ser capaz de

manipular o PMAR, direito, então esse outro programa

pode ser capaz de fazer algo desagradável para o computador,

direito?
Ele altera o PMAR para apontar para

alguns outros memória do programa.
E agora, de repente, todos os

endereços de memória no sistema vai ser resolvido.

Então de repente, nós vamos ser o tipo de

resolução de endereços de memória em relação a algum outro módulo

mapa da página.
E que é provável que seja um

coisa problemática.
É provável que fazer com que outros

módulo para bater, por exemplo,

porque o processador está configurado para executar as instruções

o programa atual.
Por isso queremos ter certeza que

apenas algo este kernel pode alterar o PMAR.

E este kernel vai ser esse tipo de módulo de supervisão

que todos os outros módulos vão ter a confiança para

tipo de fazer a coisa certa e gerenciar a execução do computador

Para você.
E este kernel,

exceto para este uma diferença que um kernel pode alterar o

PMAR, o kernel é, em todos os outros aspectos,

essencialmente apenas vai para ser outro módulo que está sendo executado no

o sistema de computador.
Assim, em particular,

o kernel também vai ter um destes 32 bits virtual

espaços de endereço associados a ele, OK?

Mas, o que vamos fazer é o que vamos dizer que o

núcleo no mesmo espaço de endereço tem todos os mapas de página de todos os

os outros programas que estão actualmente em execução no sistema

mapeado para o espaço de endereço.
OK, então isso é um pouco

complicado porque apresentei isso como se A e B referenciado

peças totalmente diferentes de memória.

Assim, espécie de afirmei até agora apenas sobre os módulos que estão

fazendo referência a conjuntos disjuntos de memória.

Mas na verdade estes mapas da página, à direita, apenas residem em

memória em algum lugar.
E ele é muito bem se eu,

por exemplo, tem vários módulos que são

capazes de referenciar, que têm o mesmo físico

endereços mapeados em seu espaço de endereço virtual.

Por isso, é muito provável que eu poderia querer ter algo

aqui na parte inferior que tanto A e B podem acessar.

Então, isso pode ser coisas que serão compartilhadas entre A e b.

Pode mapear que em ambos A e na B memória.

Da mesma forma, o que eu vou fazer é que eu sou

vai mapear esses mapas de página, que também são armazenados na memória

em todos os mapas da página no espaço de endereço do kernel.

Então o kernel vai ser capaz de fazer referência o endereço

espaços de todos os módulos.
E o kernel também vai

manter uma Mesinha de todos a página mapas para todos os

programas atualmente em execução no sistema.

Estas são, por exemplo,

página de mapas para A e b.
E esta é uma lista de todos os

mapas que estão actualmente em execução no sistema.

Então, o que vai acontecer, agora, o que pode acontecer é porque

o kernel é permitido alterar o PMAR, e ele sabe

sobre a localização de todos os outros espaços de endereço que está em

o sistema, quando se quer começar a correr um desses

programas que está em execução no sistema, ele pode alterar o valor

da PMAR ser sorte do PMAR para o A ou o PMAR para B.

E, ele pode manipular todos os valores de registradores na

sistema de modo que você pode iniciar a execução de código por um destes.

Você pode alternar entre um destes dois módulos.

Assim o processo de comutação entre qual módulo

está sendo executado.
Vamos focar no que

mais da próxima vez.
Assim, não se preocupe muito se você

não entendo os detalhes de como você realmente mudar de

execução de um programa para outro programa.

Mas, você pode ver que o kernel pode alternar qual endereço

espaço está ativo no momento, simplesmente manipulando o valor de

Este registo PMAR.
Além disso,

o kernel pode fazer coisas como ele pode criar um novo mapa.

Então o kernel pode simplesmente alocar dentre estes novos

tabelas e ele podem criar um mapeamento de um conjunto de virtual

aborda-se a um conjunto de endereços físicos para que você possa criar

um novo espaço de endereçamento que um novo módulo pode iniciar a execução

dentro.
Da mesma forma, o kernel pode fazer

coisas como alocam memória nova em um desses endereços.

Assim ele pode mapear alguns endereços virtuais adicionais em real

memória física para que quando um destes módulos,

digamos, por exemplo, solicitações de memória adicional para

executar, o kernel pode adicionar que a memória, adicione uma entrada para o

tabela assim que novo memória que o programa solicitou

na verdade mapeia para um endereço físico válido.

OK, então, é claro, então resta saber

assim você pode ver o valor de ter este módulo do kernel.

Mas a questão é, como nós nos comunicamos entre

Estes módulos que executam esses módulos de nível de usuário que

estão em execução e o módulo do kernel que os módulos de usuário

necessidade de chamar, por exemplo,

memória de novo pedido.
Assim a maneira que nós estamos indo

fazer que isso é como nós fizemos tudo mais nesta palestra

até agora: adicionando um pouco de extra, por alterar a

processador só um pouco.
Assim, em particular,

o que vamos fazer-

É o que vamos fazer é adicionar essa noção de uma

chamada de supervisor.
Chame esse SDC.

Então chamar um supervisor é simplesmente uma instrução especial que está na

o processador que invoca o kernel.

Assim quando o supervisor chamar instrução se,

ele vai configurar o estado destes kernel PMAR e usuário

instruções de bit para que o kernel pode começar a execução.

Também vai chamar o supervisor.

Mas quando o supervisor chamar instrução é executada,

temos de ser um baixo, mas cuidado, porque nós também precisamos decidir

de alguma forma que o código dentro do kernel queremos começar

executando quando executa a instrução de chamada de supervisor,

direito?
Assim que o supervisor call

instrução faz é que ele aceita um parâmetro que é o nome de um

função de chamada de portão.
Assim, uma função de portão é um bem

definido o ponto de entrada em outro módulo que pode ser usado para

invoca um pedaço de código em outro módulo.

Assim, por exemplo, o kernel vai ter um

função de porta específica que corresponde à atribuição de

memória adicional para um módulo.
Assim, quando executa um programa de usuário

uma instrução, chamada de supervisor,

para portão dizer por exemplo, isso pode ser alguma memória

código de alocação, esta instrução especial é

vai para fazer as seguintes coisas.

Primeiro ele vai definir o bit de kernel do usuário para o kernel.

Em seguida, vai definir o valor de registo para PMAR

o mapa de páginas do kernel.
Ele vai salvar o programa

contador para a instrução atualmente em execução,

e, em seguida, ele vai definir o contador de programa para ser o

Endereço da função portão, OK?

Assim que introduzimos uma instrução de processador novo especial que

leva estas etapas.
Assim, quando esta instrução é

executado, que essencialmente mudar em execução dentro do

espaço de endereço do kernel.
OK e este kernel,

N, podemos começar a execução dentro do espaço de endereço do kernel na

Endereço desta função de portão dentro de endereço do kernel

espaço.
OK, então o que isso tem feito é

Este é um ponto de entrada bem definidas.

Se o programa tentar executar essa instrução com o nome

de uma função de portão que não existe, então, que o programa é

vai para obter um erro quando se tenta fazer isso.

Então o programa pode apenas nomear funções de portão que realmente

correspondem às coisas reais que o sistema operacional pode fazer,

que o kernel pode fazer.
E, portanto, o kernel então

vai ser chamado e tomar a ação que foi solicitada

do mesmo.
No retorno, essencialmente,

Assim, quando o kernel termina a execução desse processo,

quando ele termina a execução, a dizer, a alocação de memória

instrução, estamos apenas indo para reverter esta etapa.

Então vamos apenas definir o PMAR ser, vamos definir

o PMAR volta ao programa do usuário.

Vamos definir o bit de kernel do usuário de volta no modo de usuário.

E então, vamos voltar para o endereço de retorno salvo

que nós aqui, salvo o contador de programa memorizado

Endereço do programa do usuário.
Assim, quando o programa termina,

Quando o kernel termina este serviço em execução

instrução, o controle retornará apenas voltar para o programa

no lugar onde o programa precisa para começar a execução.

OK, então agora usando esta porta, então usando esta noção

então o que temos visto até agora é a capacidade para o,

podemos usar a abstração de memória virtual para proteger

as referências de memória de dois módulos entre si.

E nós vemos quando temos essa noção do kernel que pode ser

usado para, por exemplo, que pode ser usado para gerenciar

Estes espaços de endereçamento para alocar memória nova para estes endereços

espaços e em geral, espécie de gerenciar esses endereços

espaços.
Então este kernel também vai

nos permitir fazer exatamente o que definimos a tentar fazer,

que é agir como o intermediário chamado confiável

entre, digamos, por exemplo, um cliente e um servidor que executa o

na mesma máquina.

OK, então eu confio que intermediário é apenas um pedaço de

código.
Assim, suponha que temos um cliente e

um servidor, à direita e estes são dois pedaços de

código escrito por dois programadores diferentes.

Talvez os dois desenvolvedores não necessariamente confiam que o outro

desenvolvedor tem escrito um pedaço de código que é 100% infalível

porque ele não tem quaisquer erros.

Mas ambos os desenvolvedores podem estar dispostos a dizer que eles

vai confiar que o kernel está escrito corretamente e não

tem algum bug nele.
E assim eles estão dispostos a

permitir que o kernel sentar-se entre esses dois programas e

Certifique-se de que nenhum deles tem qualquer maus interações com

Um ou outro.
Então vamos ver como podemos usar

Este kernel, o kernel combinado com memória virtual a fim de

ser capaz de fazer isso.
Assim, suponho que este é nosso kernel.

Então, a idéia é que este kernel em execução tem, suponha que nós temos

[sue]? processos A e B que querem se comunicar com cada um

outros un de alguma forma.
E, nós já dissemos que nós

não quero que esses dois processos para ser capaz de referenciar diretamente

em cada um dos outros do memória porque que se torna dependente

Um ou outro.
Isso significa que se houver um bug

em A, que A pode substituir alguma memória no espaço de endereço do B e

causa B [OBSCURECE ruído].
Então, isso ' uma coisa ruim.

Então, ao invés, o que vamos fazer é o que vamos criar,

bem, uma coisa que podemos fazer é criar um conjunto especial de estas

chamadas de supervisor que estes dois módulos podem usar para interagir com

Um ou outro.
Assim, em particular,

talvez dentro do kernel mantemos uma fila de mensagens

que esses dois programas estão trocando uns com os outros,

uma lista das mensagens que eles estão trocando.

E, em seguida, suponha que A é, que vamos chamar esse cara,

A é um produtor.
Ele está criando mensagens.

E B é um consumidor.
Pode chamadas alguma função como

Posto que supervisionará a sua chamada como colocar que causará um

item de dados para ser colocado nessa fila.

E algum tempo depois, B pode chamar essa chamada de supervisor

Obter e puxar esse valor fora da fila, OK?

Então, em desta forma, o produtor e o consumidor

podem interagir uns com os outros.
Eles podem trocar dados com

uns dos outros e porque temos essa interface de portão,

Esta interface de porta bem definidas com essas Put e Get

chamadas está sendo chamadas pelo kernel, o kernel pode ser muito

cuidado, assim como no caso do cliente e o servidor que executa o

em duas máquinas diferentes.
Neste caso,

o kernel pode verificar cuidadosamente que estas colocar e receber comandos

que estes dois módulos diferentes estão chamando realmente são

formado corretamente, que os parâmetros são válidos,

que eles estão se referindo a locais válidos na memória.

E, portanto, o kernel pode classificar de garantir

que estes dois módulos não fazem coisas maliciosas uns aos outros

ou fazer com que os outros para quebrar.
Eis aqui um exemplo de

algo que é como uma comunicação entre processos.

Assim que você viu, por exemplo, você já viu uma instância de

comunicação entre processos quando estudou o papel do UNIX.

Nós conversamos sobre tubos e uma abstração de tubulação,

e como isso funciona.
Bem, os tubos são espécie de

algo que é implementado pelo kernel UNIX como um caminho para

dois programas para trocar dados entre si.

E, há muito esses tipos de serviços que nossos

as pessoas tendem a empurrar para o kernel que o kernel fornece

para outras aplicações, os módulos que estão em execução,

para que estes módulos podem, por exemplo,

interagir com o hardware ou interagir uns com os outros.

Então geralmente dentro de um kernel, você encontraria coisas como um arquivo

sistema, uma interface para a rede e você pode,

por exemplo, encontrar coisas como uma interface

para o hardware de gráficos.
OK, há algum tipo de

Comentário por isso se você olhar para o que realmente é dentro de um kernel,

há uma enorme quantidade de código que está indo para essas sementes.

Então eu acho que falamos anteriormente sobre como operar o Linux

sistema é muitos milhões de linhas de código.

Se você vai olhar para o kernel do Linux, o kernel do Linux é

provavelmente hoje na ordem de cerca de 5 milhões de linhas de código,

dizer que a maioria dos quais, dois-terços,

está relacionado com esses drivers de dispositivo chamados que gerenciar este

hardware de baixo nível.
Então este kernel ficou bastante

grande.
E um dos efeitos colaterais da

o kernel ficando grande é que talvez seja mais difícil para confiar nele,

direito?
Pode ser que você sorte de ter menos

confiança de que todo o código do kernel é realmente correto.

E você pode imaginar que, se você não confia o kernel então o

computador não vai ser tão estável como você gostaria de ser.

E este é um argumento para por que o Windows trava o tempo todo

é porque ele tem todos esses drivers nele e esses drivers

não são necessariamente escritos tudo perfeitamente.

Há dezenas de milhões de linhas de código no Windows,

e alguns deles falhar algumas vezes, e que faz com que o

computador inteiro para vir para baixo.
Para que haja uma tensão

Comunidade de sistemas operacionais sobre se você deve executar

essas coisas, você deve manter essas coisas

olha o sistema de arquivos ou o sistema de elementos gráficos dentro do kernel ou

Se você deve movê-los fora como serviços separados,

que pode ser chamado da mesma forma, por exemplo,

que A e B interagem uns com os outros, fazendo com que alguns dados

estrutura que tem armazenado dentro do kernel que buffers a

solicitações entre, digamos, o serviço e este,

dizer, por exemplo, o serviço de gráfica e programas dos usuários

que querem interagir com ele.
OK, então é basicamente isso para

hoje.
O que eu mostrei a você é,

bem, na verdade, temos mais alguns minutos.

Desculpe.
[RISOS] Eu sei que você é tudo

ficando até sair, mas assim, OK, eu só quero

rapidamente abordar um último tópico que é isso,

Então, o que eu mostrei-lhe até agora é como podemos usar a noção de

memória virtual a fim de proteger os dados,

proteger dois programas entre si, para que eles não podem

necessariamente interagir com uns dos outros dados.

Mas há algumas situações em que podemos realmente querer

tenho dois programas capazes de compartilhar alguns dados com os outros.

Então eu não sei se vocês se lembrar, mas quando foi de Hari

palestras anteriores, ele falou sobre como são

bibliotecas que ficar ligadas nos programas.

E uma das maneiras comuns que as bibliotecas são estruturadas estas

dias é uma biblioteca compartilhada chamada.

Assim, uma biblioteca compartilhada é algo que só é armazenado em

um local na memória física.
Mas vários módulos diferentes

que está em execução em que o sistema pode chamar funções dentro

Essa biblioteca compartilhada.
Portanto, para fazer este trabalho,

certo, temos de ter mapeado a memória para o compartilhada

biblioteca que tem todas as funções que essas outras

módulos querem chamar para os espaços de endereço para estes dois

módulos para que eles podem realmente executar o código que

lá.
Assim o sistema de memória virtual

torna muito trivial de fazer isso.

Assim, suponha que eu tenho o meu espaço de endereço para alguma função,

A e eu tenho o meu espaço de endereço para alguma função,

B. e suponha que essa função uma

módulo B e biblioteca de referências, uma referência a bibliotecas

um e dois.
OK, então, usando a memória virtual

sistema, suponha que nós temos, portanto, esta é a nossa memória física.

Assim, suponha que o módulo A, A, do programa é carregada.

E quando ele é carregado, o programa que executa outros

programas, o carregador neste caso, vai carregar isso

biblioteca compartilhada, um, como ele carrega para o programa A.

Então, ele vai carregar primeiro o código para A,

e, em seguida, ele vai carregar o código para um.

E, estas coisas vão sentar-se na memória em algum lugar.

Assim, dentro do espaço, vamos ter o código de endereçamento

A vai ser mapeado e o código para um vai ser

mapeado.
Agora, quando executa B,

à direita, o que queremos evitar, para a finalidade de compartilhados

bibliotecas é fazer com que quando os dois programas estão executando

e ambos usam a mesma biblioteca não há duas cópias

de que biblioteca de memória usando o dobro de

a memória de, direito, porque há todos os

Essas bibliotecas que compartilham de todos os programas de computador.

Por exemplo, no Linux existe o [LIB C?]

funções de biblioteca que implementa todas as de padrão que

as pessoas usam em programas em C.
Se houver 50 programas escritos

c em sua máquina Linux, você não quer ter 50

cópias desta biblioteca LIB C na memória.

Você quer ter apenas um.
Por isso que queremos é que quando

módulo B obtém carregado, queremos mapear este código

que é já foi mapeado para o espaço de endereço da em seu

memória também, OK?

E então, naturalmente, vamos ter que carregar

memória adicional para B-se e para a biblioteca de dois que A

já não tenha carregado.
Agora, aqueles que vão ser

carregado em alguns locais adicionais na memória na B,

vão ser carregados em alguns locais adicionais na

memória física e mapeados para A memória.

Então, isso é apenas mostrar que podemos realmente usar esta noção

de espaços de endereçamento, além de usá-lo para

isolar dois módulos, cada um com os outros para que eles não podem referir-se

memória de uns dos outros, também podemos usar isso como uma forma de

permitir que dois módulos compartilhar as coisas com os outros.

E, em particular, esta é uma boa idéia no caso

de coisas como bibliotecas compartilhadas, onde temos duas coisas,

ambos os programas precisam ser capaz de ler os mesmos dados.

Assim eles poderiam usar isso para fazer isso.

OK, então, o que vimos hoje foi esta noção de memória virtual

e espaços de endereçamento.
Vimos como temos o kernel

que é um intermediário de confiança entre dois aplicativos.

O que vamos ver a próxima vez é como podemos tirar isso

noção de virtualizar um computador.

Vimos como virtualizar a memória hoje.

Da próxima vez, vamos ver como vamos virtualizar o processador

a fim de criar a abstração de vários

processadores rodando em apenas uma peça única, física de

hardware.
Então vejo você amanhã.