Gerenciamento de Memória em Sistemas Operacionais

Transcrição

1 PROGRAMA ESPECIAL DE TREINAMENTO - CIÊNCIAS DA COMPUTAÇÃO 1 Gerenciamento de Memória em Sistemas Operacionais Wanderson Rigo wander@inf.ufsc.br Abstract Certainly, all the programmer will like dispose a fast memory, with a unending size and not volatile, that is, which will not lost your contents when the energy is cut. Not be enough everthing, we would like which the price will be the smallest possible. Unfortunately this panacea the technology not offer yet...so, have everthing difficulty, how wich ours computers deal with this hindrances, give to us the ilusion as have the memory with capacity unlimited and access almost instant? This questions will be answer in the course of this article, that search elucidate the management memory process maked by Operating System (O.S.). Resumo Com certeza, todo programador gostaria de ter a disposição uma memória rápida, com acesso quase instantâneo e que também fosse infinitamente grande e não volátil, isto é, que não perdesse seu conteúdo quando ocorresse uma queda de energia. Não bastasse tudo isso, gostaríamos que o preço fosse o menor possível. Infelizmente essa panacéia a tecnologia ainda não oferece... Então, dada todas essas dificuldades, como é que nossos computadores tratam esses empecilhos, nos dando a ilusão de possuem uma memória com capacidade ilimitada e acesso quase instantâneo? Estas questões serão respondidas no decorrer deste artigo, o qual procura elucidar o processo de gerenciamento de memória feito pelo Sistema Operacional (S.O.). Palavras-chave Memória, Swapping, Paginação, Segmentação, Memória Virtual, MMU. I. INTRODUÇÃO Os programas de computador exibem tanto localidade temporal (tendência a reutilizar informações acessadas recentemente) quanto localidade espacial (tendência a referenciar informações que estão próximas àquelas que foram acessadas a pouco). Para tirar proveito dessas características, a maioria dos computadores têm um sistema de memória organizados de maneira hierárquica, o qual tira proveito da localidade temporal, pois as informações acessadas recentemente são mantidas em componentes da hierarquia próximo do processador. Tais sistemas hierárquicos também se beneficiam da localidade espacial movendo para os componentes íntimos do processador blocos com palavras de memória contíguas[2]. Essa hierarquia coloca os componentes menores e mais rápidos próximo ao processador (nível mais alto). Portanto, acessos que gerem acertos (o bloco de memória referenciado está na unidade pesquisada) no nível mais alto da hierarquia podem ser processados mais rápidos. Já no caso das faltas (o bloco de memória referenciado naõ se encontra na unidade pesquisada), os componentes dos níveis mais baixos da hierarquia devem ser pesquisados. Eles são maiores e mais lentos. Se a taxa de acertos é suficientemente alta, a hierarquia de memória tem um tempo de acesso efetivo muito próximo ao Fig. 1. Hierarquia de Memória do componente do nível mais alto e, em conseqüência, mais rápido, exibindo um tamanho próximo ao do seu nível mais baixo, e de maior capacidade. Nessa hierarquia figuram a memória cache, a principal (RAM), além de milhares de megabytes representados pelo disco rígido. A cache é uma memória volátil, muito pequena e veloz, situando-se justamente próxima ao processador para potencializar o desempenho do mesmo. Ela armazena as informações temporalmente mais usadas em um programa. Porém, todos essas qualidades são contra-balanceadas com o alto custo por megabyte que é verificado nas memórias cache. A RAM (Random Access Memory - Memória de Acesso Randômico) apresenta tempo de acesso 1 superior ao da cache, porém o preço, de certa forma, compensa essa desvantagem, pois possibilita equiparmos um computador com milhares de megabytes a um custo não muito oneroso. Ela armazena o S.O., programas e dados, os quais são carregados dinamicamente em tempo de execução. Os discos rígidos, que dominam o mercado desde 1965, são dispositivos mecânicos e que usam propriedades magnéticas para reter as informações, sendo que, ao contrário das demais memórias, elas não são perdidas quando a energia é desligada. Por depender de artefatos mecânicos, a velocidade de operação do disco é lenta e o tempo de acesso a uma nova informação varia ligeiramente em função da localização (trilha) da última informação acessada. A grande vantagem desse dispositivo está no preço por megabyte, que é relativamente baixo, possibilitando a criação de cluster com centenas de milhares de 1 O tempo de acesso é sempre fixo, independente da localização da informação na memória

