Paginao, Deadlocks e Starvation | Amigo Nerd

http://amigonerd.net/exatas/informatica/paginacao-deadlocks...

Com pressa? No achou o que precisava? Solicite um trabalho personalizado. Clique aqui!
Curtir 3.978 pessoas curtiram isso. Cadastre-se para ver do que seus amigos gostam. +129

Paginao, Deadlocks e Starvation

Autor: Flvio Vieira de Castro Instituio: CEFET Tema: Algoritmos de Substituio de Paginao

Compartilhe este trabalho

Algoritmos de Substituio de Pginas

Introduo Neste trabalho apresentarei caractersticas dos sitemas operacionias modernos como: Paginao Um excelente recurso que faz com que projetos de hardware de pouco desempenho em relao a memrias, possam apresentar bom desempenho frente a programas que exijam maior quantidade de memria do que o existente no projeto. Deadlock Um problema que est presente em todos os sistemas operacionais atuais, que leva ao travamento de processos, sero apresentadas algumas formas de evitar este problema. Starvation A situao de starvation est presente quando o sistema operacional prov prioridades a processos, que no atualizados fazem com que os processos de menor prioridade nunca sejam executados causando assim, deficincia em servidores de impresso e etc.

1 - Paginao A maioria dos sistemas de memria virtual usa a tcnica denominada paginao, que ser descrita a seguir. Em muitos computadores existe um conjunto de endereos de memria que os programas podem gerar no decorrer de suas execues. Quando um programa executa uma instruo como MOVE REG,1000 ele est copiando o contedo do endereo de memria 1000 para o REG, ou vice-versa, dependendo do computador. Os endereos podem ser gerados por indexao, registradores-base, registradores de segmento, alm de vrias outras tcnicas. Tais endereos, gerados pelo programa, so chamados de endereos virtuais e forma o espao de endereamento virtual. Em computadores sem memria virtual, o endereo virtual colocado diretamente no barramento da memria, fazendo com que o endereo fsico da memria, equivalente a ele, seja lido ou escrito. Quando a memria virtual usada, os endereos virtuais no vo direto para o barramento da memria. Em vez disso, eles so encaminhados unidade de gerncia de memria (MMU), um chip ou um conjunto de chips que mapeiam os endereos virtuais em endereos fsicos da memria, conforme ilustrado na Fig. 3.10. Um exemplo de como este mapeamento trabalha mostrado na Fig. 3.11. Neste exemplo, temos um computador que pode gerar endereos de 16 bits, de 0 at 64k, correspondentes ao espao de endereamento virtual da mquina. No entanto, este computador tem apenas 32K de memria fsica, de forma que apesar de podermos escrever programas com at 64K, estes no podem ser totalmente carregados na memria e executados. Uma cpia completa do programa deve sempre ser mantida no disco, de forma que pedaos dele possam ser colocados na memria, quando necessrios. O espao de endereamento virtual dividido em unidades denominadas pginas. As unidades correspondentes na memria fsica so as molduras de pgina (page frames). As pginas e as molduras de pgina so sempre do mesmo tamanho. Neste exemplo, elas tm 4K endereos, porm pginas de 512 at 8K so usadas rotineiramente. Com 64K de espao de endereamento virtual, e 32K de memria real, teremos 16 pginas virtuais e oito molduras de pgina. As transferncias da memria para o disco e vice-versa so sempre feitas em pginas. Quando o programa tenta acessar o endereo 0, por exemplo, usando a instruo MOVE REG,0 o endereo virtual 0 enviado MMU. Esta conclui que este endereo virtual cai na pgina 0 (endereos virtuais de 0 a 4095), que de acordo com seu processo de mapeamento est na moldura de pgina 2(endereos reais de 8.192 a 12.287). Ela ento transforma o endereo que lhe foi entregue para 8.192, e coloca este valor no barramento da memria. A placa de memria desconhece a existncia da MMU, e simplesmente enxerga uma requisio para ler ou escrever no endereo 8.192, realizando tal acesso. Ento, a MMU efetivamente mapeia todos os endereos virtuais de 0 a 4.095 nos endereos reais de 8.192 a 12.287. Da mesma forma, a instruo MOVE REG,8192 executada como

1 de 9

20-06-2013 22:57

Paginao, Deadlocks e Starvation | Amigo Nerd

MOVE REG,24576

http://amigonerd.net/exatas/informatica/paginacao-deadlocks...

