1

Programação concorrente:Problemas, comunicação e sincronização de processo

*baseado no material do Prof. Orlando Loques - IC/UFF

Referências:

- Capítulo 2, Modern Operating Systems, A. Tanenbaum- Capítulo 5, Operating Systems: Internals and Design Principles, Willian Stallings- Capítulo 6, Operating System Concepts, Silberschatz & Galvin- http://www.cne.gmu.edu/modules/ipc/- Apostila

2

• Um sistema operacional executa uma variedade de programas de forma “simultânea”

• Livros usam os termos job e processo quase que indeterminadamente.

• Processo – um programa em execução; execução do processo deve progredir de maneira seqüencial.

• Tecnicamente um processo é criado quando um outro processo faz uma chamada ao sistema de criação de processos - Fork clone identico ao processo que o chamou

• Inicialização de processos em segundo plano pelo - Daemons

Conceito de processo

3

• Durante a execução de um processo, ele altera seu estado–Novo (new): O processo está sendo criado.–Executando (running): instruções estão sendo executadas.–Esperando (waiting): O processo está esperando algum evento acontecer.

–Pronto (ready): O processo está esperando ser associado a um procesador.

–Terminado (terminated): O processo terminou sua execução.

Estados do processo

4

Diagrama de estados do processo

5

Tipos de Processamento Concorrente

• Multiprogramação: vários processos em um sistema monoprocessador

• Multiprocessamento: vários processos em um sistema multiprocessador (memória comum - acesso compartilhado)

• Processamento Distribuído: vários processos executando em vários (multi) processadores distribuídos (memória privada - acesso exclusivo)

6

Programação Concorrente• Conceitos e mecanismos para expressar paralelismo potencial

• Facilita a solução de problemas inerentes associados ao compartilhamento de recursos, à sincronização e à comunicação de processos

• Provê as abstrações de programação para o tratamento de situações comuns, existentes no mundo real

• sistemas operacionais• sistemas de comunicação• sistemas de controle de processos (embutidos)

• Pode ser suportada através do compartilhamento de um único processador ou por vários processadores operando em paralelo

• Leva a sistemas eficientes, modulares e bem estruturados

7

Concorrência: utilizações

• Compartilhamento de recursos

• Sincronização de processos

• Comunicação entre processos

8

Exemplo de CompartilhamentoAtualização de uma variável compartilhada, exemplo: saldo bancário

var V:integer; // valor do saldo...processo T_1; begin

.

. | V = V +1; <---------------|

. |

. end;

processo T_2; begin

.

. | V = V +1; <---------------|

. |

. end;

{ sequência de instruções }

load Vadd 1store v

load Vadd 1store v

9

Sequência de Execução

Processo

1

2

1

2

1

2

Ação

load V

load V

add 1

add1

store V

storeV

Valor de V

4

4

-

-

5

5

tempo

10

Outro Exemplo

procedure echo;var out, in: character;begininput(in, keyboard);out := in;output(out, display)

end.

Programa simplesmente lê um valor e o imprime

11

P1, P2 executando em processadores separados

Process P1 --- echo• input(in,keyboard) “x”• out := inoutput(out,display)• •

Process P2 --- echo• • input(in,keyboard) ”y”out := in• output(out,display)•

P1 e P2 concorrentesSaídas: “yy” ou “xx” ?!

P1 e P2 exclusivosSaída: “xy” ok!

Entrada: “xy”

Cada processo tem uma linha de código executada por vez de forma alternada...

12

• Processos trocam dados, as vezes, através de memória–Principal, arquivo...

• Região/seção crítica–Porção de programa que pode levar a condição de disputa

• Tipo de memória não altera o problema–Alguma forma de garantir que apenas 1 esteja na região crítica

Condições de corrida (Race Conditions)

13

• Condições de Corrida:–Situações onde dois ou mais processos estão acessando dados compartilhados.

–O resultado final pode variar de acordo com a ordem de execução.

• Mecanismo de Sincronização.–Garante o compartilhamento de recursos e a comunicação entre os processos.

–Garante a integridade e a confiabilidade dos dados compartilhados.

Condições de corrida (Race Conditions)

14

• Exemplo 1:

–Resultado Final: Contador = 6 (ERRO!)

7Processo

A7+1

ProcessoB

7-1

1

72