2 2 PROGRAMA ESPECIAL DE TREINAMENTO - CIÊNCIAS DA COMPUTAÇÃO megabytes. II. DESENVOLVIMENTO A. Gerenciamento Básico de Memória Agora que já foram apresentados os protagonistas principais de nosso artigo, o foco agora será a Unidade de Gerência de Memória (Memory Management Unit - MMU), componente do hardware que provê os mecanismos básicos que serão usados pelo S.O. para gerenciar a hierarquia de memória que foi previamente apresentada. Esta tarefa inclui controlar quais partes da memória estão em uso e quais não estão, efetuar alocação de memória para processos 2 quando eles necessitarem e desalocação quando eles terminarem, bem como gerenciar a troca (swapping) entre a memória principal e o disco quando o tamanho da memória principal for insuficiente para armazenar todos os processos. Também é trabalho da MMU mapear os endereços lógicos 3 gerados pelos processos nos correspondentes endereços físicos (usados para endereçar os circuitos integrados da memória). Fig. 2. Mapeamento de Endereços A classificação mais geral dos sistemas de gerenciamento de memória divide-se em duas classes: os que movem processos entre a memória principal e o disco (e vice-versa) durante a execução (fazendo troca e paginação) e aqueles que não o fazem. O leitor deve manter em mente que a troca e paginação são em grande parte artefatos causados pela falta de memória principal suficiente para armazenar todos os processos simultaneamente[1]. A seguir explora-se a evolução dos meios usados para gerenciar a memória nos computadores. 1) Monoprogramação sem Troca ou Paginação: O esquema mais simples possível de alocação de memória a processos é aquele no qual só existe um único processo na memória a cada instante, sendo permitido a este processo ocupar toda a memória disponível. O usuário carrega a memória principal com um processo vindo do disco ou dispositivo de entrada/saída, e este assume o controle de todos os recursos da máquina. Apesar deste esquema ter sido muito utilizado até 1960, foi abandonado desde então[4]. A técnica usualmente utilizada pelos microcomputadores mais simples consiste em dividir a memória entre o S.O. e um único processo usuário, sendo que somente um processo por vez pode ser executado. O MS-DOS enquadra-se nessa categoria, sendo que ele utiliza a memória da seguinte forma: ao S.O. é destinado a parte inferior da memória RAM, aos drivers de dispositivo cabe a parte superior da memória, sendo que estes estão em uma ROM (Read Only Memory - Memória Apenas de Leitura). A parte do sistema na ROM é chamada 2 Basicamente são programas em execução. 3 especificados pelas instruções de máquina BIOS (Basic Input Output System - Sistema Básico de Entrada e Saída). O restante da memória é destinada aos programas do usuário. Quando o usuário digita um comando, o sistema operacioanal transfere o programa requisitado do disco para a memória principal, preparando o ambiente para sua execução. Ao término da execução do processo, o sistema operacioanal aguarda um novo comando (sinalizado com o caracter de prompt) para carregar um novo processo, o qual irá sobrepor o primeiro. Este esquema desprestigia a capacidade do processador, pois permite que ele permaneça ocioso enquanto cada um dos processos é carregado na memória. Logo, a quantidade efetiva de trabalho desempenhado pelo processador é mínima e conseqüentemete a performance deixa muito a desejar. 2) Multiprogramação com Partições Fixas: A principal virtude desse modelo de gerenciamento de memória reside no fato de que a CPU pode ser utilizada de uma maneira mais proveitosa. Vamos explicar: em sistemas de compartilhamento de tempo, ter múltiplos processos na memória simultaneamente significa que quando um processo é bloqueado esperando a E/S acabar, outro pode utilizar a CPU. Isso também tem grande valia até mesmo em computadores pessoais, pois freqüentemente utilizamos dois ou mais programas ao mesmo tempo. Porém manter diversos processos na memória implica em alocar e delimitar a área ocupada por cada um dos processos, de modo que um processo não acesse ou interfira na área de outro. A proteção que a memória exige é provida pela MMU, e é conseguida com a utilização de dois registradores especiais, denominados de base e limite, que são protegidos e não podem ser acessados em modo usuário. Fig. 3. Mapeamento de Endereços Segue agora o estudo deste processo mais de perto: o compilador gera as instruções de máquina de um programa assumindo que elas serão carregadas a partir do endereço zero. Entretanto, elas podem ser carregadas em qualquer lugar da memória física, pois cada endereço é somado com o registrador de base, o qual contém o endereço físico inicial.

