Itabera, 20 de setembro de 2014.

Curso: Sistemas de Informao Disciplina: Sistemas Operacionais

Professor: Khyquer Ronaldy de Oliveira Camargo
Acadmico(a): Alan Ferreira Costa
Jacyelle Vieira Peres


Regio Crtica

Esta parte do programa, cujo processamento pode levar ocorrncia de
condies de corrida, denominada regio crtica ou seo crtica. Se
pudermos arranjar as coisas de forma que no seja nunca permitido que dois
ou mais processos estejam processando suas sees crticas correspondentes
ao mesmo tempo, poderemos evitar a ocorrncia das condies de corrida.
O problema : como evitar as condies de corrida? A questo chave
para evitar problemas em situaes onde existe compartilhamento de recursos
(memria, arquivo, etc) evitar que mais de um processo acesse o dado
compartilhado ao mesmo tempo => geralmente, consideraremos 2 processos
apenas? Excluso mtua de execuo: uma forma encontrada para se ter
certeza de que se um processo estiver usando uma varivel ou um arquivo
compartilhados, os demais sero impedidos de fazer a mesma coisa?
Apesar do esquema descrito acima evitar a ocorrncia das condies de
corrida, ele no suficiente para permitir que processos paralelos cooperem
correta e eficientemente no uso de recursos compartilhados. necessrio que
quatro condies sejam atendidas para que tenhamos uma boa soluo para o
problema:
dois ou mais processos no podem estar simultaneamente dentro de
suas regies crticas correspondentes.
nenhuma considerao pode ser feita a respeito da velocidade relativa
dos processos, ou a respeito do nmero de processadores do sistema.
Sistemas Operacionais
nenhum processo que esteja rodando fora de sua regio crtica pode
bloquear a execuo de outro processo.
nenhum processo pode ser obrigado a esperar indefinidamente para
entrar em sua regio crtica.
Estratgias de solues => consideram excluso mtua com espera
ocupada => quando um processo entra em sua regio crtica, nenhum outro
processo pode entrar em sua regio crtica correspondente.

A soluo mais simples para tal problemas obtida fazendo com que
cada processo iniba as interrupes logo aps seu ingresso em uma regio
crtica, habilitando-as outra vez imediatamente antes de deix-la. Com as
interrupes inibidas, o processo no poder ser interrompido por exceder o
tempo de processamento concedido a ele. Como o processador s pode ser
chaveado entre processos atravs de interrupes de tempo, com as
interrupes inibidas no haver chaveamento. Ento, uma vez inibidas as
interrupes, o processo pode examinar e atualizar a memria compartilhada,
sem se preocupar com a eventual interveno de outro processo em seu
processamento.
Inibir interrupo uma funo til, se s puder ser realizada dentro do
kernel, no sendo apropriada para servir como mecanismo para
implementao de excluso mtua de execuo entre processos de usurios.
Como segunda tentativa de implementao de excluso mtua de
execuo, vamos examinar uma soluo implementada por software.
Considere a existncia de uma nica varivel compartilhada (varivel de
travamento), cujo valor seja inicialmente 0. Quando um processo desejar entrar
em sua regio crtica, ele deve primeiro testar a varivel de travamento. Se ela
for 0, o processo muda seu valor para 1 e entra na regio crtica. Se o valor da
varivel j for 1, o processo deve esperar que ele volte a 0, antes de entrar na
regio crtica. Nesta soluo, o valor da varivel de travamento em 0 significa
que no h nenhum processo executando a sua regio crtica, e o valor em 1
significa que algum processo est executando sua regio crtica.
Infelizmente esta idia incorre na mesma falha. Suponha que um
processo leia a varivel de travamento e verifique que seu valor 0. Antes que
ele possa atualiz-lo para 1, ocorre uma interrupo, e outro processo posto
para rodar. Tal processo encontra a varivel de travamento em 0, atualiza seu
valor para 1 e entra na sua regio crtica. Ocorre que o processo interrompido
guardou em seu contexto o valor 0 para a varivel de travamento, de modo
que, quando ele for reativado, atualizar seu valor para 1 e executar sua
regio crtica. Observe ento que dois processos podero estar executando
suas regies crticas correspondentes ao mesmo tempo.
Uma terceira forma de abordar a questo da excluso mtua o trecho
de um programa escrito em C:

while (TRUE) {
while (turn != 0) /* espera */
regiao critica ( );
turn = 1;
regiao nao-critica ( );
}
while (TRUE) {
while (turn != 1) /* espera */
regiao critica ( );
turn = 0;
regiao nao-critica ( );
}
A varivel inteira turn, inicialmente em 0, estabelece de quem a vez de
entrar na regio crtica. Primeiramente, o processo 0 inspeciona turn, encontra
seu valor em 0 e entra em sua regio crtica. O processo 1 tambm encontra
turn em 0, entrando em um loop, que testa continuamente o valor de turn,
aguardando que ele se torne igual a 1. O teste contnuo do valor de uma
varivel, aguardando que ela assuma determinado valor denominado de
espera ocupada. A espera ocupada deve ser evitada, em razo de consumir
tempo de processador. Somente nos casos em que houver uma razo muito
forte para supor que a espera ser muito curta que devemos usar a espera
ocupada.
Quando o processo 0 deixar sua regio crtica, ele faz com que turn
assuma o valor 1, para permitir que o processo 1 entre em sua regio crtica.
Suponha que o processo 1 termine rapidamente a execuo de sua regio
crtica, fazendo com que ambos os processos estejam fora de suas regies
crticas, com turn igual a 0. O processo 0 executa seu loop rapidamente,
retornando sua seo no-crtica fazendo turn igual a 1, e voltando para o
incio do loop. Infelizmente ele no pode executar sua regio crtica, mesmo
com o processo 1 em seu trecho no-crtico, pois turn vale 1. Podemos concluir
que a estrita alternncia de processos executando suas regies crticas no
uma boa idia quando um dos processos muito mais lento que o outro.
Esta situao viola a condio 3 estabelecida acima, pois o processo 0
est sendo bloqueado por um processo que no est em sua regio crtica. Tal
soluo no vivel na prtica.
Combinando a idia de estabelecer a vez dos processos entrarem em suas
regies crticas, com a da varivel de travamento e com a de uma varivel de
tenso, um matemtico holands, T. Dekker, foi o primeiro a criar uma soluo
em software para o problema da excluso mtua (1965). Em 1981, G. L.
Petersen descobriu uma forma muito mais simples que a de Dekker de se obter
excluso mtua.
Antes de usar as variveis compartilhadas (ou seja, antes de entrar na
sua regio crtica), cada processo deve chamar enter_region, com seu prprio
nmero, 0 ou 1, como parmetro. Esta chamada vai fazer com que o processo
espere, se necessrio, at que seja seguro entrar na regio crtica. Quando ele
terminar a execuo da regio crtica, deve chamar leave_region, permitindo a
entrada do outro processo na regio crtica, se for o caso.
Vamos ver como esta soluo funciona. Inicialmente, nenhum processo
est executando sua regio crtica. Em seguida, o processo 0 chama
enter_region. Ele indica seu interesse em executar a regio crtica, setando seu
elemento do vetor interested, e fazendo turn igual a 0. Uma vez que o processo
1 no est interessado na execuo de sua regio crtica, ele sai
imediatamente do procedimento enter_region. Se o processo 1 chamar
enter_region, ele vai ficar preso nesta rotina at que interested [0] seja FALSO,
o que s ocorrer quando o processo 0 chamar leave_region.
Agora considere o caso de ambos os processos chamarem enter_region
quase simultaneamente. Ambos vo armazenar seus nmeros em turn. O
armazenamento que for feito por ltimo ser o que vai valer, sendo o primeiro
perdido. Suponha que o processo 1 armazene por ltimo, de maneira que turn
ser 1. Quando ambos os processos executarem o comando while, o processo
0 vai execut-lo zero vezes, e entrar em sua regio crtica. O processo 1 fica
em loop no while, no chegando a executar sua regio crtica.
Vamos examinar uma proposta que precisa de uma pequena ajuda do
hardware. Muitos computadores, especialmente aqueles projetados com o
propsito de suportar mltiplos processadores, possuem uma instruo bsica,
denominada TEST AND SET LOCKED (TSL) que funciona como descrito a
seguir.
Ela transfere o contedo de um endereo de memria para um
registrador, e depois armazena um valor no nulo em tal endereo. As
operaes de transferncia e de armazenamento so indivisveis nenhum
outro processador ou processo pode acessar a palavra antes que a execuo
da instruo tenha chegado ao fim. O processador que estiver executando a
instruo TSL, bloqueia o barramento de memria, de forma a no permitir que
nenhum outro processador tenha acesso memria at que termine a
execuo da instruo.
Para executar a instruo TSL, necessrio o uso de uma varivel
compartilhada, flag, para coordenar o acesso memria compartilhada.
Quando flag for igual a 0, qualquer processo pode faz-la igual a 1, atravs da
execuo da instruo TSL, e ento ler ou escrever na memria compartilhada.
Ao terminar o acesso memria, o prprio processo faz flag de volta a 0,
usando uma instruo bsica de MOVE.
Enfim, encontramos uma soluo simples e correta para o problema do
acesso a regies crticas. Antes de entrar em sua regio crtica, o processo
chama enter_region, a qual coloca o processo em espera at que seu ingresso
nela seja permitido. Quando isto ocorre, a sub-rotina termina sua execuo,
permitindo que o processo que a chamou entre em sua regio crtica. Ao
terminar a execuo desta, o processo chama leave_region, que armazena o
valor 0 em flag. A exemplo de todas as solues para o problema da regio
crtica, os processos devem chamar enter_region e leave_region nos
momentos apropriados. Se um dos processos trapacear nas chamadas,
deixando, por exemplo, de executar leave_region, a excluso mtua de
execuo das regies estar comprometida.
Tanto a soluo de Peterson quanto a baseada na instruo TSL so
corretas, mas ambas tm o defeito de usar a espera ocupada em suas
implementaes. Em essncia, o que estas solues fazem o seguinte:
quando um processo deseja entrar em sua regio crtica, ele verifica uma
condio para saber se sua entrada ou no possvel. Se no houver
possibilidade de executar um loop, at que lhe seja permitido entrar na regio
crtica.
Tal soluo, alm de gastar tempo de processamento, pode ter efeitos
colaterais indesejveis. Considere um computador que esteja executando dois
processos, um H com alta prioridade, e outro L, com baixa prioridade. As
regras de escalonamento so definidas de maneira que H rode sempre que
estiver no estado de pronto. Em determinado instante, com L executando sua
regio crtica, vai para o estado de pronto quando, por exemplo, uma operao
de entrada/sada solicitada por ele terminar. O processo H inicia ento a
execuo de um loop de espera ocupado, mas uma vez que L nunca
escolhido para rodar enquanto H estiver rodando, ele nunca vai ter chance de
sair de sua regio crtica, de forma que H vai permanecer eternamente no loop
de espera ocupada. Esta situao conhecida na literatura como problema da
prioridade invertida.
Um dos pares de primitivas mais simples para resolver este problema
o denominado SLEEP e WAKEUP. A primitiva SLEEP uma chamada de
sistema que bloqueia o processo que a chamou, isso , suspende a execuo
de tal processo, at que outro processo o acorde. A primitiva WAKEUP tem um
parmetro, o processo a ser acordado. Alternativamente, tanto SLEEP quanto
WAKEUP podem Ter um outro parmetro, um endereo de memria usado
para casar uma primitiva SLEEP com sua correspondente WAKEUP.
O chamado problema do produtor-consumidor, tambm conhecido como
problema do buffer limitado (bounded buffer), um bom exemplo do uso das
primitivas acima descritas. Neste problema, dois processos compartilham um
buffer de tamanho fixo. Um dos processos, o produtor, coloca informao no
buffer, e o outro, o consumidor, retira informao do buffer.










Referncias:

Equipe Brasil Escola, Brasil Escola.{online}. disponvel na Internet via
http://monografias.brasilescola.com/computacao/processos-solucoes-
software.htm. Arquivo capturado em 21 de set de 2014.

Cios Informtica. {online}. disponvel na Internet
via http://cioseducando.blogspot.com.br/2011/06/regioes-criticas-e-exclusao-
mutua.html
Arquivo capturado em 21 de set de 2014.

Fundamento da Computao. {online}. disponvel na Internet via
http://adswb.wordpress.com/2013/04/17/fundamentos-da-computaosistemas-
operacionais-2/ Arquivo capturado em 21 de set de 2014.

Rafael Oliveira Vasconcelos, {online}. disponvel na Internet via
http://rafaeloliveirav.wordpress.com/2009/03/19/threads-o-problema-dos-leitores-e-
escritores-implementado-em-c-%E2%80%93-regiao-critica-e-exclusao-mutua/
Arquivo capturado em 21 de set de 2014.