Um sistema distribuído para busca de caminhos em grafos dinâmicos

1. Um sistema distribuído para busca de caminhos em grafos dinâmicos Marcelo Luís Vinagreiro Orientador: Prof. Alfredo Goldman

2. Descrição do Problema/Cenário de aplicação • Desenvolvimento de um modelo que permita a busca de caminhos em um grafo distribuído • Exemplos de aplicação: • Sistema descentralizado para monitoramento do trânsito de uma dada cidade • Busca de caminhos para unidades móveis • Simulação de rede distribuída

3. Algoritmos dinâmicos – Narváez et al. • Considerações iniciais: • Algoritmo básico: permite transformar versões estáticas de algoritmos de busca em suas respectivas versões dinâmicas • Duas variações do algoritmo básico: First Incremental Method, Second Incremental Method.

4. Arquitetura Proposta Modelagem 8 13 • Bordas 14 6 9 10 7 11 16 4 15 5 12 3 17 18 2 19 1 EA EB • B(GA) = { 1, 2, 5, 6, 8, 10, 11, 12 } • B(GB) = {10, 11, 12, 13, 14, 16, 18, 20} • B(GA)  B(GB) = { 10, 11, 12 }

5. Modelagem – (cont.) • Dois tipos de servidores: • Estação-base (Base Server) (BSi) • Servidor de Busca (Search Server) (SBi) • Seja: • NBS >= 1 : o número de BSs BS = { BSi | 1  i  NEB } • NSS >= 1 : o número de SSs SS = { SSi | 1  i  NSB } • Onde: SS  BS

6. RootSet e RootWeightSet • RootSet(Gi) = RS(Gi): um subconjunto de nós na borda de Gi • RootWeightSet(RSi): custo dos melhores caminhos entre todas combinações possíveis de pontos em RSi • Exemplo: RootSet(Gi): { B1, B2, B3, B4 } RootWeightSet(Gi): B1 1 0 8 B3 5 B2 I1 2 8 B4 BSi

7. Forward Tree de RSi – FT(RSi) RS3 RS2 3 10 2 RS1 8 RS5 0 2 RS1 8 RS4 RS2 X 2 2 3 Z 0 Z K 2 RS3 RS4 8 Forward Tree (RS2) RS5

8. Model Tree – MT(Rx)

9. Roteamento adaptativo através de árvores dinâmicas • Processamento em BSi • BSi mantém subgrafo Gi; • Em intervalos regulares, BSi obtém/atualiza as árvores FTstateId(RSk), para cada nó RSk, com dados de stateId; • Com os dados de FT(RSk), BSi gera RootWeightSetstateId(Gi) e envia para o conjunto SS; • Processamento em SSk • SSk recebe de EBt o conjunto RootWeightSetstateIdt, em 1  t  NBS. Assim que SSk recebe todos conjuntos RootWeightSetstateIdt, SSk atualiza árvores MTstateId(t) • E envia msg Received_RwsetstateId, informandoa Bt com uma o recebimento de RootWeightSetstateIdt

10. Busca de caminhos • Seja uma requisição de caminho de X a Y enviada à estação-base BSX. O processamento da busca de caminhos é feita em dois níveis: • Intra-estação: busca no interior de BSX e/ou, • Inter-estação: nesse caso BSX consulta algum servidor de busca SSj para incluir informações de outras estações na busca. • Dois tipos de requisições cliente: • Busca global: caminho completo de X a Y • Busca local: caminho de X a R tal que R está em RS(BSX).

11. Procedimento de Busca • Formado por 4 procedimentos principais: • PerformBSPathSearch: executado em BSx; • PerformInterPath: executado em BSx; • PerformSSPathSearch: executado em SSj • PerformPathInForwardTrees: executado em BSy;

