Sistemas Operacionais: Conceitos e Mecanismos V - Gerncia de Memria

Prof. Carlos Alberto Maziero DAInf UTFPR http://dainf.ct.utfpr.edu.br/maziero 2 de junho de 2013

Este texto est licenciado sob a Licena Attribution-NonCommercial-ShareAlike 3.0 Unported da Creative Commons (CC). Em resumo, voc deve creditar a obra da forma especicada pelo autor ou licenciante (mas no de maneira que sugira que estes concedem qualquer aval a voc ou ao seu uso da obra). Voc no pode usar esta obra para ns comerciais. Se voc alterar, transformar ou criar com base nesta obra, voc poder distribuir a obra resultante apenas sob a mesma licena, ou sob uma licena similar presente. Para ver uma cpia desta licena, visite http://creativecommons.org/licenses/by-nc-sa/3.0/. Este texto foi produzido usando exclusivamente software livre: Sistema Operacional GNU/Linux (distriA buies Fedora e Ubuntu), compilador de texto L TEX 2 , gerenciador de referncias BibTeX, editor grco Inkscape, criadores de grcos GNUPlot e GraphViz e processador PS/PDF GhostScript, entre outros.

c Carlos Maziero

: SUMRIO

Sumrio
1 2 Estruturas de memria Endereos, variveis e funes 2.1 Endereos lgicos e fsicos . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Modelo de memria dos processos . . . . . . . . . . . . . . . . . . . . . . Estratgias de alocao 3.1 Parties xas . . . . . . . . . . . . 3.2 Alocao contgua . . . . . . . . . . 3.3 Alocao por segmentos . . . . . . 3.4 Alocao paginada . . . . . . . . . 3.4.1 Flags de controle . . . . . . 3.4.2 Tabelas multi-nveis . . . . 3.4.3 Cache da tabela de pginas 3.5 Alocao segmentada paginada . . Localidade de referncias Fragmentao Compartilhamento de memria Memria virtual 7.1 Mecanismo bsico . . . . . . . . . . . . 7.2 Ecincia de uso . . . . . . . . . . . . . 7.3 Algoritmos de substituio de pginas 7.3.1 Algoritmo FIFO . . . . . . . . . 7.3.2 Algoritmo timo . . . . . . . . 7.3.3 Algoritmo LRU . . . . . . . . . 7.3.4 Algoritmo da segunda chance 7.3.5 Algoritmo NRU . . . . . . . . . 7.3.6 Algoritmo do envelhecimento 7.4 Conjunto de trabalho . . . . . . . . . . 7.5 A anomalia de Belady . . . . . . . . . 7.6 Thrashing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 4 7 9 10 10 12 13 16 18 19 21 25 25 28 32 34 35 38 39 40 40 41 43 45 45 46 48 49

4 5 6 7

c Carlos Maziero

: Estruturas de memria

Resumo A memria principal um componente fundamental em qualquer sistema de computao. Ela constitui o espao de trabalho do sistema, no qual so mantidos os processos, threads, bibliotecas compartilhadas e canais de comunicao, alm do prprio ncleo do sistema operacional, com seu cdigo e suas estruturas de dados. O hardware de memria pode ser bastante complexo, envolvendo diversas estruturas, como caches, unidade de gerncia, etc, o que exige um esforo de gerncia signicativo por parte do sistema operacional. Uma gerncia adequada da memria essencial para o bom desempenho de um computador. Neste captulo sero estudados os elementos de hardware que compe a memria de um sistema computacional e os mecanismos implementados ou controlados pelo sistema operacional para a gerncia da memria.

Estruturas de memria

Existem diversos tipos de memria em um sistema de computao, cada um com suas prprias caractersticas e particularidades, mas todos com um mesmo objetivo: armazenar dados. Observando um sistema computacional tpico, pode-se identicar vrios locais onde dados so armazenados: os registradores e o cache interno do processador (denominado cache L1), o cache externo da placa-me (cache L2) e a memria principal (RAM). Alm disso, discos rgidos e unidades de armazenamento externas (pendrives, CD-ROMs, DVD-ROMs, tas magnticas, etc.) tambm podem ser considerados memria em um um sentido mais amplo, pois tambm tm como funo o armazenamento de dados. Esses componentes de hardware so construdos usando diversas tecnologias e por isso tm caractersticas distintas, como a capacidade de armazenamento, a velocidade de operao, o consumo de energia e o custo por byte armazenado. Essas caractersticas permitem denir uma hierarquia de memria, representada na forma de uma pirmide (Figura 1). Nessa pirmide, observa-se que memrias mais rpidas, como os registradores da CPU e os caches, so menores (tm menor capacidade de armazenamento), mais caras e consomem mais energia que memrias mais lentas, como a memria principal (RAM) e os discos rgidos. Alm disso, as memrias mais rpidas so volteis, ou seja, perdem seu contedo ao carem sem energia. Memrias que preservam seu contedo mesmo quando no tiverem energia so denominadas no-volteis. Outra caracterstica importante das memrias a rapidez de seu funcionamento, que pode ser detalhada em duas dimenses: tempo de acesso (ou latncia) e taxa de transferncia. O tempo de acesso caracteriza o tempo necessrio para iniciar uma transferncia de dados de/para um determinado meio de armazenamento. Por sua vez, a taxa de transferncia indica quantos bytes por segundo podem ser lidos/escritos naquele meio, uma vez iniciada a transferncia de dados. Para ilustrar esses dois conceitos complementares, a Tabela 1 traz valores de tempo de acesso e taxa de transferncia de alguns meios de armazenamento usuais. Neste captulo sero estudados os mecanismos envolvidos na gerncia da memria principal do computador, que geralmente constituda por um grande espao de 3

c Carlos Maziero

: Endereos, variveis e funes

registradores

cache L1

velocidade, custo e consumo de energia

cache L2

voltil no-voltil

memria RAM

memria Flash disco rgido

CD-ROM, DVD-ROM, ta magntica

capacidade

Figura 1: Hierarquia de memria.

Meio Cache L2 Memria RAM Memria ash (NAND) Disco rgido IDE Tempo de acesso 1 ns 60 ns 2 ms 10 ms (tempo necessrio para o deslocamento da cabea de leitura e rotao do disco at o setor desejado) de 100 ms a vrios minutos (caso a gaveta do leitor esteja aberta ou o disco no esteja no leitor) Taxa de transferncia 1 GB/s (1 ns/byte) 1 GB/s (1 ns/byte) 10 MB/s (100 ns/byte) 80 MB/s (12 ns/byte)

DVD-ROM

10 MB/s (100 ns/byte)

Tabela 1: Tempos de [Patterson and Henessy, 2005].

acesso

taxas

de

transferncia

tpicas

memria do tipo RAM (Random Access Memory ou memria de leitura/escrita). Tambm ser estudado o uso do disco rgido como extenso da memria principal, atravs de mecanismos de memria virtual (Seo 7). A gerncia dos espaos de armazenamento em disco rgido abordada no Captulo ??. Os mecanismos de gerncia dos caches L1 e L2 geralmente so implementados em hardware e so independentes do sistema operacional. Detalhes sobre seu funcionamento podem ser obtidos em [Patterson and Henessy, 2005].

Endereos, variveis e funes

Ao escrever um programa usando uma linguagem de alto nvel, como C, C++ ou Java, o programador usa apenas referncias a entidades abstratas, como variveis, funes, parmetros e valores de retorno. No h necessidade do programador denir 4

c Carlos Maziero

: Endereos, variveis e funes

ou manipular endereos de memria explicitamente. O trecho de cdigo em C a seguir (soma.c) ilustra esse conceito; nele, so usados smbolos para referenciar posies de dados (i e soma) ou de trechos de cdigo (main, printf e exit):
1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <stdlib.h> #include <stdio.h> int main () { int i, soma = 0 ; for (i=0; i< 5; i++) { soma += i ; printf ("i vale %d e soma vale %d\n", i, soma) ; } exit(0) ; }

Todavia, o processador do computador acessa endereos de memria para buscar as instrues a executar e seus operandos; acessa tambm outros endereos de memria para escrever os resultados do processamento das instrues. Por isso, quando programa soma.c for compilado, ligado a bibliotecas, carregado na memria e executado pelo processador, cada varivel ou trecho de cdigo denido pelo programador dever ocupar um espao especco e exclusivo na memria, com seus prprios endereos. A listagem a seguir apresenta o cdigo assembly correspondente compilao do programa soma.c. Nele, pode-se observar que no h mais referncias a nomes simblicos, apenas a endereos:

c Carlos Maziero

: Endereos, variveis e funes

00000000 <main>: 0: 8d 4c 24 04 lea 0x4(%esp),%ecx 4: 83 e4 f0 and $0xfffffff0,%esp 7: ff 71 fc pushl -0x4(%ecx) a: 55 push %ebp b: 89 e5 mov %esp,%ebp d: 51 push %ecx e: 83 ec 14 sub $0x14,%esp 11: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) 18: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp) 1f: eb 1f jmp 40 <main+0x40> 21: 8b 45 f8 mov -0x8(%ebp),%eax 24: 01 45 f4 add %eax,-0xc(%ebp) 27: 83 ec 04 sub $0x4,%esp 2a: ff 75 f4 pushl -0xc(%ebp) 2d: ff 75 f8 pushl -0x8(%ebp) 30: 68 00 00 00 00 push $0x0 35: e8 fc ff ff ff call 36 <main+0x36> 3a: 83 c4 10 add $0x10,%esp 3d: ff 45 f8 incl -0x8(%ebp) 40: 83 7d f8 04 cmpl $0x4,-0x8(%ebp) 44: 7e db jle 21 <main+0x21> 46: 83 ec 0c sub $0xc,%esp 49: 6a 00 push $0x0 4b: e8 fc ff ff ff call 4c <main+0x4c> Dessa forma, os endereos das variveis e trechos de cdigo usados por um programa devem ser denidos em algum momento entre a escrita do cdigo e sua execuo pelo processador, que pode ser: Durante a edio : o programador escolhe a posio de cada uma das variveis e do cdigo do programa na memria. Esta abordagem normalmente s usada na programao de sistemas embarcados simples, programados diretamente em linguagem de mquina. Durante a compilao : o compilador escolhe as posies das variveis na memria. Para isso, todos os cdigos-fonte que fazem parte do programa devem ser conhecidos no momento da compilao, para evitar conitos de endereos entre variveis. Uma outra tcnica bastante usada a gerao de cdigo independente de posio (PIC - Position-Independent Code), no qual todas as referncias a variveis so feitas usando endereos relativos (como 3.471 bytes aps o incio do mdulo, ou 15 bytes aps o program counter, por exemplo). Durante a ligao : o compilador gera smbolos que representam as variveis mas no dene seus endereos nais, gerando um arquivo que contm as instrues em linguagem de mquina e as denies das variveis utilizadas, denominado

c Carlos Maziero

: Endereos lgicos e fsicos

arquivo objeto1 . Os arquivos com extenso .o em UNIX ou .obj em Windows so exemplos de arquivos-objeto obtidos da compilao de arquivos em C ou outra linguagem de alto nvel. O ligador (ou link-editor) ento l todos os arquivos-objeto e as bibliotecas e gera um arquivo-objeto executvel, no qual os endereos de todas as variveis esto corretamente denidos. Durante a carga : tambm possvel denir os endereos de variveis e de funes durante a carga do cdigo em memria para o lanamento de um novo processo. Nesse caso, um carregador (loader) responsvel por carregar o cdigo do processo na memria e denir os endereos de memria que devem ser utilizados. O carregador pode ser parte do ncleo do sistema operacional ou uma biblioteca ligada ao executvel, ou ambos. Esse mecanismo normalmente usado na carga das bibliotecas dinmicas (DLL - Dynamic Linking Libraries). Durante a execuo : os endereos emitidos pelo processador durante a execuo do processo so analisados e convertidos nos endereos efetivos a serem acessados na memria real. Por exigir a anlise e a converso de cada endereo gerado pelo processador, este mtodo s vivel com o uso de hardware dedicado para esse tratamento. Esta a abordagem usada na maioria dos sistemas computacionais atuais (como os computadores pessoais), e ser descrita nas prximas sees. A Figura 2 ilustra os diferentes momentos da vida de um processo em que pode ocorrer a resoluo dos endereos de variveis e de cdigo.

2.1

Endereos lgicos e fsicos

Ao executar uma sequncia de instrues, o processador escreve endereos no barramento de endereos do computador, que servem para buscar instrues e operandos, mas tambm para ler e escrever valores em posies de memria e portas de entrada/sada. Os endereos de memria gerados pelo processador medida em que executa algum cdigo so chamados de endereos lgicos, porque correspondem lgica do programa, mas no so necessariamente iguais aos endereos reais das instrues e variveis na memria real do computador, que so chamados de endereos fsicos. Os endereos lgicos emitidos pelo processador so interceptados por um hardware especial denominado Unidade de Gerncia de Memria (MMU - Memory Management Unit), que pode fazer parte do prprio processador (como ocorre nos sistemas atuais) ou constituir um dispositivo separado (como ocorria na mquinas mais antigas). A MMU faz a anlise dos endereos lgicos emitidos pelo processador e determina os endereos fsicos correspondentes na memria da mquina, permitindo ento seu acesso pelo processador. Caso o acesso a um determinado endereo solicitado pelo processador no
Arquivos-objeto so formatos de arquivo projetados para conter cdigo binrio e dados provenientes de uma compilao de cdigo-fonte. Existem diversos formatos de arquivos-objeto; os mais simples, como os arquivos .com do DOS, apenas denem uma sequncia de bytes a carregar em uma posio xa da memria; os mais complexos, como os formatos UNIX ELF (Executable and Library Format) e Microsoft PE (Portable Executable Format), permitem denir sees internas, tabelas de relocao, informao de depurao, etc. [Levine, 2000].
1

c Carlos Maziero
edio/ programao

: Endereos lgicos e fsicos

cdigo fonte

arq.c

lib.c

biblioteca fonte

compilao

cdigo objeto

arq.o

lib.a

biblioteca esttica

ligao

cdigo executvel