3 UNIVERSIDADE FEDERAL DE SANTA CATARINA 3 Esta correção é realizada em tempo de execução automaticamente, sendo denominada de relocação. Em outras palavras, os endereços lógicos são mapeados pela MMU para uma área do espaço de endereçamento físico. Essa área de memória física inicia no valor indicado pelo registrador de base e tem o mesmo tamanho da memória lógica do processo, sendo que o registrador-limite baliza o término da área. Dessa forma a proteção da memória é alcançada, pois o processo de usuário estará restrito a essa área da memória física. A maneira mais simples de alcançar a multiprogramação consiste em dividir a memória em k partições (possivelmente desiguais). Então quando um job 4 chega, ele pode ser colocadona fila de entrada da menor partição capaz de armazená-lo. Em virtude das partições serem fixas, o espaço não utilizado por um job dentro de uma partição é perdido (Fragmentação Interna). mais que k vezes. Cada vez que ele fosse ignorado, ganharia um ponto. No instante que ele atingisse k pontos, ele não poderia ser ignorado novamente. Essa técnica é chamada de Envelhecimento e busca evitar a postergação indefinida do processo. Este sistema com partições fixas, cujo tamanho era definido pelo operador, foi chamado de MFT (Multiprogramação com um número Fixo de Tarefas) e foi utilizado por mainframes IBM OS/360 de grande porte durante muitos anos. Ele era simples de entender e igualmente simples de implementar: os jobs que chegavam eram enfileirados até que uma partição adequada estivesse disponível, momento em que o job era carregado nessa partição e executado até a sua conclusão. 3) Multiprogramação com Partições Variáveis: A principal diferença entre um sistema que utiliza partições fixas e outro que vale-se de partições variáveis é de que no último as partições variam dinamicamente tanto em número, posição e tamanho, de acordo com o fluxo de processos. A virtude principal nesse esquema é a flexibilidade, pois o fato de não se prender a um número fixo de partições, que podem ser muito grandes ou muito pequenas, otimiza a utilização da memória, mas também complica a tarefa de alocá-la desalocá-la, assim como a monitoração da memória utilizada. Quando a memória é alocada dinamicamente, é trabalho do S.O. gerencia-la. Em termos gerais, há duas maneiras de monitorar o uso da memória: mapa de bits e listas livres. Gerenciamento de Memória com Mapa de Bits Fig. 4. Filas de entrada separadas A desvantagem notória desse esquema que classifica os jobs de entrada em filas separadas fica aparente quando a fila para uma partição pequena está cheia, ao passo que não há filas em partições maiores (veja a Fig.4). A alternativa é um outro modo de organização, mantendo-se uma fila única. Assim sendo, sempre que uma partição torna-se livre, o job mais próximo do início da fila que se ajusta na posição vazia poderia ser carregado nela e executado. Todavia, é indesejável desperdiçar uma partição grande com um job pequeno, então uma estratégia para efetivar essa restrição seria pesquisar a fila de entrada inteira sempre que uma partição tornar-se livre e selecionar o maior job que se ajusta. O último algoritmo, como você pode notar, discrimina jobs pequenos porque estes não merecem ter uma partição inteira, quando que, normalmente, é desejável dar o melhor serviço aos jobs pequenos (que supostamente são iterativos), não o pior. Uma saída é dispor de pelo menos uma partição pequena a qual permitirá que jobs pequenos possam ser executados sem alocar uma partição grande para eles. Outra alternativa seria estabelecer uma regra determinando que um job elegível para executar não poderia ser ignorado 4 Programa ou um conjunto de programas. Usando esta filosofia de monitoramento, a memória é dividida em unidades de alocação, sendo que cada uma dessas unidades corresponde a um bit no mapa de bits que, por exemplo, pode assumir o valor 1 se a unidade estiver ocupada e 0 se estiver livre. O tamanho da unidade de alocação figura como uma importante questão de projeto, pois quanto menor ela for, maior o mapa de bits. Entretanto, mesmo com uma unidade de alocação tão pequena quanto 4 bytes ou equivalente a 32 bits, estes exigirão somente 1 bit do mapa. Expandindo para uma memória de 32n bits, o mapa exigirá n bits, portanto o mapa de bits ocupará 1/33 da memória. Fig. 5. Mapa de Bits Como é possível notar, um mapa de bits oferece uma maneira simples de monitorar palavras de memória em uma quantidade fixa de memória, pois o tamanho do mapa depende somente do tamanho da unidade de alocação e da memória. A desvantagem maior se verifica quando se decide trazer um

