Execuo Concorrente de Processos

Os processos de um SO podem executar concorrentemente, partilhando a CPU num dado intervalo de tempo. o temporizador (ou scheduler), um programa do SO, quem distribui o tempo de CPU pelos vrios processos prontos a executar. Vantagens da execuo concorrente: partilha de recursos fsicos e lgicos por mltiplos utilizadores. maior ecincia e modularidade podemos ter vrias tarefas em simultneo, e num sistema multiprocessador execut-las mais rpido. Contudo, a execuo concorrente de processos que cooperam entre si, requer a existncia de mecanismos de sincronizao e comunicao.

DCC/FCUP Fernando Silva

Sistemas de Operao

Comunicao entre processos (IPC)

Mtodos de comunicao entre processos: Sinais unidirecionais: um processo-lho pode enviar sinais, atravs de exit()/return() ao processo-pai que pode fazer a recepo com wait(). um processo pode enviar a outro (desde que relacionados) um sinal explcito, atravs de kill(). O processo que recebe o sinal deve executar um signal(). Pipes: um processo escreve e outro l (unidirecional). Mensagens: um processo envia uma mensagem explcita a outro. Partilha de Memria: dois processos que partilhem uma varivel/cheiro, podem comunicar entre si escrevendo e lendo dessa varivel/cheiro.
DCC/FCUP Fernando Silva Sistemas de Operao 2

Competio entre processos (race conditions)

Existe competio entre processos quando o resultado depende da ordem de execuo dos processos, e.g. dois processos a alterarem algo partilhado por ambos. Exemplo: Imprimir um cheiro Quando um processo imprime um cheiro, o nome deste colocado numa la de impresso (spool directory) e o programa lpd (printer-daemon) que se encarrega de periodicamente vericar se h cheiros na la e se houver, imprime-os e remove os nomes respectivos da la. Suponhamos que dois processos A e B, quase simultaneamente, decidem imprimir um cheiro cada. A gura ilustra a la de execuo atual:

DCC/FCUP Fernando Silva

Sistemas de Operao

fila-impressao saida A
fichA

2 3

2 entrada 4

lpd

fichB

suponha que o cdigo a executar pelos 2 processos para adicionar os cheiros la : posio= entrada adicionaNomeFila(nomeFich, posio) posio++ entrada= posio

DCC/FCUP Fernando Silva

Sistemas de Operao

Exemplo de competio entre processos

Suponhamos que tnhamos o seguinte padro de execuo:
Processo A posicao=4 adicionaNomeFich() Processo B

(*) posicao=4 adicionaNomeFich() posicao=5 entrada=5

posicao=5 entrada=5

(*) Proc. A interrompido pelo scheduler. A la foi atualizada como se tivssemos adicionado apenas um cheiro, assim o sugere a varivel entrada. O cheiro que o processo A pretendia imprimir perde-se.

DCC/FCUP Fernando Silva

Sistemas de Operao

 necessrio ter ateno atualizao concorrente da varivel entrada pelos dois processos.

DCC/FCUP Fernando Silva

Sistemas de Operao

Zonas Crticas

n processos a competirem para acederem a variveis partilhadas. cada processo tem uma parte de cdigo, zona crtica, na qual acede a memria partilhada. Problema: assegurar que quando um processo est a executar a sua zona crtica, nenhum outro processo pode executar na sua zona crtica. Se apenas permitirmos um processo de cada vez na zona crtica, evita-se competio entre processos.

DCC/FCUP Fernando Silva

Sistemas de Operao

Zonas Crticas (cont.)

Estrutura do processo Pi: repeat entrar_zc zona crtica sair_zc zona restante de cdigo until false;

DCC/FCUP Fernando Silva

Sistemas de Operao

Como evitar competio entre processos em zonas crticas?

1. Excluso Mtua: nas zonas crticas no podero estar nunca 2 processos em simultneo (atomicidade). 2. nenhum processo dever ter de esperar eternamente para entrar na sua zona crtica (devemos evitar starvation). 3. nenhum processo que esteja fora da sua zona crtica, poder bloquear outros processos (devemos evitar deadlocks). 4. no se pode assumir velocidade ou nmero de CPUs.

DCC/FCUP Fernando Silva

Sistemas de Operao

Mtodos de excluso mtua com espera ativa:

1. Desligar interrupes (soluo hardware): desligar_interrupes zona crtica ligar_interrupes com as interrupes desligadas, o CPU no poder ser comutado para outro processo. mtodo til a nvel do kernel, o scheduler usa-o, mas no apropriado como mecanismo geral para garantir excluso mtua entre processos-utilizador. se um processo-utilizador pudesse desligar interrupes, poderia ser o m do sistema. Por que?