arq.exe

lib.so lib.dll carga

biblioteca dinmica

execuo

processo

Figura 2: Momentos de atribuio de endereos. seja possvel, a MMU gera uma interrupo de hardware para noticar o processador sobre a tentativa de acesso indevido. O funcionamento bsico da MMU est ilustrado na Figura 3.

processador endereo lgico interrupo MMU endereo fsico

memria

endereo fsico dados

barramentos

endereos

Figura 3: Funcionamento bsico de uma MMU. A proteo de memria entre processos essencial para a segurana e estabilidade dos sistemas mais complexos, nos quais centenas ou milhares de processos podem estar 8

c Carlos Maziero

: Modelo de memria dos processos

na memria simultaneamente. A MMU pode ser rapidamente ajustada para mudar a forma de converso entre endereos lgicos e fsicos, o que permite implementar uma rea de memria exclusiva para cada processo do sistema. Assim, a cada troca de contexto entre processos, as regras de converso da MMU devem ser ajustadas para somente permitir o acesso rea de memria denida para cada novo processo corrente.

2.2

Modelo de memria dos processos

Cada processo visto pelo sistema operacional como uma cpsula isolada, ou seja, uma rea de memria exclusiva que s ele e o ncleo do sistema podem acessar. Essa rea de memria contm todas as informaes necessrias execuo do processo, divididas nas seguintes sees: TEXT : contm o cdigo a ser executado pelo processo, gerado durante a compilao e a ligao com as bibliotecas. Esta rea tem tamanho xo, calculado durante a compilao, e normalmente s deve estar acessvel para leitura e execuo. DATA : esta rea contm os dados estticos usados pelo programa, ou seja, suas variveis globais e as variveis locais estticas (na linguagem C, so as variveis denidas como static dentro das funes). Como o tamanho dessas variveis pode ser determinado durante a compilao, esta rea tem tamanho xo; deve estar acessvel para leituras e escritas, mas no para execuo. HEAP : rea usada para armazenar dados atravs de alocao dinmica, usando operadores como malloc e free ou similares. Esta rea tem tamanho varivel, podendo aumentar/diminuir conforme as alocaes/liberaes de memria feitas pelo processo. Ao longo do uso, esta rea pode se tornar fragmentada, ou seja, pode conter lacunas entre os blocos de memria alocados. So necessrios ento algoritmos de alocao que minimizem sua fragmentao. STACK : rea usada para manter a pilha de execuo do processo, ou seja, a estrutura responsvel por gerenciar o uxo de execuo nas chamadas de funo e tambm para armazenar os parmetros, variveis locais e o valor de retorno das funes. Geralmente a pilha cresce para baixo, ou seja, inicia em endereos elevados e cresce em direo aos endereos menores da memria. No caso de programas com mltiplas threads, esta rea contm somente a pilha do programa principal. Como threads podem ser criadas e destrudas dinamicamente, a pilha de cada thread mantida em uma rea prpria, geralmente alocada no heap. A Figura 4 apresenta a organizao da memria de um processo. Nela, observa-se que as duas reas de tamanho varivel (stack e heap) esto dispostas em posies opostas e vizinhas memria livre (no alocada). Dessa forma, a memria livre disponvel ao processo pode ser aproveitada da melhor forma possvel, tanto pelo heap quanto pelo stack, ou por ambos.

c Carlos Maziero
rea no alocada 0

: Estratgias de alocao

max

TEXT

DATA

HEAP

STACK

programa principal funes bibliotecas estticas

variveis dinmicas (malloc/free)

variveis globais variveis locais estticas buers internos

endereos de retorno de chamadas parmetros de funes variveis locais das funes

Figura 4: Organizao da memria de um processo.

Estratgias de alocao

Em um sistema mono-processo, em que apenas um processo por vez carregado em memria para execuo, a alocao da memria principal um problema simples de resolver: basta reservar uma rea de memria para o ncleo do sistema operacional e alocar o processo na memria restante, respeitando a disposio de suas reas internas, conforme apresentado na Figura 4. A memria reservada para o ncleo do sistema operacional pode estar no incio ou no nal da rea de memria fsica disponvel. Como a maioria das arquiteturas de hardware dene o vetor de interrupes (vide Seo ??) nos endereos iniciais da memria (tambm chamados endereos baixos), geralmente o ncleo tambm colocado na parte inicial da memria. Assim, toda a memria disponvel aps o ncleo do sistema destinada aos processos no nvel do usurio (user-level). A Figura 5 ilustra essa organizao da memria.
ncleo
0 vetor de interrupes rea para processo(s) no nvel usurio max

Figura 5: Organizao da memria do sistema. Nos sistemas multi-processos, vrios processos podem ser carregados na memria para execuo simultnea. Nesse caso, o espao de memria destinado aos processos deve ser dividido entre eles usando uma estratgia que permita ecincia e exibilidade de uso. As principais estratgias de alocao da memria fsica sero estudadas nas prximas sees.

3.1

Parties xas

A forma mais simples de alocao de memria consiste em dividir a memria destinada aos processos em N parties xas, de tamanhos iguais ou distintos. Em 10

c Carlos Maziero

: Parties xas

cada partio pode ser carregado um processo. Nesse esquema, a traduo entre os endereos lgicos vistos pelos processos e os endereos fsicos feita atravs de um simples registrador de relocao, cujo valor somado ao endereo lgico gerado pelo processador, a m de obter o endereo fsico correspondente. Endereos lgicos maiores que o tamanho da partio em uso so simplesmente rejeitados pela MMU. O exemplo da Figura 6 ilustra essa estratgia. No exemplo, o processo da partio 3 est executando e deseja acessar o endereo lgico 14.257. A MMU recebe esse endereo e o soma ao valor do registrador de relocao (110.000) para obter o endereo fsico 124.257, que ento acessado. Deve-se observar que o valor contido no registrador de relocao o endereo de incio da partio ativa (partio 3); esse registrador deve ser atualizado a cada troca de processo ativo.
processo na particao 3

tabela de incio das parties de memria 0 1 2 3 4 20.000 30.000 60.000 110.000 200.000 partio ativa registrador de relocao 110.000

14.257 (endereo lgico)

MMU
124.257 (endereo fsico)

ncleo
0
part 0 part 1 part 2 part 3 part 4

max

Figura 6: Alocao em parties xas. Essa abordagem extremamente simples, todavia sua simplicidade no compensa suas vrias desvantagens: Os processos podem ter tamanhos distintos dos tamanhos das parties, o que implica em reas de memria sem uso no nal de cada partio. O nmero mximo de processos na memria limitado ao nmero de parties, mesmo que os processos sejam pequenos. Processos maiores que o tamanho da maior partio no podero ser carregados na memria, mesmo se todas as parties estiverem livres. Por essas razes, esta estratgia de alocao pouco usada atualmente; ela foi muito usada no OS/360, um sistema operacional da IBM usado nas dcadas de 1960-70 [Tanenbaum, 2003]. 11

c Carlos Maziero

: Alocao contgua

3.2

Alocao contgua

A estratgia anterior, com parties xas, pode ser tornar bem mais exvel caso o tamanho de cada partio possa ser ajustado para se adequar demanda especca de cada processo. Nesse caso, a MMU deve ser projetada para trabalhar com dois registradores prprios: um registrador base, que dene o endereo inicial da partio ativa, e um registrador limite, que dene o tamanho em bytes dessa partio. O algoritmo de traduo de endereos lgicos em fsicos bem simples: cada endereo lgico gerado pelo processo em execuo comparado ao valor do registrador limite; caso seja maior ou igual a este, uma interrupo gerada pela MMU de volta para o processador, indicando um endereo invlido. Caso contrrio, o endereo lgico somado ao valor do registrador base, para a obteno do endereo fsico correspondente. A Figura 7 apresenta uma viso geral dessa estratgia. Na Figura, o processo p3 tenta acessar o endereo lgico 14.257.
TCB(P3) base limite
0 14.257 (endereo lgico) processo P3

limite 45.000 registradores atualizados na troca de contexto que ativou P3 el<lim no Erro: endereo invlido (IRQ)

sim base 110.000

MMU
Memria RAM 124.257 (endereo fsico)

ncleo
0

P1

P2

P3

P4

P5
max

rea acessvel a P3 110.000 (base) 154.999 (base+limite-1)

Figura 7: Alocao contgua de memria. Os valores dos registradores base e limite da MMU devem ser ajustados pelo despachante (dispatcher) a cada troca de contexto, ou seja, cada vez que o processo ativo substitudo. Os valores de base e limite para cada processo do sistema devem estar armazenados no respectivo TCB (Task Control Block, vide Seo ??). Obviamente, quando o ncleo estiver executando, os valores de base e limite devem ser ajustados respectivamente para 0 e , para permitir o acesso direto a toda a memria fsica. Alm de traduzir endereos lgicos nos endereos fsicos correspondentes, a ao da MMU propicia a proteo de memria entre os processos: quando um processo pi estiver executando, ele s pode acessar endereos lgicos no intervalo [0, limite(pi ) 1], que correspondem a endereos fsicos no intervalo [base(pi ), base(pi ) + limite(pi ) 1]. 12

c Carlos Maziero

: Alocao por segmentos

Ao detectar uma tentativa de acesso a um endereo fora desse intervalo, a MMU ir gerar uma solicitao de interrupo (IRQ - Interrupt ReQuest, vide Seo ??) para o processador, indicando o endereo invlido. Ao receber a interrupo, o processador interrompe o uxo de execuo do processo pi , retorna ao ncleo e ativa a rotina de tratamento da interrupo, que poder abortar o processo ou tomar outras providncias. A maior vantagem da estratgia de alocao contgua sua simplicidade: por depender apenas de dois registradores e de uma lgica simples para a traduo de endereos, pode ser implementada em hardware de baixo custo, ou mesmo incorporada a processadores mais simples. Todavia, uma estratgia pouco exvel e est muito sujeita fragmentao externa, conforme ser discutido na Seo 5.

3.3

Alocao por segmentos

A alocao por segmentos, ou alocao segmentada, uma extenso da alocao contgua, na qual o espao de memria de um processo fracionado em reas, ou segmentos, que podem ser alocados separadamente na memria fsica. Alm das quatro reas funcionais bsicas da memria do processo discutidas na Seo 2.2 (text, data, stack e heap), tambm podem ser denidos segmentos para tens especcos, como bibliotecas compartilhadas, vetores, matrizes, pilhas de threads, buers de entrada/sada, etc. Ao estruturar a memria em segmentos, o espao de memria de cada processo no mais visto como uma sequncia linear de endereos lgicos, mas como uma coleo de segmentos de tamanhos diversos e polticas de acesso distintas. A Figura 8 apresenta a viso lgica da memria de um processo e a sua forma de mapeamento para a memria fsica.
P1
S1 S5 S1 S4 S2 S6 S4 S3 S2 S3

P2

Memria RAM

ncleo
0

P1.S5

P2.S2

P1.S1

P2.S1

P1.S3

P1.S2

P2.S3

P2.S4

P1.S6

P1.S4

max

Figura 8: Alocao de memria por segmentos. No modelo de memria alocada por segmentos, os endereos gerados pelos processos devem indicar as posies de memria e os segmentos onde elas se encontram. Em 13

c Carlos Maziero

: Alocao por segmentos

outras palavras, este modelo usa endereos lgicos bidimensionais, compostos por pares [segmento:oset], onde segmento indica o nmero do segmento desejado e oset indica a posio desejada dentro do segmento. Os valores de oset variam de 0 (zero) ao tamanho do segmento. A Figura 9 mostra alguns exemplos de endereos lgicos usando alocao por segmentos.
P1
S1 S3

[3:1204] [1:5317]
0 S2 6000 0 4000

[2:5799]

10000

Figura 9: Endereos lgicos em segmentos. Na alocao de memria por segmentos, a forma de traduo de endereos lgicos em fsicos similar da alocao contgua. Contudo, como os segmentos podem ter tamanhos distintos e ser alocados separadamente na memria fsica, cada segmento ter seus prprios valores de base e limite, o que leva necessidade de denir uma tabela de segmentos para cada processo do sistema. Essa tabela contm os valores de base e limite para cada segmento usado pelo processo, alm de ags com informaes sobre cada segmento, como permisses de acesso, etc. (vide Seo 3.4.1). A Figura 10 apresenta os principais elementos envolvidos na traduo de endereos lgicos em fsicos usando memria alocada por segmentos. Nessa gura, ST reg indica o registrador que aponta para a tabela de segmentos ativa. Cabe ao compilador colocar os diversos trecho do cdigo-fonte de cada programa em segmentos separados. Ele pode, por exemplo, colocar cada vetor ou matriz em um segmento prprio. Dessa forma, erros frequentes como acessos a ndices alm do tamanho de um vetor iro gerar endereos fora do respectivo segmento, que sero detectados pelo hardware de gerncia de memria e noticados ao sistema operacional. A implementao da tabela de segmentos varia conforme a arquitetura de hardware considerada. Caso o nmero de segmentos usados por cada processo seja pequeno, a tabela pode residir em registradores especializados do processador. Por outro lado, caso o nmero de segmentos por processo seja elevado, ser necessrio alocar as tabelas na memria RAM. O processador 80.386 usa duas tabelas em RAM: a LDT (Local Descriptor Table), que dene os segmentos locais (exclusivos) de cada processo, e a GDT (Global Descriptor Table), usada para descrever segmentos globais que podem ser compartilhados entre processos distintos (vide Seo 6). Cada uma dessas duas tabelas comporta at 8.192 segmentos. As tabelas em uso pelo processo em execuo so indicadas por registradores especcos do processador. A cada troca de contexto, os registradores que indicam a tabela de segmentos ativa devem ser atualizados para reetir as reas de memria usadas pelo processo que ser ativado. Para cada endereo de memria acessado pelo processo em execuo, necessrio acessar a tabela de segmentos para obter os valores de base e limite correspondentes 14

c Carlos Maziero

: Alocao por segmentos

TCB(P3)
Segment Table address

processo P3 S4

registrador atualizado na troca de contexto que ativou P3 ST reg base