12. Busca em BSi Procedure PerformBSPathSearch(X,Y,req) BSX calcula a árvore de caminhos TstateId(X); if Y  BSXthen /* se há um caminho PXY com custo  , retorna PXY */ if um caminho PXY TstateId(X) | Weight(PXY)   then returnPXY; else Seja PINTRA := { PXY | Weight(PXY) é mínimo } PINTER = FindInterPath(X,Y,req, TstateId(X),stateId) Seja PMIN o caminho de peso mínimo entre PINTER e PINTRA return PMIN. else return FindInterPath(X,Y,req, TstateId(X),stateId). End Procedure

13. Busca em BSi (cont.) Procedure FindInterPath(X, Y, req, TstateId(X), stateId) XToRSWeightSet :=  /* caminhos para as bordas */ for each r  RootSet(Gx) do if r  TstateId(X) then XToRSWeightSet := XToRSWeightSet  {r, Weight(X,r)} else XToRSWeightSet := XToRSWeightSet  {r, } /* escolhe SS e chama remotamente FindShortestPath */ Resp := RPC (SSj, FindSSPathSearch(X,Y, req, XToRSWeightSet, stateId) )

14. Busca em BSi (cont.) if req = Global then /* Resp é um caminho: RSt -> N1 -> ... -> Y */ Seja Rt o nó inicial do caminho Resp; Rt RootSet(GX) Seja P’t o caminho de X a Rt, em TstateId(X) /* retira-se o nó Rt do conjunto*/ Seja Pt = P’t - Rt return Pt  Resp else /* Resp = (Rt,C) retorna o nó Rt em RootSet(GX) que gera o caminho de X a Y com custo C */ Seja C o peso calculado por SBj para chegar em Y. E, Rt RootSet(GX) o nó que origina tal caminho. Seja Pt o caminho de X a Rt TstateId(X). /* retorna Pt com peso C */ return Pt End Procedure

15. Busca em SBj Procedure FindSSPathSearch(X, Y, req, XToRSWeightSet, stateId) RSWeightSetToY := RPC(BSY, FindPathInForwardTrees(Y,stateId)) P´ := DynamicSPT(X, Y, XToRSWeightSet, RSWeightSetToY, stateId) if req = Local then Seja Rk o nó em RootSet de BSX que está no caminho mínimo de X até Y e C o custo associado return {Rk, C}

16. Busca em SBj else Seja P= P1->P2->...->Py o caminho global, montado buscando-se os caminhos intermediários (Pi) nas respectivas BSs envolvidas com o caminho P. return P End Procedure

17. Busca em BSY Procedure FindPathInForwardTrees(Y, stateId) RSWeightSetToY :=  for each árvore FTstateId(Ri) do if Y  FTstateId(Ri) then RSWeightSetToY := RSWeightSetToY  {Ri, Weight(Ri,Y)} else RSWeightSetToY := RSWeightSetToY  {Ri, } return RSWeightSetToY End Procedure

18. Atualização do sistema K+1 K EB =EB (I) 1 c Received_Rset(k+1) Update_Rset(k+1) Commit_Rset(k+1) EB (I) 2 Received_Rset(k+1) Update_Rset(k+1) Commit_Rset(k+1) EB (I) 3

20. BSAgents Ação Agente Perform_Path_Search BaseServerRequestAgent FindRset2YAgent Find_RsetToY_Values RequestSubPathAgent Rqst_Sub_Path UpdateRsetAgent Update_Rset UpdateTransactionAgent Update_Global_State CommitRsetAgent Commit_Rset Update_Link_State UpdateDataLinkAgent Base Server

21. SSAgents Ação Agente Find_Inter_Path PerformSSPathAgent UpdateRwsetAgent Update_Rwset Commit_Rset CommitRsetAgent Search Server

22. Influência do RootSet – Atualização

23. Influência do RootSet – Atualização (cont)

24. Influência do RootSet – Buscas

25. Arcos modificados

26. Desempenho

27. Qualidade da Solução

28. Conclusão • RootSet é um parâmetro importante do modelo • Partições devem minimizar o comprimento da borda • Modelo apropriado para o uso de algoritmos de busca em grafos dinâmicos • Políticas de interpolação podem ser consideradas, para melhorar a qualidade da solução