Sistemas Operacionais Sincronização e Comunicação entre Processos

Transcrição

1 Universidade Estadual de Mato Grosso do Sul UEMS Curso de Licenciatura em Computação Sistemas Operacionais Sincronização e Comunicação entre Processos Prof. José Gonçalves Dias Neto profneto_ti@hotmail.com

2 Comunicação entre processos A bufferização (Buffering) é uma forma de se estabelecer comunicação entre processos; Dois processos concorrentes, podem compartilhar um buffer para troca de informações através de operações de gravação e escrita; Um processo só pode gravar no buffer caso este não esteja cheio; Um processo só pode ler dados armazenados, caso exista algum dado para ser lido; Em ambos, os processos devem aguardar o buffer estar pronto.

3 Comunicação entre processos Mecanismos de sincronização: Mecanismos que garantem a comunicação entre processos concorrentes e o acesso a recursos compartilhados. Estes mecanismos são essenciais para garantir a integridade e confiabilidade na execução de aplicações concorrentes;

4 Especificação de Concorrência em Programas PARBEGIN: Comando que especifica que a sequencia de comandos seja executada concorrentemente em ordem imprevisível através da criação de um processo; PAREND: Define um ponto de sincronização, onde o processamento só continua quando todos os processos ou threads já tiverem terminado suas execuções.