4 4 PROGRAMA ESPECIAL DE TREINAMENTO - CIÊNCIAS DA COMPUTAÇÃO processo de k unidades para a memória, pois o gerenciador deve pesquisar no mapa de bits para encontrar uma lacuna de k bits 0 consecutivos. Esta é uma operação lenta, o que constitui um forte argumento contra os mapas de bits. Listas Encadeadas Outra maneira de monitorar a memória é manter uma lista encadeada dos segmentos de memória alocados e livres, onde um segmento comprende um processo ou uma lacuna entre dois processos. Vejamos uma ilustração: Fig. 6. Lista Encadeada Nesse exemplo, classificamos a lista por endereço, que tem a vantagem de que quando um processo termina ou está sendo enviado para o disco, atualizar a lista é simples e direto. Quando os processos e as lacunas são mantidos em uma lista classificada por endereço, vários algoritmos podem ser utilizados para alocar memória para um processo recentemente criado ou trocado para a memória. Partimos do pré-suposto que o gerenciador de memória conhece a quantidade de memória a alocar. Veremos agora cada um dos algoritmos. Primeiro Ajuste (First-Fit): É o mais simples. Nele o gerenciador de memória varre toda a lista de segmentos até localizar uma lacuna que seja suficientemente grande. Então a lacuna é dividida em dois pedaços, um para o processo e um para a memória não utilizada, exceto se ocorrer um ajuste exato. Este algoritmo é rápido porque pesquisar o mínimo possível, pois tão logo encontre uma lacuna que se ajusta ao requisito do processo, ele pára. Próximo Ajuste (Circular-Fit): Constitui-se uma variação do algoritmo do primeiro ajuste e funciona da mesma maneira, exceto que monitora a posição da lista em que ele está sempre que encontra uma lacuna adequada. Dessa forma, quando o algoritmo for chamado para localizar uma nova lacuna, ele começa a pesquisa na lista a partir do lugar que deixou da última vez, diferentemente do algoritmo do primeiro ajuste, que sempre inicia pelo começo da lista. Em simulações foi demonstrado que este algoritmo tem um desempemho ligeiramente inferior ao do Primeiro Ajuste. Melhor Ajuste (Best-Fit): Este algoritmo pesquisa a lista inteira, escolhendo a menor lacuna que seja adequada, dessa forma tentando localizar uma lacuna próxima do tamanho real necessário antes de dividir uma lacuna grande, a qual talvez seja necessária mais tarde. Em termos de desempenho temporal, o Melhor Ajuste é mais lento que o Primeiro Ajuste. Isso se deve ao fato de que o Melhor Ajuste deve pesquisar na lista inteira toda vez que é chamado. Pasmem, ele também resulta em maior desperdício de memória se comparado aos dois algoritmos anteriores. Isso ocorre porque ele tende a encher a memória de lacunas minúsculas e inúteis. O algoritmo do Primeiro Ajuste gera lacunas maiores, em média. Pior Ajuste (Worst-Fit): Este algoritmo sempre pega a maior lacuna disponível, de modo que após esta ser ocupada pelo processo, ainda resulte uma lacuna suficientemente grande para ser útil. Esta metodologia busca evitar o problema de dividir uma lacuna do tamanho quase exato em uma área reservada ao processo e uma lacuna tão minúscula que tornasse inutilizável. Contudo, simulações demostraram que o Pior Ajuste também não é uma boa idéia. Ajuste Rápido (Fast-Fit): Mantém listas separadas para alguns dos tamanhos exigidos mais comuns. Poderíamos ter uma tabela com n entradas, em que a primeira é um ponteiro para a cabeça de uma lista de lacunas de 4K, a segunda um ponteiro para uma lista de 8K e assim por diante. As lacunas de, digamos 22K, poderíam ser alocadas na lista de 20K ou em numa lista especial de lacunas de tamanhos variáveis, que seria a vala comum para casos particulares. Com esta filosofia, localizar uma lacuna do tamanho exigido é extremamente rápido, mas tem a mesma desvantegem que todos os esquemas que classificam por tamanho de lacunas, ou seja, quando um processo termina ou está sendo enviado para o disco, pesquisar seus vizinhos para ver se uma mescla é possível é caro. Se a mesclagem não for feita, a memória rapidamente será fragmentada em um grande número de pequenas lacunas, sendo que o tamanho das mesmas impossibilita o ajuste de qualquer processo. B. Gerenciamento Elaborado de Memória Até agora foram apresentadas somente situações que não justificam o uso de métodos mais complicados. Porém, em sistemas de compartilhamento de tempo ou computadores gráficos pessoais, a situação é diferente. Às vezes, não há memória principal suficiente para armazenar todos os processos atualmente ativos, então, alguns processos são enviados da memória para o disco e trazidos de lá para execução dinamicamente. Neste contexto duas abordagens gerais para o gerenciamento de memória podem ser utilizadas: uma chamada Troca, que é a mais simples, e a outra, denominada Memória Virtual, a qual permite que os programas executem mesmo quando estão parcialmente na memória principal. 1) Troca (Swapping): Consiste em copiar da memória para o disco um processo inteiro, mantê-lo temporariamente nessa unidade e então devolvê-lo à memória para ser executado. Esse revezamento entre a memória e o disco proporciona a execução de um maior número de processos do que caberiam em um mesmo instante na memória. Para justificar essa operação é necessário deixar o processo que sofre swapping um tempo razoável no disco, pois a

