Notas da Aula 20 - Fundamentos de Sistemas Operacionais

Notas da Aula 20 - Fundamentos de Sistemas Operacionais 1. Algoritmos de Substituição de Páginas Quando ocorre uma falta de páginas, o SO precisa trazer da área de swap para a memória principal a página necessária ao processo. Isso implica na alocação de um quadro da memória principal para armazenar a página a ser trazida. Se não há quadros livres neste momento, o SO retirar uma página atualmente alocada da memória principal e colocá-la em memória secundária. A página escolhida para remoção, denominada Página Vítima, deve ser alguma que não seja necessária em um futuro próximo ou, ainda melhor, que não seja mais necessária para nenhum processo. O módulo do SO responsável por realizar a escolha da página vítima é chamado de Algoritmo de Substituição de Páginas. Existem vários algoritmos deste tipo, cada um com uma estratégia diferente para manter a taxa de falta de páginas baixa. Especificamente, estes algoritmos podem ser classificados em dois grupos: Algoritmos locais. Algoritmos globais. Um algoritmo de substituição de páginas global pode escolher qualquer página atualmente alocada em memória principal como página vítima. Por outro lado, um algoritmo local sempre substitui uma página do próprio processo que gerou a falta de página. Algoritmos globais, em teoria, são capazes de prover um desempenho melhor ao sistema como um todo, já que eles consideram um universo maior de soluções possíveis (candidatas à página vítima). Por outro lado, estes algoritmos tendem a ser mais complexos, justamente porque o número de possíveis soluções a serem avaliadas é maior. É importante notar que os algoritmos locais precisam se preocupar com outra variável: o número de páginas alocadas para cada processo. Como obrigatoriamente a página vítima será uma página pertencente ao próprio processo que gerou a falta de página, a quantidade de páginas alocadas para os processos se mantém constante. Logo, este parâmetro é importante para este tipo de algoritmo. No caso dos algoritmos globais, o número de páginas alocadas por processo é definido implícitamente a medida que páginas são retiradas e colocadas na memória principal, e espera-se que este valor tenda para um ótimo ao longo da execução da máquina. Boa parte dos algoritmos de substituição de páginas utilizam o conceito de String de Referência. Uma string de referência é apenas uma string da forma representando a sequência de páginas acessadas por um processo ou pelo processador (considerando todos os processos em execução) ao longo do tempo. Por exemplo, a string de referência 442341 indica que inicialmente ocorreram dois acessos à página 4, seguidos de um acesso à página 2, outro à página 3, um novo acesso à página 4 e finalmente um último acesso à página 1. 2. Algoritmos Globais

Se fosse possível conhecer previamente a string de referência de todos os acessos futuros à páginas do sistema, seria possível propor um algoritmo de substituição de páginas global ótimo. Este algoritmo global ótimo funciona de maneira muito simples: a cada substituição de páginas, o algoritmo varre todas as páginas atualmente alocadas em memória principal; para cada uma, a string de referência dos acessos futuros é percorrida, buscando-se o instante do próximo acesso da página; a página vítima é aquela cujo instante do próximo acesso é o maior dentre todas as páginas. Por exemplo, considere um sistema com dois processos, A e B, em que as páginas 3A, 6B, 8B e 9A estão alocadas atualmente em memória principal. Considere ainda que a string de referência (para os acessos futuros) seja 8B3A8B9A6B9A... Neste caso, a página a ser substituída é a 6B (página 6 do processo B), já que ela só será necessária daqui a 5 acessos à memória. Este algoritmo garante a menor ocorrência de falta de páginas possível. Por outro lado, ele depende do conhecimento do comportamento futuro do sistema. Em alguns sistemas muito especializados, talvez seja possível determinar com certeza esta string de referência. Porém, no caso geral, este algoritmo não é viável. Dentre os algoritmos práticos para substituição de páginas, o mais simples é o FIFO. Como sempre, a ideia do FIFO é escolher para substituição a página que se encontra alocada a mais tempo em memória principal. A grande vantagem do FIFO é a simplicidade de implementação. Basta que o SO mantenha uma fila de páginas recentemente alocadas. A medida que novas páginas são trazidas para a memória principal, o SO insere suas referências no final da fila. Quando é necessário escolher uma página vítima, basta remover o primeiro elemento da fila. Note que, por construção, este método garante que a fila jamais terá mais que N elementos, onde N é o número de quadros da memória principal. Assim como seu equivalente de escalonamento, o algoritmo FIFO para substituição de páginas pode causar sérios problemas de desempenho por não levar em consideração outras informações. Especificamente, o FIFO não leva em consideração a frequência de utilização de cada página. Por exemplo, suponha que um processo esteja manipulando um grande vetor de dados. Para cada posição do vetor, o processo executa um pequeno trecho de código que implementa uma repetição. Como o vetor é muito grande, este está espalhado por um grande conjunto de páginas. Durante esta execução, as páginas que contém o vetor são trazidas para a memória principal de acordo com a necessidade. Em um dado momento, a página mais antiga alocada em memória principal será aquela que contém o código em execução pelo processo. O algoritmo FIFO, então, irá escolher esta página como vítima, o que causará logo em seguida uma nova falta de página. O algoritmo NRU (Not Recently Used) é, talvez, o algoritmo mais simples que tenta proativamente escolher uma página que não será utilizada no futuro. Este algoritmo utiliza dois dos bits de controle associados a cada página: o bit de sujeira e o bit de referência. Quando é necessário escolher uma página vítima, o algoritmo separa todas as páginas atualmente em