DCC/FCUP Fernando Silva

Sistemas de Operao

10

2. Variveis de Bloqueio
Variveis partilhadas: boolean flag[2]; inicialmente flag[0] = flag[1] = false; flag[j] == false Pi pode entrar na zona crtica.
Processo 0: ... while (ag[1]) ; ag[0]= true; zona_crtica(); ag[0]= false; zona_no_crtica(); ... Processo 1: ... while (ag[0]) ; ag[1]= true; zona_crtica(); ag[1]= false; zona_no_crtica(); ...

Esta soluo no satisfaz excluso mtua! Por que? P0 executa o ciclo-while e encontra flag[1]=false; P1 executa o ciclo-while e encontra flag[0]=false; P0 executa flag[0]=true e entra na zona_critica(); P1 executa flag[1]=true e entra na zona_critica();
DCC/FCUP Fernando Silva Sistemas de Operao 11

Depende da ordem de execuo dos processos.

DCC/FCUP Fernando Silva

Sistemas de Operao

12

3. Alternncia estrita
Variveis partilhadas: int vez; inicialmente vez = 0 vez == i Pi pode entrar na zona crtica.
Processo 0: ... while (vez!=0) ; zona_crtica(); vez= 1; zona_no_crtica(); ... Processo 1: ... while (vez!=1) ; zona_crtica(); vez= 0; zona_no_crtica(); ...

Esta soluo satisfaz excluso mtua, mas desperdia CPU (a no ser que o tempo de espera seja curto). S funciona se houver alternncia de vez entre dois processos. Se um dos processos falhar o outro ca bloqueado. espera ativa teste contnuo de uma varivel espera que ela tome um dado valor (while (vez!=0) ;).
DCC/FCUP Fernando Silva Sistemas de Operao 13

4. Algoritmo de Peterson

Em 1965, Dijkstra apresentou um algoritmo que garantia excluso mtua de dois processos, desenvolvido pelo matemtico holands Dekker. Dekker combinou a ideia de alternar vez com a ideia de variveis de bloqueio e variveis de aviso. Em 1981, G.L. Peterson props uma soluo mais simples: combina alternncia estrita com uma outra varivel que indica se o processo est ou no interessado em entrar na zona crtica.

DCC/FCUP Fernando Silva

Sistemas de Operao

14

4. Algoritmo de Peterson
boolean flag[2]; int vez; (flag[j]==false || vez=i) Pi pode entrar entrar na zona crtica. Processo 0: Processo 1: ... ... ag[0]=true; ag[1]=true; vez= 1; vez= 0; while (vez==1 && ag[1]) ; while (vez==0 && ag[0]) ; zona_crtica(); zona_crtica(); ag[0]=false; ag[1]= false; zona_no_crtica(); zona_no_crtica(); ... ...

DCC/FCUP Fernando Silva

Sistemas de Operao

15

Algoritmo de Peterson em funcionamento

Dois exemplos do funcionamento do algoritmo:

Processo A flag[0]=true vez=1 zona_critica

Processo B flag[1]=false

Processo A flag[0]=true vez=1

Processo B

flag[1]=true vez=0 while(vez==0 && flag[0]) ; flag[0]=false zona_critica

flag[1]=true vez=0 while(vez==0 && flag[0]) ; while(vez==1 && flag[1]); zona_critica

O processo que executar vez=valor em ltimo, ca sem conseguir entrar na zona crtica.

DCC/FCUP Fernando Silva

Sistemas de Operao

16

Instruo Test and Set (Lock)

Testa e modica o contedo de uma posio de memria de forma atmica. A instruo corresponde funo: int TSL(int *m) { int r; r= *m; *m= 1; return r; } a execuo da funo TSL(m) tem de ser indivisvel, i.e. nenhum outro processo pode aceder posio de memria m at que a instruo tenha sido executada.
DCC/FCUP Fernando Silva Sistemas de Operao 17

Como usar a instruo TSL() de forma a garantir excluso mtua no acesso a uma zona crtica? usar uma varivel partilhada lock que qualquer processo possa modicar; obrigar um processo a ativar o lock antes de entrar na zona crtica; usar TSL() para conseguir modicar lock de forma atmica).

DCC/FCUP Fernando Silva

Sistemas de Operao

18

Excluso mtua com Test-and-Set

Varivel partilhadas: int lock; inicialmente lock=0 se TSL(lock)==0 Pi pode aceder zona crtica. Algoritmo de Pi: ... while (TSL(&lock)!=0) ; zona_critica(); lock= 0; zona_no_crtica(); ... % espera ativa

