07 So

Comunicao e Sincronismo Comunicao e Sincronismo
entre processos entre processos

Prof. Marcos Ribeiro Quinet de Andrade
Universidade Federal Fluminense - UFF
Plo Universitrio de Rio das Ostras - PURO
1
Comunicao Comunicao entre entre Processos Processos
Processos precisam se comunicar;
Processos competem por recursos;
Trs aspectos importantes:
Como um processo passa informao para outro
2
Como um processo passa informao para outro
processo;
Como garantir que processos no invadam
espaos uns dos outros;
Dependncia entre processos: sequncia
adequada;
Comunicao Comunicao entre Processos entre Processos
Condies de disputa (race conditions): processos
acessam recursos compartilhados concorrentemente;
Recursos: memria, arquivos, impressoras, discos, variveis;
Ex.: Impresso: quando um processo deseja imprimir
3
Ex.: Impresso: quando um processo deseja imprimir
um arquivo, ele coloca o arquivo em um local
especial chamado spooler (tabela). Um outro
processo, chamado printer spooler, checa se existe
algum arquivo a ser impresso. Se existe, esse
arquivo impresso e retirado do spooler. Imagine
dois processos que desejam imprimir um arquivo ao
mesmo tempo...
abc
prog.c
4
5
.
.
Processo A
Prximo arquivo a ser impresso
next_free_slot = 7
Spooler fila de impresso (slots)
4
prog.c
prog.n
5
6
7
.
.
Processo B
in = 7
out = 4
Prximo slot livre
next_free_slot = 7
Coloca seu arquivo no slot 7 e
next_free_slot = 8
next_free_slot = 7
abc
4
.
.
Processo A
5
prog.c
prog.n
5
6
7
.
.
Processo B
in = 8
out = 4
Prximo slot livre
checa
next_free_slot = 7
progB.c
abc
4
.
.
Processo A
6
prog.c
prog.n
5
6
7
.
.
Processo B
in = 8
out = 4
Prximo slot livre
Coloca arquivo a ser
Impresso no slot 7 e faz
next_free_slot = 8
progA.c
Processo B nunca receber sua impresso!!!!!
Regies Crticas Regies Crticas
Como solucionar problemas de Race
Conditions???
Proibir que mais de um processo leia ou escreva
em recursos compartilhados concorrentemente (ao
mesmo tempo)
7
mesmo tempo)
Recursos compartilhados regies crticas;
Excluso mtua: garantir que um processo no
ter acesso uma regio crtica quando outro
processo est utilizando essa regio;
Excluso Mtua Excluso Mtua
Quatro condies para uma boa soluo:
1. Dois processos no podem estar simultaneamente em
regies crticas;
2. Nenhuma restrio deve ser feita com relao CPU;
8
3. Processos que no esto em regies crticas no podem
bloquear outros processos que desejam utilizar regies
crticas;
4. Processos no podem esperar para sempre para
acessarem regies crticas;
Processo A
A entra na
regio crtica
A sai da
regio crtica
A
9
Processo B
Tempo
T
1
T
2
T
3
T
4
B entra na
regio crtica
B sai da
regio crtica
B tenta entrar na
regio crtica - bloqueado
Processo A
Volta a situao inicial!!!!
10
Processo B
Tempo
T
1
T
2
T
3
T
4
T
5
Solues Solues
Excluso Mtua:
Espera Ocupada;
Primitivas Sleep/Wakeup;
Semforos;
Monitores;
11
Monitores;
Passagem de Mensagem;
Espera Ocupada (Busy Waiting): constante
checagem por algum valor;
Algumas solues para excluso mtua com
12
espera ocupada:
Desabilitar interrupes;
Variveis de Travamento (Lock);
Estrita Alternncia (Strict Alternation);
Soluo de Peterson e Instruo TSL;
Desabilitar interrupes:
Processo desabilita todas as suas interrupes ao entrar na
regio crtica e habilita essas interrupes ao sair da regio
crtica;
Com as interrupes desabilitadas, a CPU no realiza
13
chaveamento entre os processos;
Viola condio 2 (Nenhuma restrio deve ser feita com
relao CPU);
No uma soluo segura, pois um processo pode no
habilitar novamente suas interrupes e no ser finalizado;
Viola condio 4 (Processos no podem esperar para
sempre para acessarem regies crticas);
Variveis Lock:
O processo que deseja utilizar uma regio crtica
atribu um valor a uma varivel chamada lock;
Se a varivel est com valor 0 (zero) significa que
nenhum processo est na regio crtica; Se a
14
nenhum processo est na regio crtica; Se a
varivel est com valor 1 (um) significa que existe
um processo na regio crtica;
Apresenta o mesmo problema do exemplo do
spooler de impresso;
Variveis Lock - Problema:
Suponha que um processo A leia a varivel lock
com valor 0;
Antes que o processo A posso alterar a varivel
para o valor 1, um processo B escalonado e
15
para o valor 1, um processo B escalonado e
altera o valor de lock para 1;
Quando o processo A for escalonado novamente,
ele altera o valor de lock para 1, e ambos os
processos esto na regio crtica;
Viola condio 1 (Dois processos no podem estar
simultaneamente em regies crticas);
Comunicao entre Processos Comunicao entre Processos
Variveis Lock: lock==0;
while(true){
while(lock!=0); //loop
lock=1;
while(true){
while(lock!=0); //loop
lock=1;
16
lock=1;
critical_region();
lock=0;
non-critical_region();
}
Processo A
lock=1;
critical_region();
lock=0;
non-critical_region();
}
Processo B
Strict Alternation:
Fragmentos de programa controlam o acesso
s regies crticas;
Varivel turn, inicialmente em 0, estabelece qual processo
pode entrar na regio crtica;
17
(Processo A)
turn 0
(Processo B)
turn 1
while (TRUE) {
while (turn!=0); //loop
critical_region();
turn = 1;
noncritical region();}
while (TRUE){
while (turn!=1); //loop
critical_region();
turn = 0;
noncritical region();}
Problema do Strict Alternation:
1. Suponha que o Processo B mais rpido e sai da regio
crtica;
2. Ambos os processos esto fora da regio crtica e turn com
valor 0;
18
valor 0;
3. O processo A termina antes de executar sua regio no crtica
e retorna ao incio do loop; Como o turn est com valor zero,
o processo A entra novamente na regio crtica, enquanto o
processo B ainda est na regio no crtica;
4. Ao sair da regio crtica, o processo A atribui o valor 1
varivel turn e entra na sua regio no crtica;
Problema do Strict Alternation:
5. Novamente ambos os processos esto na regio no
crtica e a varivel turn est com valor 1;
6. Quando o processo A tenta novamente entrar na regio
crtica, no consegue, pois turn ainda est com valor 1;
19
crtica, no consegue, pois turn ainda est com valor 1;
7. Assim, o processo A fica bloqueado pelo processo B
que NO est na sua regio crtica, violando a
condio 3;
Soluo de Peterson e Instruo TSL (Test and Set
Lock):
Uma varivel (ou programa) utilizada para bloquear a
entrada de um processo na regio crtica quando um outro
processo est na regio;
20
processo est na regio;
Essa varivel compartilhada pelos processos que
concorrem pelo uso da regio crtica;
Ambas as solues possuem fragmentos de programas que
controlam a entrada e a sada da regio crtica;
Soluo de Peterson
#define FALSE 0
#define TRUE 1
#define N 2
int turn;
int interested[N];
21
int interested[N];
void enter_region(int process)
{
int other;
other = 1 - process;
interested[process] = TRUE;
turn = process;
while (turn == process) && interested[other] == TRUE) ;
}
void leave_region(int process)
{
interested[process] = FALSE;
}
Instruo TSL: utiliza registradores do hardware;
TSL RX, LOCK; (l o contedo de lock em RX, e armazena um valor
diferente de zero (0) em lock operao indivisvel);
Lock compartilhada
Se lock==0, ento regio crtica liberada.
Se lock<>0, ento regio crtica ocupada.
22
enter_region:
TSL REGISTER, LOCK | Copia lock para reg. e lock=1
CMP REGISTER, #0 | lock valia zero?
JNE enter_region | Se sim, entra na regio crtica,
| Se no, continua no lao
RET | Retorna para o processo chamador
leave_region
MOVE LOCK, #0 | lock=0
RET | Retorna para o processo chamador
Primitivas Primitivas Sleep Sleep//Wakeup Wakeup
Todas as solues apresentadas utilizam
espera ocupada processos ficam em
estado de espera (looping) at que possam
utilizar a regio crtica:
23
utilizar a regio crtica:
Tempo de processamento da CPU;
Situaes inesperadas;
Para solucionar esse problema de espera, um par de primitivas
Sleep e Wakeup utilizado BLOQUEIO E DESBLOQUEIO
de processos.
A primitiva Sleep uma chamada de sistema que bloqueia o
processo que a chamou, ou seja, suspende a execuo de tal
processo at que outro processo o acorde;
24
processo at que outro processo o acorde;
A primitiva Wakeup uma chamada de sistema que acorda
um determinado processo;
Ambas as primitivas possuem dois parmetros: o processo
sendo manipulado e um endereo de memria para realizar a
correspondncia entre uma primitiva Sleep com sua
correspondente Wakeup;
Problemas que podem ser solucionados com o uso
dessas primitivas:
Problema do Produtor/Consumidor (bounded buffer ou buffer
limitado): dois processos compartilham um buffer de tamanho
fixo. O processo produtor coloca dados no buffer e o
processo consumidor retira dados do buffer;
25
processo consumidor retira dados do buffer;
Problemas:
Produtor deseja colocar dados quando o buffer ainda est cheio;
Consumidor deseja retirar dados quando o buffer est vazio;
Soluo: colocar os processos para dormir, at que eles
possam ser executados;
Buffer: uma varivel count controla a
quantidade de dados presente no buffer.
Produtor: Antes de colocar dados no buffer, o
processo produtor checa o valor dessa
26
processo produtor checa o valor dessa
varivel. Se a varivel est com valor
mximo, o processo produtor colocado
para dormir. Caso contrrio, o produtor
coloca dados no buffer e o incrementa.
Consumidor: Antes de retirar dados no buffer,
o processo consumidor checa o valor da
varivel count para saber se ela est com
0 (zero). Se est, o processo vai dormir,
27
0 (zero). Se est, o processo vai dormir,
seno ele retira os dados do buffer e
decrementa a varivel;
Sincronizao Produtor Sincronizao Produtor--Consumidor Consumidor
Sincronizao
28
Processo
gravador
Processo
leitor
dado
l
e
i
t
u
r
a
g
r
a
v
a
o
Buffer
# define N 100
int count = 0;
void producer(void)
{
int item;
void consumer(void)
{
int item;
while (TRUE) {
if (count == 0)
29
int item;
while (TRUE) {
item = produce_item();
if (count == N)
sleep();
insert_item(item);
count = count + 1;
if (count == 1)
wakeup(consumer)
}
}
if (count == 0)
sleep();
item = remove_item();
count = count - 1;
if (count == N - 1)
wakeup(producer)
consume_item(item);
}
}
Problemas desta soluo: Acesso varivel count
irrestrita
O buffer est vazio e o consumidor acabou de checar a
varivel count com valor 0;
O escalonador (por meio de uma interrupo) decide que o
30
O escalonador (por meio de uma interrupo) decide que o
processo produtor ser executado; Ento o processo produtor
insere um item no buffer e incrementa a varivel count com
valor 1; Imaginando que o processo consumidor est
dormindo, o processo produtor envia um sinal de wakeup
para o consumidor;
No entanto, o processo consumidor no est dormindo, e no
recebe o sinal de wakeup;
Assim que o processo consumidor executado novamente, a
varivel count j tem o valor zero; Nesse instante, o
consumidor colocado para dormir, pois acha que no
existem informaes a serem lidas no buffer;
Assim que o processo produtor acordar, ele insere outro item
no buffer e volta a dormir. Ambos os processos dormem para
31
no buffer e volta a dormir. Ambos os processos dormem para
sempre...
Soluo: bit de controle recebe um valor true
quando um sinal enviado para um processo que
no est dormindo. No entanto, no caso de vrios
pares de processos, vrios bits devem ser criados
sobrecarregando o sistema!!!!
Semforos Semforos
Idealizados por E. W. Dijkstra (1965);
Varivel inteira que armazena o nmero de sinais
wakeups enviados;
Um semforo pode ter valor 0 quando no h sinal
armazenado ou um valor positivo referente ao
32
armazenado ou um valor positivo referente ao
nmero de sinais armazenados;
Duas primitivas de chamadas de sistema: down
(sleep) e up (wake);
Originalmente P (down) e V (up) em holands;
Semforos Semforos
Down: verifica se o valor do semforo maior do que
0; se for, o semforo decrementado; se o valor for
0, o processo colocado para dormir sem completar
sua operao de down;
Todas essas aes so chamadas de aes
33
Todas essas aes so chamadas de aes
atmicas;
Aes atmicas garantem que quando uma operao no
semforo est sendo executada, nenhum processo pode
acessar o semforo at que a operao seja finalizada ou
bloqueada;
Semforos Semforos
Up: incrementa o valor do semforo, fazendo com
que algum processo que esteja dormindo possa
terminar de executar sua operao down;
Semforo Mutex: garante a excluso mtua, no
permitindo que os processos acessem uma regio
34
permitindo que os processos acessem uma regio
crtica ao mesmo tempo
Tambm chamado de semforo binrio
Semforo Binrio Semforo Binrio
Processo deseja entrar
na regio crtica
D
O
W
0
)
Processo
bloqueado
sem finalizar
Processo executa
Down(s)
Processo
finaliza
35
Fila de espera
de processos
Processo acessa
a regio crtica
O
W
N

