Notas da Aula 10 - Fundamentos de Sistemas Operacionais

Transcrição

1 Notas da Aula 10 - Fundamentos de Sistemas Operacionais 1. Escalonadores preemptivos Escalonadores preemptivos são aqueles que têm a capacidade de interromper a execução de um processo para realizar alterações no escalonamento. Estas interrupções podem ser programadas, através de temporizadores, por exemplo, ou não programadas, através de chegada de um novo processo no sistema. Esta característica dos escalonadores preemptivos permite que eles tenham mais oportunidades de rever suas decisões de escalonamento. Por exemplo, quando um novo processo é criado no sistema (ou quando um processo é desbloqueado após uma operação de E/S) o conjunto de processos disponíveis para escalonamento muda. Com isso, o melhor processo a ser escalonado no momento, de acordo com a política do escalonador, pode mudar. Considere, por exemplo, um escalonador como o SJF. Este escalonador (que é nãopreemptivo) sempre opta por escalonar o processo mais curto disponível. Suponha que em uma dada oportunidade de escalonamento, o SJF tenha escolhido um processo A para utilizar o processador (pois A é o menor processo na lista de processos aptos neste instante). Durante a execução de A, um novo processo B, mais curto que o processo A, chega ao sistema. Como o SJF é um escalonador não-preemptivo, nada será feito e o processo A continuará sua execução até que voluntariamente saia do processador. Se o SJF fosse um escalonador preemptivo, ele poderia interromper a execução do processo A no momento da chegada de B para rever sua escolha. Isso faria com que B fosse escalonado e A voltasse à lista de processos aptos. A capacidade de rever suas decisões confere aos escalonadores preemptivos uma vantagem em relação aos não-preemptivos em termos dos objetivos de escalonamento. Em outras palavras, um escalonador preemptivo com um determinado objetivo (por exemplo, minimizar o tempo de resposta médio) tende a obter melhores resultados que um escalonador nãopreemptivo com os mesmos objetivos. Por outro lado, escalonadores preemptivos induzem mais overhead no sistema. Isso ocorre por dois motivos. Primeiro, a quantidade de oportunidades de escalonamento é maior para os escalonadores preemptivos, fazendo com que as suas rotinas sejam executadas mais vezes pelo sistema. Além disso, estes escalonadores tendem a ser mais complexos, tanto em termos de processamento, quanto em termos de quantidade de memória utilizada. Note que alguns escalonadores podem ser implementados de forma preemptiva ou nãopreemptiva. Por exemplo, o SJF poderia ser facilmente ajustado para funcionar de maneira preemptiva, bastando que seus momentos de atuação fossem estendidos para conter os instantes de chegada de novos processos ao sistema. Na maior parte dos sistemas atuais, os escalonadores preemptivos são utilizados. Isso

2 ocorre porque nestes sistemas, em geral, as aplicações são interativas. Isso quer dizer que a resposta de um dado processo não ocorre mais apenas quando este termina. Ao contrário, nestes sistemas os processos atendem a vários pequenos pedidos dos usuários durante a sua existência. Com isso, o conceito de tempo de resposta deixa de ser relativo ao início e término do processo e passa a ser relativo aos vários intervalos entre requisições e atendimentos aos usuários. Logo, permitir que um processo monopolize o processador até o fim da sua execução não é mais uma boa política. 2. Escalonamento por Prioridade Neste escalonador preemptivo, cada processo do sistema precisa receber uma prioridade, um valor numérico indicando o quão importante é a sua execução dentro do sistema. A ideia é que processos de maior prioridade devem ser executados antes dos processos de menor prioridade. Processos de prioridades iguais precisam de algum critério de desempate. Quando há uma oportunidade de escalonamento (lembre-se que este escalonador é preemptivo, então a chegada de um novo processo é uma oportunidade de escalonamento), o escalonador por prioridade varre a lista de processos aptos procurando pelo processo de mais alta prioridade. Este processo é, então, escalonado para a utilização do processador. Caso exista um empate nas prioridades, o escalonador utiliza algum outro critério como desempate. Este critério de desempate, em geral, é a ordem de chegada dos processos (como no escalonador FIFO), mas outros critérios podem ser usados (como o tamanho do próximo ciclo de processamento, como no SJF). A escolha dos valores de prioridade geralmente é feita pelos usuários. Existe um valor padrão, definido pelo sistema, que é intermediário entre a prioridade máxima e a prioridade mínima. O usuário pode especificar prioridade mais alta ou mais baixa, dependendo das necessidades da aplicação. Existem, no entanto, casos em que as prioridades são determinadas pelo próprio sistema, com base nas características da aplicação. Por exemplo, o sistema pode decidir que aplicações executadas em background (aquelas que não tem interação com o usuário) devem ter prioridade mais baixa, pois seu tempo de resposta não é tão importante. Por outro lado, programas executados em foreground (aqueles em que pode haver interação com o usuário) devem ter prioridades mais altas. É importante notar ainda que este escalonador pode ser implementado de maneira nãopreemptiva, bastando que seus momentos de atuação sejam restritos aos instantes em que os processos voluntariamente deixam o processador. Neste caso, a chegada de um novo processo ao sistema não causa alterações no escalonamento (ao menos não na decisão atual). Entretanto, usualmente este escalonador é implementado na sua forma preemptiva. O escalonador baseado em prioridades pode levar processos a starvation, caso estes processos possuam baixa prioridade e o sistema tenha muitos processos de alta prioridade