em virtude do endereo virtual 8.192 encontrar-se na pgina 2, e esta pgina ser mapeada na moldura 6 (endereos fsicos de 24.576 a 28.671) e mapeado no endereo real 12.288 + 20 = 12.308. Por si s, est capacidade de mapear as 16 pginas em qualquer uma das molduras de pgina, realizada pela MMU, no resolve o problema do espao virtual ser maior do que o espao real disponvel na memria. Como dispomos de apenas oito molduras de pgina, somente oito das pginas virtuais da Fig. 3.11 so passveis de ser mapeadas em endereos fsicos. As outras, identificadas por um X na figura, no so mapeveis. No hardware real, um bit de presena/ausncia existente em cada uma das entradas informa se a pagina pode eu no ser mapeada. O que ocorre se um programa tenta usar uma pgina no mapeada, tentando, por exemplo, executar a instruo MOVE REG,32780 cujo endereo virtual gerado est 12 bits aps a origem da pgina 8, que tem incio em 32.768? A MMU observa que se trata de uma pgina no-mapevel e fora o processador a executar um trap para o sistema operacional. Este trap denominado falta de pgina. Como resposta ao trap, o sistema operacional pega a moldura de pgina menos usada e a copia de volta para o disco. Ento ele busca a pgina referenciada e a copia na moldura que acabou de ser liberada, modifica o mapa e reexecuta a instruo causadora do trap. Por exemplo, se o sistema operacional resolver substituir a pgina na moldura 1, ele deve carregar a pgina virtual 8 no endereo 4K e fazer duas mudanas no mapeamento da MMU. Primeiro, ele deve marcar a entrada correspondente pgina virtual 1 como no-mapevel, para que um trap seja gerado quando houver qualquer acesso futuro a um endereo virtual desta pgina. Depois, ele deve substituir o xis na entrada correspondente pgina virtual 8 por um 1, de maneira que quando a instruo que gerou o trap for reexecutada, deve haver o mapeamento do endereo virtual 32.780 no endereo fsico 4.108. Agora vamos dar uma olhada dentro da MMU, para ver como ela funciona, e entender por que escolhemos um tamanho de pgina que uma potncia inteira de 2. Na Fig. 3.12, vemos um exemplo do endereo virtual 8.196 (0010000000000100 em binrio), sendo mapeado usando o mapa da MMU da Fig. 3.11. O endereo virtual de 16 bits que chaga MMU dividido em um nmero de pagina de quatro bits, e em um deslocamento de 12 bits. Com os quatro bits referentes ao nmero da pgina, podemos representar 16 pginas, e com os 12 do deslocamento podemos enderear todos os 4.096 bytes que compem uma determinada pgina. O nmero da pgina usado como ndice da tabela de pginas, levando ao nmero da moldura de pgina correspondente a esta pgina virtual. Se o bit e Presena/Ausncia for 0, gerado um trap para o sistema operacional. Se este bit for igual a 1, o nmero da moldura de pgina copiado para os trs bits de mais alta ordem do registrador de sada da MMU, junto com os 12 bits do deslocamento, copiados sem nenhuma modificao em relao ao deslocamento do endereo virtual. Juntos eles formam o endereo fsico de 15 bits. O contedo do registrador de sada ento colocado no barramento da memria, correspondendo ao endereo fsico, resultante do endereo virtual que foi apresentado anteriormente MMU. 1.1 - Algoritmos de substituio de pginas Quando ocorre falta de pgina, o sistema operacional deve escolher uma pgina a ser removida para dar lugar que deve ser gravada na memria real. Se a pgina escolhida para ser removida tiver sido modificada durante sua estada de memria, ela deve ser reescrita no disco, de forma a atualizar a cpia l existente. Se a pgina no tiver sofrido nenhuma modificao (por exemplo, uma pgina de cdigo), a cpia do disco continua atualizada, e no necessrio recopi-la. A nova pgina simplesmente escrita em cima da pgina escolhida para ser retirada. Apesar de ser poder escolher randomicamente a pgina a ser retirada a cada ocorrncia de uma falta de pgina, a performance do sistema ser muito melhor se conseguirmos substituir uma pgina que no esteja sendo muito referenciada. Se removermos uma pgina fortemente referenciada, talvez tenhamos de traz-la de volta muito em breve, causando um overhead desnecessrio. Muito trabalho, tanto terico quanto experimental, tem sido feito em cima da questo dos algoritmos de substituio de pginas. A bibliografia do paper de Smith (1978) lista nada mais nada menos que 300 outros papers a respeito do assunto. 1.1.1 - O Algoritmo timo O melhor dos algoritmos de substituio de pginas fcil de descrever, mas impossvel de implementar. Ele funciona da seguinte forma: no momento em que h a ocorrncia de falta de pgina, existe um conjunto delas armazenado na memria. Uma delas ser referenciada na prxima instruo, ou seja, trata-se da pgina que contm a instruo que gerou a falta de pgina. Outras pginas podero s ser referenciadas 10, 100 ou at 1.000 instrues depois da atual. Cada pgina pode ser identificada pelo nmero de instrues depois da corrente que devero ser executadas at que ela seja novamente referenciada. O algoritmo de substituio timo diz apenas que a pgina com o nmero de identificao mais alto deve ser removida primeiro. Se uma pgina no vai ser usada antes de oito milhes de instrues serem executadas, e outra antes da execuo de seis milhes de instrues, a primeira deve ser removida antes da segunda. Ao decidir assim, o algoritmo procura adiar o problema da prxima falta de pgina o mximo possvel. A exemplo das pessoas, os computadores tambm tendem a adiar o quanto possvel a ocorrncia de eventos desagradveis. O nico seno deste algoritmo que ele no realizvel na prtica. Na ocorrncia de uma falta de pgina, o sistema operacional no tem como saber quando cada uma das pginas da memria ser referenciada de novo. Obviamente, rodando o programa num simulador, e anotando todas as referncias a pginas realizadas, possvel implementar o algoritmo timo na segunda rodada do programa usando a lista de referncia obtida na primeira rodada. Desta forma, possvel comparar a performance de outros algoritmos realizveis na prtica com a performance do melhor algoritmo possvel de ser construir. Se um sistema operacional tem um algoritmo de substituio que causa uma performance, digamos 1 por cento abaixo da obtida com o algoritmo timo, os esforos canalizados na busca de um algoritmo melhor s podero redundar em uma melhora de no mximo 1 por cento. Para evitar confuso, deve ser enfatizado que o log de referncia a pginas obtido refere-se programa medido. O algoritmo de substituio resultante dele s vlido para este programa em particular. Apesar de este mtodo ser til na avaliao de algoritmos de substituio de pginas, ele no usado na prtica. 1.1.2 - Algoritmo da Pgina No Usada Recentemente De modo a permitir que o sistema operacional colete as informaes necessrias decidir quais das pginas na memria principal esto sendo usadas e quais no esto, muitos computadores com memria virtual tm dois bits de estado associados a cada pgina. Um deles, o bit R, feito igual a 1 sempre que a pgina a ele associada for referenciada (lida ou escrita). O outro, o bit M, setado quando alguma informao for escrita na pgina (quando a pgina for modificada). Tais bits fazem parte de cada uma as entradas da tabela de pginas. importante observar que estes bits precisam ser atualizados a casa referncia memria, de foram que fundamental que essa atualizao seja efetuada por hardware. Uma vez que um destes bits seja setado, ele permanecer em um at que o sistema operacional o faa novamente 0. Se o hardware na possuir esses bits, eles podem ser simulados com a seguir. Quando um processo (re)inicializado, toas as suas entradas da tabela de pginas so marcadas como se no estivessem na memria. To logo uma pgina seja referenciada, ocorrer uma falta de pgina. O sistema operacional ento seta o bit R (em suas tabelas internas), modifica a entrada da tabela de pginas de forma a faz-la apontar para a pgina correta, seta o modo leitura e retoma a execuo da instruo interrompida pela falta de pgina. Se a pgina for escrita depois, uma nova falta de paina gerada, permitindo ao sistema operacional setar o bit M e mudar o modo para LEITURA/ESCRITA. Os bits R e M podem ser usados para construir um algoritmo de paginao muito simples. Quando um processo (re)inicializado, ambos os bits de todas as pginas so feitos iguais a 0 pelo sistema operacional. Periodicamente, por exemplo, a cada interrupo de temo o bit R zerado para tornar possvel a identificao de painas que no tenham sido referenciadas recentemente daquelas que foram.