(
S
=
0
)
D
O
W
N

(
S
>
0
UP (S) - processo sai
da regio crtica
Libera processo
da fila de espera
sem finalizar
Down(s), pois
s=0;
finaliza
Down(s),
pois s>0;
Semforos Semforos
Problema produtor/consumidor: resolve o problema
de perda de sinais enviados;
Soluo utiliza trs semforos:
Full: conta o nmero de slots no buffer que esto
ocupados; iniciado com 0; resolve sincronizao;
36
ocupados; iniciado com 0; resolve sincronizao;
Empty: conta o nmero de slots no buffer que esto vazios;
iniciado com o nmero total de slots no buffer; resolve
sincronizao;
Mutex: garante que os processos produtor e consumidor no
acessem o buffer ao mesmo tempo; iniciado com 1; tambm
chamado de semforo binrio; Permite a excluso mtua;
Semforos Semforos
# include prototypes.h
# define N 100
typedef int semaphore;
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;
void consumer (void){
int item;
while (TRUE){
down(&full);
down(&mutex);
37
void producer (void){
int item;
while (TRUE){
produce_item(&item);
down(&empty);
down(&mutex);
enter_item(item);
up(&mutex);
up(&full);
}
}
down(&mutex);
remove_item(item);
up(&mutex);
up(&empty);
consume_item(item);
}
}
Semforos Semforos
Problema: erro de programao pode gerar um
deadlock;
Suponha que o cdigo seja trocado no processo produtor;
.. ..
down(&empty); down(&mutex);
38
Se o buffer estiver cheio, o produtor ser bloqueado com
mutex = 0; Assim, a prxima vez que o consumidor tentar
acessar o buffer, ele tenta executar um down sobre o mutex,
ficando tambm bloqueado.
down(&empty); down(&mutex);
down(&mutex); down(&empty);
.. ..
Monitores Monitores
Idealizado por Hoare (1974) e Brinch Hansen (1975)
Monitor: primitiva (unidade bsica de sincronizao)
de alto nvel para sincronizar processos:
Conjunto de procedimentos, variveis e estruturas de dados
39
agrupados em um nico mdulo ou pacote;
Somente um processo pode estar ativo dentro do
monitor em um mesmo instante; outros processos
ficam bloqueados at que possam estar ativos no
monitor;
Monitores Monitores
monitor example
int i;
condition c;
procedure A();
.
Dependem da linguagem
de programao o
Compilador que garante
a excluso mtua.
40
.
end;
procedure B();
.
end;
end monitor;
Estrutura bsica de um Monitor
Java possui este recurso
Todos os recursos
compartilhados entre
processos devem estar
implementados dentro
do Monitor;
Monitores Monitores
Execuo:
Chamada a uma rotina do monitor;
Instrues iniciais teste para detectar se um
outro processo est ativo dentro do monitor;
41
Se positivo, o processo novo ficar bloqueado at
que o outro processo deixe o monitor;
Caso contrrio, o processo novo executa as rotinas
no monitor;
Monitores Monitores
Condition Variables (condition): variveis que
indicam uma condio; e
Operaes Bsicas: WAIT e SIGNAL
wait (condition) bloqueia o processo;
42
wait (condition) bloqueia o processo;
signal (condition) acorda o processo que
executou um wait na varivel condition e foi
bloqueado;
Monitores Monitores
Variveis condicionais no so contadores,
portanto, no acumulam sinais;
Se um sinal enviado sem ningum
(processo) estar esperando, o sinal
43
(processo) estar esperando, o sinal
perdido;
Assim, um comando WAIT deve vir antes de
um comando SIGNAL.
Monitores Monitores
Como evitar dois processos ativos no monitor ao
mesmo tempo?
(1) Hoare colocar o processo mais recente para
rodar, suspendendo o outro!!! (sinalizar e esperar)
(2) B. Hansen um processo que executa um
44
(2) B. Hansen um processo que executa um
SIGNAL deve deixar o monitor imediatamente;
O comando SIGNAL deve ser o ltimo de um procedimento
do monitor;
A condio (2) mais simples e mais fcil de se
implementar.
Monitores Monitores
45
Monitores Monitores
A excluso mtua automtica dos
procedimentos do monitor garante que, por
exemplo, se o produtor dentro de um
procedimento do monitor descobrir que o
buffer est cheio, esse produtor ser capaz
46
buffer est cheio, esse produtor ser capaz
de terminar a operao de WAIT sem se
preocupar, pois o consumidor no estar
ativo dentro do monitor at que WAIT tenha
terminado e o produtor tenha sido marcado
como no mais executvel;
Monitores Monitores
Limitaes de semforos e monitores:
Ambos so boas solues somente para CPUs
com memria compartilhada. No so boas
solues para sistema distribudos;
Nenhuma das solues prov troca de
47
Nenhuma das solues prov troca de
informaes entre processo que esto em
diferentes mquinas;
Monitores dependem de uma linguagem de
programao poucas linguagens suportam
Monitores;
Passagem de Mensagem Passagem de Mensagem
Prov troca de mensagens entre processos
rodando em mquinas diferentes;
Utiliza-se de duas primitivas de chamadas de
sistema: send e receive;
48
sistema: send e receive;
Podem ser implementadas como procedimentos:
send (destination,&message);
receive (source,&message);
O procedimento send envia para um determinado
49
destino uma mensagem, enquanto que o
procedimento receive recebe essa mensagem em
uma determinada fonte; Se nenhuma mensagem
est disponvel, o procedimento receive bloqueado
at que uma mensagem chegue.
Problemas desta soluo:
Mensagens so enviadas para/por mquinas
conectadas em rede; assim mensagens podem se
perder ao longo da transmisso;
Mensagem especial chamada acknowledgement
50
Mensagem especial chamada acknowledgement
o procedimento receive envia um
acknowledgement para o procedimento send. Se
esse acknowledgement no chega no
procedimento send, esse procedimento
retransmite a mensagem j enviada;
Problemas:
A mensagem recebida corretamente, mas o
acknowledgement se perde.
Ento o receive deve ter uma maneira de saber se
51
uma mensagem recebida uma retransmisso cada
mensagem enviada pelo send possui uma identificao
sequncia de nmeros; Assim, ao receber uma nova
mensagem, o receive verifica essa identificao, se
ela for semelhante a de alguma mensagem j recebida,
o receive descarta a mensagem!
Problemas:
Desempenho: copiar mensagens de um processo
para o outro mais lento do que operaes com
semforos e monitores;
Autenticao Segurana;
52
Autenticao Segurana;
53
Outros mecanismos Outros mecanismos
RPC Remote Procedure Call
Rotinas que permitem comunicao de processos em
diferentes mquinas;
Chamadas remotas;
MPI Message-passing Interface;
Sistemas paralelos;
54
Sistemas paralelos;
RMI Java Remote Method Invocation
Permite que um objeto ativo em uma mquina virtual Java
possa interagir com objetos de outras mquinas virtuais
Java, independentemente da localizao dessas mquinas
virtuais;
Web Services
Permite que servios sejam compartilhados atravs da Web
Outros mecanismos Outros mecanismos
Pipe:
Permite a criao de filas de processos;
ps -ef | grep produtor_consumidor;
Sada de um processo a entrada de outro;
Existe enquanto o processo existir;
Named pipe:
55
Named pipe:
Extenso de pipe;
Continua existindo mesmo depois que o processo terminar;
Criado com chamadas de sistemas;
Socket:
Par endereo IP e porta utilizado para comunicao entre processos
em mquinas diferentes;
Host X (192.168.1.1:1065) Server Y (192.168.1.2:80);
Problemas clssicos de Problemas clssicos de
comunicao entre processos comunicao entre processos
Problema do Jantar dos
Filsofos
Cinco filsofos desejam comer
espaguete; No entanto, para
poder comer, cada filsofo
precisa utilizar dois garfo e no
56
precisa utilizar dois garfo e no
apenas um. Portanto, os
filsofos precisam compartilhar
o uso do garfo de forma
sincronizada.
Os filsofos comem e pensam;
Problemas clssicos de Problemas clssicos de
comunicao entre processos comunicao entre processos
Problemas que devem
ser evitados:
Deadlock todos os
filsofos pegam um garfo
ao mesmo tempo;
57
ao mesmo tempo;
Starvation os filsofos
fiquem indefinidamente
pegando garfos
simultaneamente;
Soluo 1 para Filsofos (1/2) Soluo 1 para Filsofos (1/2)
58
Problemas da soluo 1:
Execuo do take_fork(i) Se todos os filsofos
pegarem o garfo da esquerda, nenhum pega o da direita
Deadlock;
Se modificar a soluo (mudana 1):
59
Verificar antes se o garfo da direita est disponvel. Se no
est, devolve o da esquerda e comea novamente
Starvation (Inanio);
Tempo fixo ou tempo aleatrio (rede Ethernet);
Serve para sistemas no-crticos;
semaphore mutex = 1;
60
down(&mutex);
up(&mutex);
Somente um filsofo come!
Soluo 2 para Filsofos usando Soluo 2 para Filsofos usando
Semforos (1/3) Semforos (1/3)
No apresenta:
Deadlocks;
Starvation;
Permite o mximo de paralelismo;
61
Permite o mximo de paralelismo;
62
63
Problema dos Leitores / Escritores Problema dos Leitores / Escritores
O problema dos Leitores e Escritores modela o
acesso compartilhado a uma base de dados.
Processos leitores e processos escritores competem
por um acesso a essa base. possvel que vrios
processos leitores acessem a base ao mesmo
64
processos leitores acessem a base ao mesmo
tempo, no entanto, quando um processo escritor est
escrevendo (modificando) a base de dados, nenhum
outro processo pode realizar um acesso, nem
mesmo um processo leitor.
Problema dos Problema dos
Leitores Leitores
/ Escritores / Escritores
65
Problema do Barbeiro Problema do Barbeiro
Na barbearia h um barbeiro, uma cadeira de barbeiro e
n cadeiras para os clientes esperarem para ser
atendidos. Quando no h clientes, o barbeiro senta-se
na cadeira do barbeiro e dorme. Quando um cliente
chega, ele precisa acordar o barbeiro para ser atendido.
66
chega, ele precisa acordar o barbeiro para ser atendido.
Se outros clientes chegarem enquanto o barbeiro estiver
ocupado cortando o cabelo de algum cliente, eles se
sentam se houver cadeiras disponveis para clientes,
seno eles vo embora se todas as cadeiras para
clientes estiverem ocupadas.
Problema do Problema do
Barbeiro Barbeiro
67

07 So

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

07 So

Uploaded by

Copyright:

Available Formats

Comunicao e Sincronismo Comunicao e Sincronismo

entre processos entre processos

You might also like