3 constantemente aptos a execução. Em termos de implementação, este escalonador pode se tornar mais eficiente através da ordenação da lista de processos aptos por ordem de prioridade. Neste caso, sempre que um novo processo chega ao sistema, ele é inserido na fila em uma posição correspondente à sua prioridade. No momento em que é necessário tomar uma decisão de escalonamento, o escalonador precisa apenas pegar o primeiro processo da lista (supondo que o desempate seja por ordem de chegada), assim como ocorria no escalonador FIFO. Outra possibilidade é criar várias filas diferentes, uma para cada valor de prioridade permitido no sistema. Neste caso, o procedimento deste escalonador fica bastante simples. Quando um novo processo chega ao sistema, o escalonador escolhe a fila adequada de acordo com a prioridade e insere o novo processo no final. Quando há uma oportunidade de escalonamento, o escalonador percorre as filas, da mais prioritária para a menos prioritária. Ao encontrar uma fila que não esteja vazia, o primeiro processo é escolhido para execução. 3. Fatia de Tempo O escalonador baseado em fatias de tempo (ou timesharing), também conhecido como roundrobin, já foi discutido superficialmente ao longo da disciplina. A ideia é dividir o processador entre os vários processos em memória no sistema através do uso de pequenas fatias de tempo (também chamadas de slices ou quantum). Quando um escalonador escolhe um processo na lista de aptos para utilizar o processador, este processo ganha apenas uma fatia de tempo, ao invés de poder realizar toda a sua execução ininterruptamente. Quando a fatia de tempo do processo termina, o SO o remove do processador e o escalonador dá a próxima fatia de tempo a um outro processo apto. Um processo não necessariamente utiliza toda a sua fatia de tempo. Um processo pode ser tão curto que, dentro da sua primeira fatia de tempo, ele seja terminado. Pode ainda acontecer de um processo requisitar uma operação de E/S durante seu slice. Neste caso, ele será bloqueado e não completará o uso total da sua fatia atual. Assim, o escalonador volta a atuar, selecionando um novo processo apto e dando a ele um novo slice completo. A escolha de qual processo deve ser o próximo a receber uma fatia de tempo é feita através de algum critério de escalonamento. Na grande maioria dos casos, este critério é a ordem de chegada (como no escalonador FIFO). Ou seja, cada vez que o escalonador precisa escolher um processo para a próxima fatia de tempo, ele escolhe o primeiro processo da fila de chegada ao sistema. Ao terminar de usar seu slice atual ou ao ser desbloqueado após uma operação de E/S, um processo é colocado no final da fila. O tamanho da fatia de tempo dada a cada processo é, em geral, uma constante definida no projeto do SO. Idealmente, a fatia de tempo é bastante pequena, já que o grande objetivo deste escalonador é passar ao usuário a impressão de que as várias tarefas (processos) do sistema estão sendo executadas simultaneamente. Desta forma, quanto menor a fatia de tempo, menor