DCC/FCUP Fernando Silva

Sistemas de Operao

19

Processo A lock=0 while (TSL(lock)!=0); (lock==1) zona_critica . . . lock=0

Processo B

while(TSL(lock)!=0) ; . (lock==1) . em espera activa . zona_critica

Vantagens e inconvenientes: pode ser usada por um nmero arbitrrio de processos. simples e fcil de vericar. pode suportar zonas crticas mltiplas. com nmero maior de processos, espera ativa pode ser problema. possvel os processos entrarem em starvation.

DCC/FCUP Fernando Silva

Sistemas de Operao

20

Excluso mtua com Test-and-Set

Exemplo de cdigo em C usando instruo atmica swap, parte do conjunto de instrues dos processadores SUN: (swap troca o contedo de um endereo de memria com o contedo de um registrador)
1 2 3 4 5 6 7 8 9 10 11 12 13

# define s w a p _ i l ( addr , reg ) ( { int _ret ; asm volatile ( " swap %1 ,%0 " : "=r" ( _ret ) , "=m" ( * ( addr ) ) : "m" ( * ( addr ) ) , "0" ( reg ) ) ; _ret ; }) # define S_LOCK( p ) \ { \ while ( swap_il ( ( p ) , 1 ) ) \ ; \ }

/ * Output %0,%1 * / / * I n p u t (%2),%0 * /

\ \ \ \ \ \

DCC/FCUP Fernando Silva

Sistemas de Operao

21

Excluso mtua com Test-and-Set (cont.)

Outro exemplo em C usando as instrues load-linked e store-conditional, presentes no conjunto de instrues das arquiteturas MIPS.
1 2 3 4 5 6 7 8 9 10 11 12

# define s w a p _ i l ( addr , reg ) ( { register int r1 , rout =0; asm volatile ( "ll %0 ,%3; bne %0 ,$0 ,0f; nop ; add %2 ,$0 ,%4; sc %2 ,%1; 0:; " : "=r" ( r1 ) , "=m" ( * ( addr ) ) , "=r" ( rout ) : "m" ( * ( addr ) ) , "r" ( reg ) , "r" ( rout ) ) ; rout ; })

\ \ \ \ \ \ \ \ \ \ \

DCC/FCUP Fernando Silva

Sistemas de Operao

22

Semforos (Dijkstra, 1965)

permite sincronizar processos no acesso a zonas crticas, e no envolve espera ativa. um semforo denido como um inteiro no-negativo, ao qual esto associadas duas operaes atmicas (indivisiveis).

DCC/FCUP Fernando Silva

Sistemas de Operao

23

Semforos (Dijkstra, 1965) (cont.)

down(S) ou wait(S): -----------------if (S==0) suspende execuo do processo S--; up(S) ou signal(S): ------------------S++; if (S==1) retoma um processo suspenso em S Semforos Binrios: apenas tomam valores 0 e 1. So habitualmente usados para garantir excluso mtua no acesso a zonas crticas, e designam-se por mutexs.
DCC/FCUP Fernando Silva Sistemas de Operao 24

Excluso mtua com semforos

Variveis partilhadas: semforo mutex; inicialmente mutex=1. Processo Pi: ... down(mutex); zona_crtica(); up(mutex); zona_no_crtica(); ... O processo consegue aceder zona crtica se o mutex= 1 quando executou wait(mutex). Se estivesse mutex=0, ento o processo adormecia espera que algum (que est na zona crtica) sinalize o mutex.
DCC/FCUP Fernando Silva Sistemas de Operao 25

Problema do Produtor/Consumidor
Consideremos dois processos que partilham um buffer com capacidade para N elementos. Um processo, produtor, coloca informao no depsito, enquanto outro processo, o consumidor, retira informao do depsito. Problemas que podem surgir: - produtor quer adicionar um item, mas o depsito est cheio. - consumidor quer retirar um item, mas o depsito est vazio.

DCC/FCUP Fernando Silva

Sistemas de Operao

26

Soluo do Produtor/Consumidor com Semforos

typedef int semaforo; semaforo mutex= 1; /* para garantir excluso mtua */ semaforo vazio= N; /* num. posies vazias no buffer*/ semaforo cheio= 0; /* num. posies cheias no buffer*/

produtor() { int item; while (True) { produz(&item); down(&vazio); down(&mutex); adiciona(item); up(&mutex); up(&cheio); } }
DCC/FCUP Fernando Silva

consumidor() { int item; while (True) { down(&cheio); down(&mutex); retira(item); up(&mutex); up(&vazio); consome(item); } }
Sistemas de Operao 27