5 UNIVERSIDADE FEDERAL DE SANTA CATARINA 5 atividade de swapping impõe um grande custo em termos de tempo de execução. Também aqui chama-se a atenção para a questão de quanta memória deve ser alocada para um processo quando ele é criado ou é recuperado do disco. Os processos que são criados com um tamanho fixo são alocados de maneira simples: alocase exatamente o que é requerido. Porém, se os segmentos de dados dos processos crescem, alocando memória dinamicamente a partir de um heap 5, ocorre um problema sempre que um processo tenta crescer. Se existe uma lacuna adjacente ao processo, ela pode ser alocada e oferecida a ele. Todavia, se o processo é adjacente a outro processo, aquele que estiver em estágio de crescimento terá que ser movido para uma lacuna de memória suficientemente grande para ele ou um ou mais processos terão de ser enviados para o disco, criando uma lacuna a ser ocupada pelo processo em expansão. Caso um processo não possa crescer na memória e a área de troca no disco está cheia, o processo deverá esperar ou ser eliminado. Se a heurística de que a maioria dos processos crescerá ao executar for verdadeira, então, para reduzir o overhead 6 associado a mudança ou troca de processos que não cabem mais na memória alocada para eles, uma boa idéia é alocar uma pequena quantidade de memória extra sempre que se fizer a troca ou mover-se um processo. Entretanto, só a memória realmente em uso deve ser enviada quando um processo é movido para o disco. 2) Memória Virtual: E quando os programas são demasiadamente grandes a ponto de não poderem ser ajustados na memória disponível? Antigamente a solução adotada para resolver este problema era dividir o programa em pedaços, chamados overlays. Dessa forma, um programa grande era dividido pelo programador em diversos overlays, os quais eram carregados dinamicamente do disco para a memória (e viceversa) pelo sistema operacional. Quando um overlay acabava de executar, ele chamava o próximo. Imagine o quão árdua era a tarefa de modular um programa enorme... Então, Fortheringham, em 1961 propôs um método chamado Memória Virtual, o qual permite a execução de programas cujo tamanho total (tamanho do código, dos dados e da pilha) ultrapasse o tamanho da memória física disponível. Ele passava ao sistema operacional a responsabilidade de manter na memória as partes do programa efetivamente em uso, sendo que estas deveriam ser escolhidas cuidadosamente. As demais partes poderiam ser deixadas no disco. Este esquema funciona muito bem em conjunto com a multiprogramação, pois enquanto um programa está esperando que outra parte dele seja carregada na memória, ele estará bloqueado para entrada/saída e não poderá ser executado, e assim ao processador pode ser dado um processo de outro programa. 3) Paginação: Grande parte dos sistemas de memória virtual usa a técnica denominada paginação, a qual descreve-se aqui. Ela permite que um programa ocupe áreas não contíguas de memória. No decorrer da execução de um programa é gerado um con- 5 Pilha 6 custo geral junto de endereços de memória. Tais endereços são chamados endereços virtuais e formam o espaço de endereçamento virtual os quais são encaminhados à Unidade de Gerência de Memória (Memory Managements Unit - MMU), que é um chip ou um conjunto de chips que mapeiam os endereços virtuais, também chamados de páginas lógicas, em endereços físicos da memória, também denominandos de páginas físicas. Tal mapeamento resulta em uma tabela de páginas, que informa para cada página lógica qual a página física correspondente. O espaço de endereçamento virtual é dividido em unidades denominadas páginas enquanto que as unidades correspondentes na memória física são chamadas de molduras de página. Ambas possuem o mesmo tamanho. As transferências entre a memória e o disco (e vice-versa) são sempre feitas em páginas. Embora o processador de um computador doméstico atual possa endereçar 32 Gbytes, tipicamente a memória física realmente instalada é menor que 1 Gbyte. Embora programas de 32 Gbytes possam ser escritos, eles não podem ser carregados na memória em sua totalidade e executados. Entretanto, uma cópia completa do programa deve estar presente no disco, de modo que pedaços possam ser trazidos conforme necessário. Logo você deve estar se perguntando, como é que o espaço virtual, que é maior que a memória real e logo possui mais endereços, pode ser inteiramente mapeado na memória física, que os possui em quantida menor? Acontece que algumas páginas não são mapeadas (um bit presente/ausente em cada entrada de página monitora se ela é mapeada ou não), sendo que quando uma destas é referenciada por alguma instrução, a MMU força o processador a executar um trap (interrupção), passando a Unidade de Processamento Central (Cental Process Unit - CPU) para o sistema operacional. Este trap é denominado falta de página. Em resposta so trap, o sistema operacional localiza a moldura de página menos usada e a copia de volta para o disco. Em seguida, busca a página referenciada e a copia na moldura que a cabou de ser liberada, possibilitando a execução da instrução que gerou o trap. Fig. 7. Paginação Algoritmos de Substituição de Páginas