memória em 4 conjuntos, de acordo com os estados dos seus bits: 1. Bit de referência 0 e bit de sujeira 0. 2. Bit de referência 0 e bit de sujeira 1. 3. Bit de referência 1 e bit de sujeira 0. 4. Bit de referência 1 e bit de sujeira 1. O algoritmo percorre as classes de cima para baixo (da classe 1 para a classe 4) procurando pela primeira não-vazia. O NRU, então, escolhe aleatoriamente a página vítima dentre as páginas pertencentes a esta classe. Páginas do primeiro conjunto não foram acessadas recentemente nem foram modificadas. Isso quer dizer que esta página pode ser facilmente removida (pois não foi modificada e, portanto, não requer que seu conteúdo seja atualizado na área de swap) e que, pelo princípio da localidade referencial, ela provavelmente não será utilizada em um futuro próximo (já que ela não foi recentemente acessada). A segunda classe pode parecer impossível, a princípio, já que ela contém páginas que não foram acessadas recentemente, porém foram modificadas. Na verdade, em geral o bit de referência é zerado de tempos em tempos pelo SO para que ele reflita uma informação mais recente sobre o acesso das páginas. Por outro lado, o bit de sujeira precisa ficar intacto, já que a informação sobre a modificação de uma página é essencial quando esta é retirada da memória principal. Esta segunda classe, portanto, contém páginas que demandam mais esforço do sistema para remoção (já que foram modificadas), porém provavelmente não serão necessárias em um futuro próximo. A terceira classe contém as páginas que foram acessadas recentemente, mas que não foram modificadas. Se as duas primeiras classes estiverem vazias, esta é a melhor escolha, já que, ao menos, o processo de substituição será mais rápido (não existe a necessidade de copiar o conteúdo da página vítima para a área de swap). Se mesmo a terceira classe está vazia, não resta outra opção ao SO senão remover uma página que foi acessada recentemente e foi modificada. Um problema do NRU é o fato deste ser bem menos eficiente que o FIFO. A cada execução, este algoritmo precisa varrer todas as páginas alocadas no sistema. Com o aumento na quantidade de memória utilizada pelos sistemas atuais, este algoritmo fica cada vez menos viável. O Algoritmo do Relógio consegue levar em consideração o bit de referência, tendo uma implementação mais eficiente que o NRU. A ideia deste algoritmo é manter uma lista circular das páginas atualmente carregadas em memória, ordenada pelo momento de chegada da página à memória (similar à fila do FIFO). O algoritmo mantém ainda um ponteiro que, a princípio, aponta para a página mais antiga (a mais tempo na memória principal). Quando uma nova página é colocada em memória, o SO cria um novo nó na lista circular, inserido imediatamente antes do nó atualmente apontado pelo ponteiro.