2 de 9

20-06-2013 22:57

Paginao, Deadlocks e Starvation | Amigo Nerd

http://amigonerd.net/exatas/informatica/paginacao-deadlocks...

Na ocorrncia de uma falta de pgina, o sistema operacional inspeciona todas as pginas, dividindo-as em quatro categorias, baseado no valor corrente dos bits R e M: Classe 0: no-referenciadas, no-modificadas. Classe 1: no-referenciadas, modificadas. Classe 2: referenciadas, no-modificadas. Classe 3: referenciadas, modificadas. Apesar da caracterizao da classe 1 parecer em princpio sem sentido, ma pgina pode ser colocada nesta classe quando ela j houver sido modificada, e numa interrupo de tempo o sistema operacional tenha zerado seu bit R. Evidentemente que o sistema operacional no pode muar o bit M, pois tal informao necessria para que se possa saber se ser ou no preciso copiar esta pgina de volta no disco quando ela sair da memria. O algoritmo NUR (No Usada Recentemente) remove randomicamente uma pgina da classe com o menor nmero de identificao, e que no esteja vazia. Implicitamente, este algoritmo diz que melhor remover uma paina que tenha sido modificada e no referenciada em pelo menos entre duas interrupes de tempo (tipicamente 20 ms), do que uma no-modificao que esteja em uso. A maior atrao do NUR que ele fcil de entender, fcil de implementar e tem uma boa performance, embora no certamente a tima. 1.1.3 - O Algoritmo FIFO Um outro algoritmo com muito pouco overhead na implementao o FIFO (Primeiro-a-Entrar, Primeiro-a-Sair). Para ilustrar seu funcionamento, considere um supermercado que tem prateleiras suficientes para armazenar exatamente K produtos diferentes. Certo dia, alguma indstria introduz um novo tipo de alimento que faz um tremendo sucesso comercial. Nosso supermercado deve, ento, arranjar um jeitinho pra vend-lo, eliminando de suas prateleira algum outro produto. Uma possibilidade descobrir qual dos produtos este supermercado vem estocando h mais tempo e livrar-se dele. De fato, tal deciso tomada com facilidade, pois o supermercado mantm uma fila ligada de todos os produtos vendidos atualmente, na ordem em que eles entraram pela primeira vez no estoque. O mais novo est no fim da fila, e o mais velho o incio, devendo este ser eliminado. Em algoritmos de substituio de pginas, a mesma idia pode ser aplicada. O sistema operacional mantm uma fila de todas as pginas que esto na memria, com a pgina no topo da fila sendo a mais antiga e a do fim da fila a que chegou h menos tempo. Na ocorrncia de uma falta de pgina, a pgina do incio deve ser removida, sendo a nova pgina adicionada ao fim desta fila. Quando aplicado ao problema do supermercado, o algoritmo FIFO tanto pode remover um dos itens mais vendidos, como sal ou manteiga, quanto um dos menos vendidos, como sacos de lixo. Quando aplicada aos computadores, o mesmo problema ocorre. Por isso, o algoritmo FIFO, em sua forma pura, nunca usado. 1.1.4 - O Algoritmo da Segunda Chance Uma pequena mudana no algoritmo FIFO, para evitar que pginas muito usadas sejam descartadas, fazer com que o algoritmo examine o bit R da pgina mais antiga. Se ele for 0, a pgina, alem de velha, no tem sido referenciada, de modo que ela deve ser removida imediatamente para da lugar a outra. Se R for igual a 1, este bit zerado, a pgina colocada no fim da fila de pginas, sendo ento considerada como tendo acabado de entrar na memria. Depois disso, a busca continua. A operao deste algoritmo, denominado segunda chance, mostrada na Fig. 3.24. Na Fig. 3.24(a) vemos as pginas de A at H, mantidas numa fila ligada, ordenadas de acordo com o tempo de chegada memria. Suponha que uma falta de pgina ocorra no tempo 20. A pgina mais antiga A, que chegou no tempo 0, quando o processo (re)iniciou sua execuo. Se A tem bit R em 0, ela ser retirada da memria, sendo escrita de volta no disco ou simplesmente abandona, conforme o valor de seu bit M. Por outro lado, se R estiver setado, A ser colocado no fim da fila, sendo seu "tempo de carga" atualizado pra o tempo corrente (20). O bit R recebe o valor 0. A procura pela pgina que vai ser eliminado continua com o exame das informaes referentes a B. O Algoritmo da segunda chance seta procurando uma pgina antiga que no tenha sido referenciada dentro do ltimo intervalo entre duas interrupes de tempo. Se todas as pginas presentes na memria tiverem sido referenciadas no intervalo citado, este algoritmo degenera no FIFO puro. Especificamente, considere que todas as pginas da Fig. 3.24(a) tm seus bits R setados. Uma a uma, o sistema operacional move as pginas para o fim da fila, zerando seus bits R a cada vez que uma pgina movimentada. Inevitavelmente ele voltar a examinar a pgina A, agora com R em 0. Neste momento A escolhida para deixar a memria. 1.1.5 - O Algoritmo Relgio Apesar do algoritmo da segunda chance ser razovel, ele desnecessariamente ineficiente, pois est sempre movendo pginas para o fim da lista. Uma forma mais apropriada pra gerenciar a idade das pginas mant-las em uma fila circular, em forma de relgio, como mostra a Fig. 3.25. Um ponteiro aponta para a pgina mais antiga. Na ocorrncia de uma falta de pgina, a pgina aponta inspecionada. Se seu bit R for 0, ela sai da memria, uma nova pgina inserida em seu lugar, e o ponteiro atualizado para apontar para a prxima posio. Se R for 1, o algoritmo zera seu valor e avana para examinar a prxima pgina. Este procedimento se repete at que seja encontrada uma pgina com R=0. No sem razo, este algoritmo conhecido como algoritmo do relgio, diferindo da segunda chance apenas na implementao mais eficiente. 1.1.6 - O Algoritmo da Pgina Usada H mais tempo (LRU) Uma boa aproximao do algoritmo timo baseada na observao de que pginas que foram muito usadas pelas ltimas instrues executadas continuaro sendo usadas pelas prximas instrues. Da mesma forma, as pginas que no foram referenciadas pelas ltimas instrues provavelmente continuaro no sendo usadas por um bom tempo. Esta idia sugere um novo algoritmo: quando ocorrer uma falta de pgina, remova da memria a pgina que foi usada h mais tempo. Esta estratgia conhecida como da pgina usada h mais tempo (LRU). Apesar do LRU ser em tese realizvel, sua implementao no barata. Para implementar totalmente o LRU, necessria a manuteno de uma lista ligada de todas as pginas da memria, com aquela que foi usada mais recentemente na frente, e a que foi usada h mais tempo atrs. O problema que a lista precisa ser atualizada a cada referncia memria. Encontra uma pgina na lista, retira-la da lista e mover uma outra para o inicio da lista so operaes que consomem muito tempo. Alm do mais, h necessidade de se contar com um hardware especial (caro). Uma alternativa seria buscar uma forma de implementar uma aproximao deste algoritmo por software. A busca em uma lista ligada e a manipulao das informaes esta lista a cada instruo executada so proibitivas em funo da lentido intrnseca destas operaes, mesmo quando realizadas por hardware. No entanto, existem outras formas de se implementar o LRU em hardware. Vamos considerar em primeiro lugar, a mais simples delas. O mtodo requer um contador de 64 bits, C, que incrementado automaticamente, aps a execuo de cada instruo. Alm disso, cada entrada da tabela de pginas precisa ter um campo extra para armazenar o valor do contador. Aps cada referencia memria, o valor corrente do contador armazenado na entrada da tabela de pginas correspondente pgina que acabou de ser referenciada. Na ocorrncia de falta de pgina, o sistema operacional examina todos os valores dos contadores armazenados na tabela de pginas para encontrar o mais baixo. A pgina correspondente a esta entrada ser aquela que foi usada h mais tempo. Vamos examinar agora um outro tipo de hardware para tal algoritmo. Para uma mquina com n molduras de pgina, o hardware do LRU pode manter uma matriz n X n, inicialmente zerada. Sempre que uma moldura K for referenciada, o hardware coloca todos os bits da linha K em 1, e depois zera todos os bits da coluna K. Em cada instante, a linha com o menor valor binrio armazenado ser correspondente pgina usada h mais tempo; aquela com o prximo valor ser a prxima usada h

