Problemas relacionados a exclusão mútua

Transcrição

1 Problemas relacionados a exclusão mútua Deadlock: um conjunto de processos fica bloqueado, cada um a espera de um recurso que o outro detém. Starvation: alguns processos são repetidamente preteridos, enquanto outros ficam com o acesso ao recurso desejado. Exemplo: Considere uma estrada com uma ponte por onde só passa um carro de cada vez.

2 Deadlock Um carro começa a atravessar de cada um dos lados, e os dois se encontram no meio da ponte. Nenhum dos dois tem como continuar...

3 Deadlocks com semáforos detém ESPERA deseja deseja ESPERA detém P(sem_rec1); P(sem_rec2); P(sem_rec2); P(sem_rec1);

4 Deadlock em um sistema de Computação Impressora pertence a João Maria precisa da impressora Impressora João Maria João precisa da unidade de cartucho unidade de cartucho unidade pertence a Maria

5 Starvation Se, ao chegar à ponte, há um carro já atravessando na direção desejada, o carro que chegou atravessa também. Se há alguém vindo em direção oposta, o carro que chegou espera até que este tenha acabado de cruzar. Pode nunca chegar a sua vez......

6 Starvation em um sistema de Computação Aberto LEITORES Fechado Abre Abre ESCRITORES

7 Problema dos Produtores e Consumidores ou do Buffer Limitado Dois processos concorrentes compartilham um buffer de tamanho fixo: Produtor: coloca dados em um buffer Consumidor: ler dados de um buffer Ordem dos eventos: Produtor coloca os dados Consumidor ler os dados Produtor dados buffer dados Consumidor

8 Exemplo com Semáforos Processo Produtor... P(s) Armazena_dados(d) V(s)... Processo Consumidor... P(s) Le_dados(d) V(s)...

9 Exemplo com Monitor Monitor prod-cons buffer: matriz[1..n]... Procedure Armazena_dados(dados) begin... End Procedure Le_dados(dados) begin... end Processo Produtor... Armazena_dados(d)... Processo Consumidor... Le_dados(d)...