Os semforos vazio e cheio so usados para sincronizar os dois processos, permitindo-lhes suspender caso a operao que pretendem realizar no possa prosseguir.

DCC/FCUP Fernando Silva

Sistemas de Operao

28

Implementao de Semforos

Um semforo denido por uma estrutura com dois campos: typedef struct { int val; ProcessList *L; } Semaforo; Assume-se duas operaes simples: block() suspende o processo que a invoca; wakeup(P) retoma a execuo do processo suspenso P.

DCC/FCUP Fernando Silva

Sistemas de Operao

29

Implementao de Semforos (cont.)

Operaes sobre os semforos: Semaforo S; down(S): if (S.val==0) { adiciona(processID, S.L); block(); } S.val--; S.val++; if (S.val==1) { pid_susp= retira_primeiro(S.L); wakeup(pid_susp); }
Sistemas de Operao 30

up(S):

DCC/FCUP Fernando Silva

Implementao de Semforos com a instruo TSL

typedef enum {False,True} BOOL; typedef struct { int val; BOOL mutex; BOOL espera; } Semaforo; Semaforo S={1,False,True}; #define DOWN(S) { \ #define UP(S) { while (TSL(&S.mutex)); \ while (TSL(&S.mutex)); if (S.val==0) { \ S.val++; S.mutex=False; \ if (S.val == 1) { while (TSL(&S.espera)) ; \ while (!S.espera) ; } \ S.espera=False; S.val--; \ } S.mutex=False; \ S.mutex=False; } }
DCC/FCUP Fernando Silva Sistemas de Operao

\ \ \ \ \ \ \ \

31

Impasse (Deadlock)

Ateno ordem de chamada das operaes sobre um semforo! Podemos facilmente criar uma situao favorvel a impasses. impasse (deadlock) verica-se quando dois ou mais processos cam espera pela ocorrncia de um evento que s pode ser causado por um dos processos em espera. Exemplo: sejam S e Q dois semforos inicializados em 1, P0 down(S) down(Q) ... up(S) up(Q) P1 down(Q) down(S) ... up(Q) up(S)

DCC/FCUP Fernando Silva

Sistemas de Operao

32

Impasse (Deadlock)
Um conjunto de processos est em um estado de impasse se: Cada um dos processos est esperando por um evento que pode ser gerado somente por um outro processo do conjunto. Os impasses em geral envolvem recursos no-preemptivos, pois: Se um recurso preemptivo, os impasses podem ser evitados atravs da realocao dos recursos aos processos. Isso no pode ser feito com os recursos no-preemptivos, seno o resultado da tarefa cooperativa seria incorreto.

DCC/FCUP Fernando Silva

Sistemas de Operao

33

Impasse (Deadlock)
Um impasse ocorrer somente se existirem as seguintes condies: Condio de excluso mtua: cada recurso est atribudo a um nico processo em um dado intervalo de tempo. Condio de segura e espera: um processo pode solicitar novos recursos quando ainda est segurando outros recursos. Condio de nenhuma preempo: um recurso concedido a um processo somente pode ser liberado pelo processo. Condio de espera circular: existe uma cadeia circular de dependncia entre os processos.

DCC/FCUP Fernando Silva

Sistemas de Operao

34

Modelagem de Impasses
Podemos usar o seguinte grafo de recursos, para modelar as solicitaes e liberaes dos recursos pelos processos. Existe um n para cada um dos processos (os crculos). Existe um n para cada um dos recursos (os quadrados). Se um recurso est alocado a um processo, existe um arco do n deste recurso para o n deste processo. Se um processo fez uma solicitao a um recurso, existir um arco do n deste processo para o n deste recurso.

DCC/FCUP Fernando Silva

Sistemas de Operao

35

Modelagem de Impasses

DCC/FCUP Fernando Silva

Sistemas de Operao

36

Modelagem de Impasses
O grafo que modela o compartilhamento dos recursos: Pode ser usado para detectar se uma dada sequncia de solicitaes e de liberaes gera ou no um impasse. Pode ser usado pelo sistema operacional para tentar evitar a ocorrncia dos impasses. Pode ser facilmente estendido para vrios recursos de um mesmo tipo.

DCC/FCUP Fernando Silva

Sistemas de Operao

37

Modelagem de Impasses
Podemos usar quatro estratgias para tratar dos impasses: Ignorar totalmente a existncia dos impasses. Detectar o impasse e recuperar o sistema aps a ocorrncia deste impasse. Evitar a ocorrncia dos impasses em tempo de execuo, ao alocar os recursos aos processos. Impedir ocorrncia de impasses, denindo regras que impedem a existncia de uma das quatro condies necessrias.