3 de 9

20-06-2013 22:57

Paginao, Deadlocks e Starvation | Amigo Nerd

http://amigonerd.net/exatas/informatica/paginacao-deadlocks...

mais tempo, e assim por diante. Um exemplo do funcionamento deste algoritmo aparece ilustrado na Fig. 3.26 para quatro molduras de pgina e a seguinte ordem de referncias s pginas 0123210323 Aps a referncia pgina 0, temos a situao mostrada na Fig. 3.26(a), e assim sucessivamente. 1.1.6.1 - Simulao do LRU em Software Apesar de ambas as implementaes do LRU serem perfeitamente realizveis, elas dependem de um hardware especial, sendo de pouca utilidade para projetistas de sistemas operacionais que vo rodar em mquinas que no possuam tal hardware. Por conta disso, necessrio que haja uma soluo em software. Uma de tais solues a denominada pgina no usada frequentemente ou algoritmo NFU. Sua implementao requer um contador em software associado a cada pgina, inicialmente em zero. A cada interrupo de tempo, o sistema operacional percorre todas as pginas da memria. Para cada uma delas, o valor do bit R, que 0 ou 1, adicionado ao valor corrente do contador. Com efeito, as contagens constituem uma tentativa de tomar conta de freqncia de uso de cada pgina. Quando ocorre uma falta de pgina, a pgina com a contagem mais baixa escolhida para deixar a memria. O grande problema do NFU que ele nunca esquece coisa alguma. Por exemplo, na execuo de um compilador com mais de um passo, as pginas que foram muito usadas durante o primeiro passo tero ainda uma contagem alta durante os demais passos. Na verdade, o passo que executar por mais tempo vai fazer com que as pginas com seu cdigo tenham sempre contagem mais alta que aquelas pertencentes aos outros passos. Em conseqncia, o sistema operacional vai remover pginas em uso, em vez daquelas que no mais esto sendo usadas. Felizmente, uma pequena modificao no algoritmo do NFU torna-o habilitado a simular muito bem o LRU. A modificao consiste em duas partes. Primeira, os contadores so sempre deslocados um bit direita, antes de serem adicionados a R. Segundo, o bit R adicionado ao bit mais esquerda do contador, em vez do mais direita. A Fig. 3.27 ilustra como este algoritmo, conhecido como aging, funciona. Suponha que aps o primeiro sinal do clock os bits R das pginas de 0 a 5 sema 1, 0, 1, 0, 1, respectivamente (pgina 0 1, pgina 1 0, pgina 2 1, e consequentemente). Em outras palavras, entre as interrupes de tempo 0 e 1, as pginas 0, 2, 4 e 5 foram referenciadas, pois seus bits R esto em 1, e as demais no foram, pois seus bits R mantiveram-se em 0. Aps os seis contadores correspondentes terem sido deslocados e os bits R inseridos esquerda de cada um deles, os valores resultantes de tais contadores so mostrados na Fig. 3.27(a). As quatro colunas restantes mostram a situao dos seis contadores aps a ocorrncia das prximas quatro interrupes de tempo. Quando ocorre uma falta de pgina, a pgina cujo contador tem o valor mais baixo deve der removida. Fica claro que a pgina que no tiver sido referenciada por, digamos, quatro interrupes consecutivas, vai ter quatro zeros nos bits mais significativos de seu contador, e, portanto ter um valor menor que o de outro contador cuja pgina no foi referenciada por trs interrupes consecutivas. Este algoritmo difere do LRU em dois aspectos. Considere as pginas 3 e 5 da Fig. 3.27(e). Nenhuma das duas foi referenciada nos dois primeiros intervalos entre interrupes de tempo; e ambas referencias no intervalo anterior e estes. De acordo com o LRU, se uma pgina tiver que ser substituda, uma destas duas dever ser a escolhida. O problema que no temos como saber qual delas foi referenciada por ltimo no intervalo entre as interrupes 1 e 2. Guardando somente um bit por intervalo perdemos a capacidade de distinguir a ordem das referncias dois intervalos antes, e a 3 no. A segunda diferena entre o LRU e a aging que neste ltimo os contadores tm um nmero finito de bits, oito neste exemplo. Suponha duas pginas, ambas com seu contador zerado. Tudo o que podemos fazer remover uma delas randomicamente. Na realidade, pode muito bem ter acontecido de uma as pginas ter sido referenciada por ltimo h nove intervalos, e a outra h 1.000 intervalos. No h como enxergar isto. Contudo, a prtica mostra que oito bits so suficientes se o intervalo entre interrupes de tempo for de em torno de 20 ms. Se a pagina no foi referenciada por 160 ms, provavelmente no to importante.