0 1

[4:6.914] (endereo lgico)

segmento

offset
6.914

limite 5.500 4.200 10.500 1.500 8.750 12.000 7.600

8.750 4

1.200 8.000 15.000 27.500 32.300 45.000 87.000

Tabela de segmentos (em memria RAM)

2 3 4 5 6

o<lim

no

Erro: violao de segmento (IRQ)

sim

...

... MMU

32.300

Memria RAM

39.214 (endereo fsico)

ncleo
0 32.300 (base)

P3.S4
max 41.049 (base+limite-1)

Figura 10: Traduo de endereos em memria alocada por segmentos. ao endereo lgico acessado. Todavia, como as tabelas de segmentos normalmente se encontram na memria principal, esses acessos tm um custo signicativo: considerando um sistema de 32 bits, para cada acesso memria seriam necessrias pelo menos duas leituras adicionais na memria, para ler os valores de base e limite, o que tornaria cada acesso memria trs vezes mais lento. Para contornar esse problema, os processadores denem alguns registradores de segmentos, que permitem armazenar os valores de base e limite dos segmentos mais usados pelo processo ativo. Assim, caso o nmero de segmentos em uso simultneo seja pequeno, no h necessidade de consultar a tabela de segmentos com excessiva frequncia, o que mantm o desempenho de acesso memria em um nvel satisfatrio. O processador 80.386 dene os seguintes registradores de segmentos: CS: Code Segment, indica o segmento onde se encontra o cdigo atualmente em execuo; este valor automaticamente ajustado no caso de chamadas de funes de bibliotecas, chamadas de sistema, interrupes ou operaes similares. SS: Stack Segment, indica o segmento onde se encontra a pilha em uso pelo processo atual; caso o processo tenha vrias threads, este registrador deve ser ajustado a cada troca de contexto entre threads.

15

c Carlos Maziero

: Alocao paginada

DS, ES, FS e GS: Data Segments, indicam quatro segmentos com dados usados pelo processo atual, que podem conter variveis globais, vetores ou reas alocadas dinamicamente. Esses registradores podem ser ajustados em caso de necessidade, para acessar outros segmentos de dados. O contedo desses registradores preservado no TCB (Task Control Block) de cada processo a cada troca de contexto, tornando o acesso memria bastante eciente caso poucos segmentos sejam usados simultaneamente. Portanto, o compilador tem uma grande responsabilidade na gerao de cdigo executvel: minimizar o nmero de segmentos necessrios execuo do processo a cada instante, para no prejudicar o desempenho de acesso memria. Exemplos de processadores que utilizam a alocao por segmentos incluem o 80.386 e seus sucessores (486, Pentium, Athlon e processadores correlatos).

3.4

Alocao paginada

Conforme visto na Seo anterior, a alocao de memria por segmentos exige o uso de endereos bidimensionais na forma [segmento:oset], o que pouco intuitivo para o programador e torna mais complexa a construo de compiladores. Alm disso, uma forma de alocao bastante suscetvel fragmentao externa, conforme ser discutido na Seo 5. Essas decincias levaram os projetistas de hardware a desenvolver outras tcnicas para a alocao da memria principal. Na alocao de memria por pginas, ou alocao paginada, o espao de endereamento lgico dos processos mantido linear e unidimensional (ao contrrio da alocao por segmentos, que usa endereos bidimensionais). Internamente, e de forma transparente para os processos, o espao de endereos lgicos dividido em pequenos blocos de mesmo tamanho, denominados pginas. Nas arquiteturas atuais, as pginas geralmente tm 4 Kbytes (4.096 bytes), mas podem ser encontradas arquiteturas com pginas de outros tamanhos2 . O espao de memria fsica destinado aos processos tambm dividido em blocos de mesmo tamanho que as pginas, denominados quadros (do ingls frames). A alocao dos processos na memria fsica ento feita simplesmente indicando em que quadro da memria fsica se encontra cada pgina de cada processo, conforme ilustra a Figura 11. importante observar que as pginas de um processo podem estar em qualquer posio da memria fsica disponvel aos processos, ou seja, podem estar associadas a quaisquer quadros, o que permite uma grande exibilidade de alocao. Alm disso, as pginas no usadas pelo processo no precisam estar mapeadas na memria fsica, o que proporciona maior ecincia no uso da mesma. O mapeamento entre as pginas de um processo e os quadros correspondentes na memria fsica feita atravs de uma tabela de pginas (page table), na qual cada entrada corresponde a uma pgina e contm o nmero do quadro onde ela se encontra. Cada processo possui sua prpria tabela de pginas; a tabela de pginas ativa, que
As arquiteturas de processador mais recentes suportam diversos tamanhos de pginas, inclusive pginas muito grandes, as chamadas super-pginas (hugepages, superpages ou largepages). Uma super-pgina tem geralmente entre 1 e 16 MBytes, ou mesmo acima disso; seu uso em conjunto com as pginas normais permite obter mais desempenho no acesso memria, mas torna os mecanismos de gerncia de memria bem mais complexos. O artigo [Navarro et al., 2002] traz uma discusso mais detalhada sobre esse tema.
2

16

c Carlos Maziero
pginas processo P1
0 1 2 3 4 5 6 7 0 1 2 3

: Alocao paginada

processo P2
4 5 6 7

Memria RAM

ncleo
rea no-paginada
0 1 2 3 4 5 6

quadros

Figura 11: Alocao de memria por pginas. corresponde ao processo em execuo no momento, referenciada por um registrador do processador denominado PTBR Page Table Base Register. A cada troca de contexto, esse registrador deve ser atualizado com o endereo da tabela de pginas do novo processo ativo. A diviso do espao de endereamento lgico de um processo em pginas pode ser feita de forma muito simples: como as pginas sempre tm 2n bytes de tamanho (por exemplo, 212 bytes para pginas de 4 Kbytes) os n bits menos signicativos de cada endereo lgico denem a posio daquele endereo dentro da pgina (deslocamento ou oset), enquanto os bits restantes (mais signicativos) so usados para denir o nmero da pgina. Por exemplo, o processador Intel 80.386 usa endereos lgicos de 32 bits e pginas com 4 Kbytes; um endereo lgico de 32 bits decomposto em um oset de 12 bits, que representa uma posio entre 0 e 4.095 dentro da pgina, e um nmero de pgina com 20 bits. Dessa forma, podem ser endereadas 220 pginas com 212 bytes cada (1.048.576 pginas com 4.096 bytes cada). Eis um exemplo de decomposio de um endereo lgico nesse sistema:

01805E9AH 0000 0001 1000 0000 0101 1110 1001 10102 0000 0001 1000 0000 01012 e 1110 1001 10102 bits 01805H e E9AH
20 12

bits

pgina

oset

pgina 01805H e oset E9AH

17

c Carlos Maziero

: Flags de controle

Para traduzir um endereo lgico no endereo fsico correspondente, a MMU precisa efetuar os seguintes passos: 1. decompor o endereo lgico em nmero de pgina e oset; 2. obter o nmero do quadro onde se encontra a pgina desejada; 3. construir o endereo fsico, compondo o nmero do quadro com o oset; como pginas e quadros tm o mesmo tamanho, o valor do oset preservado na converso; 4. caso a pgina solicitada no esteja mapeada em um quadro da memria fsica, a MMU deve gerar uma interrupo de falta de pgina (page fault) para o processador; 5. essa interrupo provoca o desvio da execuo para o ncleo do sistema operacional, que deve ento tratar a falta de pgina. A Figura 12 apresenta os principais elementos que proporcionam a traduo de endereos em um sistema paginado com pginas de 4.096 bytes.
processo P3
0 1 2 3 4 5 6 7

TCB(P3) PTBR
registrador atualizado na troca de contexto que ativou P3

0000 5E9A (endereo lgico)

PTBR
pgina
0 13 1 2

offset

A7 2F 4B

0000 5

E9A

Pginas no-mapeadas

3 4 5

Erro: falta de pgina (IRQ)

0002 F

Tabela de pginas (em memria RAM)

7 1A

quadro

offset

...

MMU
Memria RAM 0002 FE9A (endereo fsico)

ncleo
rea no-paginada
0 1 2 3 4 5 6 47

Figura 12: Traduo de endereos usando paginao.

3.4.1

Flags de controle

Como o espao de endereamento lgico de um processo pode ser extremamente grande (por exemplo, o espao de endereos lgicos de cada processo em uma arquitetura 18

c Carlos Maziero

: Tabelas multi-nveis

de 32 bits pode ir at 232 bytes), uma parte signicativa das pginas de um processo pode no estar mapeada em quadros de memria fsica. reas de memria no usadas por um processo no precisam estar mapeadas na memria fsica, o que permite um uso mais eciente da memria. Assim, a tabela de pginas de cada processo indica as reas no mapeadas com um ag adequado (vlido/invlido). Cada entrada da tabela de pginas de um processo contm o nmero do quadro correspondente e um conjunto de ags (bits) de controle, com diversas nalidades: Presena: indica se a pgina est presente (mapeada) no espao de endereamento daquele processo; Proteo: bits indicando os direitos de acesso do processo pgina (basicamente leitura, escrita e/ou execuo); Referncia: indica se a pgina foi referenciada (acessada) recentemente, sendo ajustado para 1 pelo prprio hardware a cada acesso pgina. Este bit usado pelos algoritmos de memria virtual (apresentados na Seo 7); Modicao: tambm chamado de dirty bit, ajustado para 1 pelo hardware a cada escrita na pgina, indicando se a pgina foi modicada aps ser carregada na memria; usado pelos algoritmos de memria virtual. Alm destes, podem ser denidos outros bits, indicando a poltica de caching da pgina, se uma pgina de usurio ou de sistema, se a pgina pode ser movida para disco, o tamanho da pgina (no caso de sistemas que permitam mais de um tamanho de pgina), etc. O contedo exato de cada entrada da tabela de pginas depende da arquitetura do hardware considerado. 3.4.2 Tabelas multi-nveis

Em uma arquitetura de 32 bits com pginas de 4 Kbytes, cada entrada na tabela de pginas ocupa cerca de 32 bits, ou 4 bytes (20 bits para o nmero de quadro e os 12 bits restantes para ags). Considerando que cada tabela de pginas tem 220 pginas, cada tabela ocupar 4 Mbytes de memria (4 220 bytes) se for armazenada de forma linear na memria. No caso de processos pequenos, com muitas pginas no mapeadas, uma tabela de pginas linear ocupar mais espao na memria que o prprio processo, como mostra a Figura 13, o que torna seu uso pouco interessante. Para resolver esse problema, so usadas tabelas de pginas multi-nveis, estruturadas na forma de rvores: uma tabela de pginas de primeiro nvel (ou diretrio de pginas) contm ponteiros para tabelas de pginas de segundo nvel, e assim por diante, at chegar tabela que contm os nmeros dos quadros desejados. Para percorrer essa rvore, o nmero de pgina dividido em duas ou mais partes, que so usadas de forma sequencial, um para cada nvel de tabela, at encontrar o nmero de quadro desejado. O nmero de nveis da tabela depende da arquitetura considerada: os processadores Intel 80.386 usam tabelas com dois nveis, os processadores Sun Sparc e DEC Alpha usam tabelas com 3 nveis; processadores mais recentes, como Intel Itanium, podem usar tabelas com 3 ou 4 nveis. 19

c Carlos Maziero
TCB(P3) PTBR
100 pginas mapeadas (CODE, DATA, HEAP) 1.048.576 pginas (espao de endereamento lgico)

: Tabelas multi-nveis

1.048.456 pginas no-mapeadas

20 pginas mapeadas (STACK)

1.048.576 ponteiros de 32 bits = 4 MBytes

Figura 13: Inviabilidade de tabelas de pgina lineares. Um exemplo permite explicar melhor esse conceito: considerando uma arquitetura de 32 bits com pginas de 4 Kbytes, 20 bits so usados para acessar a tabela de pginas. Esses 20 bits podem ser divididos em dois grupos de 10 bits que so usados como ndices em uma tabela de pginas com dois nveis:

01805E9AH 0000 0001 1000 0000 0101 1110 1001 10102 0000 0001 102 e 00 0000 01012 e 1110 1001 10102 bits 10 bits 0006H e 0005H e E9AH
10 12

bits

p1 0006H , p2 0005H e oset E9AH A traduo de endereos lgicos em fsicos usando uma tabela de pginas estruturada em dois nveis efetuada atravs dos seguintes passos, que so ilustrados na Figura 14: 1. o endereo lgico el (0180 5E9AH ) decomposto em um oset de 12 bits o (E9AH ) e dois nmeros de pgina de 10 bits cada: o nmero de pgina de primeiro nvel p1 (006H ) e o nmero de pgina de segundo nvel p2 (005H ); 2. o nmero de pgina p1 usado como ndice na tabela de pgina de primeiro nvel, para encontrar o endereo de uma tabela de pgina de segundo nvel; 3. o nmero de pgina p2 usado como ndice na tabela de pgina de segundo nvel, para encontrar o nmero de quadro q (2FH ) que corresponde a [p1 p2 ]; 4. o nmero de quadro q combinado ao oset o para obter o endereo fsico e f (0002 FE9AH ) correspondente ao endereo lgico solicitado el.

20

c Carlos Maziero
TCB(P3) PTBR
processo P3 registrador atualizado na troca de contexto que ativou P3
0 1 2 3 4 5 6 7

: Cache da tabela de pginas

0180 5E9A (endereo lgico)

PTBR
Tabela de pginas (em memria RAM)
0 1 2 3 4 5 6 7 006

0000000110 0000000101 111010011010

pg 1

pg2

offset
E9A

...

0 5C 1 14 2 2

2B 22 31

005

3 1A 3B 4 17 13 5 8E A4 6 10 7 8 9 19 7F 16

6C 21 4E 2F 7
0002F

71 9A 12 2C

quadro

offset

MMU
0002 FE9A (endereo fsico)

... ...

Memria RAM

ncleo
rea no-paginada
0 1 2 3 4 5 6 47

... ...