DCC/FCUP Fernando Silva

Sistemas de Operao

38

Deteco e Recuperao
O sistema usa o grafo de recursos para detectar os impasses e recuperar o sistema deste erro: O sistema atualiza o grafo a cada solicitao ou liberao de um recurso. Se o sistema detectar um ciclo no grafo: Um processo do ciclo, escolhido aleatoriamente, terminado, e os seus recursos so liberados. A escolha continua at que o grafo seja acclico. Problema 1: nem sempre possvel reiniciar um processo. Problema 2: reverter todas as alteraes feitas durante a execuo de cada um dos processos terminados.

DCC/FCUP Fernando Silva

Sistemas de Operao

39

Deteco e Recuperao (cont.)

Outra idia, mais simples: eliminar um processo que esteja bloqueado por um longo perodo de tempo. Esta estratgia em geral usada nos sistemas de lote dos computadores de grande porte.

DCC/FCUP Fernando Silva

Sistemas de Operao

40

Inanio (Starvation)

Inanio (starvation) verica-se quando um processo ca espera da vez de acesso a um semforo por tempo indenido. O processo est em execuo mas no consegue acesso ao recurso.

DCC/FCUP Fernando Silva

Sistemas de Operao

41

Monitor (Hoare 1974 e Hansen 1975)

primitiva de alto-nvel para sincronizao de processos concorrentes no acesso a recursos partilhados. um tipo-abstrato de dados, constitudo por variveis, estruturas de dados e procedimentos que operam sobre essas variveis e estruturas de dados. um programa apenas tem acesso aos procedimentos do monitor. goza da seguinte propriedade: em qualquer instante, apenas pode estar um processo ativo dentro do monitor. Esta propriedade garante excluso mtua.

DCC/FCUP Fernando Silva

Sistemas de Operao

42

Monitor (Hoare 1974 e Hansen 1975) (cont.)

se um processo invoca um procedimento do monitor (i.e. pretende entrar no monitor), e existir outro processo ativo dentro do monitor, suspenso e colocado numa la de espera, entrada, at que o outro processo deixe o monitor. os procedimentos incluem em si as zonas crticas de cdigo nas quais se pretende garantir excluso mtua. nas zonas crticas, e quando o processo no puder continuar a executar parte do cdigo, interessa-nos permitir que um processo possa suspender a execuo numa condio: variveis de condio + operaes cwait() e csignal().

DCC/FCUP Fernando Silva

Sistemas de Operao

43

Monitores: variveis de condio + cwait() e csignal()

as variveis de condio so denidas por (depende da linguagem!): CondVar x; x varivel de condio. cwait(x): o processo que executa a operao suspende na varivel de condio x, at que outro processo sinalize esta varivel. csignal(x): o processo que executa a operao acorda um dos processos suspensos (normalmente o primeiro da la) nesta varivel de condio. Quando um processo suspende dentro do monitor por ao de cwait(), o monitor ca livre para acesso por outro processo.

DCC/FCUP Fernando Silva

Sistemas de Operao

44

Monitores: variveis de condio + cwait() e csignal()

como csignal(x) acorda um dos processos suspensos em x, como evitar que estejam dois processos ativos dentro do monitor. Duas estratgias: (Hansen) o processo que faz o csignal() deixa de imediato o monitor. csignal() a ltima instruo do procedimento! (Hoare) o processo que foi acordado deve executar de imediato, suspendendo-se o processo que fez o csignal(). A soluo de Hansen a mais simples de concretizar e normalmente a usada. as variveis de condio no acumulam os sinais.

DCC/FCUP Fernando Silva

Sistemas de Operao

45

Estrutura de um monitor
Fila de Processos para entrar no Monitor Area de espera entrada Monitor mutex de acesso a fila.

condicao c1 cwait(c1)

variaveis e estruturas de dados locais

variaveis de condicao condicao c2 cwait(c2)

. . .

procedimento 1

condicao cn cwait(cn)

. . .
procedimento k

fila-urgente csignal Codigo Inicializacao

saida

DCC/FCUP Fernando Silva

Sistemas de Operao

46

Exemplo com monitores: Produtor/Consumidor

1 2 3 4 5 6 7 8 9 10 11 12 13 14

MONITOR PC { int buf [ N ] , first , last ; int ctr ; CondVar naoCheio , naoVazio ; void adicionar ( int val ) if ( ctr==N ) cwait ( naoCheio ) ; buf [ first ] = val ; first= ( first +1) % N ; ctr ++; if ( ctr ==1) csignal ( naoVazio ) ; }