2 - Deadlocks O deadlock pode ser definido formalmente como se segue: Um conjunto de processos est em uma situao de deadlock, se cada processo do conjunto estiver esperando por um evento que somente outro processo pertencente ao conjunto poder fazer acontecer. Os computadores possuem diversos recursos que s podem ser usados por um processo de cada vez. Exemplos tpicos e tais recursos incluem impressoras, unidades de fita e posies na tabela de ns-i do sistema. O fato de haver dois processos usando a impressora simultaneamente leva a resultados indesejveis. Da mesma forma, o sistema de arquivos de um computador ficar irremediavelmente comprometido se dois processos utilizarem a mesma posio da tabela de ns-i. Em conseqncia, fica claro que o sistema operacional deve ser capaz de garantir, temporariamente, a um determinado processo, acesso exclusivo a certos recursos. Em muitas aplicaes, um processo precisa ter acesso exclusivo no apenas a um recurso, mas a vrios. Um processo que estiver fazendo cpia de arquivo armazenado em fita magntica para a impressora precisa ter acesso exclusivo a ambos os dispositivos, ao mesmo tempo. Em um sistema com somente um processo, este pode simplesmente adquirir acesso a todos os recursos de que precisar e fazer seu trabalho. No entanto, em sistemas multiprogramados, a questo do aceso aos recursos torna-se um pouco mais complicada. Suponha por exemplo, que existam dois processos, cada um dos quais querendo imprimir um arquivo armazenado em fita. O processo A solicita e consegue permisso pra usar a impressora. O processo B requer e tambm consegue permisso para usar a unidade de fita. A seguir, o processo A pede acesso unidade de fita, mas a solicitao no vai poder ser atendida at que o processo B libera esta unidade. Infelizmente, em vez de liberar a fita, B solicita permisso pra usar a impressora. Neste ponto, ambos os processos esto bloqueados, e assim permanecero pra sempre. Est situao conhecida como deadlock. Os deadlocks podem ocorrer em diversas outras situaes, alm daquela onde processos solicitam aceso a dispositivos de entrada/sada dedicados. Em um sistema de banco de dados, um programa pode ser obrigado a bloquear vrios registros, pra evitar a ocorrncia de condies de corrida. Se um processo A bloqueia o acesso a um registro R1, e o processo B faz o mesmo com um registro R2, e ento cada processo tenta acesso ao registro do outro processo, tambm teremos a ocorrncia de um deadlock. Conclui-se que os deadlocks podem ocorrer tanto em recursos de hardware quanto em recursos de software. Pelo fato de todos os processos estarem esperando, nenhum deles poder fazer acontecer qualquer um dos eventos que pode vira a acordar um dos demais membros do conjunto. Assim sendo todos os processos do conjunto vo ficar eternamente bloqueados. Na maioria dos casos, o evento que cada processo est esperando a liberao de algum dos recursos, no momento alocado a um outro processo do conjunto. Em outras palavras, cada um dos membros do conjunto de processos em deadlock est esperando por um recurso que foi entregue a outro processo deste mesmo conjunto. Como nenhum destes processos pode rodar, nenhum recurso ser liberado, e nenhum dos processos ser acordado. Observe que tanto a quantidade de processos quanto a de recursos envolvidos no problema irrelevante. 2.1 - Condies para Ocorrncia de Deadlocks O artigo de Coffman et al. (1971) mostrou que quatro condies devem ocorrer para que se configure uma situao de deadlock: 1. Condio de excluso mtua: cada recurso ou est alocado a exatamente um processo ou est disponvel.

4 de 9

20-06-2013 22:57

Paginao, Deadlocks e Starvation | Amigo Nerd

http://amigonerd.net/exatas/informatica/paginacao-deadlocks...