Figura 14: Tabela de pgina multi-nvel. Com a estruturao da tabela de pginas em nveis, a quantidade de memria necessria para armazen-la diminui signicativamente, sobretudo no caso de processos pequenos. Considerando o processo apresentado como exemplo na Figura 13, ele faria uso de uma tabela de primeiro nvel e somente duas tabelas de segundo nvel (uma para mapear suas primeiras pginas e outra para mapear suas ltimas pginas); todas as demais entradas da tabela de primeiro nvel estariam vazias. Assumindo que cada entrada de tabela ocupa 4 bytes, sero necessrios somente 12 Kbytes para armazenar essas trs tabelas (4 3 210 bytes). Na situao limite onde um processo ocupa toda a memria possvel, seriam necessrias uma tabela de primeiro nvel e 1.024 tabelas de segundo nvel. Essas tabelas ocupariam de 4 (210 210 + 210 ) bytes, ou seja, 0,098% a mais que se a tabela de pginas fosse estruturada em um s nvel (4 220 bytes). Essas duas situaes extremas de alocao esto ilustradas na Figura 15. 3.4.3 Cache da tabela de pginas

A estruturao das tabelas de pginas em vrios nveis resolve o problema do espao ocupado pelas tabelas de forma muito eciente, mas tem um efeito colateral muito nocivo: aumenta drasticamente o tempo de acesso memria. Como as tabelas de pginas so armazenadas na memria, cada acesso a um endereo de memria implica 21

c Carlos Maziero
Nvel 1

: Cache da tabela de pginas

...

Nvel 2

RAM (quadros) Nvel 1

...

Nvel 2

...

...

...

RAM (quadros)

Figura 15: Tabela de pginas multi-nvel vazia (alto) e cheia (baixo). em mais acessos para percorrer a rvore de tabelas e encontrar o nmero de quadro desejado. Em um sistema com tabelas de dois nveis, cada acesso memria solicitado pelo processador implica em mais dois acessos, para percorrer os dois nveis de tabelas. Com isso, o tempo efetivo de acesso memria se torna trs vezes maior. Quando um processo executa, ele acessa endereos de memria para buscar instrues e operandos e ler/escrever dados. Em cada instante, os acessos tendem a se concentrar em poucas pginas, que contm o cdigo e as variveis usadas naquele instante3 . Dessa forma, a MMU ter de fazer muitas tradues consecutivas de endereos nas mesmas pginas, que iro resultar nos mesmos quadros de memria fsica. Por isso, consultas recentes tabela de pginas so armazenadas em um cache dentro da prpria MMU,
3

Esse fenmeno conhecido como localidade de referncias e ser detalhado na Seo 4.

22

c Carlos Maziero

: Cache da tabela de pginas

evitando ter de repeti-las constantemente e assim diminuindo o tempo de acesso memria fsica. O cache de tabela de pginas na MMU, denominado TLB (Translation Lookaside Buer) ou cache associativo, armazena pares [pgina, quadro] obtidos em consultas recentes s tabelas de pginas do processo ativo. Esse cache funciona como uma tabela de hash: dado um nmero de pgina p em sua entrada, ele apresenta em sua sada o nmero de quadro q correspondente, ou um ag de erro chamado erro de cache (cache miss). Por ser implementado em um hardware especial rpido e caro, geralmente esse cache pequeno: TLBs de processadores tpicos tm entre 16 e 256 entradas. Seu tempo de acesso pequeno: um acerto custa cerca de 1 ciclo de relgio da CPU, enquanto um erro pode custar entre 10 e 30 ciclos. A traduo de endereos lgicos em fsicos usando TLBs se torna mais rpida, mas tambm mais complexa. Ao receber um endereo lgico, a MMU consulta o TLB; caso o nmero do quadro correspondente esteja em cache, ele usado para compor o endereo fsico e o acesso memria efetuado. Caso contrrio, uma busca normal (completa) na tabela de pginas deve ser realizada. O quadro obtido nessa busca usado para compor o endereo fsico e tambm adicionado ao TLB para agilizar as consultas futuras. A Figura 16 apresenta os detalhes desse procedimento.
TCB(P3) PTBR
processo P3 registrador atualizado na troca de contexto que ativou P3
0 1 2 3 4 5 6 7

0180 5E9A (endereo lgico)

PTBR
Tabela de pginas (em memria RAM)
0 1 2 3 4 5 6 7 006

0000000110 0000000101 111010011010

pg 1

pg2

offset
E9A

... TLB

01805

p1,p2

0 5C 1 14 2 2

2B 22 31

005

3 1A 3B 4 17 13 5 8E A4 6 10 7 8 9 19 7F 16

update 0002F 0002F

6C 21 4E 2F 7

71 9A 12 2C

quadro

offset

MMU
0002 FE9A (endereo fsico)

... ...

Memria RAM

ncleo
rea no-paginada
0 1 2 3 4 5 6 47

... ...

Figura 16: Uso da TLB.

23

c Carlos Maziero

: Cache da tabela de pginas

fcil perceber que, quanto maior a taxa de acertos do TLB (cache hit ratio), melhor o desempenho dos acessos memria fsica. O tempo mdio de acesso memria pode ento ser determinado pela mdia ponderada entre o tempo de acesso com acerto de cache e o tempo de acesso no caso de erro. Por exemplo, considerando um sistema operando a 2 GHz (relgio de 0,5 ns) com tempo de acesso RAM de 50 ns, tabelas de pginas com 3 nveis e um TLB com custo de acerto de 0,5 ns (um ciclo de relgio), custo de erro de 10 ns (20 ciclos de relgio) e taxa de acerto de 95%, o tempo mdio de acesso memria pode ser estimado como segue: tmdio = 95% 0, 5ns + 5% (10ns + 3 50ns) + 50ns // em caso de acerto // em caso de erro, consultar as tabelas // acesso ao quadro desejado

tmdio = 58, 475ns Este resultado indica que o sistema de paginao multi-nvel aumenta em 8,475 ns (16,9%) o tempo de acesso memria, o que razovel considerando-se os benefcios e exibilidade que esse sistema traz. Todavia, esse custo muito dependente da taxa de acerto do TLB: no clculo anterior, caso a taxa de acerto fosse de 90%, o custo adicional seria de 32,9%; caso a taxa subisse a 99%, o custo adicional cairia para 4,2%. Obviamente, quanto mais entradas houverem no TLB, melhor ser sua taxa de acerto. Contudo, trata-se de um hardware caro e volumoso, por isso os processadores atuais geralmente tm TLBs com poucas entradas (geralmente entre 16 e 256 entradas). Por exemplo, o Intel i386 tem um TLB com 64 entradas para pginas de dados e 32 entradas para pginas de cdigo; por sua vez, o Intel Itanium tem 128 entradas para pginas de dados e 96 entradas para pginas de cdigo. O tamanho do TLB um fator que inuencia a sua taxa de acertos, mas h outros fatores importantes a considerar, como a poltica de substituio das entradas do TLB. Essa poltica dene o que ocorre quando h um erro de cache e no h entradas livres no TLB: em alguns processadores, a associao [pgina, quadro] que gerou o erro adicionada ao cache, substituindo a entrada mais antiga; todavia, na maioria dos processadores mais recentes, cada erro de cache provoca uma interrupo, que transfere ao sistema operacional a tarefa de gerenciar o contedo do TLB [Patterson and Henessy, 2005]. Outro aspecto que inuencia signicativamente a taxa de acerto do TLB a forma como cada processo acessa a memria. Processos que concentram seus acessos em poucas pginas de cada vez faro um uso eciente desse cache, enquanto processos que acessam muitas pginas distintas em um curto perodo iro gerar frequentes erros de cache, prejudicando seu desempenho no acesso memria. Essa propriedade conhecida como localidade de referncia (Seo 4). Finalmente, importante observar que o contedo do TLB reete a tabela de pginas ativa, que indica as pginas de memria pertencentes ao processo em execuo naquele momento. A cada troca de contexto, a tabela de pginas substituda e portanto o cache TLB deve ser esvaziado, pois seu contedo no mais vlido. Isso permite concluir que trocas de contexto muito frequentes prejudicam a ecincia de acesso memria, tornando o sistema mais lento. 24

c Carlos Maziero

: Alocao segmentada paginada

3.5

Alocao segmentada paginada

Cada uma das principais formas de alocao de memria vistas at agora tem suas vantagens: a alocao contgua prima pela simplicidade e rapidez; a alocao por segmentos oferece mltiplos espaos de endereamento para cada processo, oferecendo exibilidade ao programador; a alocao por pginas oferece um grande espao de endereamento linear, enquanto elimina a fragmentao externa. Alguns processadores oferecem mais de uma forma de alocao, deixando aos projetistas do sistema operacional a escolha da forma mais adequada de organizar a memria usada por seus processos. Vrios processadores permitem combinar mais de uma forma de alocao. Por exemplo, os processadores Intel i386 permitem combinar a alocao com segmentos com a alocao por pginas, visando oferecer a exibilidade da alocao por segmentos com a baixa fragmentao da alocao por pginas. Nessa abordagem, os processos vem a memria estruturada em segmentos, conforme indicado na Figura 9. O hardware da MMU converte os endereos lgicos na forma [segmento:oset] para endereos lgicos lineares (unidimensionais), usando as tabelas de descritores de segmentos (Seo 3.3). Em seguida, esse endereos lgicos lineares so convertidos nos endereos fsicos correspondentes atravs do hardware de paginao (tabelas de pginas e TLB), visando obter o endereo fsico correspondente. Apesar do processador Intel i386 oferece as duas formas de alocao de memria, a maioria dos sistemas operacionais que o suportam no fazem uso de todas as suas possibilidades: os sistemas da famlia Windows NT (2000, XP, Vista) e tambm os da famlia UNIX (Linux, FreeBSD) usam somente a alocao por pginas. O antigo DOS e o Windows 3.* usavam somente a alocao por segmentos. O OS/2 da IBM foi um dos poucos sistemas operacionais comerciais a fazer uso pleno das possibilidades de alocao de memria nessa arquitetura, combinando segmentos e pginas.

Localidade de referncias

A forma como os processos acessam a memria tem um impacto direto na ecincia dos mecanismos de gerncia de memria, sobretudo o cache de pginas (TLB, Seo 3.4.3) e o mecanismo de memria virtual (Seo 7). Processos que concentram seus acessos em poucas pginas de cada vez faro um uso eciente desses mecanismos, enquanto processos que acessam muitas pginas distintas em um curto perodo iro gerar frequentes erros de cache (TLB) e faltas de pgina, prejudicando seu desempenho no acesso memria. A propriedade de um processo ou sistema concentrar seus acessos em poucas reas da memria a cada instante chamada localidade de referncias [Denning, 2006]. Existem ao menos trs formas de localidade de referncias: Localidade temporal : um recurso usado h pouco tempo ser provavelmente usado novamente em um futuro prximo (esta propriedade usada pelos algoritmos de gerncia de memria virtual); Localidade espacial : um recurso ser mais provavelmente acessado se outro recurso prximo a ele j foi acessado ( a propriedade vericada na primeira execuo); 25

c Carlos Maziero

: Localidade de referncias

Localidade sequencial : um caso particular da localidade espacial, no qual h uma predominncia de acesso sequencial aos recursos (esta propriedade til na otimizao de sistemas de arquivos). Como exemplo prtico da importncia da localidade de referncias, considere um programa para o preenchimento de uma matriz de 4.096 4.096 bytes, onde cada linha da matriz est alocada em uma pgina distinta (considerando pginas de 4.096 bytes). O trecho de cdigo a seguir implementa essa operao, percorrendo a matriz linha por linha:
1 2 3 4 5 6 7 8 9 10