/ * b u f f e r e v a r s . de acesso * / / * num . elementos no b u f f e r * / / * v a r s . de condio */ */

{ / * b u f f e r c h e i o ?

/ * adiciona valor a buffer * / / * deixou de e s t a r v a z i o ? * /

DCC/FCUP Fernando Silva

Sistemas de Operao

47

Exemplo com monitores: Produtor/Consumidor

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

int retirar ( ) { int val ; if ( ctr ==0) cwait ( naoVazio ) ; val=buf [ last ] ; last= ( last +1) % N ; ctr; if ( ctr ==( N1) ) csignal ( naoCheio ) ; return val ; } void init ( ) { first=last=ctr= 0 ; } } / * FimMonitor * / / * b u f f e r v a z i o ? / * r e t i r a v a l o r do b u f f e r */ */

/ * deixou de e s t a r c h e i o ? * /

DCC/FCUP Fernando Silva

Sistemas de Operao

48

Exemplo com monitores: (cont.)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

produtor ( ) { int v ; while ( true ) { produz_item (& v ) ; PC . adicionar ( v ) ; } } main ( ) { PC . init ( ) ; if ( fork ( ) ==0) produtor ( ) ; else consumidor ( ) ; }

consumidor ( ) { int v ; while ( true ) { v= PC . retirar ( ) ; consome_item ( v ) ; } }

DCC/FCUP Fernando Silva

Sistemas de Operao

49

Exemplo com monitores: (cont.)

um dos problemas com monitores que poucas linguagens oferecem esta primitiva. contudo, possvel implement-la usando mutexs ou semforos. outro problema que no funciona para sistemas distribudos, pois requer memria partilhada na sua implementao.

DCC/FCUP Fernando Silva

Sistemas de Operao

50

Troca de Mensagens

mtodo de comunicao e sincronizao entre processos, pode ser usado em sistemas de memria partilhada ou distribuda. baseia-se em duas operaes: send( destino, mensagem): envia a mensagem para o processo destino. Este processo pode esperar ou no esperar que haja um processo pronto a receber. receive( origem, mensagem): recebe uma mensagem previamente enviada pelo processo origem. Se no existir mensagem em origem, o processo ou espera que a mensagem chegue ou prossegue e ignora o receive.

DCC/FCUP Fernando Silva

Sistemas de Operao

51

Troca de Mensagens (cont.)

O que conduz s seguintes formas de sincronizao: envio com bloqueio; recepo com bloqueio: ambos emissor e receptor bloqueiam at que consigam sincronizar para o envio/recepo da mensagem. Estratgia designada por rendez-vous. envio sem bloqueio; recepo com bloqueio: apenas o receptor bloqueia espera de receber a mensagem. o mtodo mais til, pois o envio mais rpido. envio sem bloqueio; recepo sem bloqueio: nenhuma das partes espera.

DCC/FCUP Fernando Silva

Sistemas de Operao

52

Implementao de Troca de Mensagens

Duas formas possveis, associadas ao tipo de endereamento dos processos: endereamento-direto os endereos dos processos destino e origem so conhecidos e xos partida. til em sistemas concorrentes. endereamento-indireto usa-se uma estrutura de dados intermdia, em memria partilhada, conhecida dos dois processos e atravs da qual enviam e recebem mensagens. Um exemplo tpico so as caixas-de-correio (mailboxs).

DCC/FCUP Fernando Silva

Sistemas de Operao

53

Processos a enviar P1

Processos a receber

Q1

Mailbox

P2

Q2

uma relao muitos-um (muitos a enviar e um a receber) til para interao do tipo cliente/servidor. Neste caso a mailbox designada por porta (port). relao um-muitos til para broadcast.

DCC/FCUP Fernando Silva

Sistemas de Operao

54

Excluso mtua com troca de mensagens

Considere um conjunto de processos P1 . . . Pn e uma mailbox, mutex, partilhada pelos processos. A mailbox inicializada com uma mensagem de contedo vazio. Um processo para entrar na zona crtica, tenta primeiro receber uma mensagem. Se a mailbox estiver vazia o processo bloqueia. Aps conseguir receber a mensagem, executa a zona crtica e envia a mensagem nula para a mailbox.
1 2 3 4 5 6

... receive ( mutex , msg ) ; zona_crtica ( ) ; send ( mutex , msg ) ; zona_no_crtica ( ) ; ...

A mensagem funciona como um testemunho que passa de processo

DCC/FCUP Fernando Silva Sistemas de Operao 55

para processo, e s quem tiver o testemunho que entra na zona crtica. Pressupostos desta soluo: se existir uma mensagem na mailbox, ela entregue a apenas um processo enquanto os outros cam bloqueados. se a mailbox estiver vazia, todos os processos cam bloqueados; quando chega uma mensagem, apenas um processo ativado e recebe a mensagem.