2. Condio de posse e de espera: processos que estejam de posse de recursos obtidos anteriormente podem solicitar novos recursos. 3. Condies de no-preempo: recursos j alocados a processos no podem ser tomados fora. Eles precisam ser liberados explicitamente pelo processo que detm sua posse. 4. Condio de espera circular: deve existir uma cadeia circular de dois ou mais processos, cada um dos quais esperando por um recurso que est com o prximo membro da cadeia. Todas as quatro condies acima citadas devem estar presentes para que possa ocorrer deadlock. Se uma delas estiver ausente, no h a menor possibilidade de ocorrer uma situao de deadlock. 2.2 - Preveno de Deadlocks Estudos anteriores deixaram claro que evitar os deadlocks impossvel na prtica, pois so necessrias informaes sobre solicitaes futuras, que em geral no esto disponveis. Em vista disto, fica a questo de como os sistemas operacionais evitam o deadlock. A resposta pode ser encontrada, se voltarmos s quatro condies enunciadas por Coffman et al. (1971). Se pudermos garantir que pele menos uma destas condies nunca ser satisfeita, poderemos garantir que ser estruturalmente impossvel a ocorrncia de deadlocks (Havender, 1968). 2.2.1 - Ataque ao Problema da Excluso Mtua Em primeiro lugar, vamos analisar a questo da excluso mtua. Se no houver possibilidade de nenhum recurso ser entregue exclusivamente a um nico processo, nunca teremos configurada uma situao de deadlock. No entanto, est claro tambm que dar permisso a dois processos para acessar a mesma impressora ao mesmo tempo vai levar a uma situao catica. Lembremo-nos, contudo, de que se usarmos a tcnica do spooll para as sadas dos processos na impressora, vrios processos podero gerar sadas ao mesmo tempo. Neste modelo, o nico processo que pode requerer a posse fsica da impressora o gerente da impressora. Considerando que tal processo nunca precisa de outro recurso que no seja a impressora, com a adoo deste modelo no teremos deadlocks envolvendo a impressora. Lamentavelmente, nem todos os dispositivos podem ser gerenciados pela tcnica do spooll. Alm disso, se usarmos esta tcnica para tratar da competio por espao em disco, seremos levados a situaes de deadlock. O que aconteceria se dois processos usassem cada um a metade do espao em disco pra escrever suas sadas, e nenhum dos dois tiver terminado? Se o gerente de impresso tiver sido programado pra comear a impresso fsica logo depois que o processo enviar o primeiro conjunto de dados para a rea de spooll, a impressora pode permanecer sem uso, mas alocada a este processo por muito tempo, se ele s mandar o segundo conjunto de dados para impresso horas depois de ter mandado o primeiro. Por isso, em geral, os gerentes de impresso so programados para iniciar a impresso somente depois de toda a sada estar disponvel. No caso citado acima, como nenhum processo terminou de gravar seus dados na rea de spooll, teremos uma situao de deadlock no disco. No entanto, este o germe de uma idia aplicada com freqncia: evitar entregar um recurso, quando ele no for absolutamente necessrio, e tentar estar certo de que o mnimo possvel de processos est precisando de recursos. 2.2.2 - Ataque ao Problema da Posse e da Espera A segunda das condies de Coffmam et al. Parece ser um pouco mais promissora do que a primeira, no que concerne a resultados prticos. Se pudermos impedir processos de manter a posse de recursos enquanto esperam por outros recursos, poderemos eliminar completamente a possibilidade de ocorrncia de deadlocks. Uma forma de se alcanar este objetivo exigir que todos os processos requisitem todos os recursos de que precisam, antes de iniciar a execuo. Se todos estiverem disponveis, sero alocados ao processo, fazendo com que ele possa rodar at terminar. Se um ou mais destes recursos estiverem ocupados, nenhum deles ser alocado ao processo, devendo esse aguardar antes de iniciar sua execuo. Um problema imediato que pode ocorrer com esta abordagem o fato de muitos processos no conhecerem com antecedncia quantos e quais os recurso necessrios sua execuo. Normalmente, esta informao s estar disponvel ao longo do processamento. Caso o processo dispusesse destas informaes, o algoritmo do banqueiro poderia ser empregado com sucesso. Um outro problema o fato de os recursos no serem usados de maneira tima quando este mtodo empregado. Tomemos como exemplo o caso de um processo que l dados de uma unidade de fita, analisa-os durante uma hora, e ento escreve suas concluses numa fita de sada, alm de imprimir os resultados em um plotter. Se todos os recursos precisarem ser solicitados com antecedncia, o processo vai ocupar desnecessariamente, por uma hora, tanto a unidade de fita de sada quanto o plotter. Apesar disso, alguns sistemas batch que rodam em mainframes exigem que o usurio liste todos os recursos que pretende usar na primeira linha de comando do job. O sistema ento adquire todos estes recursos, mantendo-os reservados at que o job termine. Apesar de este mtodo passar ao programador mais uma obrigao, alm de desperdiar recursos, ele no previne os deadlocks. Uma forma um pouco diferente de tratar a questo da posse-espera exigir que um processo que esteja solicitando um recurso libere, em primeiro lugar, todos os recursos que lhe estiverem alocados. Depois disso, ele deve tentar adquirir de uma vez todos os recursos que lhe forem necessrios. 2.2.3 - Ataque ao Problema da Condio de No-Preempo Resta-nos somente uma condio para tentar resolver a questo dos deadlocks, j que nenhuma das trs anteriores revelou-se atrativa na prtica. A condio de espera circular pode ser eliminada de diversas maneiras. Uma delas simplesmente seguindo regra de que um processo s est autorizado a usar apenas um recurso por vez. Se ele precisar de um segundo recurso deve liberar o primeiro. Para um processo que precise copiar o contedo de uma fita inteira pra a impressora, esta restrio inaceitvel. Outra forma de evitar a espera circular utilizar uma numerao global para todos os recursos, conforme mostrado na Fig. 6.11(a). Agora a regra esta: processos podem solicitar recursos sempre que necessrio, mas todas as solicitaes precisam ser feitas em ordem numrica. Um processo pode solicitar primeiro uma impressora, e depois uma unidade de fita, mas no pode requisitar primeiro a fita e depois a impressora. Com esta regra, o grafo de alocao de recursos nunca vai conter ciclos. Vamos ver a razo disto ser verdadeiro, usando os dois processos mostrados na Fig. 6.11(b). Neste caso, s poder haver deadlock se A requisitar o recurso j, e B o recurso i. Assumindo que i e j so recurso distintos, eles vo ter numerao diferente. Se i>j, ento A no pode requisitar j. Se i<j, ento B no pode requisitar i. De qualquer forma, impossvel que uma condio de deadlock se configure. Mesmo com o uso de vrios processos, esta regra continua a valer. A cada instante, um dos recursos alocados ter o nmero mais alto. O processo que estiver de posse deste recurso no vai poder solicitar nenhum dos recursos j alocados. Ou ele termina usando os recursos sua disposio, ou, no pior caso, solicita um recurso de numerao ainda maior do que a de todos os j alocados. Eventualmente, este processo vai terminar e liberar todos os seus recursos. Neste momento, algum dos demais processos vai pegar o recurso de numerao mais alta e tambm vai terminar sua execuo. Em resumo, est montado um cenrio em que tosos os processos podem terminar sua execuo, de forma que no h possibilidade de ocorrer deadlock. Uma pequena variao deste algoritmo forar os processos a solicitar seus recursos numa ordem estritamente crescente, e insistir no fato de que nenhum processo possa adquirir um recurso de numerao menor do que qualquer um que ele j possua. Se determinado processo requisitar os recursos 9 e 10, utiliza-los e depois libera-los, ele poder requisitar o recurso 1, sem nenhum problema. Apesar da ordenao numrica dos recursos eliminar o problema dos deadlocks, impossvel encontrar uma ordenao que satisfaa a todos. Quando os recursos inclurem posies na tabela de processos, espao em disco para spooll, registros de base de dados bloqueados, e outros recursos abstratos, o nmero de recursos em potencial e seus diferentes usos vai ficar to grande que nenhum tipo de ordenao vai funcionar.