Quando é necessário escolher uma página vítima, o algoritmo do relógio avalia a página atualmente apontada pelo ponteiro. Se o bit de referência da página está em 1 (a página foi recentemente acessada), o algoritmo altera o bit de referência para 0 e avança o ponteiro para a próxima página da lista. Quando o algoritmo encontra uma página com bit de referência em 0, esta é escolhida como a página vítima. Note que, no pior caso, todas as páginas da lista terão o bit de referência em 1. Neste caso, o algoritmo do relógio percorrerá toda a lista, zerando o bit para todas as páginas. Eventualmente, como se trata de uma lista circular, o algoritmo voltará à primeira página analisada, que, desta vez, terá o bit de referência em 0. A ideia do algoritmo do relógio é misturar os conceitos do algoritmo FIFO (escolher a página a mais tempo carregada em memória) com o conceito do NRU (escolher páginas não utilizadas recentemente). O resultado é um algoritmo relativamente eficiente (em geral, não é preciso varrer todas as páginas atualmente alocadas, como no NRU) e que leva em consideração o princípio da localidade referencial. Note, no entanto, que ao contrário do NRU, o algoritmo do relógio não leva em consideração o bit de sujeira. Note que a página mais antiga em memória, apontada pelo ponteiro mantido pelo algoritmo do relógio, pode ganhar uma segunda chance. Caso ela tenha seu bit de referência em 1 quando o algoritmo é executado, o ponteiro avança para a próxima página na lista. Isto é equivalente (do ponto de vista do algoritmo) a remover e trazer novamente a página para a memória principal. Em outras palavras, o avanço do ponteiro faz com que esta página mais antiga passe a estar na última posição da lista, assim como ocorreria com uma nova página trazida para a memória. Por causa deste funcionamento, este algoritmo às vezes é conhecido como Segunda Chance. Para alguns autores, os dois algoritmos se diferenciam apenas pela maneira de implementação: o segunda chance é implementado com uma lista encadeada comum (ao invés de avançar o ponteiro, o primeiro elemento da lista é movido para o final), enquanto o algoritmo do relógio é implementado com a lista circular. Um problema comum ao algoritmo do relógio e ao NRU é o fato de ambos considerarem apenas o estado atual do bit de referência. Isto quer dizer que os dois algoritmos levam em consideração apenas se cada página foi acessada recentemente, sem considerar a quantidade de acessos que foram realizados ou o tempo absoluto desde o último acesso. O algoritmo LRU (Least Recently Used) se baseia justamente neste ponto. A ideia do algoritmo é sempre escolher como página vítima aquela que está a mais tempo sem acesso pelos processos. Note que isso é, em teoria, a melhor aproximação para o algoritmo ótimo: enquanto o algoritmo ótimo procura a página cujo acesso está mais distante no futuro, o LRU escolhe a página cujo acesso está mais distante no passado. Embora o algoritmo LRU seja implementável na prática, sua implementação é muito cara em termos computacionais. A cada acesso de memória, é preciso salvar o instante de tempo atual em algum campo da tabela de páginas para consulta posterior pelo algoritmo. Realizar esta implementação em software é completamente inviável. Com suporte do hardware existem

