1

Sincronizao de Processos (2)

(Aula 14)
2
2
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
3a. Tentativa
O problema da tentativa anterior que ela guarda a
identificao do processo que quer entrar na R.C.
Entretanto, o que se precisa, de fato, de informao de
estado dos processos (i.e., se eles querementrar na R.C.)
Cada processo deve ento ter a sua prpria chave de
inteno. Assim, se falhar, ainda ser possvel a um
outro entrar na sua R.C.
A soluo se baseia no uso de uma varivel array para
indicar a inteno de entrada na R.C.
3
3
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
3a. Tentativa
Antes de entrar na sua R.C, o processo examina a
varivel array. Se ningum mais tiver manifestado
interesse, o processo indica a sua inteno de ingresso
ligando o bit correspondente na varivel array e
prossegue em direo a sua R.C.
var flag: array[0..1] of boolean;
flag[0]:= false; flag[1]:= false;
Process P0:
...
while flag[1] do {nothing};
flag[0] := true;
< critical section >
flag[0] := false;
...
Process P1:
...
while flag[0] do {nothing};
flag[1] := true;
< critical section >
flag[1] := false;
...
4
4
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
Problemas da 3a. Tentativa
Agora, se um processo falha fora da sua R.C. no haver
nenhum problema, nenhum processo ficar eternamente
bloqueado devido a isso. Entretanto, se o processo falhar
dentro da R.C., o problema ocorre.
No assegura excluso mtua, pois cada processo pode
chegar concluso de que o outro no quer entrar e,
assim, entrarem simultaneamente nas R.C.
Isso acontece porque existe a possibilidade de cada processo
testar se o outro no quer entrar (comando while) antes de um
deles marcar a sua inteno de entrar.
5
5
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
4a. Tentativa
A idia agora que cada processo marque a sua inteno
de entrar antes de testar a inteno do outro, o que
elimina o problema anterior.
o mesmo algoritmo anterior, porm com uma troca de
linha.
Process P0:
...
flag[0] := true;
while flag[1] do
{nothing};
< critical section >
flag[0] := false;
...
Process P1:
...
flag[1] := true;
while flag[0] do
{nothing};
< critical section >
flag[1] := false;
...
6
6
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
Problemas da 4a. Tentativa
Garante a excluso mtua mas se um processo falha
dentro da sua R.C. (ou mesmo aps setar o seu flag) o
outro processo ficar eternamente bloqueado.
Uma falha fora da R.C. no ocasiona nenhum problema
para os outros processos.
Problemo:
Todos os processos ligam os seus flags para true (marcando o
seu desejo de entrar na sua R.C.). Nesta situao todos os
processos ficaro presos no while em um loop eterno (situao
de deadlock).
7
7
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
5a. Tentativa
Na tentativa anterior o processo assinalava a sua
inteno de entrar na R.C. sem saber da inteno do
outro, no havendo oportunidade dele mudar de idia
depois (i.e., mudar o seu estado para false).
A 5a. tentativa corrige este problema:
Aps testar no loop, se o outro processo tambm quer entrar na
sua R.C, em caso afirmativo, o processo com a posse da UCP
declina da sua inteno, dando a vez ao parceiro.
8
8
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
5a. Tentativa (cont.)
Process P0:
...
flag[0] := true;
while flag[1] do
begin
flag[0] := false;
<delay for a short time>
flag[0] := true
end;
< critical section >
flag[0] := false;
...
Process P1:
...
flag[1] := true;
while flag[0] do
begin
flag[1] := false;
<delay for a short time>
flag[1] := true
end;
< critical section >
flag[1] := false;
...
9
9
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
5a. Tentativa (cont.)
Esta soluo quase correta. Entretanto, existe um
pequeno problema: a possibilidade dos processos ficarem
cedendo a vez um para o outro indefinidamente
(problema da mtua cortesia)
Livelock
Na verdade, essa uma situao muito difcil de se
sustentar durante um longo tempo na prtica, devido s
velocidades relativas dos processos. Entretanto, ela uma
possibilidade terica, o que invalida a proposta como
soluo geral do problema.
10
10
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
5a. Tentativa Exemplo
P
0
seta flag[0] para true.
P
1
seta flag[1] para true.
P
0
testa flag[1].
P
1
testa flag[0].
P
0
seta flag[0] para false.
P
1
seta flag[1] para false.
P
0
seta flag[0] para true.
P
1
seta flag[1] para true.
11
11
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
Soluo de Dekker
Trata-se da primeira soluo correta para o problema da
excluso mtua de dois processos (proposta na dcada
de 60).
O algoritmo combina as idias de varivel de bloqueio e
array de inteno.
similar ao algoritmo anterior mas usa uma varivel
adicional (vez/turn) para realizar o desempate, no caso
dos dois processos entrarem no loop de mtua cortesia.
12
12
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
Algoritmo de Dekker
var flag: array[0..1] of boolean;
turn: 0..1; //who has the priority
flag[0] := false
flag[1] := false
turn := 0 // or 1
Process p0: Process p1:
flag[0] := true flag[1] := true
while flag[1] { while flag[0] {
if turn 0 { if turn 1 {
flag[0] := false flag[1] := false
while turn 0 {} while turn 1 {}
flag[0] := true flag[1] := true
} }
} }
// critical section // critical section
turn := 1 turn := 0
... ...
// non-critical section // non-critical section
flag[0] := false flag[1] := false
13
13
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
Algoritmo de Dekker (cont.)
Quando P0 quer entrar na sua R.C. ele coloca seu flag em true. Ele
ento vai checar o flag de P1.
Se o flag de P1 for false, ento P0 pode entrar imediatamente na
sua R.C.; do contrrio, ele consulta a varivel turn.
Se turn = 0 ento P0 sabe que a sua vez de insistir e, deste modo,
fica em busy wait testando o estado de P1.
Em certo ponto, P1 notar que a sua vez de declinar. Isso permite
ao processo P0 prosseguir.
Aps P0 usar a sua R.C. ele coloca o seu flag em false para liber-la,
e faz turn = 1 para transferir o direito para P1.
14
14
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
Algoritmo de Dekker (cont.)
Algoritmo de Dekker resolve o problema da excluso mtua
Uma soluo deste tipo s aceitvel se houver um nmero de CPUs
igual (ou superior) ao nmero de processos que se devam executar no
sistema. Porqu?
Poderamos nos dar 'ao luxo' de consumir ciclos de CPU,
Situao rara na prtica (em geral, h mais processos do que CPUs)
Isto significa que a soluo de Dekker pouco usada.
Contudo, a soluo de Dekker mostrou que possvel resolver o
problema inteiramente por software, isto , sem exigir instrues
mquina especiais.
Devemos fazer uma modificao significativa do programa se
quisermos estender a soluo de 2 para N processos:
flag[] com N posies; varivel turn passa a assumir valores de 1..N;
alterao das condies de teste em todos os processos
15
15
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
Soluo de Peterson
Proposto em 1981, uma soluo simples e elegante
para o problema da excluso mtua, sendo facilmente
generalizado para o caso de n processos.
O truque do algoritmo consiste no seguinte:
Ao marcar a sua inteno de entrar, o processo j indica (para o
caso de empate) que a vez do outro.
Mais simples de ser verificado
16
16
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
Algoritmo de Peterson
flag[0] = 0
flag[1] = 0
turn = 0
Process P0: Process P1:
flag[0] = 1 flag[1] = 1
turn = 1 turn = 0
while ( flag[1] && turn == 1 ){ while ( flag[0] && turn == 0 ){
// do nothing // do nothing
} }
// critical section // critical section
... ...
// end of critical section // end of critical section
flag[0] = 0 flag[1] = 0
17
17
http://www.inf.ufes.br/~zegonc/so.htm
Sistemas Operacionais 2007/2 Prof. J os Gonalves LPRM/DI/UFES
Soluo de Peterson (cont.)
Excluso mtua atingida.
Uma vez que P0 tenha feito flag[0] = true, P1 no pode entrar
na sua R.C.
Se P1 j estiver na sua R.C., ento flag[1] = true e P0 est
impedido de entrar.
Bloqueio mtuo (deadlock) evitado.
Supondo P0 bloqueado no seu while, isso significa que flag[1] =
true e que turn = 1
se flag[1] = true e que turn = 1, ento P1 por sua vez entrar
na sua seo crtica
Assim, P0 s pode entrar quando ou flag[1] tornar-se false ou
turn passar a ser 0.