4 o tempo de espera de um processo na fila de aptos. Por outro lado, a fatia de tempo não deve ser pequena demais. Neste caso, os overheads associados ao escalonamento podem se tornar muito representativos, reduzindo a eficiência no uso do processador. É importante notar que, de todos os escalonadores vistos até aqui, o round-robin é o que atua mais frequentemente no sistema. Logo, seu overhead é consideravelmente maior que os dos demais algoritmos discutidos. Um problema importante para a implementação deste escalonador, portanto, é a escolha do valor da fatia de tempo. O objetivo na escolha é basicamente encontrar o menor valor possível (para garantir o efeito de vários processos sendo executados ao mesmo tempo), de forma que o overhead de chaveamento entre processos (salvamento e restituição de contexto) seja baixo. Estes objetivos dependem da velocidade de execução do processador, da quantidade de instruções necessárias para o chaveamento de contexto e do que é considerado um baixo overhead. Suponha, por exemplo, que a máquina em questão tem um processador de 1GHz e que cada instrução demora 1 ciclo do relógio. Isso significa que este processador é capaz de executar uma instrução a cada 1 ns. Considere ainda que a operação de chaveamento entre dois processos gasta 200 instruções. Logo, esta operação demora 200 ns. Se o máximo overhead aceitável é de 1%, o menor valor aceitável para uma fatia de tempo é de 20 Por outro lado, para um processador que trabalha a 100 MHz, a fatia de tempo precisa ser aumentada para 0,2 ms. Uma característica importante do escalonador round-robin é que ele evita completamente o starvation. Isso ocorre porque os processos ficam, no máximo, o tempo de uma fatia de tempo no processador antes de serem substituídos por outros. Mesmo que um processo entre em um loop infinito (o que causava problemas para o escalonamento FIFO), isto não afetará os demais processos, que eventualmente receberão uma chance de utilizar o processador. Por outro lado, um problema com este escalonador é que os processos I/O Bound são prejudicados. Isso ocorre pois estes processos raramente usam sua fatia de tempo completa, porém precisam esperar o mesmo tempo na fila que outros processos. 4. Fatia de Tempo com Prioridades É possível juntar ambas as políticas de escalonamento por prioridades e por fatia de tempo em uma única decisão de escalonamento. O escalonador resultante funciona de maneira simples. A ideia é manter várias filas de processos aptos, uma para cada prioridade (como já pode ocorrer no escalonamento baseado em prioridades). No entanto, quando o escalonador escolhe um processo para utilizar o processador, ao invés de permitir que o processo utilize o processador por um tempo indeterminado (até que o processo requisite uma operação de E/ S ou até que um novo processo chegue ao sistema), o escalonador especifica uma fatia de tempo máxima.

5 Basicamente, o que este escalonador faz é executar um escalonamento do tipo round-robin no nível de prioridade mais alto que tenha processos prontos. Quando não há processos aptos no nível de prioridade mais alto (ou porque todos estão bloqueados aguardando o fim de uma operação de E/S ou porque todos já foram encerrados), o escalonador passa o round-robin para o próximo nível mais alto. Este escalonador tem a desvantagem de poder levar processos de menor prioridade a um estado de starvation (como ocorre com o escalonador baseado em prioridades original). 5. Escalonamento com Múltiplas Filas Uma outra maneira de combinar diferentes políticas de escalonamento é através do uso de múltiplas filas com diferentes políticas. O SO mantém filas diferentes de processos aptos para tipos diferentes de processos, sendo que cada fila é governada por uma política diferente de escalonamento. Suponha, por exemplo, que o SO diferencie os processos do sistema entre processos executados em background e foreground. Processos em foreground precisam de uma política de escalonamento que dê ao usuário um melhor tempo de resposta. Processos em background podem utilizar uma política menos agressiva. Neste sistema, o SO pode dividir os processos em duas filas de aptos: uma utilizando o escalonamento round-robin (para processos em foreground) e outra com o escalonamento FIFO (para os processos executados em background). Quando há uma oportunidade de escalonamento, é preciso primeiro decidir qual das filas será atendida. Para isso, é necessário um terceiro algoritmo de escalonamento que, ao invés de escolher diretamente processos, escolhe filas a serem atendidas. Este algoritmo pode ser, por exemplo, baseado em prioridades. Neste caso, a fila de processos em foreground tem uma prioridade mais alta que a dos processos em background. Enquanto a fila de foreground tiver processos aptos, estes utilizarão o processador, segundo a política de round-robin. Quando esta fila ficar vazia, a vez passará para os processos em background, que serão executados através do escalonamento FIFO. Embora neste exemplo tenham sido adotados os escalonadores FIFO, baseado em prioridades e round-robin, qualquer conjunto de escalonadores pode ser utilizado, de acordo com as características do sistema. Por exemplo, o esquema de prioridades entre as duas filas pode ser substituído por um esquema do tipo round-robin.