7

5

8

3 4

6

6

Condições de corrida (Race Conditions)

15

• Exemplo 2:

–Valor armazenado peloprocesso B é perdido.

65

4

3

próximaentrada

7

ProcessoA

ProcessoB

1

7

suspensorecebe CPU

2

8

recebe CPUsuspenso

3

7

4

75

8

6

X

10

Y 9

8

Condições de corrida (Race Conditions)

16

• Região Crítica:–Parte do código onde é feito acesso a recursos compartilhados, e que podem levar a condições de corrida.

• Ex: Processo A.–Código normal–Início da Seção Crítica (Protocolo de Entrada)– Seção Crítica–Término da Seção Crítica (Protocolo de Saída)–Código normal

Condições de corrida (Race Conditions)

17

• Enquanto um processo estiver usando um recurso, os outros devem aguardar até que o recurso esteja liberado.

• Exclusão Mútua.–Exclusividade no acesso a um determinado recurso.

• A exclusão mútua deve afetar os processos concorrentes quando um deles estiver em uma região crítica.

Condições de corrida (Race Conditions)

18

• Como evitar condições de disputa?–Implementar exclusão mútua–Um por vez junto à região

• Garantir que dois ou mais processos estarão sincronizados, e só um dentro da região crítica–Operando sobre dados compartilhados

Regiões críticas

19

• Quatro requisitos básicos para os algoritmos solucionarem o problema de região crítica

–Dois ou mais processos NUNCA podem estar simultaneamente na região crítica

–Não considerar velocidade relativas dos processos–Quem estiver fora da região não pode bloquear quem quer entrar

–Tem que entrar em algum momento!

Regiões críticas

20

Regiões críticas

Dois tipos de bloqueios

• Dois tipos de bloqueio são considerados básicos:– bloquear até que um recurso se torne

disponível;– bloquear até que chegue um sinal de outro

processo.

21

22

LocksConceito e Implementações

Locks - Funcionamento

23

Um processo só entra num trecho delimitado pelo par lock/unlock se nenhum outro processo está executando em um outro trecho delimitado dessa maneira.

Isto é, o primeiro processo que executa o comando lock passa e tranca a passagem (chaveia a fechadura) para os demais.

O comando unlock deixa passar (desbloqueia) o primeiro processo da fila de processos que estão bloqueados por terem executado um lock (enquanto a fechadura estava trancada). Se a fila está vazia, a fechadura é destrancada (isto é, é deixada aberta).

24

Solução: Locks (i)Definição:

Lock L = valor binário

L = 0 lock aberto; o processo prossegueL = 1 lock fechado; o processo espera

Tentativa de Implementação

• Lock (L) ::= while L=1 do nothing; L:= 1;

• UnLock (L) ::= L := 0;

Espera ocupada

o processo esperando em um lock fica em loop,

usando inutilmente o processador.

Isso pode degradar o desempenho do sistema

25

Solução: Locks

•Encapsulamento Lock/Unlock garante a Exclusão Mútua– Permite acesso seguro a variáveis compartilhadas

Thread_T;

begin. . .Lock (L);

- - seção crítica

UnLock (L);. . .

end;

26

Implementação de Locks

• Hardware: Inibição de Interrupção

Lock ::= < desabilita interrupção >

Unlock ::= < habilita interrupção >

• A perda da capacidade de entremear a execução de programas pode afetar o desempenho

• A capacidade de resposta rápida a eventos (associados a interrupções) é também afetada

• Em multiprocessadores, mais que um processo pode estar executando ao mesmo tempo: bloquear interrupções não garante a exclusão mútua

desligar_interrupções zona crítica ligar_interrupções

27

Locks: Falha de TSL

A instrução TSL pode falhar se o acesso ao barramento não for bloqueado

TSL = Test and Set Lock • Mecanismo implementado a nível de hardware• É atômico

28

Sleep / Wakeup

29

Funcionamento• Quando um processo P executa o comando sleep, ele se

bloqueia até que um outro processo execute o comando wakeup(P).

• Este último comando acorda (desbloqueia) o processo especificado por P.

• Se wakeup(P) é executado antes, o processo P não se bloqueia ao executar o sleep.

• Não formam uma estrutura sintática (isto é, não precisam estar casados, como se fossem um abre e fecha parênteses), eles são comandos independentes