unsigned char buffer[4096][4096] ; int main () { int i, j ; for (i=0; i<4096; i++) // percorre as linhas do buffer for (j=0; j<4096; j++) // percorre as colunas do buffer buffer[i][j]= (i+j) % 256 ; }

Outra implementao possvel seria percorrer a matriz coluna por coluna, conforme o cdigo a seguir:
1 2 3 4 5 6 7 8 9 10

unsigned char buffer[4096][4096] ; int main () { int i, j ; for (j=0; j<4096; j++) // percorre as colunas do buffer for (i=0; i<4096; i++) // percorre as linhas do buffer buffer[i][j]= (i+j) % 256 ; }

Embora percorram a matriz de forma distinta, os dois programas geram o mesmo resultado e so conceitualmente equivalentes (a Figura 17 mostra o padro de acesso memria dos dois programas). Entretanto, eles no tm o mesmo desempenho. A primeira implementao (percurso linha por linha) usa de forma eciente o cache da tabela de pginas, porque s gera um erro de cache a cada nova linha acessada. Por outro lado, a implementao com percurso por colunas gera um erro de cache TLB a cada clula acessada, pois o cache TLB no tem tamanho suciente para armazenar as 4.096 entradas referentes s pginas usadas pela matriz. A diferena de desempenho entre as duas implementaes pode ser grande: em processadores Intel e AMD, verses 32 e 64 bits, o primeiro cdigo executa cerca de 10 vezes mais rapidamente que o segundo! Alm disso, caso o sistema no tenha memria suciente para manter as 4.096 pginas em memria, o mecanismo de memria virtual ser ativado, fazendo com que a diferena de desempenho seja muito maior.

26

c Carlos Maziero
i pginas

: Localidade de referncias

0 0

4095

1 2 3 4

4095

Figura 17: Comportamento dos programas no acesso memria. A diferenca de comportamento das duas execues pode ser observada na Figura 18, que mostra a distribuio dos endereos de memria acessados pelos dois cdigos4 . Nos grcos, percebe-se claramente que a primeira implementao tem uma localidade de referncias muito mais forte que a segunda: enquanto a primeira execuo usa em mdia 5 pginas distintas em cada 100.000 acessos memria, na segunda execuo essa mdia sobe para 3.031 pginas distintas.

Figura 18: Localidade de referncias nas duas execues. A Figura 19 traz outro exemplo de boa localidade de referncias. Ela mostra as pginas acessadas durante uma execuo do visualizador grco gThumb, ao abrir um arquivo de imagem. O grco da esquerda d uma viso geral da distribuio dos acessos na memria, enquanto o grco da direita detalha os acessos da parte inferior, que corresponde s reas de cdigo, dados e heap do processo.
Como a execuo total de cada cdigo gera mais de 500 milhes de referncias memria, foi feita uma amostragem da execuo para construir os grcos.
4

27

c Carlos Maziero

: Fragmentao

Figura 19: Distribuio dos acessos memria do programa gThumb: viso geral ( esquerda) e detalhe da parte inferior ( direita). A localidade de referncia de uma implementao depende de um conjunto de fatores, que incluem: As estruturas de dados usadas pelo programa: estruturas como vetores e matrizes tm seus elementos alocados de forma contgua na memria, o que leva a uma localidade de referncias maior que estruturas mais dispersas, como listas encadeadas e rvores; Os algoritmos usados pelo programa: o comportamento do programa no acesso memria denido pelos algoritmos que ele implementa; A qualidade do compilador: cabe ao compilador analisar quais variveis e trechos de cdigo so usadas com frequncia juntos e coloc-los nas mesmas pginas de memria, para aumentar a localidade de referncias do cdigo gerado. A localidade de referncias uma propriedade importante para a construo de programas ecientes. Ela tambm til em outras reas da computao, como a gerncia das pginas armazenadas nos caches de navegadores web e servidores proxy, nos mecanismos de otimizao de leituras/escritas em sistemas de arquivos, na construo da lista arquivos recentes dos menus de muitas aplicaes interativas, etc.

Fragmentao

Ao longo da vida de um sistema, reas de memria so liberadas por processos que concluem sua execuo e outras reas so alocadas por novos processos, de forma contnua. Com isso, podem surgir reas livres (vazios ou buracos na memria) entre os processos, o que constitui um problema conhecido como fragmentao externa. Esse problema somente afeta as estratgias de alocao que trabalham com blocos de tamanho varivel, como a alocao contgua e a alocao segmentada. Por outro lado, a alocao paginada sempre trabalha com blocos de mesmo tamanho (os quadros e pginas), sendo por isso imune fragmentao externa. 28

c Carlos Maziero

: Fragmentao

A fragmentao externa prejudicial porque limita a capacidade de alocao de memria no sistema. A Figura 20 apresenta um sistema com alocao contgua de memria no qual ocorre fragmentao externa. Nessa Figura, observa-se que existem 68 MBytes de memria livre em quatro reas separadas (A1 . . . A4 ), mas somente processos com at 28 MBytes podem ser alocados (usando a maior rea livre, A4 ). Alm disso, quanto mais fragmentada estiver a memria livre, maior o esforo necessrio para gerenci-la: as reas livres so mantidas em uma lista encadeada de rea de memria, que manipulada a cada pedido de alocao ou liberao de memria.
A1: 20M A2: 8M A3: 12M A4: 28M

ncleo

P1

P2

P3

P4

24M

40M

60M

72M

80M

88M

100M

116M

144M

Figura 20: Memria com fragmentao externa. Pode-se enfrentar o problema da fragmentao externa de duas formas: minimizando sua ocorrncia, atravs de critrios de escolha das reas a alocar, ou desfragmentando periodicamente a memria do sistema. Para minimizar a ocorrncia de fragmentao externa, cada pedido de alocao deve ser analisado para encontrar a rea de memria livre que melhor o atenda. Essa anlise pode ser feita usando um dos seguintes critrios: Melhor encaixe (best-t) : consiste em escolher a menor rea possvel que possa atender solicitao de alocao. Dessa forma, as reas livres so usadas de forma otimizada, mas eventuais resduos (sobras) podem ser pequenos demais para ter alguma utilidade. Pior encaixe (worst-t) : consiste em escolher sempre a maior rea livre possvel, de forma que os resduos sejam grandes e possam ser usados em outras alocaes. Primeiro encaixe (rst-t) : consiste em escolher a primeira rea livre que satisfaa o pedido de alocao; tem como vantagem a rapidez, sobretudo se a lista de reas livres for muito longa. Prximo encaixe (next-t) : variante da anterior (rst-t) que consiste em percorrer a lista a partir da ltima rea alocada ou liberada, para que o uso das reas livres seja distribudo de forma mais homognea no espao de memria. Diversas pesquisas [Johnstone and Wilson, 1999] demonstraram que as abordagens mais ecientes so a de melhor encaixe e a de primeiro encaixe, sendo esta ltima bem mais rpida. A Figura 21 ilustra essas estratgias. Outra forma de tratar a fragmentao externa consiste em desfragmentar a memria periodicamente. Para tal, as reas de memria usadas pelos processos devem ser movidas na memria de forma a concatenar as reas livres e assim diminuir a fragmentao. Ao mover um processo na memria, suas informaes de alocao (registrador base ou tabela de segmentos) devem ser ajustadas para reetir a nova posio do processo. 29

c Carlos Maziero

: Fragmentao

alocao de 10M rst-t A1: 20M A2: 8M best-t A3: 12M worst-t A4: 28M

ncleo

P1

P2

P3

P4

24M

40M

60M

72M

80M

88M

100M

116M

144M

Figura 21: Estratgias para minimizar a fragmentao externa. Obviamente, nenhum processo pode executar durante a desfragmentao. Portanto, importante que esse procedimento seja executado rapidamente e com pouca frequncia, para no interferir nas atividades normais do sistema. Como as possibilidades de movimentao de processos podem ser muitas, a desfragmentao deve ser tratada como um problema de otimizao combinatria, cuja soluo tima pode ser difcil de calcular. A Figura 22 ilustra trs possibilidades de desfragmentao de uma determinada situao de memria; as trs alternativas produzem o mesmo resultado, mas apresentam custos distintos.
Situao inicial

ncleo

P1
30M 40M

P2
20M 30M

P3
40M 20M

Soluo 1: deslocar P2 e P3 (custo: mover 60M)

ncleo

P1

P2

P3

Soluo 2: deslocar P3 (custo: mover 40M)

ncleo

P1

P3

P2

Soluo 3: deslocar P3 (custo: mover 20M)

ncleo

P1

P3

P2

Figura 22: Possibilidades de desfragmentao. Alm da fragmentao externa, que afeta as reas livres entre os processos, as estratgias de alocao de memria tambm podem apresentar a fragmentao interna, que pode ocorrer dentro das reas alocadas aos processos. A Figura 23 apresenta uma situao onde ocorre esse problema: um novo processo requisita uma rea de memria com 4.900 Kbytes. Todavia, a rea livre disponvel tem 5.000 Kbytes. Se for alocada 30

c Carlos Maziero

: Fragmentao

exatamente a rea solicitada pelo processo (situao A), sobrar um fragmento residual com 100 Kbytes, que praticamente intil para o sistema, pois muito pequeno para acomodar novos processos. Alm disso, essa rea residual de 100 Kbytes deve ser includa na lista de reas livres, o que representa um custo de gerncia desnecessrio. Outra possibilidade consiste em arredondar o tamanho da rea solicitada pelo processo para 5.000 Kbytes, ocupando totalmente aquela rea livre (situao B). Assim, haver uma pequena rea de 100 Kbytes no nal da memria do processo, que provavelmente no ser usada por ele.
situao inicial
5.000 Kbytes

Pedido de alocao de 4.900 Kbytes

Soluo 1: aloca 4.900 Kbytes

Soluo 2: aloca 5.000 Kbytes

4.900 Kbytes

5.000 Kbytes

fragmentao externa

fragmentao interna

Figura 23: Fragmentao interna. A fragmentao interna afeta todas as formas de alocao; as alocaes contgua e segmentada sofrem menos com esse problema, pois o nvel de arredondamento das alocaes pode ser decidido caso a caso. No caso da alocao paginada, essa deciso no possvel, pois as alocaes so feitas em pginas inteiras. Assim, em um sistema com pginas de 4 Kbytes (4.096 bytes), um processo que solicite a alocao de 550.000 bytes (134,284 pginas) receber 552.960 bytes (135 pginas), ou seja, 2.960 bytes a mais que o solicitado. Em mdia, para cada processo haver uma perda de 1/2 pgina de memria por fragmentao interna. Assim, uma forma de minimizar a perda por fragmentao interna seria usar pginas de menor tamanho (2K, 1K, 512 bytes ou ainda menos). Todavia, essa abordagem implica em ter mais pginas por processo, o que geraria tabelas de pginas maiores e com maior custo de gerncia.

31

c Carlos Maziero

: Compartilhamento de memria

Compartilhamento de memria

A memria RAM um recurso escasso, que deve ser usado de forma eciente. Nos sistemas atuais, comum ter vrias instncias do mesmo programa em execuo, como vrias instncias de editores de texto, de navegadores, etc. Em servidores, essa situao pode ser ainda mais frequente, com centenas ou milhares de instncias do mesmo programa carregadas na memria. Por exemplo, em um servidor de e-mail UNIX, cada cliente que se conecta atravs dos protocolos POP3 ou IMAP ter um processo correspondente no servidor, para atender suas consultas de e-mail (Figura 24). Todos esses processos operam com dados distintos (pois atendem a usurios distintos), mas executam o mesmo cdigo. Assim, centenas ou milhares de cpias do mesmo cdigo executvel podero coexistir na memria do sistema.
code cliente 1 code code code cliente 3 code code cliente 5 data5 heap5 stack5 data1 heap1 stack1 data2 heap2 stack2 data3 heap3 stack3 data4 heap4 stack4 cliente 4 cliente 2

...

datan heapn stackn cliente n

servidor de e-mail

Figura 24: Vrias instncias do mesmo processo. Conforme visto na Seo 2.2, a estrutura tpica da memria de um processo contm reas separadas para cdigo, dados, pilha e heap. Normalmente, a rea de cdigo no precisa ter seu contedo modicado durante a execuo, portanto geralmente essa rea protegida contra escritas (read-only). Assim, seria possvel compartilhar essa rea entre todos os processos que executam o mesmo cdigo, economizando memria fsica. O compartilhamento de cdigo entre processos pode ser implementado de forma muito simples e transparente para os processos envolvidos, atravs dos mecanismos de traduo de endereos oferecidos pela MMU, como segmentao e paginao. No caso da segmentao, bastaria fazer com que todos os segmentos de cdigo dos processos apontem para o mesmo segmento da memria fsica, como indica a Figura 25. importante observar que o compartilhamento transparente para os processos: cada processo continua a acessar endereos lgicos em seu prprio segmento de cdigo, buscando suas instrues a executar. No caso da paginao, a unidade bsica de compartilhamento a pgina. Assim, as entradas das tabelas de pginas dos processos envolvidos so ajustadas para referenciar os mesmos quadros de memria fsica. importante observar que, embora referenciem os mesmos endereos fsicos, as pginas compartilhadas podem ter endereos lgicos distintos. A Figura 26 ilustra o compartilhamento de pginas entre processos. 32

c Carlos Maziero

: Compartilhamento de memria

S4

S4

S2

S3 S4

S2

S3

S1

P2
S1

S2

S3

P1

S1

P3

Memria RAM

ncleo
0

P1.S2

P1.S3

P*.S1

P3.S3

P1.S3

P3.S2

P2.S3

P2.S4

P3.S4

P1.S4

max

Figura 25: Compartilhamento de segmentos.

processo P1
0 1 2 3 4 5 6 7 0 1 2 3

processo P2
4 5 6 7

Memria RAM

ncleo
rea no-paginada
0 1 2 3 4 5 6

Figura 26: Compartilhamento de pginas. O compartilhamento das reas de cdigo permite proporcionar uma grande economia no uso da memria fsica, sobretudo em servidores e sistemas multi-usurios. Por exemplo: consideremos um processador de textos que necessite de 100 MB de memria para executar, dos quais 60 MB so ocupados por cdigo executvel. Sem o compartilhamento de reas de cdigo, 10 instncias do editor consumiriam 1.000 MB de memria; com o compartilhamento, esse consumo cairia para 460 MB (60MB + 10 40MB). O mecanismo de compartilhamento de memria no usado apenas com reas de cdigo; em princpio, toda rea de memria protegida contra escrita pode ser compartilhada, o que poderia incluir reas de dados constantes, como tabelas de constantes, textos de ajuda, etc., proporcionando ainda mais economia de memria. Uma forma mais agressiva de compartilhamento de memria proporcionada pelo mecanismo denominado copiar-ao-escrever (COW - Copy-On-Write). Nele, todas as reas de memria de um processo (segmentos ou pginas) so passveis de compartilhamento por outros processos, condio que ele ainda no tenha modicado seu contedo. A idia central do mecanismo simples:

33

c Carlos Maziero

: Memria virtual

1. ao carregar um novo processo em memria, o ncleo protege todas as reas de memria do processo contra escrita (inclusive dados, pilha e heap), usando os ags da tabela de pginas (ou de segmentos); 2. quando o processo tentar escrever na memria, a MMU gera uma interrupo (negao de escrita) para o ncleo do sistema operacional; 3. o sistema operacional ajusta ento os ags daquela rea para permitir a escrita e devolve a execuo ao processo, para ele poder continuar; 4. processos subsequentes idnticos ao primeiro, ao serem carregados em memria, sero mapeados sobre as mesmas reas de memria fsica do primeiro processo que ainda estiverem protegidas contra escrita, ou seja, que ainda no foram modicadas por ele; 5. se um dos processos envolvidos tentar escrever em uma dessas reas compartilhadas, a MMU gera uma interrupo para o ncleo; 6. o ncleo ento faz uma cpia separada daquela rea fsica para o processo que deseja escrever nela e desfaz seu compartilhamento, ajustando as tabelas do processo que provocou a interrupo. Os demais processos continuam compartilhando a rea inicial. Todo esse procedimento feito de forma transparente para os processos envolvidos, visando compartilhar ao mximo as reas de memria dos processos e assim otimizar o uso da RAM. Esse mecanismo mais efetivo em sistemas baseados em pginas, porque normalmente as pginas so menores que os segmentos. A maioria dos sistemas operacionais atuais (Linux, Windows, Solaris, FreeBSD, etc.) usa esse mecanismo. reas de memria compartilhada tambm podem ser usadas para permitir a comunicao entre processos. Para tal, dois ou mais processos solicitam ao ncleo o mapeamento de uma rea de memria comum, sobre a qual podem ler e escrever. Como os endereos lgicos acessados nessa rea sero mapeados sobre a mesma rea de memria fsica, o que cada processo escrever nessa rea poder ser lido pelos demais, imediatamente. importante observar que os endereos lgicos em cada processo podero ser distintos, pois isso depende do mapeamento feito pela tabela de pginas (ou de segmentos) de cada processo; apenas os endereos fsicos sero iguais. Portanto, ponteiros (variveis que contm endereos lgicos) armazenados na rea compartilhada tero signicado para o processo que os escreveu, mas no necessariamente para os demais processos que acessam aquela rea. A Seo ?? traz informaes mais detalhadas sobre a comunicao entre processos atravs de memria compartilhada.

Memria virtual

Um problema constante nos computadores a disponibilidade de memria fsica: os programas se tornam cada vez maiores e cada vez mais processos executam simultaneamente, ocupando a memria disponvel. Alm disso, a crescente manipulao 34

c Carlos Maziero

: Mecanismo bsico

de informaes multimdia (imagens, udio, vdeo) contribui para esse problema, uma vez que essas informaes so geralmente volumosas e seu tratamento exige grandes quantidades de memria livre. Como a memria RAM um recurso caro (cerca de U$50/GByte no mercado americano, em 2007) e que consome uma quantidade signicativa de energia, aumentar sua capacidade nem sempre uma opo factvel. Observando o comportamento de um sistema computacional, constata-se que nem todos os processos esto constantemente ativos, e que nem todas as reas de memria esto constantemente sendo usadas. Por isso, as reas de memria pouco acessadas poderiam ser transferidas para um meio de armazenamento mais barato e abundante, como um disco rgido (U$0,50/GByte) ou um banco de memria ash (U$10/GByte)5 , liberando a memria RAM para outros usos. Quando um processo proprietrio de uma dessas reas precisar acess-la, ela deve ser transferida de volta para a memria RAM. O uso de um armazenamento externo como extenso da memria RAM se chama memria virtual; essa estratgia pode ser implementada de forma eciente e transparente para processos, usurios e programadores.

7.1

Mecanismo bsico

Nos primeiros sistemas a implementar estratgias de memria virtual, processos inteiros eram transferidos da memria para o disco rgido e vice-versa. Esse procedimento, denominado troca (swapping) permite liberar grandes reas de memria a cada transferncia, e se justica no caso de um armazenamento com tempo de acesso muito elevado, como os antigos discos rgidos. Os sistemas atuais raramente transferem processos inteiros para o disco; geralmente as transferncias so feitas por pginas ou grupos de pginas, em um procedimento denominado paginao (paging), detalhado a seguir. Normalmente, o mecanismo de memria virtual se baseia em pginas ao invs de segmentos. As pginas tm um tamanho nico e xo, o que permite simplicar os algoritmos de escolha de pginas a remover, os mecanismos de transferncia para o disco e tambm a formatao da rea de troca no disco. A otimizao desses fatores seria bem mais complexa e menos efetiva caso as operaes de troca fossem baseadas em segmentos, que tm tamanho varivel. A idia central do mecanismo de memria virtual em sistemas com memria paginada consiste em retirar da memria principal as pginas menos usadas, salvando-as em uma rea do disco rgido reservada para esse m. Essa operao feita periodicamente, de modo reativo (quando a quantidade de memria fsica disponvel cai abaixo de um certo limite) ou pr-ativo (aproveitando os perodos de baixo uso do sistema para retirar da memria as pginas pouco usadas). As pginas a retirar so escolhidas de acordo com algoritmos de substituio de pginas, discutidos na Seo 7.3. As entradas das tabelas de pginas relativas s pginas transferidas para o disco devem ento ser ajustadas de forma a referenciar os contedos correspondentes no disco rgido. Essa situao est ilustrada de forma simplicada na Figura 27. O armazenamento externo das pginas pode ser feito em em um disco exclusivo para esse m (usual em servidores de maior porte), em uma partio do disco principal
5

Estes valores so apenas indicativos, variando de acordo com o fabricante e a tecnologia envolvida.

35

c Carlos Maziero
processo P1
0 1 2 3 4 5 6 7 0 1 2 3

: Mecanismo bsico
processo P2
4 5 6 7

rea de troca Memria RAM

ncleo
rea no-paginada
0 1 2 3 4 5 6

Figura 27: Memria virtual paginada. (usual no Linux e outros UNIX) ou em um arquivo reservado dentro do sistema de arquivos do disco principal da mquina, geralmente oculto (como no Windows NT e sucessores). Em alguns sistemas, possvel usar uma rea de troca remota, em um servidor de arquivos de rede; todavia, essa soluo apresenta baixo desempenho. Por razes histricas, essa rea de disco geralmente denominada rea de troca (swap area), embora armazene pginas. No caso de um disco exclusivo ou partio de disco, essa rea geralmente formatada usando uma estrutura de sistema de arquivos otimizada para o armazenamento e recuperao rpida das pginas. As pginas que foram transferidas da memria para o disco provavelmente sero necessrias no futuro, pois seus processos proprietrios provavelmente continuam vivos. Quando um processo tentar acessar uma pgina ausente, esta deve ser transferida de volta para a memria para permitir seu acesso, de forma transparente ao processo. Conforme exposto na Seo 3.4, quando um processo acessa uma pgina, a MMU verica se a mesma est mapeada na memria RAM e, em caso positivo, faz o acesso ao endereo fsico correspondente. Caso contrrio, a MMU gera uma interrupo de falta de pgina (page fault) que fora o desvio da execuo para o sistema operacional. Nesse instante, o sistema deve vericar se a pgina solicitada no existe ou se foi transferida para o disco, usando os ags de controle da respectiva entrada da tabela de pginas. Caso a pgina no exista, o processo tentou acessar um endereo invlido e deve ser abortado. Por outro lado, caso a pgina solicitada tenha sido transferida para o disco, o processo deve ser suspenso enquanto o sistema transfere a pgina de volta para a memria RAM e faz os ajustes necessrios na tabela de pginas. Uma vez a pgina carregada em memria, o processo pode continuar sua execuo. O uxograma da Figura 28 apresenta as principais aes desenvolvidas pelo mecanismo de memria virtual. Nesse procedimento aparentemente simples h duas questes importantes. Primeiro, caso a memria principal j esteja cheia, uma ou mais pginas devero ser removidas para o disco antes de trazer de volta a pgina faltante. Isso implica em mais operaes de leitura e escrita no disco e portanto em mais demora para atender o pedido do processo. Muitos sistemas, como o Linux e o Solaris, mantm um processo daemon

36

c Carlos Maziero

: Mecanismo bsico

processo P tenta acessar uma pgina X

sim

a pgina X est presente?

no MMU gera interrupo (falta de pgina)

a pgina X existe?

no

endereo invlido: aborta o processo P

sim suspende o processo P

h espao na memria?

no

escolhe uma pgina "vtima", transfere essa pgina para o disco, ajusta a tabela de pginas

sim carrega a pgina X na memria, ajusta a tabela de pginas de P, acorda o processo P

P acessa a pgina X

Figura 28: Aes do mecanismo de memria virtual. com a nalidade de escolher e transferir pginas para o disco, ativado sempre que a quantidade de memria livre estiver abaixo de um limite mnimo. Segundo, retomar a execuo do processo que gerou a falta de pgina pode ser uma tarefa complexa. Como a instruo que gerou a falta de pgina no foi completada, ela deve ser re-executada. No caso de instrues simples, envolvendo apenas um endereo de memria sua re-execuo trivial. Todavia, no caso de instrues que envolvam vrias aes e vrios endereos de memria, deve-se descobrir qual dos endereos gerou a falta de pgina, que aes da instruo foram executadas e ento executar somente o que estiver faltando. A maioria dos processadores atuais prov registradores especiais que auxiliam nessa tarefa.

37

c Carlos Maziero

: Ecincia de uso

7.2

Ecincia de uso

O mecanismo de memria virtual permite usar o disco como uma extenso de memria RAM, de forma transparente para os processos. Seria a soluo ideal para as limitaes da memria principal, se no houvesse um problema importante: o tempo de acesso dos discos utilizados. Conforme os valores indicados na Tabela 1, um disco rgido tpico tem um tempo de acesso cerca de 100.000 vezes maior que a memria RAM. Cada falta de pgina provocada por um processo implica em um acesso ao disco, para buscar a pgina faltante (ou dois acessos, caso a memria RAM esteja cheia e outra pgina tenha de ser removida antes). Assim, faltas de pgina muito frequentes iro gerar muitos acessos ao disco, aumentando o tempo mdio de acesso memria e, em consequncia, diminuindo o desempenho geral do sistema. Para demonstrar o impacto das faltas de pgina no desempenho, consideremos um sistema cuja memria RAM tem um tempo de acesso de 60 ns (60 109 s) e cujo disco de troca tem um tempo de acesso de 6 ms (6 103 s), no qual ocorre uma falta de pgina a cada milho de acessos (106 acessos). Caso a memria no esteja saturada, o tempo mdio de acesso ser: tmdio = (999.999 60ns) + 6ms + 60ns 1.000.000 106 60 109 + 6 103 = 106

tmdio = 66ns Caso a memria esteja saturada, o tempo mdio ser maior: (999.999 60ns) + 2 6ms + 60ns 1.000.000 6 10 60 109 + 2 6 103 = 106

tmdio =

tmdio = 72ns Caso a frequncia de falta de pginas aumente para uma falta a cada 100.000 acessos (105 acessos), o tempo mdio de acesso memria subir para 180 ns, ou seja, trs vezes mais lento. A frequncia de faltas de pgina depende de vrios fatores, como: O tamanho da memria RAM, em relao demanda dos processos em execuo: sistemas com memria insuciente, ou muito carregados, podem gerar muitas faltas de pgina, prejudicando o seu desempenho e podendo ocasionar o fenmeno conhecido como thrashing (Seo 7.6). o comportamento dos processos em relao ao uso da memria: processos que agrupem seus acessos a poucas pginas em cada momento, respeitando a localidade 38

c Carlos Maziero

: Algoritmos de substituio de pginas

de referncias (Seo 4), necessitam usar menos pginas simultaneamente e geram menos faltas de pgina. A escolha das pginas a remover da memria: caso sejam removidas pginas usadas com muita frequncia, estas sero provavelmente acessadas pouco tempo aps sua remoo, gerando mais faltas de pgina. A escolha das pginas a remover tarefa dos algoritmos apresentados na Seo 7.3.

7.3

Algoritmos de substituio de pginas

A escolha correta das pginas a remover da memria fsica um fator essencial para a ecincia do mecanismo de memria virtual. Ms escolhas podero remover da memria pginas muito usadas, aumentando a taxa de faltas de pgina e e diminuindo o desempenho do sistema. Vrios critrios podem ser usados para escolher vtimas, ou seja, pginas a transferir da memria para a rea de troca no disco: Idade da pgina : h quanto tempo a pgina est na memria; pginas muito antigas talvez sejam pouco usadas. Frequncia de acessos pgina : pginas muito acessadas em um passado recente possivelmente ainda o sero em um futuro prximo. Data do ltimo acesso : pginas h mais tempo sem acessar possivelmente sero pouco acessadas em um futuro prximo (sobretudo se os processos respeitarem o princpio da localidade de referncias). Prioridade do processo proprietrio : processos de alta prioridade, ou de tempo-real, podem precisar de suas pginas de memria rapidamente; se elas estiverem no disco, seu desempenho ou tempo de resposta podero ser prejudicados. Contedo da pgina : pginas cujo contedo seja cdigo executvel exigem menos esforo do mecanismo de memria virtual, porque seu contedo j est mapeado no disco (dentro do arquivo executvel correspondente ao processo). Por outro lado, pginas de dados que tenham sido alteradas precisam ser salvas na rea de troca. Pginas especiais : pginas contendo buers de operaes de entrada/sada podem ocasionar diculdades ao ncleo caso no estejam na memria no momento em que ocorrer a transferncia de dados entre o processo e o dispositivo fsico. O processo tambm pode solicitar que certas pginas contendo informaes sensveis (como senhas ou chaves criptogrcas) no sejam copiadas na rea de troca, por segurana. Existem vrios algoritmos para a escolha de pginas a substituir na memria, visando reduzir a frequncia de falta de pginas, que levam em conta alguns dos fatores acima enumerados. Os principais sero apresentados na sequncia. Uma ferramenta importante para o estudo desses algoritmos a cadeia de referncias (reference string), que indica a sequncia de pginas acessadas por um processo durante 39

c Carlos Maziero

: Algoritmo FIFO

sua execuo. Ao submeter a cadeia de referncias de uma execuo aos vrios algoritmos, podemos calcular quantas faltas de pgina cada um geraria naquela execuo em particular e assim comparar sua ecincia. Cadeias de referncias de execues reais podem ser muito longas: considerando um tempo de acesso memria de 50 ns, em apenas um segundo de execuo ocorrem por volta de 20 milhes de acessos memria. Alm disso, a obteno de cadeias de referncias conveis uma rea de pesquisa importante, por envolver tcnicas complexas de coleta, ltragem e compresso de dados de execuo de sistemas [Uhlig and Mudge, 1997]. Para possibilitar a comparao dos algoritmos de substituio de pginas apresentados na sequncia, ser usada a seguinte cadeia de referncias ctcia, extrada de [Tanenbaum, 2003]: 0, 2, 1, 3, 5, 4, 6, 3, 7, 4, 7, 3, 3, 5, 5, 3, 1, 1, 1, 7, 1, 3, 4, 1 Deve-se observar que acessos consecutivos a uma mesma pgina no so relevantes para a anlise dos algoritmos, porque somente o primeiro acesso em cada grupo de acessos consecutivos provoca uma falta de pgina. 7.3.1 Algoritmo FIFO

Um critrio bsico a considerar para a escolha das pginas a substituir poderia ser sua idade, ou seja, o tempo em que esto na memria. Assim, pginas mais antigas podem ser removidas para dar lugar a novas pginas. Esse algoritmo muito simples de implementar: basta organizar as pginas em uma la de nmeros de pginas com poltica FIFO (First In, First Out). Os nmeros das pginas recm carregadas na memria so registrados no nal da lista, enquanto os nmeros das prximas pginas a substituir na memria so obtidos no incio da lista. A aplicao do algoritmo FIFO cadeia de referncias apresentada na Seo anterior, considerando uma memria fsica com 3 quadros, apresentada na Tabela 2. Nesse caso, o algoritmo gera no total 15 faltas de pgina. Apesar de ter uma implementao simples, na prtica este algoritmo no oferece bons resultados. Seu principal defeito considerar somente a idade da pgina, sem levar em conta sua importncia. Pginas carregadas na memria h muito tempo podem estar sendo frequentemente acessadas, como o caso de pginas contendo bibliotecas dinmicas compartilhadas por muitos processos, ou pginas de processos servidores lanados durante a inicializao (boot) da mquina. 7.3.2 Algoritmo timo

Idealmente, a melhor pgina a remover da memria em um dado instante aquela que car mais tempo sem ser usada pelos processos. Esta idia simples dene o algoritmo timo (OPT). Entretanto, como o comportamento futuro dos processos no pode ser previsto com preciso, este algoritmo no implementvel. Mesmo assim ele importante, porque dene um limite mnimo conceitual: se para uma dada cadeia de referncias, o algoritmo timo gera 17 faltas de pgina, nenhum outro algoritmo ir

40

c Carlos Maziero

: Algoritmo LRU

t 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

qo 0 0 0 3 3 3 6 6 6 4 4 4 4 4 4 4 1 1 1 1 1 1 1

antes q1 2 2 2 5 5 5 3 3 3 3 3 3 5 5 5 5 5 5 7 7 7 7

q2 1 1 1 4 4 4 7 7 7 7 7 7 7 3 3 3 3 3 3 3 4

pgina 0 2 1 3 5 4 6 3 7 4 7 3 3 5 5 3 1 1 1 7 1 3 4 1

qo 0 0 0 3 3 3 6 6 6 4 4 4 4 4 4 4 1 1 1 1 1 1 1 1

depois q1 2 2 2 5 5 5 3 3 3 3 3 3 5 5 5 5 5 5 7 7 7 7 7

q2 1 1 1 4 4 4 7 7 7 7 7 7 7 3 3 3 3 3 3 3 4 4

faltas

ao realizada p0 carregada no quadro vazio q0 p2 carregada em q1 p1 carregada em q2 p3 substitui p0 (a mais antiga na memria) p5 substitui p2 (idem) p4 substitui p1 p6 substitui p3 p3 substitui p5 p7 substitui p4 p4 substitui p6 p7 est na memria p3 est na memria p3 est na memria p5 substitui p3 p5 est na memria p3 substitui p7 p1 substitui p4 p1 est na memria p1 est na memria p7 substitui p5 p1 est na memria p3 est na memria p4 substitui p3 p1 est na memria

Tabela 2: Aplicao do algoritmo de substituio FIFO. gerar menos de 17 faltas de pgina ao tratar a mesma cadeia. Assim, seu resultado serve como parmetro para a avaliao dos demais algoritmos. A aplicao do algoritmo timo cadeia de referncias apresentada na Seo anterior, considerando uma memria fsica com 3 quadros, apresentada na Tabela 3. Nesse caso, o algoritmo gera 11 faltas de pgina, ou seja, 4 a menos que o algoritmo FIFO. 7.3.3 Algoritmo LRU

Uma aproximao implementvel do algoritmo timo proporcionada pelo algoritmo LRU (Least Recently Used, menos recentemente usado). Neste algoritmo, a escolha recai sobre as pginas que esto na memria h mais tempo sem ser acessadas. Assim, pginas antigas e menos usadas so as escolhas preferenciais. Pginas antigas mas de uso frequente no so penalizadas por este algoritmo, ao contrrio do que ocorre no algoritmo FIFO. Pode-se observar facilmente que este algoritmo simtrico do algoritmo OPT em relao ao tempo: enquanto o OPT busca as pginas que sero acessadas mais longe no futuro do processo, o algoritmo LRU busca as pginas que foram acessadas mais longe no seu passado. 41

c Carlos Maziero

: Algoritmo LRU

t 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

qo 0 0 0 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4

antes q1 2 2 2 5 5 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7

q2 1 1 1 4 4 4 4 4 4 4 4 5 5 5 1 1 1 1 1 1 1

pgina 0 2 1 3 5 4 6 3 7 4 7 3 3 5 5 3 1 1 1 7 1 3 4 1

qo 0 0 0 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4

depois q1 2 2 2 5 5 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7

q2 1 1 1 4 4 4 4 4 4 4 4 5 5 5 1 1 1 1 1 1 1 1

faltas

ao realizada p0 carregada no quadro vazio q0 p2 carregada em q1 p1 carregada em q2 p3 substitui p0 (no ser mais acessada) p5 substitui p2 (no ser mais acessada) p4 substitui p1 (s ser acessada em t = 17) p6 substitui p5 (s ser acessada em t = 14) p3 est na memria p7 substitui p6 (no ser mais acessada) p4 est na memria p7 est na memria p3 est na memria p3 est na memria p5 substitui p4 (s ser acessada em t = 23) p5 est na memria p3 est na memria p1 substitui p5 (no ser mais acessada) p1 est na memria p1 est na memria p7 est na memria p1 est na memria p3 est na memria p4 substitui p3 (no ser mais acessada) p1 est na memria

Tabela 3: Aplicao do algoritmo de substituio timo. A aplicao do algoritmo LRU cadeia de referncias apresentada na Seo anterior, considerando uma memria fsica com 3 quadros, apresentada na Tabela 4. Nesse caso, o algoritmo gera 14 faltas de pgina (trs faltas a mais que o algoritmo timo). O grco da Figura 29 permite a comparao dos algoritmos OPT, FIFO e LRU sobre a cadeia de referncias em estudo, em funo do nmero de quadros existentes na memria fsica. Pode-se observar que o melhor desempenho do algoritmo OPT, enquanto o pior desempenho proporcionado pelo algoritmo FIFO. O algoritmo LRU parte do pressuposto que pginas recentemente acessadas no passado provavelmente sero acessadas em um futuro prximo, e ento evita remov-las da memria. Esta hiptese se verica na prtica, sobretudo se os processos respeitam o princpio da localidade de referncia (Seo 4). Embora possa ser implementado, o algoritmo LRU bsico pouco usado na prtica, porque sua implementao exigiria registrar as datas de acesso s pginas a cada leitura ou escrita na memria, o que difcil de implementar de forma eciente em software e com custo proibitivo para implementar em hardware. Alm disso, sua implementao exigiria varrer as datas de acesso de todas as pginas para buscar a pgina com acesso mais antigo (ou manter uma lista de pginas ordenadas por data de acesso), o que

42

c Carlos Maziero

: Algoritmo da segunda chance

t 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

qo 0 0 0 3 3 3 6 6 6 4 4 4 4 5 5 5 5 5 5 7 7 7 4

antes q1 2 2 2 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3

q2 1 1 1 4 4 4 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1

pgina 0 2 1 3 5 4 6 3 7 4 7 3 3 5 5 3 1 1 1 7 1 3 4 1

qo 0 0 0 3 3 3 6 6 6 4 4 4 4 5 5 5 5 5 5 7 7 7 4 4

depois q1 2 2 2 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3

q2 1 1 1 4 4 4 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1

faltas

ao realizada p0 carregada no quadro vazio q0 p2 carregada em q1 p1 carregada em q2 p3 substitui p0 (h mais tempo sem acessos) p5 substitui p2 (idem) p4 substitui p1 (...) p6 substitui p3 p3 substitui p5 p7 substitui p4 p4 substitui p6 p7 est na memria p3 est na memria p3 est na memria p5 substitui p4 p5 est na memria p3 est na memria p1 substitui p7 p1 est na memria p1 est na memria p7 substitui p5 p1 est na memria p3 est na memria p4 substitui p7 p1 est na memria

Tabela 4: Aplicao do algoritmo de substituio LRU. exigiria muito processamento. Portanto, a maioria dos sistemas operacionais reais implementa algoritmos baseados em aproximaes do LRU. As prximas sees apresentam alguns algoritmos simples que permitem se aproximar do comportamento LRU. Por sua simplicidade, esses algoritmos tm desempenho limitado e por isso somente so usados em sistemas operacionais mais simples. Como exemplos de algoritmos de substituio de pginas mais sosticados e com maior desempenho podem ser citados o LIRS [Jiang and Zhang, 2002] e o ARC [Bansal and Modha, 2004]. 7.3.4 Algoritmo da segunda chance

O algoritmo FIFO move para a rea de troca as pginas h mais tempo na memria, sem levar em conta seu histrico de acessos. Uma melhoria simples desse algoritmo consiste em analisar o bit de referncia (Seo 3.4.1) de cada pgina candidata, para saber se ela foi acessada recentemente. Caso tenha sido, essa pgina recebe uma segunda chance, voltando para o m da la com seu bit de referncia ajustado para zero. Dessa forma, evita-se substituir pginas antigas mas muito acessadas. Todavia, caso todas as pginas sejam muito acessadas, o algoritmo vai varrer todas as pginas, ajustar todos os 43

c Carlos Maziero

: Algoritmo da segunda chance

20

OPT FIFO LRU

15

Faltas de pgina

10

0 1 2 3 4 Nmero de quadros de RAM 5 6 7

Figura 29: Comparao dos algoritmos de substituio de pginas. bits de referncia para zero e acabar por escolher a primeira pgina da la, como faria o algoritmo FIFO. Uma forma eciente de implementar este algoritmo atravs de uma la circular de nmeros de pgina, ordenados de acordo com seu ingresso na memria. Um ponteiro percorre a la sequencialmente, analisando os bits de referncia das pginas e ajustandoos para zero medida em que avana. Quando uma pgina vtima encontrada, ela movida para o disco e a pgina desejada carregada na memria no lugar da vtima, com seu bit de referncia ajustado para zero. Essa implementao conhecida como algoritmo do relgio e pode ser vista na Figura 30.
3 12
1 1

21
1

17
1 0

3 42 4
1

21
0 0

17
0 0

prxima vtima

ajustados para zero

12
0

23 4
1

nova pgina

2 11 26
0

2 0 11
bits de referncia nmeros de pgina
0

0 9

26

1 1 1

1 1 1

18 7

33 6

18 7

33 6

14

14

Figura 30: Algoritmo da segunda chance (ou do relgio).

44

c Carlos Maziero

: Algoritmo NRU

7.3.5

Algoritmo NRU

O algoritmo da segunda chance leva em conta somente o bit de referncia de cada pgina ao escolher as vtimas para substituio. O algoritmo NRU (Not Recently Used, ou no usada recentemente) melhora essa escolha, ao considerar tambm o bit de modicao (dirty bit, vide Seo 3.4.1), que indica se o contedo de uma pgina foi modicado aps ela ter sido carregada na memria. Usando os bits R (referncia) e M (modicao), possvel classicar as pginas em memria em quatro nveis de importncia: 00 (R = 0, M = 0): pginas que no foram referenciadas recentemente e cujo contedo no foi modicado. So as melhores candidatas substituio, pois podem ser simplesmente retiradas da memria. 01 (R = 0, M = 1): pginas que no foram referenciadas recentemente, mas cujo contedo j foi modicado. No so escolhas to boas, porque tero de ser gravadas na rea de troca antes de serem substitudas. 10 (R = 1, M = 0): pginas referenciadas recentemente, cujo contedo permanece inalterado. So provavelmente pginas de cdigo que esto sendo usadas ativamente e sero referenciadas novamente em breve. 11 (R = 1, M = 1): pginas referenciadas recentemente e cujo contedo foi modicado. So a pior escolha, porque tero de ser gravadas na rea de troca e provavelmente sero necessrias em breve. O algoritmo NRU consiste simplesmente em tentar substituir primeiro pginas do nvel 0; caso no encontre, procura candidatas no nvel 1 e assim sucessivamente. Pode ser necessrio percorrer vrias vezes a lista circular at encontrar uma pgina adequada para substituio. 7.3.6 Algoritmo do envelhecimento

Outra possibilidade de melhoria do algoritmo da segunda chance consiste em usar os bits de referncia das pginas para construir contadores de acesso s mesmas. A cada pgina associado um contador inteiro com N bits (geralmente 8 bits so sucientes). Periodicamente, o algoritmo varre as tabelas de pginas, l os bits de referncia e agrega seus valores aos contadores de acessos das respectivas pginas. Uma vez lidos, os bits de referncia so ajustados para zero, para registrar as referncias de pginas que ocorrero durante prximo perodo. O valor lido de cada bit de referncia no deve ser simplesmente somado ao contador, por duas razes: o contador chegaria rapidamente ao seu valor mximo (overow) e a simples soma no permitiria diferenciar acessos recentes dos mais antigos. Por isso, outra soluo foi encontrada: cada contador deslocado para a direita 1 bit, descartando o bit menos signicativo (LSB - Least Signicant Bit). Em seguida, o valor do bit de referncia colocado na primeira posio esquerda do contador, ou seja, em seu bit mais signicativo (MSB - Most Signicant Bit). Dessa forma, acessos mais recentes 45

c Carlos Maziero

: Conjunto de trabalho

tm um peso maior que acessos mais antigos, e o contador nunca ultrapassa seu valor mximo. O exemplo a seguir mostra a evoluo dos contadores para quatro pginas distintas, usando os valores dos respectivos bits de referncia R. Os valores decimais dos contadores esto indicados entre parnteses, para facilitar a comparao. Observe que as pginas acessadas no ltimo perodo (p2 e p4 ) tm seus contadores aumentados, enquanto aquelas no acessadas (p1 e p3 ) tm seus contadores diminudos. R 0 1 0 1 contadores 0000 0011 com 0011 1101 1010 1000 1110 0011 (3) (61) = (168) (227) R 0 0 0 0 contadores 0000 0001 e 1001 1110 0101 0100 1111 0001 (1) (158) (84) (241)

p1 p2 p3 p4

O contador construdo por este algoritmo constitui uma aproximao razovel do algoritmo LRU: pginas menos acessadas envelhecero, cando com contadores menores, enquanto pginas mais acessadas permanecero jovens, com contadores maiores. Por essa razo, esta estratgia conhecida como algoritmo do envelhecimento [Tanenbaum, 2003], ou algoritmo dos bits de referncia adicionais [Silberschatz et al., 2001].

7.4

Conjunto de trabalho

A localidade de referncias (estudada na Seo 4) mostra que os processos normalmente acessam apenas uma pequena frao de suas pginas a cada instante. O conjunto de pginas acessadas na histria recente de um processo chamado Conjunto de Trabalho (Working Set, ou ws) [Denning, 1980, Denning, 2006]. A composio do conjunto de trabalho dinmica, variando medida em que o processo executa e evolui seu comportamento, acessando novas pginas e deixando de acessar outras. Para ilustrar esse conceito, consideremos a cadeia de referncias apresentada na Seo 7.3. Considerando como histria recente as ltimas n pginas acessadas pelo processo, a evoluo do conjunto de trabalho ws do processo que gerou aquela cadeia apresentada na Tabela 5. O tamanho e a composio do conjunto de trabalho dependem do nmero de pginas consideradas em sua histria recente (o valor n na Tabela 5). Em sistemas reais, essa dependncia no linear, mas segue uma proporo exponencial inversa, devido localidade de referncias. Por essa razo, a escolha precisa do tamanho da histria recente a considerar no crtica. Esse fenmeno pode ser observado na Tabela 5: assim que a localidade de referncias se torna mais forte (a partir de t = 12), os trs conjuntos de trabalho cam muito similares. Outro exemplo apresentado na Figura 31, que mostra o tamanho mdio dos conjuntos de trabalhos observados na execuo do programa gThumb (analisado na Seo 4), em funo do tamanho da histria recente considerada (em nmero de pginas referenciadas). Se um processo tiver todas as pginas de seu conjunto de trabalho carregadas na memria, ele sofrer poucas faltas de pgina, pois somente acessos a novas pginas podero gerar faltas. Essa constatao permite delinear um algoritmo simples para 46

c Carlos Maziero
ws(n = 3) {0} {0, 2} {0, 2, 1} {2, 1, 3} {1, 3, 5} {3, 5, 4} {5, 4, 6} {4, 6, 3} {6, 3, 7} {3, 7, 4} {4, 7} {4, 7, 3} {7, 3} {3, 5} {3, 5} {5, 3} {5, 3, 1} {3, 1} {1} {1, 7} {7, 1} {7, 1, 3} {1, 3, 4} {3, 4, 1} ws(n = 4) {0} {0, 2} {0, 2, 1} {0, 2, 1, 3} {2, 1, 3, 5} {1, 3, 5, 4} {3, 5, 4, 6} {5, 4, 6, 3} {4, 6, 3, 7} {6, 3, 7, 4} {3, 4, 7} {4, 7, 3} {4, 7, 3} {7, 3, 5} {3, 5} {5, 3} {5, 3, 1} {5, 3, 1} {3, 1} {1, 7} {7, 1} {7, 1, 3} {7, 1, 3, 4} {3, 4, 1} ws(n = 5) {0} {0, 2} {0, 2, 1} {0, 2, 1, 3} {0, 2, 1, 3, 5} {2, 1, 3, 5, 4} {1, 3, 5, 4, 6} {5, 4, 6, 3} {5, 4, 6, 3, 7} {6, 3, 7, 4} {6, 3, 4, 7} {4, 7, 3} {4, 7, 3} {4, 7, 3, 5} {7, 3, 5} {5, 3} {5, 3, 1} {5, 3, 1} {5, 3, 1} {3, 1, 7} {3, 7, 1} {7, 1, 3} {7, 1, 3, 4} {7, 3, 4, 1}

: Conjunto de trabalho

t 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

pgina 0 2 1 3 5 4 6 3 7 4 7 3 3 5 5 3 1 1 1 7 1 3 4 1

Tabela 5: Conjuntos de trabalho ws para n = 3, n = 4 e n = 5.

350

Tamanho mdio do conjunto de trabalho (pginas)

300

250

200

150

100

50

0 0 1000 2000 3000 4000 5000 6000 Tamanho da histria recente (pginas) 7000 8000 9000

Figura 31: Tamanho do conjunto de trabalho do programa gThumb. substituio de pginas: s substituir pginas que no pertenam ao conjunto de

47

c Carlos Maziero

: A anomalia de Belady

trabalho de nenhum processo ativo. Contudo, esse algoritmo difcil de implementar, pois exigiria manter atualizado o conjunto de trabalho de cada processo a cada acesso memria, o que teria um custo computacional proibitivo. Uma alternativa mais simples e eciente de implementar seria vericar que pginas cada processo acessou recentemente, usando a informao dos respectivos bits de referncia. Essa a base do algoritmo WSClock (Working Set Clock) [Carr and Hennessy, 1981], que modica o algoritmo do relgio (Seo 7.3.4) da seguinte forma: 1. Uma data de ltimo acesso ta (p) associada a cada pgina p da la circular; essa data pode ser atualizada quando o ponteiro do relgio visita a pgina. 2. Dene-se um prazo de validade para as pginas, geralmente entre dezenas e centenas de mili-segundos; a idade i(p) de uma pgina p denida como a diferena entre sua data de ltimo acesso ta (p) e o instante corrente tc (i(p) = tc ta (p)). 3. Quando h necessidade de substituir pginas, o ponteiro percorre a la buscando pginas candidatas: (a) Ao encontrar uma pgina referenciada (com R = 1), sua data de ltimo acesso atualizada com o valor corrente do tempo (ta (p) = tc ), seu bit de referncia limpo (R = 0) e o ponteiro do relgio avana, ignorando aquela pgina. (b) Ao encontrar uma pgina no referenciada (com R = 0), se sua idade for menor que , a pgina est no conjunto de trabalho; caso contrrio, ela considerada fora do conjunto de trabalho e pode ser substituda. 4. Caso o ponteiro d uma volta completa na la e no encontre pginas com idade maior que , a pgina mais antiga (que tiver o menor ta (p)) encontrada na volta anterior substituda. 5. Em todas as escolhas, d-se preferncia a pginas no-modicadas (M = 0), pois seu contedo j est salvo no disco. O algoritmo WSClock pode ser implementado de forma eciente, porque a data ltimo acesso de cada pgina no precisa ser atualizada a cada acesso memria, mas somente quando a referncia da pgina na la circular visitada pelo ponteiro do relgio (caso R = 1). Todavia, esse algoritmo no uma implementao pura do conceito de conjunto de trabalho, mas uma composio de conceitos de vrios algoritmos: FIFO e segunda-chance (estrutura e percurso do relgio), Conjuntos de trabalho (diviso das pginas em dois grupos conforme sua idade), LRU (escolha das pginas com datas de acesso mais antigas) e NRU (preferncia s pginas no-modicadas).

7.5

A anomalia de Belady

Espera-se que, quanto mais memria fsica um sistema possua, menos faltas de pgina ocorram. Todavia, esse comportamento intuitivo no se verica em todos os algoritmos de substituio de pginas. Alguns algoritmos, como o FIFO, podem apresentar um comportamento estranho: ao aumentar o nmero de quadros de memria, 48

c Carlos Maziero

: Thrashing

o nmero de faltas de pgina geradas pelo algoritmo aumenta, ao invs de diminuir. Esse comportamento atpico de alguns algoritmos foi estudado pelo matemtico hngaro Laslo Belady nos anos 60, sendo por isso denominado anomalia de Belady. A seguinte cadeia de referncias permite observar esse fenmeno; o comportamento dos algoritmos OPT, FIFO e LRU ao processar essa cadeia pode ser visto na Figura 32, que exibe o nmero de faltas de pgina em funo do nmero de quadros de memria disponveis no sistema. A anomalia pode ser observada no algoritmo FIFO: ao aumentar a memria de 4 para 5 quadros, esse algoritmo passa de 22 para 24 faltas de pgina. 0, 1, 2, 3, 4, 0, 1, 2, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 5, 0, 1, 2, 3, 4, 5
30

OPT FIFO LRU

25

20 Faltas de pgina

15

10

0 1 2 3 4 Nmero de quadros de RAM 5 6 7

Figura 32: A anomalia de Belady. Estudos demonstraram que uma famlia de algoritmos denominada algoritmos de pilha ( qual pertencem os algoritmos OPT e LRU, entre outros) no apresenta a anomalia de Belady [Tanenbaum, 2003].

7.6

Thrashing

Na Seo 7.2, foi demonstrado que o tempo mdio de acesso memria RAM aumenta signicativamente medida em que aumenta a frequncia de faltas de pgina. Caso a frequncia de faltas de pginas seja muito elevada, o desempenho do sistema como um todo pode ser severamente prejudicado. Conforme discutido na Seo 7.4, cada processo tem um conjunto de trabalho, ou seja, um conjunto de pginas que devem estar na memria para sua execuo naquele momento. Se o processo tiver uma boa localidade de referncia, esse conjunto pequeno e varia lentamente. Caso a localidade de referncia seja ruim, o conjunto de trabalho 49

c Carlos Maziero

: Thrashing

geralmente grande e muda rapidamente. Enquanto houver espao na memria RAM para os conjuntos de trabalho dos processos ativos, no havero problemas. Contudo, caso a soma de todos os conjuntos de trabalho dos processos prontos para execuo seja maior que a memria RAM disponvel no sistema, poder ocorrer um fenmeno conhecido como thrashing [Denning, 1980, Denning, 2006]. No thrashing, a memria RAM no suciente para todos os processos ativos, portanto muitos processos no conseguem ter seus conjuntos de trabalho totalmente carregados na memria. Cada vez que um processo recebe o processador, executa algumas instrues, gera uma falta de pgina e volta ao estado suspenso, at que a pgina faltante seja trazida de volta RAM. Todavia, para trazer essa pgina RAM ser necessrio abrir espao na memria, transferindo algumas pginas (de outros processos) para o disco. Quanto mais processos estiverem nessa situao, maior ser a atividade de paginao e maior o nmero de processos no estado suspenso, aguardando pginas. A Figura 33 ilustra o conceito de thrashing: ela mostra a taxa de uso do processador (quantidade de processos na la de prontos) em funo do nmero de processos ativos no sistema. Na zona esquerda no h thrashing, portanto a taxa de uso do processador aumenta com o aumento do nmero de processos. Caso esse nmero aumente muito, a memria RAM no ser suciente para todos os conjuntos de trabalho e o sistema entra em uma regio de thrashing: muitos processos passaro a car suspensos aguardando a paginao, diminuindo a taxa de uso do processador. Quanto mais processos ativos, menos o processador ser usado e mais lento car o sistema. Pode-se observar que um sistema ideal com memria innita no teria esse problema, pois sempre haveria memria suciente para todos os processos ativos.
taxa de uso do processador zona de saturao da RAM

sistema ideal sistema real

situao normal

thrashing

nmero de processos ativos

Figura 33: Thrashing no uso da memria RAM. Um sistema operacional sob thrashing tem seu desempenho muito prejudicado, a ponto de parar de responder ao usurio e se tornar inutilizvel. Por isso, esse fenmeno deve ser evitado. Para tal, pode-se aumentar a quantidade de memria RAM do sistema, limitar a quantidade mxima de processos ativos, ou mudar a poltica de escalonamento 50

c Carlos Maziero

: REFERNCIAS

dos processos durante o thrashing, para evitar a competio pela memria disponvel. Vrios sistemas operacionais adotam medidas especiais para situaes de thrashing, como suspender em massa os processos ativos, adotar uma poltica de escalonamento de processador que considere o uso da memria, aumentar o quantum de processador para cada processo ativo, ou simplesmente abortar os processos com maior alocao de memria ou com maior atividade de paginao.

Referncias
[Bansal and Modha, 2004] Bansal, S. and Modha, D. (2004). CAR: Clock with adaptive replacement. In USENIX Conference on File and Storage Technologies. [Carr and Hennessy, 1981] Carr, R. and Hennessy, J. (1981). WSclock - a simple and eective algorithm for virtual memory management. In ACM symposium on Operating systems principles. [Denning, 1980] Denning, P. (1980). Working sets past and present. IEEE Transactions on Software Engineering, 6(1):6484. [Denning, 2006] Denning, P. J. (2006). The locality principle. In Barria, J., editor, Communication Networks and Computer Systems, chapter 4, pages 4367. Imperial College Press. [Jiang and Zhang, 2002] Jiang, S. and Zhang, X. (2002). LIRS: an ecient low interreference recency set replacement policy to improve buer cache performance. In ACM SIGMETRICS Intl Conference on Measurement and Modeling of Computer Systems, pages 3142. [Johnstone and Wilson, 1999] Johnstone, M. S. and Wilson, P. R. (1999). The memory fragmentation problem: solved? ACM SIGPLAN Notices, 34(3):2636. [Levine, 2000] Levine, J. (2000). Linkers and Loaders. Morgan Kaufmann. [Navarro et al., 2002] Navarro, J., Iyer, S., Druschel, P., and Cox, A. (2002). Practical, transparent operating system support for superpages. In 5th USENIX Symposium on Operating Systems Design and Implementation, pages 89104. [Patterson and Henessy, 2005] Patterson, D. and Henessy, J. (2005). Organizao e Projeto de Computadores. Campus. [Silberschatz et al., 2001] Silberschatz, A., Galvin, P., and Gagne, G. (2001). Sistemas Operacionais Conceitos e Aplicaes. Campus. [Tanenbaum, 2003] Tanenbaum, A. (2003). Sistemas Operacionais Modernos, 2a edio. Pearson Prentice-Hall. [Uhlig and Mudge, 1997] Uhlig, R. and Mudge, T. (1997). Trace-driven memory simulation: a survey. ACM Computing Surveys, 29(2):128170.

51