algumas possíveis maneiras de realizar a implementação de forma eficiente. No entanto, são raras as máquinas que dão suporte a esta funcionalidade. Um simplificação do algoritmo LRU pode ser implementada sem suporte do hardware. Nesta simplificação, chamada NFU (Not Frequently Used), o SO realiza uma amostragem periódica dos bits de referência. Para cada página, o SO verifica o valor atual do bit e armazena em um mapa de bits específico para aquela página. O bit de referência, então, é zerado. O mapa de bits tem um tamanho fixo, que determina a quantidade de amostras que o algoritmo NFU leva em consideração (por exemplo, as últimas 20 amostras). A cada nova amostra coletada pelo SO, o mapa de bits sofre um shift para a direita e o novo bit é adicionado mais a esquerda (no bit mais significativo). Quando o NFU precisa escolher uma página vítima, ele varre todas as páginas atualmente em memória, verificando seus mapas de bits. Cada mapa de bits é visto como um número inteiro positivo. A página cujo mapa de bits representa o menor valor inteiro é aquela menos recentemente acessada e, portanto, a página vítima. Há duas limitações do NFU, em relação ao LRU original. Em primeiro lugar, como o número de bits do mapa é limitado, existe perda de informação do passado mais distante. Em outras palavras, é impossível decidir entre duas páginas que têm seus mapas de bits zerados qual foi acessada a mais tempo pela última vez. Mesmo no caso de haver informações sobre acessos no mapa de bits, existe a limitação da taxa de amostragem utilizada pelo SO: vários acessos diferentes podem ocorrer entre duas amostragens do SO. 3. Algoritmos Locais Diferentemente dos algoritmos globais, algoritmos locais analisam apenas as páginas em memória do próprio processo que causou a falta de página para efeito da seleção da página vítima. A motivação destes algoritmos tem por base a ideia de que todo processo tem um subconjunto de páginas que são necessárias para manter uma baixa falta de páginas no sistema. Este sub-conjunto tende a mudar durante a execução. No entanto, se o algoritmo conseguir acompanhar as necessidades de páginas do processo, ele manterá o percentual de falta de páginas do sistema sob controle. Por outro lado, algoritmos globais podem decidir remover uma página de um processo para a inserção da página de outro. Desta forma, os algoritmos globais tendem a aumentar a probabilidade de falta de páginas para um processo para resolver a falta de páginas de outro. Um algoritmo de substituição de páginas local ótimo funciona da seguinte maneira. O sistema define um parâmetro f equivalente a uma janela de tempo no futuro. Por exemplo, f pode ser definido como uma janela dos próximos 10 segundos. A cada escolha de uma página vítima, o objetivo do algoritmo ótimo é garantir que a página retirada não seja necessária pelas próximas f unidades de tempo. Supondo que o sistema tenha conhecimento sobre os acessos futuros a páginas do processo, basta que o algoritmo escolha uma página que não será acessada nas próximas f unidades de tempo.

Note que, dependendo do valor de f e da quantidade de páginas alocadas para o processo, pode ser impossível encontrar uma solução. Por exemplo, suponha que o processo tem 3 páginas alocadas, 2, 5 e 6, e que no momento é necessária a página 4. Suponha ainda que f = 5 acessos a memória e que a string de referência dos próximos 5 acessos seja 45226. Neste caso, 4 páginas são necessárias para que o processo não sofra uma falta de páginas durante a janela de f. Uma solução seria simplesmente alocar mais uma página para o processo. No entanto, isso nem sempre é possível. Logo, pode ser necessário reduzir o valor de f para manter o algoritmo ótimo viável. Assim como no caso dos algoritmos globais, o algoritmo local ótimo também não é implementável, no caso geral. Uma aproximação é o algoritmo Working Set. A ideia do Working Set é usar o princípio da localidade de referência para prever as demandas de página futuras, com base nas demandas anteriores. Assim como no algoritmo ótimo, o Working Set define o mesmo parâmetro f. No entanto, ao invés de tentar olhar os acessos nas próximas f unidades de tempo, o algoritmo olha para os acessos nas últimas f unidades de tempo. A partir desta informação, o Working Set determina quais o conjunto de páginas atualmente em uso pelo processo. Este conjunto é mantido em memória e as demais páginas podem ser liberadas. Assim como acontecia no algoritmo ótimo, no algoritmo de Working Set é possível que sejam necessárias mais páginas para um processo do que seja possível alocar. O desafio, portanto, é escolher um valor de f tal que o algoritmo seja viável (portanto, f não pode ser muito grande) e que o conjunto de páginas obtido não seja excessivamente pequeno (portanto, f não pode ser muito pequeno). O valor ideal de f depende de uma série de fatores, como a quantidade de memória da máquina, o grau de multiprogramação desejado e o tamanho médio do conjunto de páginas necessário a cada processo. No algoritmo Working Set, se é necessário alocar mais páginas a um processo e não há mais quadros disponíveis, em geral o SO suspende algum outro processo, removendo todas as suas páginas da memória principal. A decisão de qual processo remover cabe ao escalonador de médio prazo. 4. Thrashing O grande motivação para a utilização da memória virtual e o melhor aproveitamento dos recursos do sistema. Aumentando o grau de multiprogramação, aumenta-se a eficiência na utilização de recursos como o processador. No entanto, a técnica de memória virtual (especificamente na paginação sob demanda) tem um preço, que é o aumento do tempo médio de acesso à memória. Quando a taxa de ocorrência de falta de página é baixa, este preço é irrelevante. Por outro lado, se a taxa aumenta, a queda de desempenho do sistema é notável. Isso porque o SO precisa constantemente tratar faltas de página, o que aumenta consideravelmente o tempo médio de acesso à memória principal.