10 Problema dos Produtores e Consumidores N = 100; /* número máximo de slots inteiro cont = 0; /* número de itens no buffer produtor() consumidor() { { Enquanto (TRUE) { Enquanto (TRUE) { produz_item(); if (cont == 0) sleep(); if (cont == N) sleep(); /* se buffer tá cheio, bloqueia remove_item(); entra_item(); /* coloca item no buffer cont = cont - 1; cont = cont + 1; if (cont == N-1) If (cont == 1) wakeup(consumidor); wakeup(produtor) } } } } OBS.: Solução com deadlock

11 Problema dos Produtores e Consumidores Situação de Deadlock Acesso ao contador (variável cont) Descrição: Buffer vazio => cont = 0 Consumidor ler valor de cont (cont = 0) Ocorre a interrupção da execução do Consumidor Produtor coloca item no buffer e incrementa cont (cont =1) Produtor conclui que consumidor está dormindo e chama a primitiva wakeup para acordá-lo Consumidor não está na lista de processos bloqueados, ele está pronto para ser executado Sinal emitido pelo wakeup é perdido Consumidor volta a executar e testa o valor de cont que ele leu (cont = 0) Consumidor irá dormir Quando o buffer encher, o Produtor irá dormir Os dois processos dormirão eternamente => DEADLOCK

12 Problema dos Leitores e Escritores semáforo scl = 1; /* semáforo para acesso exclusivo a variável compartilhada cont_leitores semáforo sbd = 1; /* semáforo para acesso exclusivo ao banco de dados inteiro cont_leitores; leitor() escritor() { { Enquanto (TRUE) { Enquanto (TRUE) { wait(scl); /* acesso exclusivo a variável cont_leitores wait(sbd); cont_leitores = cont_leitores + 1; escreve(); } Se (cont_leitores == 1) wait(sbd); /* quando é o primeiro leitor signal(sbd); signal(scl); } ler_banco_de_dados(); wait(scl); cont_leitores = cont_leitores - 1; Se (cont_leitores == 0) signal(sbd); signal(scl); } OBS.: Solução com prioridade para os leitores, ocasionando Starvation para escritores.

13 Comunicação entre Processos Comunicação Memória Compartilhada Troca de Mensagens Em Sistemas Distribuídos não há memória compartilhada

14 Troca de Mensagens Na ausência de memória compartilhada: comunicação entre processos: TROCA DE MENSAGENS Primitivas para Comunicação: SEND(destino, mensagem) RECEIVE(origem, mensagem) Comunicação: Processo A -> Envia Mensagem Processo B -> Recebe Mensagem Envio da Mensagem: Receptor esperando para receber Receptor em qualquer estado

15 Tipos de Comunicação Comunicação Síncrona: troca de mensagens requer participação do emissor e do receptor há um sincronismo entre os dois processos (emissor e receptor) Comunicação Assíncrona: emissor pode enviar a mensagem em qualquer momento e continuar seu trabalho receptor pode pegar a mensagem em um momento posterior ao envio necessidade de um buffer para as mensagens Exemplo: Sistema Telefônico x Sistema de Correio Eletrônico

16 Exemplo de Comunicação Síncrona Produtor e Consumidor Processo Produtor... Repeat Produz_item() Monta msg(item) Send(consumidor, msg) Until False... Processo Consumidor... Repeat Receive(*,msg) Ler msg() Consome_item() Until False...

17 Programas de Aplicação X TCP/IP Como os programas de aplicação usam as facilidades oferecidas pelo TCP/IP para transmissão de suas mensagens? Os padrões não especificam como os programas de aplicação interagem com a implementação do protocolo TCP/IP (Interface Não Padronizada!!!) A interface fica a cargo do Sistema Operacional

18 Apoio à Programação Distribuída bibliotecas bibliotecas+ferramentas linguagens de programação distribuídas plataformas de Middleware flexibilidade de programação facilidade de desenvolvimento e reuso

19 Bibliotecas Uso de uma linguagem de programação tradicional com chamadas a uma biblioteca de programação distribuída. Exemplos: sockets (originalmente Unix): programação baseada no modelo cliente-servidor; pvm, p4, Express >> mpi: programação baseada na comunicação entre processos pares. Dados são transmitidos através de streams de bytes ou buffers - interpretação correta fica por conta do programa.

20 Socket Forma de Comunicação entre Processos disponível no UNIX BSD UNIX BSD (Berkeley) System V (AT&T) Socket TLI (Transport Layer Interface) Usado para um processo comunicar-se com outro que esteja em uma máquina qualquer Idéia similar a de descritor de arquivos O Socket é identificado por um inteiro chamado descritor do socket descritor_do_socket = socket()

21 Socket Socket: Espera uma conexão Inicia uma conexão Socket Passivo: espera por uma conexão (usado por Servidores) Socket Ativo: Inicia uma conexão (usado pelos Clientes) Complexidade do Socket: parâmetros que o programador pode setar

22 Socket Exemplo de alguns parâmetros: Transferência de: stream (TCP) datagrama (UDP) endereço remoto: específico (geralmente usado pelo cliente) inespecífico (geralmente usado pelo servidor)

23 TCP/IP Protocolo de Comunicação Não estabelece como o Sistema Operacional (SO) vai se comunicar com ele. A interface do SO é responsável pela comunicação com o TCP/IP O UNIX faz isso usando socket. TCP/IP estabelece uma abstração chamada Porta.

24 Chamadas usadas no Socket socket( ) -> cria um socket usado para comunicação e retorna um descritor connect( ) -> depois de criar um socket um cliente chama connect para estabelecer uma conexão com um servidor, usando o descritor do socket write( ) -> para enviar dados através de uma conexão TCP read( ) -> para receber dados através de uma conexão TCP close( ) -> para desalocar o socket. bind( ) -> usado por servidores para especificar uma porta na qual ele irá esperar conexões. listen( ) -> servidores chamam o listen para colocar o socket no modo passivo e torná-lo disponível para aceitar conexões accept( ) -> depois que um servidor chama socket para criar um socket, bind para especificar seu endereço e listen para colocá-lo no modo passivo, ele deve chamar o accept para pegar a primeira solicitação de conexão na fila.

25 Exemplo do Uso de Socket SERVIDOR socket bind listen accept bloqueia até chegar uma conexão do cliente read write conexão estabelecida dados CLIENTE socket connect write close dados read close

26 Definições de Constantes #define SERV_TCP_PORT 6543 #define SERV_HOST_ADDR

27 Código do Servidor usando o Protocolo TCP/IP main(int argc, char *argv[]) { int sockfd, newsockfd, tam_cli, filho_pid; struct sockaddr_in cli_addr, serv_addr; if ((sockfd = socket(af_inet, SOCK_STREAM, 0)) < 0) /* abre um socket TCP */ erro; /* Liga o processo servidor ao seu endereço local */ bzero((char *)&serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = htonl(inaddr_any); serv_addr.sin_port = htons(serv_tcp_port); if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) erro; listen(sockfd, 5); for (;;) { newsockfd = accept(sockfd, (struct sockaddr *)&cli_addr, &tam_cli); if (newsockfd <0) erro; if (( filho_pid = fork()) < 0) erro; else if (filho_pid == 0) { /* processo filho */ close(sockfd); /* fecha o socket original */ str_echo(newsockfd); /* processa a solicitação */ exit(); } close(newsockfd); /* processo pai */ } }

28 Código do Cliente usando o Protocolo TCP/IP main(int argc, char *argv[]) { int sockfd; struct sockaddr_in serv_addr; if ((sockfd = socket(af_inet, SOCK_STREAM, 0)) < 0) /* abre um socket TCP */ erro; /* Preenche a estrutura serv_addr com o endereço do servidor com o qual ele deseja se conectar*/ bzero((char *)&serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = inet_addr(serv_host_addr); serv_addr.sin_port = htons(serv_tcp_port); if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) erro; str_cli(stdin, sockfd); /* envia a solicitação */ close(sockfd); exit(); } }

