Canais Assíncronos II - Aplicações
Upcoming SlideShare
Loading in...5
×
 

Canais Assíncronos II - Aplicações

on

  • 1,956 views

 

Statistics

Views

Total Views
1,956
Views on SlideShare
1,947
Embed Views
9

Actions

Likes
0
Downloads
20
Comments
0

1 Embed 9

http://www.slideshare.net 9

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Canais Assíncronos II - Aplicações Canais Assíncronos II - Aplicações Presentation Transcript

  • II. Memória Distibuída Passagem de Mensagens Assíncrona ( Aplica ções ) Fco. Heron de Carvalho Jr., Dr. [email_address]
  • Passagem de Mensagens Assíncrona (Aplicações)
    • Algoritmos Probe/Echo
    • ( computa ção distribuída em grafos)
  • Algoritmos Probe/Echo
    • Grafos e árvores são estruturas encontradas em muitos algoritmos;
      • Jogos, bancos de dados, sistemas especialistas;
    • DFS (Depth First Search)
      • Busca em profundidade para árvores e grafos ;
      • Para cada nodo ( pai ), cada nodo filho é visitado e sua informação é retornada ao pai ;
      • Em grafos, é necessário marcar nós visitados;
  • Algoritmos Probe/Echo
    • Computações distribuídas em processos organizados em grafos:
      • Algoritmos probe/echo ;
      • Análogos a DFS em grafos;
    • Probe (sondagem)
      • Mensagem enviada de um nodo para seus sucessores na rede;
    • Echo (eco)
      • Resposta dos sucessores ;
  • Algoritmos Probe/Echo (Topologia de redes de processos)
    • Revisitando a computação da topologia de uma rede de processos:
      • Novo algoritmos, usando probe/echo ;
    • Premissas do novo algorimo
      • Existência de um nodo iniciador ;
        • Computa a topologia completa e a dissemina (broadcast) aos outros processos;
      • Como computar a topologia ?
        • Duas fases (próximo slide);
  • Algoritmos Probe/Echo (Topologia de redes de processos)
    • Fases para computação da topologia:
      • Cada nodo envia um probe para cada vizinho;
      • Cada nodo envia um echo contendo a informação de sua topologia local para o nodo que lhe enviou o primeiro probe ;
      • No final, o iniciador recebe a topologia completa e a dissemina aos outros processos;
  • Algortimos Probe/Echo (Topologia de redes de processos)
    • Solução: const source = i type kind = enum(PROBE, ECHO) chan probe_echo [1:n](kind, sender:int, links[1:n,1:n]) chan finalecho [1:n](links[1:n,1:n] int) Node[p:1..n]:: (... ) Initiator :: (...)
  • Algortimos Probe/Echo (Topologia de redes de processos)
    • Solução ( continuação ): Node[p:1..n]:: var links[1:n]:bool := vizinhos de p var localtop[1:n,1:n]:bool := ([n*n] false) localtop[p,1:n] := links var newtop[1:n,1:n]:bool var first:int var k:kind, sender:int var need_echo: int := número de vizinhos-1 (...)
  • Algortimos Probe/Echo (Topologia de redes de processos)
    • Solução ( continuação ): Node[p:1..n]:: (...) receive probe_echo [p](k,sender,newtop) first := sender fa q := 1 to n st links[q] and q  first send proble_echo [q](PROBE, p,  ) af (...)
  • Algortimos Probe/Echo (Topologia de redes de processos)
    • Solução ( continuação ): Node[p:1..n]:: (...) do need_echo > 0 -> receive probe_echo [p](k,sender,newtop) if k = PROBE -> send probe_echo [sender](ECHO, p,  ) [] k = ECHO -> localtop := localtop or newtop need_echo := need_echo – 1 fi od (...)
  • Algortimos Probe/Echo (Topologia de redes de processos)
    • Solução ( continuação ): Node[p:1..n]:: (...) if p = source -> send finalecho (localtop) [] p  source -> send probe_echo [first](ECHO, p localtop) fi (...)
  • Algortimos Probe/Echo (Topologia de redes de processos)
    • Solução ( continuação ): Initiator :: var top[1:n,1:n]:bool send probe_echo [source](PROBE, source,  ) receive finalecho (top)
  • Passagem de Mensagens Assíncrona (Aplicações)
    • Algoritmos de Dissemina ção ( Broadcast )
    • - semáforos distribuídos -
  • Algoritmos de Disseminação
    • Um algoritmo de disseminação pode ser implementado por meio de probe/echo ;
    • Todos os processos compartilhando um canal em comum;
      • Suposição válida na maioria das redes locais;
        • Ethernet, token-ring, etc. ;
      • Primitiva broadcast :
        • Seja P[1:n] um vetor de processos e ch[1:n] um vetor de canais, um pra cada processo:
        • Um processo P[1:n] dissemina um dado para todos os processos executando:
          • broadcast ch ( m )
  • Algoritmos de Disseminação
    • Observações sobre broadcast :
      • Efeito semelhante a execução de n comandos send em paralelo;
      • Processos recebem o dado disseminado executando receive , como usualmente;
      • broascast não é indivisível !
        • Mensagens disseminadas por dois processos A e B podem ser recebidas por outros processos em diferentes ordens;
  • Algoritmos de Disseminação
    • broadcast ’s podem ser usados para resolver muitos problemas de sincronização ;
    • Inicialmente, mostraremos como implementar um relógio lógico , usando broadcasts ;
    • Posteriormente, apresentarems uma solução para implementar semáforos distribuídos ;
  • Algoritmos de Disseminação (Relógios lógicos e ordenação de eventos)
    • Em sistemas distribuídos, as ações de comunicação são os eventos relevantes;
      • Eventos correspondem a ocorrência das operações send e receive ;
    • Não há como saber a ordem relativa entre operações locais realizadas por processos distintos;
    • Entretanto, há meios de ordenar eventos ( operações globais ) realizadas por processos;
  • Algoritmos de Disseminação (Relógios lógicos e ordenação de eventos)
    • Ordem parcial !
      • Sequências de eventos não-relacionadas ;
        • Lembram de categorias ????? CPO’s ???
    • Usando um relógio único centralizado:
      • Podemos estabelecer ordem total;
      • Identificadores usados pra distinguir timestamp de mensagens enviadas simultaneamente;
      • Irrealístico! 
  • Algoritmos de Disseminação (Relógios lógicos e ordenação de eventos)
    • Opção realística: 
      • Assumir que cada processador tem seu próprio relógio (físico);
      • Relógios sincronizados garantiriam ordenação;
        • Irrealístico ! 
      • Algoritmos de sincronização de relógio servem para manter dois relógios o mais sincronizados possível, mas nunca perfeitamente;
        • Podemos simular relógios físicos !! 
  • Algoritmos de Disseminação (Relógios lógicos e ordenação de eventos)
    • Um relógio lógico é um contador simples que é incrementado quando um evento acontece;
  • Algoritmos de Disseminação (Relógios lógicos e ordenação de eventos)
    • Regra de Atualização de relógios lógicos :
      • Seja lc um relógico lógico em um processo A.
      • (1) Quando A envia ou dissemina uma mensagem, ele atualiza o timestamp da mensagem para lc e incrementa lc ;
      • (2) Quando A recebe uma mensagem com timestamp ts , ele atualiza lc para o máximo de lc e ts + 1 e incrementa lc;
  • Algoritmos de Disseminação (Relógios lógicos e ordenação de eventos)
    • O timestamp da mensagem enviada é o valor do relógio na execução de send (lc);
    • O timestamp da mensagem de recebimento é o valor do relógio após calcular o maior entre lc e ts+1 e antes de incrementar lc ;
    • Assim, garante-se que se um evento a ocorre antes de um evento b , então o valor do relógio associado a a é menor que aquele associado a b ;
      • Ordem total dos eventos ! 
      • Identificador distingue evendos com mesmo timestamp
  • Algoritmos de Disseminação (Semáforos Distribuídos)
    • Solução type kind = enum(V,P,ACK) chan semop [1:n](sender, kind, timestamp:int), go [1:n](timestamp:int)
  • Algoritmos de Disseminação (Semáforos Distribuídos)
    • Solução User[i:1..n]:: var lc:int :=0 var ts:int # execução de uma operação V broadcast semop (i, V ,lc); lc := lc + 1; (...) # execução de uma operação P broadcast semop (i, P ,lc); receive go [i](ts); lc := max(lc, ts+1); lc := lc + 1 Helper[i:1..n]:: (..)
  • Algoritmos de Disseminação (Semáforos Distribuídos)
    • Solução Helper[i:1..n]:: var mq: queue of (int, kind , int) var lc:int := 0 var sem:int := valor inicial var sender:int, k:kind, ts:int (...)
  • Algoritmos de Disseminação (Semáforos Distribuídos)
    • Solução Helper[i:1..n]:: (...) do true -> {DSEM} receive semop [i](sender,k,ts) lc := max(lc,ts+1); lc := lc+1 if k = P or k = V -> (...) [] k = ACK -> (...) fi od (...)
  • Algoritmos de Disseminação (Semáforos Distribuídos)
    • Solução Helper[i:1..n]:: (...) do true -> {DSEM} (...) if k = P or k = V -> inser ir (sender, k, ts) em mq broadcast semop (i,ACK,lc); lc := lc+1; [] k = ACK -> (...) fi od (...)
  • Algoritmos de Disseminação (Semáforos Distribuídos)
    • Solução (...) if k = P or k = V -> (...) [] k = ACK -> registre recebimento de um ACK fa mensagens V totalmente reconhecidas-> remover a msg de mq ; sem := sem+1 ; fa fa mensagens P totalmente reconhecidas-> remover a msg de mq ; sem := sem-1 ; if sender = i -> send go [i](lc); lc := lc + 1 fi fa fi od (...)
  • Passagem de Mensagens Assíncrona (Aplicações)
    • Algoritmos
    • Token Passing
    • - Exclusão m útua distribuída -
    • - Detecção de terminação distribuída -
  • Token Passing
    • Token
      • Um tipo especial de mensagem que pode ser usado para carregar uma permissão para executar uma ação ou capturar uma imformação relativa ao estado global da aplicação;
    • Aplicações:
      • Exclusão mútua distribuída;
      • Detecção de terminação distribuída;
  • Token Passing
    • Exclusão mútua distribuída: chan token [1:n](), enter [1:n](), go [1:n](), exit [1:n]() (...)
  • Token Passing
    • Exclusão mútua distribuída: Helper [i:1..n]:: do true -> {DMUTEX} receive token [i]() if not ( empty ( enter [i])) -> receive enter [i]() send go [i]() receive exit [i]() fi send token [(i mod n) + 1]() od
  • Token Passing
    • Exclusão mútua distribuída: P [i:1..n]:: do true -> send enter [i]() receive go [i]() seção crítica send token [(i mod n) + 1]() seção não-crítica od
  • Passagem de Mensagens Assíncrona (Aplicações)
    • Servidores Replicados
    • - Replicação de Arquivos (disponibilidade) -
    • - Quadratura Adaptativa (paralelismo) -
  • Servidores Replicados
    • Quadratura adaptativa:
      • Replicação de função;
      • n processo encarregados de aproximar paralelamente a integral de uma função;
      • Solução estática X solução dinâmica;
  • Servidores Replicados
    • Solução (Quadratura Adaptativa): chan bag (a,b,fa,fb,area:real) chan result (a,b,area:real) (...)
  • Servidores Replicados
    • Solução (Quadratura Adaptativa): Administrator:: var l,r,fl,fr,a,b,area,total:real outras variáveis para registrar intervalos finalizados fl := f(l); fr := f(r) area := (fl + fr)*(l+r)/2 send bag (l,r,fl,fr,area) do area total ainda não computada -> receive result (a,b,area) total := total + area registre que completou intervalo [a,b] od
  • Servidores Replicados
    • Solução (Quadratura Adaptativa): Worker[1:n]:: var a,b,m,fa,fb,fm:real var larea, rarea, tarea, diff:real do true -> receive bag (a,b,fa,fb,tarea) m := (a+b)/2; fm := f(m); computar larea e rarea diff := tarea – (larea + rarea) if diff small -> send result (a,b,area) [] diff too large -> send bag (a,m,fa,fm,larea) fi od
  • II. Memória Distibuída Cap. 8 Passagem de Mensagens Síncrona Fco. Heron de Carvalho Jr., Dr. fhcj @ poli .upe.br