O aumento da taxa de falta de páginas pode ser causado tanto por escolhas ruins por parte dos algoritmos de substituição de página, quanto pela pouca quantidade de memória RAM no sistema. De toda forma, existem casos em que processos passam a ter um número tão baixo de páginas em memória principal que a taxa de falta de páginas aumenta demais. Neste caso, a maior parte do tempo do sistema passa a ser dedicado a tratar faltas de página, ao invés de realizar o processamento dos processos. Esta situação, na qual o overhead do tratamento de falta de páginas passa a ser alto demais por conta de um número muito grande de faltas de páginas, é conhecida como Thrashing. O Thrashing pode ocorrer isoladamente com um processo (quando este processo específico tem um número insuficiente de páginas em memória) ou com todo o sistema. Quando o Thrashing ocorre em todo o sistema, isso geralmente significa que existem processos demais carregados simultaneamente. A solução, portanto, é suspender completamente um ou mais processos (enviar todos os seus quadros da memória principal para a área de swap). Pode ser interessante também tentar evitar a ocorrência de thrashing. Para isso, o SO precisa empregar alguma política de controle de admissão de novos processos. Como discutido no Capítulo 4, esta política é implementada pelo escalonador de longo prazo. Quando um novo processo chega ao sistema, o escalonador de longo prazo deve utilizar critérios para avaliar se o sistema tem recursos suficientes para comportar este processo sem incorrer em thrashing. 5. Estudo de Caso: Arquitetura x86 Os métodos de gerenciamento de memória e memória virtual vistos até aqui foram descritos de forma genérica, sem foco em uma arquitetura específica. Na prática, cada arquitetura de hardware emprega suas próprias especificidades. A arquitetura x86 (considerando dos processadores 80386 para cima) suportam uma série de métodos de gerenciamento de memória, incluindo segmentação, paginação e paginação com segmentação, sendo que o modo mais comum de operação destes processadores ainda é o terceiro. Na paginação com segmentação implementada pelo 80386, cada endereço lógico é representado por 48 bits, sendo 32 bits de deslocamento e mais 16 utilizados para identificação de segmentos. No entanto, as instruções utilizadas pelo processador usam endereços de apenas 32 bits. Na verdade, o processador conta com uma série de Registradores de Segmento, que armazenam os valores usados para identificar um segmento na tabela de segmentos de um processo. Ao invés de anexar o identificador no endereço, o processo configura o conteúdo de um dos registradores de segmento e passa o deslocamento para uma instrução especificamente projetada para usar aquele registrador. Por exemplo, existem registradores de segmento padrão, como o CS (Code Segment), o DS (Data Segment) e o SS (Stack Segment). Quando o processo executa uma instrução, o processador automaticamente considera o segmento CS para o cálculo do endereço de memória que contém a instrução.

Como são utilizados 32 bits do endereço lógico para o deslocamento interno de um segmento, a arquitetura permite segmentos de até 4 GB. Em relação à paginação, os quadros utilizados nesta arquitetura sempre são de 4 KB. Logo, o número máximo de páginas na tabela de páginas de um segmento é de 1M páginas (2^20). A arquitetura utiliza paginação em dois níveis. A página principal, chamada de Diretório de Páginas, possui 1K entradas de 4 bytes, cada uma apontando para o endereço de uma página de segundo nível. Páginas de segundo nível também contém 1K entradas de 4 bytes. As informações contidas em cada entrada podem ser divididas em vários campos: 20 bits para o identificador do quadro que contém a página. 1 bit de sujeira. 1 bit de referência. 1 bit de validade. 3 bits reservados para o SO (para serem usados da forma mais conveniente). 2 bits de permissões. 4 bits sem uso definido.