6 6 PROGRAMA ESPECIAL DE TREINAMENTO - CIÊNCIAS DA COMPUTAÇÃO Quando ocorre uma falta de página, o sistema operacional precisa escolher uma página que abdique seu lugar na memória em favor de outra que precisa ser carregada. Se a página a ser removida tiver sido modificada enquanto na memória, ela deve ser regravada no disco, de forma a atualiza-lo. Caso a página não tenha sido alterada, nenhuma regravação é exigida. A página a ser lida simplesmente sobrescreve a página que está sendo expulsa. Apesar de ser possível escolher aleatoriamente a página a ser retirada quando ocorre uma falta de página, a performance do sistema será muito melhor se conseguirmos subtituir uma página que não esteja sendo muito referenciada. Se removermos uma página intensamente referenciada, talvez tenhamos que trazê-la de volta muito em breve, causando um overhead desnecessário. Algoritmo de Substituição de Página Ótimo Sabe-se que dada uma falta de página, algum conjunto de páginas está na memória. Uma dessas páginas será referenciada na instrução mais próxima (a página que contém essa instrução). Outras páginas podem não ser referenciadas nas dezenas ou centenas de instruções seguintes. Então, pode-se rotular cada página com o número de instruções que serão executadas antes dessa página ser referenciada. Buscando adiar o problema da falta de página o máximo possível, o algoritmo ótimo simplesmente diz que a página com o rótulo mais alto deve ser removida. Porém, todo esse discurso não pode ser implementado na prática, pois o sistema operacional não tem como saber quando cada uma das páginas da memória será referenciada novamente. Ele somente é usado como base para calcular a performance de outros algoritmos que são realizáveis na prática, tomando-se sempre como referência um programa em particular. Veja como isto é feito: usando um simulador para rodar o programa e tomando nota de todas as referências a páginas que foram realizadas é possível implementar este algoritmo na segunda vez que o programa for executado, valendose da lista de referências obtida na primeira vez que o programa foi rodado. Esta abordagem sugere que se um sistema operacional tem um algoritmo de substituição cuja performance é 1% abaixo do algoritmo ótimo, os esforços na busca de um algoritmo melhor resultariam em uma melhora de no máximo 1% para aquele programa específico. Apesar desta metodologia ser útil na avaliação de algoritmos de substituição de página, na prática, ela não é utilizada. Algoritmo dá Página Não Usada Recentemente (Not Used Recently - NUR) Muitos computadores com memória virtual têm dois bits de estado associados a cada página, os quais são configurados pelo hardware a cada referência a memória e atualizados pelo sistema operacional via software. Eles permitem ao sistema operacional monitorar periodicamente o status das páginas na memória principal. São eles: R, que acusa se a página foi referenciada (a cada interrupção do relógio este bit é limpo, distinguindo páginas referenciadas das não refenciadas) e M que denota se a página foi modificada. Na ocorrência de uma falta de página, o sistema operacional inspeciona todas as páginas, dividindo-as em quatro categorias, baseando-se no valor dos bits mencionados. São elas: 1) Classe 0: não-referenciadas, não-modificadas. 2) Classe 1: não-referenciadas, modificadas. 3) Classe 2: referenciadas, não-modificadas. 4) Classe 3: referenciadas, modificadas. Dado este panorama e valendo-se da funcionalidade descrita no parágrafo precedente, aborda-se agora um algoritmo fácil de entender, implementar e que tem uma boa performance. Sua metodologia é a de remover aleatoriamente uma página pertencente à classe que ocorre em menor número, sendo que o número de ocorrências não pode ser nulo. Implicitamente ele sugere que é melhor remover uma página que tenha sido modificada e não referenciada em pelo menos entre duas interrupções de tempo (normalmente 20 ms), do que uma não-modificada que esteja em uso. O Algoritmo FIFO(First In, First Out 7 ) O sistema operacional mantém uma fila de todas as páginas que estão na memória, sendo que a página locada no topo da fila é a mais antiga, ao passo que no final da fila encontra-se a página que chegou a menos tempo. Então, quando da ocorrência de uma falta de página, este algoritmo, fazendo jus ao nome, remove a página do início da fila. Dado isso, então agora a nova página (a última que foi referenciada) pode ser adicionada ao final desta fila. A grande deficiência deste algoritmo é que ele não leva em conta se a página a ser removida é fortememente referenciada ou não. Essa total ignorância compromete a performance, pois talvez a página removida venha a ser novamente necessitada em breve, forçando a execução de mais um trap. Em virtude disso, este algoritmo em sua forma pura nunca é usado. O Algoritmo da Segunda Chance É semelhante ao algoritmo FIFO, porém implementa melhoras no sentido de evitar que páginas muito usadas sejam descartadas. Isso é conseguido examinando-se o bit R da página mais antiga (que está no topo da fila). Se ele for 0, a página, além de velha, não tem sido referenciada, devendo ser removida imediatamente para dar lugar a outra. Se o bit for igual a 1, ele é zerado e a página é colocada no fim da fila, considerando como se ela tivesse acabado de entrar na memória. Após isso, a busca continua na próxima página da fila. 7 Primeiro que entrou é o primeiro a sair.