30

Semáforo

Dijkstra 1965

31

Semáforos• Em 1965 Dijkstra propôs usar uma variável inteira para

contar o número de sinais de acordar e salvá-los para uso futuro. Esta variável recebeu o nome de semáforo e é usada para sincronizar processos.

• Seu objetivo é coordenar o acesso a uma região crítica e evitar os problemas que levam a condições de corrida.

• O Semáforo guarda a quantidade de wakeups feito!!!– valor 0 (indicando que nenhum sinal de acordar foi salvo) ou

outro valor positivo caso 1 ou mais sinais de acordar estejam pendentes.

32

Semáforos• Um semáforo S tem associado a ele:

     -  Um valor inteiro     -  Uma fila de processos bloqueados     -  Duas operações: P ou Wait & V ou Signal

Em holandes P = Probeer ('Try') V = Verhoog ('Increment', 'Increase by one').

33

Semáforos• Para ser indivisível as operações P e V são implementadas

como chamadas de sistema. Com isso, por um pequeno instante as interrupções são desabilitadas, mas não geram nenhum problema.

• Semáforos Binários: apenas tomam valores 0 e 1. São habitualmente usados para garantir exclusão mútua no acesso a zonas críticas, e designam-se por mutexes.

34

Mutex

Mutual Exclusion

35

Mutex• Mutex é uma versão simplificada dos semáforos que

serve para controlar o acesso a RC e que pode estar somente em dois estados distintos: impedido ou desempedido. Portanto, apenas um bit é necessário para armazenar esta informação.

• Existe 2 procedimentos para usar o esquema de mutex: – 1. mutex_lock: se o mutex estiver desempedido (RC livre)

o processo ganha acesso a RC. Caso o mutex estiver impedido o processo será bloqueado.

– 2. mutex_unlock: procedimento chamado pelo processo que deixa a RC para liberar o acesso aos demais processos.

36

Mutex

37

Monitor

Hoare 74 / Brinch Hansen 73

38

• Mecanismo de sincronização de alto nível proposto por Hoare (1974) e Brinch Hansen (1975);

• Conjunto de procedimentos e funções de alto nível agrupadas em um módulo– Similar a uma classe, na OO

• Característica mais importante é a implementação automática da exclusão mútua:–Somente um processo pode estar ativo dentro um monitor em um

determinado instante de tempo.– Somente um procedimento sendo executado, até a completude, por vez– Programador livre de especificar as restrições

Monitor: Conceito

39

Monitor: Conceitomonitor example;

... declarações locais do monitor… variáveis de condição

procedure entry proc_declaration_1;:

begin::end;

procedure entry proc_declaration_2;:

begin::end;

: // mais procedimentos ... //begin:... iniciação do monitor:end example.

• entry: assegura exclusão mútua na execução do procedimento

• Javaentry = synchronized

• variáveis de condição:

• associadas a filas de espera• definidas por expressões lógicas

• primitivas:• wait (condição)• signal (condição)

40

T_1

M_1

B_Dados

M_2

Display

T_2T_4

T_3

Monitor: Sistema

41

Mensagens

42

• Primitivas de SEND/RECEIVE–Enviar para e receber de–Recepção bloqueante

• Novos problemas–Perda de mensagens

• ACK, NACK–Recebimento duplicado

• Controle de seqüência–Segurança...

Troca de mensagens

43

• Produtor/consumidor

Consumidor

enviar N msg vaziaswhile (TRUE) { receive (produtor, &m); extrai_item(); send (produtor, &m); consome_item();}

Produtor

while (TRUE) { produz_item(); receive (consumidor, &m); constroi_msg(); send (consumidor, &m);}

Troca de mensagens

44

Endereçamento indireto: caixa postal

P1

Pn

Q1

Qnmailbox

send ( mailbox , msg ) receive ( mailbox , msg )

dilema em sistemas distribuídos: onde fica a caixa postal ?

45

Outras Técnicas

46

• Rendezvous– Uma chamada coloca um processo para dormir até

que uma segunda chamada rendezvous ocorra • Eventos

– Processos subscrevem / manifestam interesse por eventos

• RPC (Remote Procede Call)• Distributed Shared Memory (DSM)• Sincronização por barreira

– Processos inteiros esperam até que uma “barreira” seja alcançada