29 Rotina Auxiliar do Servidor de Echo /* Rotina que lê um stream de uma linha e envia a linha de volta ao cliente */ #define MAXLINE 512 str_echo(int sockfd) { int n; char line[maxline]; for (;;) { n = readline(sockfd, line, MAXLINE); if (n ==0 ) return; /* termina a conexão */ else if (n < 0) erro; if (writen(sockfd, line, n)!= n) erro; } }

30 Rotina Auxiliar do Cliente /* Rotina que lê o conteúdo do arquivo FILE *fp, escreve cada linha no socket, lê uma linha de volta do socket, e escreve esta linha na saída padrão */ #define MAXLINE 512 str_cli(file *fp, int sockfd) { int n; char sendline[maxline], recvline[maxline + 1]; While (fgets(sendline, MAXLINE, fp)!= NULL) { n = strlen(sendline); if (writen(sockfd, sendline, n)!= n) erro; n = readline(sockfd, recvline, MAXLINE); /* lê a linha enviada pelo servidor */ if ((n < 0) erro; fputs(recvline, stdout); /* imprime a linha na saída padrão */ if (writen(sockfd, line, n)!= n) erro; } }

31 Chamadas do Socket Socket(int family, int type, int protocol) AF_INET AF_UNIX AF_NS SOCK_STREAM SOCK_DGRAM 0 sockfd = socket(af_inet, SOCK_STREAM, 0)

32 Chamadas do Socket bind(int sockfd, struct sockaddr *addr, int addrlen) endereço específico de protocolo tamanho da estrutura de endereço sockfd = socket(af_inet, SOCK_STREAM, 0)

33 Usos do Bind Servidor registrar seu endereço Cliente registrar seu endereço Cliente usando protocolo sem conexão solicitar ao sistema a atribuição de um endereço

34 Endereçamento O socket oferece uma estrutura diferente para cada protocolo onde o programador especifica os detalhes de endereçamento Para o protocolo TCP/IP a estrutura sockaddr_in especifica o formato de endereço struct sockaddr_in { u_short sin_family; /* tipo de endereço */ u_short sin_port; /* número da porta */ u_long sin_addr; /* endereço IP */ }

35 Definindo o endereço de um servidor struct sockaddr_in { u_short sin_family; /* tipo de endereço */ u_short sin_port; /* número da porta */ u_long sin_addr; /* endereço IP */ } struct sockaddr_in serv_addr; bzero((char *)&serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = htonl (INADDR_ANY) serv_addr.sin_port = htons( 6644 )

36 Portas Formas de Processos serem associados a uma porta: o processo solicita uma porta específica (tipicamente usado por servidores) o sistema automaticamente atribui uma porta para o processo (tipicamente usado por clientes) o processo especifica porta = 0 antes de fazer a chamada ao bind. O bind atribui uma porta automaticamente

37 TCP/IP - Tabela de Portas Portas reservadas Portas automaticamente atribuídas pelo sistema

38 Funções para conversão para formato padrão u_long htonl(u_long hostlong) host network long u_short htons(u_long hostshort) host network short

39 Operações sobre Bytes Não são manipuladas por operações padrão sobre strings pois: Não terminam com nulo Podem ter bytes nulos dentro deles bcopy(char *src, char *dest, int nbytes) Move o nbytes da origem (src) para o destino bzero(char *dest, int nbytes) zera nbytes do destino int bcmp(char *ptr1, char *ptr2, int nbytes) Compara dois strings. Retorna 0 se os dois são idênticos.

40 INADDR_ANY Para máquinas com duas interfaces de rede, usa-se o INADDR_ANY para estabelecer que o servidor está escutando nas duas redes Rede A Rede B

41 I/O Assíncrono Processo informa ao kernel para notificá-lo quando um determinado descritor está pronto para I/O. Processo Kernel signal

42 I/O Assíncrono Processo usa a função signal para estabelecer um handler para o sinal SIGIO Processo usa a função fcntl para setar o ID do processo para receber sinais SIGIO. Processo habilita o I/O assíncrono usando a chamada fcntl

43 Desvantagem O processo pode ter somente um handler para um dado sinal Se o I/O assíncrono é habilitado para mais que um descritor, quando o sinal chega, o processo não sabe qual descritor está pronto para I/O

44 Select Chamada do sistema que permite que um processo instrua o kernel para observar múltiplos eventos e acorda-lo quando um dos eventos acontecer Útil para o kernel ser instruído para notificar o processo apenas quando dados estão disponíveis em um dos sockets, arquivos,... usados pelo processo => Servidores que administram vários serviços

45 Chamada Select int select(int ndesc, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); ndesc número de descritores a serem testados readfds, writefds, exceptfds descritores de arquivos observados (pronto para leitura, pronto para escrita e de exceções) timeout: - quando diferente de NULL e de zero, aponta um intervalo de tempo fixo para a chamada ficar monitorando os descritores. - igual a NULL, o select permanece indefinidamente monitorando os descritores - igual a zero, a chamada retorna imediatamente após verificar os descritores