7 UNIVERSIDADE FEDERAL DE SANTA CATARINA 7 O algoritmo da segunda chance procura uma página antiga que não tenha sido referenciada no intervalo de relógio anterior. Se todas as páginas presentes na memória tiverem sido referenciadas no intervalo citado, este algoritmo degenera para o FIFO puro. O Algoritmo do Relógio Embora o algoritmo da segunda chance seja razoável, ele é ineficiente porque está sempre movendo páginas para o fim da lista. Uma forma mais apropriada e eficiente de gerenciar a idade das páginas é mantê-las em um fila circular em forma de relógio, sendo que um ponteiro aponta para a página mais antiga. Quando ocorrer uma falta de página, a página apontada pelo ponteiro é inspecionada. Caso seu bit R for 0, ela sai da memória, uma nova página é inserida em seu lugar e o ponteiro é atualizado, apontando para a próxima posição. Caso R seja 1, o algoritmo zera seu valor e avança para examinar a próxima página. Isto se repete até que seja encontrada uma página com R=0. O Algoritmo da Página Usada a mais Tempo (Least Recently Used - LRU) Constitui-se uma boa aproximação do algoritmo ótimo, baseando-se na observação de que páginas que foram muito referenciadas pelas últimas instruções executadas continuarão sendo usadas pelas próximas instruções, ao passo que as páginas que não foram referenciadas pelas últimas instruções provavelmente continuarão não sendo usadas tão logo. Então, dada a ocorrência de uma falta de página, é removida da memória a página que foi usada a mais tempo. Embora que o algoritmo LRU seja teoricamente realizável, sua implementação é cara, pois é necessário a manutenção de uma lista ligada de todas as páginas da memória, mantendo aquela que foi usada mais recentemente na frente e a que foi usada a mais tempo atrás. O problema é que esta lista precisa ser atualizada a cada referência à memória. Também, encontrar uma página na lista, retirá-la e mover outra para o início da lista são operações que consomem muito tempo. Não bastasse isso, precisa-se de uma hardware especial (leia-se caro). Uma alternativa seria buscar uma forma de implementar uma aproximação deste algoritmo por software. 4) Segmentação: Até agora discutimos o sistema de memória virtual considerado unidimensional, dado que os endereços virtuais ocupam uma faixa linear de endereços compreendida entre 0 e um valor máximo. Entretanto, algumas vezes, é mais vantajoso e conveniente ter dois ou mais espaços distintos de endereçamento virtual. Por exemplo, um compilador ao longo do processo de compilação gera muitas tabelas, dentre as quais algumas que crescem continuamente durante o processo de compilação. Num sistema de memória virtual unidimensional, onde as tabelas seriam armazenadas contiguamente na memória, é bem possível que o espaço alocado para alguma tabela seja esgotado, dado que, por exemplo, o programa contenha um número excessivamente grande de variáveis, ao passo que talvez esteja sobrando espaço nas demais tabelas. Caso isso aconteça, a compilação seria interrompida por falta de espaço para a tabela que cresceu indiscriminadamete. O que é realmente necessário é um esquema que livre o programador das consequências da expansão ou contração destas tabelas, de maneira semelhante como a memória virtual eliminou a necessidade de se organizar a memória principal em overlays. Uma solução simples e direta para resolver esta questão é equipar a máquina com vários espaços de endereçamento completamente independentes, os quais são chamados segmentos. Segmentos são entidades lógicas, sendo que cada programa normalmente está dividido nos seguintes segemntos: código; dados alocados estaticamente; dados alocados dinamicamente; pilha de execução O tamanho de cada segmento pode variar entre 0 e um valor máximo de endereços. Caso uma pilha de um certo segmento preciar de mais espaço para crescer, podê obtêlo, já que não há nada mais em seu espaço de endereço em que colidir. Naturalmente que um segmento pode encher-se, mas isso é raro. Dado que cada segmento é um espaço de endereçamento distinto, segmentos diferentes podem crescer ou diminuir independentemente, sem afetar um ao outro. Visando especificar um endereço em uma memória segmentada ou bidimendional, veremos logo abaixo que uma posição da memória lógica passa a ser endereçada por um número de segmento e um deslocamento em relação ao início do seu segmento. No momento da carga, cada segmento é copiado para a memória física, e uma tabela de segmentos é construída, possibilitando o mapeamento para posterior recuperação da informação. Fig. 8. Segmentação Em suma, este esquema busca simplificar o problema do tratamento de estruturas de dados cujo tamanho altera-se durante a fase de execução. Além disso, evita que, no caso de uma recompilação, o segmento que armazena um procedimento que não foi alterado seja modificado. Também facilita