5 Exemplo void Expressao(){ float X, Temp1, Temp2, Temp3; PARBEGIN Temp1 = SQRT(1024); Temp2 = 35,4*0,23; Temp3 = 302/7; PAREND; X = Temp1 + Temp2 Temp3; printf( X = %f, X);

6 Problemas de Compartilhamento de Recursos Imagine um programa de gerenciamento de contas correntes de um banco. Dois programas acessam o arquivo de contas correntes, recuperam o saldo do mesmo cliente e lançam duas despesas distintas. O que de errado pode acontecer, caso façam isto concorrentemente??

7 Problemas de Compartilhamento de Recursos Programa 1: Lê o saldo do cliente (R$ 2.000); Programa 2: Lê o saldo do cliente (R$ 2.000); Programa 1: Soma um débito ao saldo (- R$ 250); Programa 2: Soma um débito ao saldo (- R$ 100); Programa 1: Salva o valor do saldo lido + debito; Programa 2: Salva o valor do saldo lido + debito; Quanto o cliente possui na conta agora? Quanto deveria possuir?

8 Exclusão Mútua (Mutual Exclusion) Impede que dois ou mais processos acessem um mesmo recurso simultaneamente. Enquanto um processo estiver acessando um recurso, todos os demais processos que queiram acessá-lo deverão esperar pelo termino da utilização do recurso. Utilizada apenas quando um processo utiliza um recurso compartilhado. O código do programa onde é feito o acesso ao recurso compartilhado é denominada região critica (Critical Region).

9 Exclusão Mútua (Mutual Exclusion) Os mecanismos que implementam a exclusão mutua utilizam de protocolos de acesso a região crítica; Os protocolos de entrada e de saída garantem a exclusão mútua da região crítica de um programa;

10 Exclusão Mútua (Mutual Exclusion) Programa 1: Caso dos programas de conta bancária: verifica se existe outro programa utilizando o recurso; Como não existe, o programa 1 indica que usará o arquivo; Programa 2: Verifica se existe outro programa utilizando o recurso; Como o programa 1 está utilizando, o programa 2 fica aguardando a saída do programa 2 da região crítica; Programa 1: Efetua o débito, atualiza o saldo da conta e indica que saiu da região crítica; Programa 2: recebe a informação que a região crítica está disponível, indica que usará o arquivo, efetua o débito, atualiza o saldo da conta e indica que saiu da região crítica.

11 Exclusão Mútua - Starvation Starvation: Situação onde um processo nunca consegue executar sua região crítica e, consequentemente acessar o recurso. Starvation acontece em função do critério de escalonamento (todos são postos para executar, menos determinado processo); Possível solução para starvation é a organização de filas segundo critério FIFO. Vilão fila por prioridade

12 Exclusão Mútua Processo fora da região crítica pode impedir que outros processos entrem nas suas próprias regiões criticas; Problema voltado a esquecimentos ou finalizações erradas; Um processo pode entrar na região critica bloqueando os outros, e ao sair não desbloqueá-la.

13 Soluções para exclusão mútua Soluções em Hardware: Desabilitação de interrupções; Instrução test-and-set; Soluções em Software: Implementação de algorítmos (Dekker, Peterson)

14 Hardware Desabilitação de interrupções Considerada a solução mais simples de ser implementada; O processo que acessa a região crítica, desabilita todas as interrupções ao entrar e as reabilita ao sair. Mudanças de contexto de processos são executadas apenas através de interrupções. Pode ocorrer complicações de sincronização devido a esquecimentos de processos.

15 Hardware Desabilitação de interrupções Problema agravado em ambientes multiprocessados; O mecanismo de clock é implementado sobre interrupções; Solução utilizada quando precisa-se garantir atomicidade de pequenos grupos de instruções;

16 Hardware Instrução test and set Muitos processadores possuem esta instrução; A instrução lê uma variável, armazena seu conteúdo em uma outra área e atribui um novo valor a mesma variável; Trata-se de uma instrução indivisível; Isso garante que outros processos não manipulem a mesma área ao mesmo tempo; Test and set(x,y);

17 Soluções de Software Solução dependente do algoritmo implementado; Os primeiros algoritmos tratavam inicialmente de apenas 2 (dois) processos e apresentavam problemas;

18 Algorítmo 1 void Processo_A(){ repeat while (vez == 'B'); Região_Crítica_A; vez = 'B'; Processamento_A; until (false); void Processo_B(){ repeat while (vez == 'A'); Região_Crítica_B; vez = 'A'; Processamento_B; until (false); Int main(){ vez = 'A'; PARBEGIN Processo_A(); Processo_B(); PAREND; return 0;

19 Algorítmo 1 - Análise O mecanismo é utilizável apenas por 2 (dois) processos; O acesso é sempre de maneira alternada; Mesmo que um processo A seja de execução mais rápida, sua velocidade ao final será dependente da velocidade de B; Se o processo A demorar muito no processamento, poderá afetar o acesso do processo B a região crítica, mesmo que o processo A não esteja utilizando o recurso;

20 Algorítmo 2 void Processo_A(){ repeat while (CB); CA = true; Região_Crítica_A; CA = false; Processamento_A; until (false); void Processo_B(){ repeat while (CA); CB = true; Região_Crítica_B; CB = false; Processamento_B; until (false); Int main(){ CA = false; CB = false; PARBEGIN Processo_A(); Processo_B(); PAREND; return 0;

21 Algorítmo 2 - Análise Caso um processo tenha problema dentro da região critica ou antes de alterar a variável, o outro permanecerá indefinidamente bloqueado.

22 Algorítmo de Peterson void Processo_A(){ repeat CA = true; vez = 'B'; while (CB && vez == 'B'); Região_Crítica_A; CA = false; Processamento_A; until (false); void Processo_B(){ Repeat CB = true; vez = 'A'; while (CA && vez == 'A'); Região_Crítica_B; CB = false; Processamento_B; until (false); Int main(){ CA = false; CB = false; PARBEGIN Processo_A(); Processo_B(); PAREND; return 0;

23 Algorítmo de Peterson - Análise Apesar de sua implementação para dois processos, pode ser generalizada para N destes; CA e CB indicam a intenção de cada processo de entrar na região crítica; Variável vez resolve os conflitos gerados pela concorrência; Além de garantir a exclusão mútua, a starvation de um processo nunca ocorrerá (variável vez);

24 Sincronização Condicional Situação em que o acesso ao recurso compartilhado exige a sincronização de processos vinculada a uma condição de acesso. Caso da comunicação através de buffer; Problema do produtor/consumidor;

25 Semáforos Conceito proposto por E.W Dijkstra (1963); Um dos principais mecanismos utilizados em projetos de sistemas operacionais; Consiste em uma variável inteira não negativa que só pode ser manipulada por duas rotinas: UP e DOWN; UP incrementa a variável, DOWN decrementa; Semáforos podem ser binários (Mutexes Mutual Exclusion Semaphores) ou contadores;

26 Exclusão Mútua - Semáforos A exclusão mútua pode ser implementada através da utilização de um semáforo binário; Instruções DOWN e UP funcionam como protocolos de entrada e saída, respectivamente; Semáforo com valor 1 indica recurso liberado, já com valor 0 indica a utilização do recurso; Ao entrar na região crítica o processo executa uma operação DOWN no semáforo, ao sair executa a operação UP, assim outro processo pode utilizá-la.

27 Exclusão Mútua - Semáforos

28 Exclusão Mútua - Semáforo #<bibliotecas>; int semaforo = 1; void Processo_A(){ repeat DOWN(semaforo); Região_Crítica_A; UP(semaforo); until (false); void Processo_B(){ repeat DOWN(semaforo); Região_Crítica_B; UP(semaforo); until (false); UP(int semaforo){ if(semaforo == 0 && existe_processo_bloqueado()) desbloqueia_processo(); else semaforo++; DOWN(int semaforo){ if(semaforo == 0) bloqueia_processo(); else semaforo ; Int main(){ PARBEGIN Processo_A(); Processo_B(); PAREND; return 0;

29 Sincronização Condicional - Semáforos Os semáforos também podem ser utilizados nos casos de sincronização condicional; Utilizados principalmente no caso produtor/consumidor; Se o buffer estiver vazio a operação DOWN(cheio) deixa o consumidor em espera; Apos a gravação de dados pelo produtor este executa UP(cheio) liberando o consumidor;

30 Produtor/Consumidor - Semáforos #<bibliotecas>; int vazio = 2; Int cheio = 0; Int mutex = 1; void Produtor(){ repeat Produz_Dado(); DOWN(vazio); DOWN(mutex); Grava_Buffer(Dado_1, Buffer); UP(mutex); UP(cheio); until (false); void Consumidor(){ repeat DOWN(cheio); DOWN(mutex); Consome_Dado(Dado_2); UP(mutex); UP(vazio); until (false); Int main(){ PARBEGIN Produtor(); Consumidor(); PAREND; return 0;

31 Troca de mensagens Semáforos e monitores não são implementados diretamente pelas linguagens como C/C++, Java, Pascal. Cabe ao programador (masoquista) implementálos manualmente e imbuti-los em bibliotecas; Um descuido com as variáveis e o sistema pode ocasionar deadlocks;

32 Deadlocks - impasses O deadlock ocorre com um conjunto de processos e recursos não-preemptíveis, onde um ou mais processos desse conjunto está aguardando a liberação de um recurso por um outro processo que, por sua vez, aguarda a liberação de outro recurso alocado ou dependente do primeiro processo. (wikipedia) É a situação em que um processo aguarda por um recurso que nunca estará disponível ou um evento que não ocorrerá. (Machado, Maia)

33 Deadlocks -Impasses

34 Deadlocks - Impasses

35 Jantar dos Filósofos Problema clássico de sincronização de processos; Adivinha quem propôs o problema? Dijkstra Consiste em ter 5 filósofos dispostos em uma mesa redonda para jantar espaguete; A mesa possui 5 pratos, um para cada filósofo; Entre cada prato possui um garfo (5 garfos); Um filósofo pode comer e pensar; Para comer, um filósofo necessita de dois garfos; Cada filósofo só pode pegar um garfo por vez; Ao comer, o filósofo usa os garfos e após alguns instantes deve obrigatoriamente soltá-los;

36 Jantar dos filósofos

37 Solução óbvia void filosofo(int i){ while(true){ pense(); pegar_garfo(esquerda); pegar_garfo(direita); comer(); soltar_garfo(esquerda); soltar_garfo(direita); Isto funciona? Por que?

38 Problemas da solução anterior Caso todos os filósofos pegue o garfo do mesmo lado ao mesmo tempo, deadlock ocorrerá; A solução seria, após pegar o garfo, verificar se o do outro lado está em uso, caso esteja, soltar o garfo que havia pego. (mas não funciona starvation); Esperar tempos aleatórios seria uma solução, mas isso não garante 100% dos casos;

39 Solução Jantar dos Filósofos void filosofo(int i){ while(true){ pense(); pegar_garfos(i); comer(); soltar_garfos(i); void pegar_garfos(int i){ DOWN(&mutex); state[i] = FAMINTO; teste(i); UP(&mutex); DOWN(&S[i]); void soltar_garfos(int i){ DOWN(&mutex); state[i] = PENSANDO; teste(esquerda); teste(direita); UP(&mutex); Void teste(int i){ if(state[i] == FAMINTO && state(esquerda)!= COMENDO && state(direita)!= COMENDO{ state[i] = COMENDO; UP(&S[I]);

40 Problema do Barbeiro Um barbeiro precisa atender clientes sem sua barbearia; Na barbearia existe uma cadeira de barbeiro e N cadeiras para clientes esperarem; Caso o barbeiro não tenha clientes, ele se senta e dorme; Quando um cliente chega: Se o barbeiro tiver trabalhando e houver cadeira de espera disponível, o cliente se senta, caso todas as cadeiras estejam ocupadas o cliente vai embora sem atendimento; A solução proposta utiliza três semáforos: clientes: um semáforo contador; barbeiro e mutex: semáforos binários.

41 Solução problema do Barbeiro void barbeiro(){ while(true){ DOWN(clientes); DOWN(mutex); espera ; UP(barbeiro); UP(mutex(); corta_cabelo(); void cliente(){ DOWN(mutex); if(espera < cadeiras){ espera++; UP(clientes); UP(mutex); DOWN(barbeiro); Ter_cabelo_cortado(); eles UP(mutex);