5 de 9

20-06-2013 22:57

Paginao, Deadlocks e Starvation | Amigo Nerd

http://amigonerd.net/exatas/informatica/paginacao-deadlocks...

As vrias abordagens para preveno de deadlocks so mostradas resumidamente na Fig. 6.12.

3 - O problema dos filsofos jantando spaghetti

O problema dos filsofos jantando consiste numa mesa com 5 pratos de spaghetti e cinco garfos entre os pratos. Pelo fato do spaguetti ser muito escorregadio (o molho um bolonhesa bem ralo) cada filsofo precisa de dois garfos para comer. Enquanto um filsofo est comendo os outros dois filsofos vizinhos no podem comer pela falta dos garfos. Ento eles aproveitam para pensar um pouco. A dificuldade do problema a implementao de uma rotina que no entre em deadlock quando um filsofo tentar pegar os garfos dos seus vizinhos. Exemplos: Uma implementao no correta: #include "prototypes.h" #define N 5 // so 5 filsofos void philosoper(int i) { while (TRUE) { think(); take_fork(i); take_fork((i+1) % N); eat(); put_fork(i); put_fork((i+1) % N); } } Uma implementao correta usando semforos #include "prototypes.h" #define N 5 // numero de filosofos #define LEFT (i-1)%N // uma macros para calcula o filosofo da esquerda #define RIGHT (i+1)%N // idem da direita #define THINKING 0 #define HUNGRY 1 #define EATING 2 typedef int semaphore; int state[N]; // um estado para cada filosofo semaphore mutex = 1; // semaforo da secao critica semaphore s[N]; // um semaforo para cada filosofo

6 de 9

20-06-2013 22:57

Paginao, Deadlocks e Starvation | Amigo Nerd

void philospher(int i) // a rotina dos filosofos { while (TRUE) { think(); take_forks(i); eat(); put_forks(i); } } void take_forks(int i) // verifica se os vizinhos nao estao comendo e pega os garfos { down(&mutex); state[i] = HUNGRY; test(i); up(&mutex); down(&s[i]); }

http://amigonerd.net/exatas/informatica/paginacao-deadlocks...

void put_forks(int i) // devolve os garfos e acorda algum vizinho que estiver com fome { down(&mutex); state[i] = THINKING; test(LEFT); test(RIGHT); up(&mutex); } void test(int i) // verifica se os garfos estao disponiveis { if (state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) { state[i] = EATING; up(&s[i]); } } Esse clssico problema discutido entre 5 filsofos, mas voc realmente deveria considerar os filsofos como N. 5 filsofos, 5 pratos de macarro, 5 garfos, jantando numa mesa circular. Cada um precisa de dois garfos. Todos esses itens satisfazem as condies prvias para paralisao completa ou Deadlock, onde podemos reconhecer alguns casos tpicos de tentativas de resolver o problema. Excluso mtua: garfo compartilhado. Segure e espera: A pessoa pode segurar o garfo esquerdo e sempre pode esperar pelo garfo certo. No-Preempo: A pessoa pode no querer deixar o outro tome posse do garfo. Espera circular: Um dever esperar o outro num processo que percorrer da mesa.

4 - Starvation Adiamento Indefinido a situao onde um processo nunca consegue executar sua regio crtica e, conseqentemente, acessar o recurso compartilhado.

7 de 9

20-06-2013 22:57

Paginao, Deadlocks e Starvation | Amigo Nerd

http://amigonerd.net/exatas/informatica/paginacao-deadlocks...