8 8 PROGRAMA ESPECIAL DE TREINAMENTO - CIÊNCIAS DA COMPUTAÇÃO o compartilhamento de procedimentos ou dados entre vários processos, como por exemplo, numa biblioteca compartilhada, já que cada segmento representa uma parte específica do programa. Cita-se, por exemplo, os avançados sistemas de janelas que possuem bibliotecas gráficas extremamente grandes compiladas em quase cada programa. Em um sistema segmentado, a biblioteca gráfica pode ser colocada em um segmento e compartilhada por múltiplos processos, eliminando a necessidade de tê-la no espaço de endereçamento de cada processo. Um segmento compartilhado somente é removido da memória principal quando nenhum processo o estiver usando, isto é, ele não faz mais parte de nenhuma tabela de segmentos em uso[3]. [3] Alexandre da Silva Carissimi e Simão Sirineo Toscani Rômulo Silva de Oliveira. Sistemas Operacionais. Instituto de Informática da UFRGS, [4] Andrew S. Tanembaum. Sistemas Operacionais Modernos. Bookman, Wanderson Rigo é membro do PET/CCO desde 2002, e atualmente concentra suas pesquisas na área de Inteligência Artificial e cognição humana. Tem grande afinidade pela leitura de livros da área supracitada, bem como por periódicos de cultura geral. III. CONCLUSÃO Sabemos que a performance do computador deve-se a inúmeros fatores, sendo que a memória figura como um dos principais, pois os programas gastam a maior parte de seu tempo de processamento acessando a memória. Embora os avanços tecnológicos nos proporcionam processadores cada vez mais velozes, as memórias não consegue evoluir nessa marcha. Esse descompasso constitui o principal fator limitante da performance e velocidade esperadas de um computador. Dessa forma, os paradigmas de gerenciamento de memória devem prover maneiras de contornar esse encausto, livrando o usuário de penantes esperas, bem como devem ajustar-se de modo gradativo a maior necessidade de memória, que se constitui um dos recursos com tendência a ser mais e mais requisitado. Dado tudo isso, não é difícil notar que o desafio é projetar sistemas de memória que pelo menos atenuem essa diferença de velocidade entre os processadores e os componentes da memória. Uma saída tem sido o acréscimo de caches de vários níveis. Também a aquisição considerável de memória é outro falor limitante ao usuário, pois o preço das mesmas onera de forma significativa o preço final de um computador. Talvez dentre todos os desafios, o maior é implementar todos os benefícios que a estrutura e o sistema de gerencia de memória oferece hoje somados a dádiva de alguma descoberta no meio da Ciência que venha possibilitar a construção de componentes mais rápidos e baratos. Se isso não ocorrer tão logo, talvez seja a hora de repensar os modelos atuais e suas evoluções ao longo da história. Quem sabe descobre-se alguma nuance ainda a ser explorada...então, mãos-a-obra. AGRADECIMENTOS O autor agradece aos colegas do grupo PET pela oportunidade e incentivo, especialmente ao Prof. Luís Fernando Friedrich, nosso Tutor e orientador. Salientamos que sem o apoio dos citados, a viabiliadade deste trabalho estaria comprometida. REFERÊNCIAS [1] Andrew S. Tanembaum e Albert S. Woodhull. Sistemas Operacionais: Projeto e Implementação. Bookman, [2] David A. Patterson e John L. Hennessy. Organização e projeto de computadores: A interface HARDWARE/SOFTWARE. Morgan Kaufmann Publishers, Inc., 2000.