DCC/FCUP Fernando Silva

Sistemas de Operao

56

Exemplo de Troca de Mensagens: Produtor/Consumidor

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

produtor ( ) { ... while ( 1 ) { receive ( podeproduzir , pmsg ) ; pmsg= produz ( ) ; send ( podeconsumir , pmsg ) ; } } main ( ) { ... create_mailbox ( podeproduzir ) ; create_mailbox ( podeconsumir ) ; for ( i =0; i<N ; i ++) send ( podeproduzir , null ) ; if ( fork ( ) ==0) produtor ( ) ; else consumidor ( ) ; }

consumidor ( ) { ... while ( 1 ) { receive ( podeconsumir , cmsg ) ; consumir ( cmsg ) ; send ( podeproduzir , null ) ; } }

DCC/FCUP Fernando Silva

Sistemas de Operao

57

Observaes

A forma mais geral de comunicao entre processos atravs de memria partilhada. Os processos tm normalmente um espao de endereamento distinto, no entanto possvel denir zonas de memria comuns a dois ou mais processos, como j visto anteriormente. A vantagem da memria partilhada que podemos denir variveis ou estruturas de dados nesse espao e fazer uso como se de variveis locais se tratasse. O inconveniente que a sincronizao entre os processos, com vista a garantir excluso mtua, tem de ser feita por um dos mtodos vistos antes (test-and-set, semforos, etc.). As trocas de mensagens com recurso a mailboxs algo que se situa, em termos de funcionalidade, entre as pipes e a memria partilhada.

DCC/FCUP Fernando Silva

Sistemas de Operao

58

Problemas clssicos de IPC: O Jantar dos Filsofos

O problema deve-se a (Dijkstra 1965) e modela processos em competio para acesso exclusivo a um nmero limitado de recursos.
Descrio:
P0 P1

5 lsofos sentados a uma mesa; cada lsofo tem um prato com esparguete;

P4

para comer, um lsofo precisa de dois

P2

garfos; entre dois pratos existe apenas um garfo

P3

(no. garfos = no. lsofos).

DCC/FCUP Fernando Silva

Sistemas de Operao

59

O Jantar dos Filsofos (cont.)

A vida de um lsofo consiste em perodos alternados de comer e pensar. Quando tem fome, tenta obter o garfo esquerdo e depois o direito, um de cada vez. Caso consiga os dois garfos, come durante algum tempo, depois pousa os garfos e continua a pensar. Ser possvel escrever um programa que simule o comportamento dos lsofos (processos concorrentes) sem deixar que cheguem a uma situao de deadlock ou starvation? deadlock todos pegam em um garfo e cam espera de conseguir o segundo! starvation pegar e largar o garfo sem nunca conseguir os dois (os processos esto em execuo, mas no conseguem aceder aos recursos).

DCC/FCUP Fernando Silva

Sistemas de Operao

60

Soluo para o Jantar dos Filsofos

A execuo de um lsofo poderia corresponder a:
1 2 3 4 5 6

pensar ( ) ; pegar_garfo ( dir ) ; pegar_garfo ( esq ) ; comer ( ) ; pousar_garfo ( esq ) ; pousar_garfo ( dir ) ;

contudo esta soluo no funciona, porque permite situaes em que todos os lsofos peguem no garfo direito ao mesmo tempo, cando depois espera de conseguirem o garfo esquerdo. proteger o acesso zona crtica (i.e pegar nos dois garfos).

DCC/FCUP Fernando Silva

Sistemas de Operao

61

Soluo para o Jantar dos Filsofos (cont.)

Se usarmos apenas um mutex, resolvemos o problema mas camos com os lsofos a comer vez. Alternativas: associar um semforo por lsofo, permitindo-lhe suspender caso no consiga os dois garfos e esperar ser acordado por outros. associar um estado (pensar=0, fome=1, comer=2) a cada lsofo; assim, um lsofo s consegue os dois garfos, se: estiver com fome, e se o lsofo da esquerda e da direita no estiverem a comer.

DCC/FCUP Fernando Silva

Sistemas de Operao

62

Jantar dos Filsofos usando Semforos

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