Em sistemas onde processos ficam esperando pela alocao de recursos ou pelas decises de escalonamento, possvel que ocorra adiamento indefinido tambm chamado de bloqueamento indefinido ou starvation). Adiamento indefinido pode ocorrer devido s polticas de escalonamento de recursos do sistema. Quando recursos so alocados segundo um esquema de prioridades, possvel que um determinado processo espere indefinidamente por um recurso conforme processos com prioridades mais altas venham chegando. Os sistemas operacionais devem ser justos com processos em espera, bem como devem considerar a eficincia de todo o sistema. Em alguns sistemas, o adiamento indefinido pode ser evitado permitindo que a prioridade de um processo em espera cresa conforme ele espera por um recurso. Isto chamado de aging (envelhecimento). 4.1 - Escalonamento com Prioridades O algoritmo round robin assume que todos os processos so igualmente importantes. Freqentemente, as pessoas que possuem e operam centros de computao possuem um pensamento diferente sobre este assunto. Em uma Universidade, por exemplo, as prioridades de processamento normalmente so para a administrao em primeiro lugar, seguida de professores, secretrias e finalmente estudantes. A necessidade de se levar em conta fatores externos nos leva ao escalonamento com prioridades. A idia bsica direta: cada processo possui uma prioridade associada, e o processo pronto para executar com a maior prioridade quem ganha o processador. Para evitar que processos com alta prioridade executem indefinidamente, o escalonador pode decrementar a prioridade do processo atualmente executando a cada tick de relgio (isto , a cada interrupo de relgio). Se esta ao fizer com que a prioridade do processo se torne menor do que a prioridade do processo que possua a segunda mais alta prioridade, ento uma troca de processos ocorre. Prioridades podem ser associadas a processos estaticamente ou dinamicamente. Em um computador militar, por exemplo, processos iniciados por generais deveriam comear com a prioridade 100, processos de coronis com 90, de majores com 80, de capites com 70, de tenentes com 60, e assim por diante. Alternaticamente, em um centro de computao comercial (incomum hoje em dia), jobs de alta prioridade poderiam custar 100 dlares por hora, os de mdia prioridade a 75 por hora, e os de baixa prioridade a 50 por hora. O sistema operacional UNIX possui um comando, nice, que permite a um usurio voluntariamente reduzir a prioridade de um processo seu, de modo a ser gentil (nice) com os outros usurios. Na prtica, ningum utiliza este comando, pois ele somente permite baixar a prioridade do processo. Entretanto, o superusurio UNIX pode aumentar a prioridade de processos. Prioridades podem tambm ser atribudas dinamicamente pelo sistema para atingir certos objetivos do sistema. Por exemplo, alguns processos so altamente limitados por E/S, e passam a maior parte do tempo esperando por operaes de E/S. Sempre que um desses processos quiser a CPU, ele deve obt-la imediatamente, para que possa iniciar sua prxima requisio de E/S, e deix-la sendo feita em paralelo com outro processo realmente processando. Fazer com que processos limitados por E/S esperem um bom tempo pela CPU significa deix-los um tempo demasiado ocupando memria. Um algoritmo simples para prover um bom servio a um processo limitado por E/S ajustar a sua prioridade para 1/f, onde f a frao do ltimo quantum de processador que o processo utilizou. Um processo que utilizou somente 2 ms do seu quantum de 100 ms ganharia uma prioridade 50, enquanto um processo que executou durante 50 ms antes de bloquear ganharia prioridade 2, e um processo que utilizou todo o quantum ganharia uma prioridade 1. freqentemente conveniente agrupar processos em classes de prioridade e utilizar escalonamento com prioridades entre as classes, mas round robin dentro de cada classe. Por exemplo, em um sistema com quatro classes de prioridade, o escalonador executa os processos na classe 4 segundo a poltica round robin at que no haja mais processos na classe 4. Ento ele passa a executar os processos de classe 3 tambm segundo a poltica round robin, enquanto houverem processos nesta classe. Ento executa processos da classe 2 e assim por diante. Se as prioridades no forem ajustadas de tempos em tempos, os processos nas classes de prioridades mais baixas podem sofrer o fenmeno que chamamos starvation (o processo nunca recebe o processador, pois sua vez nunca chega).

Concluso Apesar da constante evoluo dos Sistemas Operacionais e do aparecimento de novas ideologias sobre suas constituies ainda existem problemas que no foram sanados, um desafio para os matemticos e desenvolvedores de Sistemas em todo o mundo. O deadlock um exemplo claro desses problemas foram desenvolvidos vrios metos que visam diminuir a sua incidncia, porm ainda no conseguiram o erradicar por completo. Muito j foi feito, mas essa linha de estudo muito ampla recursos j implantados como paginao de memria, podem e devem ser melhorados visando sempre uma melhor performance quanto velocidade. Durante os ltimos anos, talvez incentivados pelo Linux, muitos programadores tem se lanado em projetos prprios que nascem em todas as partes do mundo vises diferentes sobre gerenciamento de recursos. Velhos paradigmas so derrubados solues de velhos problemas so apresentadas, novos sistemas nascem e junto com eles novos desafios.

Bibliografia TANNEMBAW, Andrew Sistemas Operacionais Modernos 1997 http://www.i2.com.br/~rora/aulas/soii00b/aula3/ Acessado em 28/05/04 s 13:30

Comentrios

8 de 9

20-06-2013 22:57

Paginao, Deadlocks e Starvation | Amigo Nerd

http://amigonerd.net/exatas/informatica/paginacao-deadlocks...

Comentar... Comentrio usando...

Plug-in social do Facebook

Pginas relacionadas
Exatas > Informtica

Deadlocks
Exatas > Informtica

Memria Virtual e Paginao do Windows 2000

Exatas > Informtica

Paginao
Exatas > Informtica

Questes de Implementao
Exatas > Engenharia

Segmentao de Memria
Exatas > Informtica

Gerncia de Memria
Exatas > Informtica

Memria Virtual

Biolgicas
Biologia Bioqumica Educao Fsica Enfermagem Farmcia Fisioterapia Fonoaudiologia Medicina Nutrio Odontologia Terapia Ocupacional Veterinria Zootecnia

Exatas
Agronomia Astronomia Engenharia Estatstica Informtica Qumica

Humanas
Administrao Arquitetura Cinema Contabilidade Desenho Industrial Direito Economia Hotelaria Marketing Produo Cultural Relaes Internacionais Secretariado Executivo Turismo

Sociais Aplicadas
Arquivologia Arte Biblioteconomia Cincias Sociais Comunicao Filosofia Geografia Histria Letras Pedagogia Psicologia Servio Social

Outras
Colegial Diversos

Poltica de privacidade | Contato

9 de 9

20-06-2013 22:57