Semforo mutex =1; / * c o n t r o l a acesso z o n a _ c r t i c a * / Semforo s [ N ] ; / * um semforo por f i l s o f o */ int estado [ N ] ; / * PENSAR=0 , FOME=1 , COMER=2 */ filosofo ( int i ) { while ( True ) { pensar ( ) ; pegar_garfos ( i ) ; comer ( ) ; pousar_garfos ( i ) ; } } pegar_garfos ( int i ) { DOWN (& mutex ) ; / * e n t r a r na zona c r t i c a */ estado [ i ] = FOME ; tentativa ( i ) ; / * t e n t a apanhar 2 g a r f o s */ UP (& mutex ) ; DOWN (& s [ i ] ) ; / * b l o q u e i a se no c o n s e g u i r * / } tentativa ( int i ) { if ( estado [ i ]== FOME && estado [ ESQ ] ! = COMER && estado [ DIR ] ! = COMER ) { estado [ i ] = COMER ; UP (& s [ i ] ) ; }

DCC/FCUP Fernando Silva

Sistemas de Operao

63

25 26 27 28 29 30 31 32 33 34 35

} pousar_garfos ( int i ) { DOWN (& mutex ) ; estado [ i ] = PENSAR ; tentativa ( ESQ ) ; / * v i z i n h o ESQ e s t comer ? * / tentativa ( DIR ) ; / * v i z i n h o DIR e s t comer ? * / UP (& mutex ) ; } main ( ) { int i ; for ( i =0; i<N ; i ++) if ( fork ( ) ==0) { filsofo ( i ) ; } }

DCC/FCUP Fernando Silva

Sistemas de Operao

64

Problemas clssicos de IPC: Leitores e Escritores

modela o acesso a uma base de dados. Ex: sistema de reserva de passagens areas. vrios leitores a acederem em simultneo; apenas um escritor pode estar a atualizar a base de dados, sem que qualquer outro processo, escritor ou leitor, tenha acesso. Solues: prioridade aos leitores. Se um escritor quiser atualizar a BD e existirem leitores a aceder, o escritor espera! prioridade dos escritores. enquanto houver um escritor que queira ou esteja a atualizar a BD, nenhum leitor pode conseguir o acesso. Qualquer das solues pode conduzir a starvation!.
DCC/FCUP Fernando Silva Sistemas de Operao 65

1 2 3 4 5 6 7 8 9 10 11 12 13 14

Semaforo mutex =1; Semaforo bd =1; int numLeit =0; escritor ( ) { while ( True ) { produz_dado ( ) down (& bd ) ; escreve_dado_bd ( ) up (& bd ) ; } }

leitor ( ) { while ( True ) { down (& mutex ) ; numLeit ++; if ( numLeit ==1) down (& bd ) ; up (& mutex ) ; le ( ) ; down (& mutex ) ; numLeit ; if ( numLeit ==0) up (& bd ) ; up (& mutex ) ; process_data_read ( ) ; } }

DCC/FCUP Fernando Silva

Sistemas de Operao

66

Problemas clssicos de IPC: o Barbeiro dorminhoco

1 barbeiro; 1 cadeira de barbeiro N cadeiras para os clientes esperarem.
Se no existirem clientes, o barbeiro senta-se e dorme. Quando chega um cliente, acorda o barbeiro. Se chegarem mais clientes enquanto o barbeiro estiver a cortar um cabelo, sentam-se, caso tenham cadeiras livres, ou deixam a barbearia (se as cadeiras estiverem ocupadas). Como evitar competio entre os processos cliente e barbeiro?

DCC/FCUP Fernando Silva

Sistemas de Operao

67

Problemas clssicos de IPC: o Barbeiro dorminhoco (cont.)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

Semaforo clientes =0; / * # c l i e n t e s espera de vez */ Semaforo barbeiros =0; / * # b a r b e i r o s espera de c l i e n t e s * / Semaforo mutex =1; / * sem . b i n r i o excluso mtua */ int sentados =0; / * # c l i e n t e s sentados */ barbeiros ( ) { while ( 1 ) { down ( clientes ) ; / * existem c l i e n t e s ? se no adormece * / down ( mutex ) ; sentados ; / * menos um c l i e n t e espera */ up ( barbeiros ) ; / * menos um b a r b e i r o adormecido */ up ( mutex ) ; cortar ( ) ; } } clientes ( ) { / * se no existem c a d e i r a s l i v r e s * / down ( mutex ) ; if ( sentados <NCads ) { / * v a i embora ; se existem e n t r a * / sentados ++; / * mais um c l i e n t e espera */ up ( clientes ) ; / * acorda b a r b e i r o se n e c e s s r i o * / up ( mutex ) ; / * l i b e r t a zona c r t i c a */ down ( barbeiros ) ; / * adormece se no h b a r b e i r o s * / sentar_e_cortar ( ) ; / * l i v r e s */ } else up ( mutex ) ; }

DCC/FCUP Fernando Silva

Sistemas de Operao

68