Distributed Maintenance of Spanning Tree using Labeled Tree Encoding

Slides:



Advertisements
Similar presentations
Routing and Congestion Problems in General Networks Presented by Jun Zou CAS 744.
Advertisements

Stefan Schmid & Christian Scheideler Dept. of Computer Science
Chapter 15 Basic Asynchronous Network Algorithms
Self Stabilizing Algorithms for Topology Management Presentation: Deniz Çokuslu.
CSCE 668 DISTRIBUTED ALGORITHMS AND SYSTEMS Fall 2011 Prof. Jennifer Welch CSCE 668 Self Stabilization 1.
Lecture 4: Elections, Reset Anish Arora CSE 763 Notes include material from Dr. Jeff Brumfield.
Broadcasting Protocol for an Amorphous Computer Lukáš Petrů MFF UK, Prague Jiří Wiedermann ICS AS CR.
Lectures on Network Flows
Dynamic Hypercube Topology Stefan Schmid URAW 2005 Upper Rhine Algorithms Workshop University of Tübingen, Germany.
CPSC 668Self Stabilization1 CPSC 668 Distributed Algorithms and Systems Spring 2008 Prof. Jennifer Welch.
LSRP: Local Stabilization in Shortest Path Routing Anish Arora Hongwei Zhang.
Self-Stabilization An Introduction Aly Farahat Ph.D. Student Automatic Software Design Lab Computer Science Department Michigan Technological University.
Self Stabilization Classical Results and Beyond… Elad Schiller CTI (Grece)
Maximal Independent Set Distributed Algorithms for Multi-Agent Networks Instructor: K. Sinan YILDIRIM.
GS 3 GS 3 : Scalable Self-configuration and Self-healing in Wireless Networks Hongwei Zhang & Anish Arora.
Broadcast & Convergecast Downcast & Upcast
Computing and Communicating Functions over Sensor Networks A.Giridhar and P. R. Kumar Presented by Srikanth Hariharan.
CSCE350 Algorithms and Data Structure Lecture 17 Jianjun Hu Department of Computer Science and Engineering University of South Carolina
CS4231 Parallel and Distributed Algorithms AY 2006/2007 Semester 2 Lecture 10 Instructor: Haifeng YU.
Controller and Estimator for Dynamic Networks Amos Korman Shay Kutten Technion.
De-Nian Young Ming-Syan Chen IEEE Transactions on Mobile Computing Slide content thanks in part to Yu-Hsun Chen, University of Taiwan.
Shifted Codes Sachin Agarwal Deutsch Telekom A.G., Laboratories Ernst-Reuter-Platz Berlin Germany Joint work with Andrew Hagedorn and Ari Trachtenberg.
1 Nasser Alsaedi. The ultimate goal for any computer system design are reliable execution of task and on time delivery of service. To increase system.
An Efficient Decentralized Algorithm for the Distributed Trigger Counting Problem (DTCP) Venkatesan Chakravarthy, IBM India Research Lab Anamitra R. Choudhury,
1 Efficient Dependency Tracking for Relevant Events in Shared Memory Systems Anurag Agarwal Vijay K. Garg
On dynamic distributed algorithms Amos Korman Technion Based on a paper with Shay Kutten.
Fault Management in Mobile Ad-Hoc Networks by Tridib Mukherjee.
Superstabilizing Protocols for Dynamic Distributed Systems Authors: Shlomi Dolev, Ted Herman Presented by: Vikas Motwani CSE 291: Wireless Sensor Networks.
BAHIR DAR UNIVERSITY Institute of technology Faculty of Computing Department of information technology Msc program Distributed Database Article Review.
Mehdi Kargar Department of Computer Science and Engineering
Multiway Search Trees Data may not fit into main memory
A Study of Group-Tree Matching in Large Scale Group Communications
Approximating the MST Weight in Sublinear Time
Vineet Mittal Should more be added here Committee Members:
Michael Langberg: Open University of Israel
The minimum cost flow problem
Conventions Red edges: traversed tree edges White edges: back edges
Minimum Spanning Tree 8/7/2018 4:26 AM
Week 11 - Friday CS221.
Lectures on Network Flows
Lecture 9: Asynchronous Network Algorithms
Concurrent Graph Exploration with Multiple Robots
B+ Trees What are B+ Trees used for What is a B Tree What is a B+ Tree
Agreement Protocols CS60002: Distributed Systems
B+-Trees and Static Hashing
Student: Fang Hui Supervisor: Teo Yong Meng
CS222/CS122C: Principles of Data Management Notes #07 B+ Trees
3.5 Minimum Cuts in Undirected Graphs
Searching for Solutions
Throughput-Optimal Broadcast in Dynamic Wireless Networks
Lectures on Graph Algorithms: searching, testing and sorting
B+Trees The slides for this text are organized into chapters. This lecture covers Chapter 9. Chapter 1: Introduction to Database Systems Chapter 2: The.
Introduction Wireless Ad-Hoc Network
Lecture 8: Synchronous Network Algorithms
Abstraction.
Dhruv Gupta EEC 273 class project Prof. Chen-Nee Chuah
Algorithms (2IL15) – Lecture 7
Distributed Error- Confinement
Dynamic Graph Algorithms
Discrete Mathematics for Computer Science
Tree-Structured Indexes
B-Trees.
On Constructing k-Connected k-Dominating Set in Wireless Networks
Synchronizers Outline motivation principles and definitions
CS222/CS122C: Principles of Data Management UCI, Fall 2018 Notes #06 B+ trees Instructor: Chen Li.
Maximum Flow Problems in 2005.
CS222P: Principles of Data Management UCI, Fall Notes #06 B+ trees
M. Mock and E. Nett and S. Schemmer
Presentation transcript:

Distributed Maintenance of Spanning Tree using Labeled Tree Encoding Vijay K. Garg Anurag Agarwal PDSL Lab University of Texas at Austin

Outline Previous work and System model “Core” and “Non-core” strategy Neville’s code Self-stabilizing spanning tree algorithm Conclusion

Motivation Maintaining spanning trees in distributed fashion Broadcast Convergecast Self Stabilization [Dijkstra 74] is a powerful fault-tolerance paradigm Design algorithms to tolerate transient data faults Despite faults, algorithm converges to a good state

Previous Work Many self-stabilizing algorithms for spanning trees Breadth-first spanning tree: [DIM90, AK93] Depth-first spanning tree: [CD94] Minimum spanning tree: [AS97] Our work makes stronger assumptions but achieves better bounds - Add references plus time comparisons

Comparison with Previous Work Popular model assumes all communication registers can be read/written in one time step In a completely connected topology, it amounts to doing O(n) work in one time step Our model assumes processes take one communication step In our model, the previous algorithms would have at least O(n) time complexity

System Model System with n nodes labeled 1 … n Nodes form a completely connected graph Topology is static Computation step Internal computation One communication event A message is ready to be delivered in one time step - Make round a separate bullet : highlight this fact

“Core and Non-Core” Strategy for Self Stabilization Maintain “Core” and “Non-Core” data structures Core structures are always correct Non-core structures can be derived from Core structures Non-Core Structure Core Structure Index of permutation 1 … n! Permutation

“Core and Non-Core” strategy for Self Stabilization Strategy: Always assume Non-Core structures got corrupted and align it with Core structures Core Structure Non-Core Structure Index of permutation 2 Permutation n = 4 1 4 3 Talk about the other case as well – probably add a slide here explaining it

“Core and Non-Core” strategy for Self Stabilization Strategy: Always assume Non-Core structures got corrupted and align it with Core structures Core Structure Non-Core Structure Index of permutation 2 Permutation n = 4 1 4 3 Talk about the other case as well – probably add a slide here explaining it 1 2 3 4

“Core and Non-Core” strategy for Self Stabilization Strategy: Always assume Non-Core structures got corrupted and align it with Core structures Challenge lies in efficient detection and correction n = 4 Non-Core Structure Core Structure Index of permutation 2 Permutation 1 2 3 4 1 2 4 3 1

Neville’s Code [Neville 53] Similar to Prufer code Each labeled tree with n nodes has one to one correspondence with a Neville’s code Code is a sequence of n - 2 numbers from the set {1,…,n} code[i] denotes the ith number in the code sequence

Neville’s Code: Example 8 6 3 Code = 7768338 7 5 4 Highlight the fact that we are not deleting the nodes 5 and 4 2 1

Spanning Tree → Neville’s Code x = least node with degree 1 for i = 1 to n-1 code[i] = parent[x] Delete edge between x and parent[x] if (degree[parent[x]] = 1 && parent[x] ≠ n) x = parent[x] else Change symbols for not equals etc

Neville’s Code: Example x = least node with degree 1 for i = 1 to n-1 code[i] = parent[x] Delete edge between x and parent[x] if (degree[parent[x]] = 1 && parent[x] ≠ n) x = parent[x] else 8 6 3 7 5 4 Highlight the fact that we are not deleting the nodes 5 and 4 2 1 code = 7 code = 7768338 code = 77 code = 776 code = 7768 x = 6 x = 2 x = 1 x = 7

Self Stabilization using Neville’s code Need to maintain “parent” (Non-core) for each node Auxiliary data structures for efficiency code[i] : Neville’s code f[i] : Iteration in which node i is chosen as “x” z[i] : last occurrence of node i in code Node i maintains ith components of data structures Put constraints on these data structures so that the parent pointers give a valid tree

Constraints Three constraint sets provide different guarantees on the structure of the resulting spanning tree with respect to the tree generated by Neville’s code Spanning Tree (R) Isomorphic (C) Identical Efficiency

Constraints for R (R1) For all i: code[f[i]] = parent[i] Follows from the code building procedure 8 6 3 4 7 1 2 5 Node 7 was chosen as “x” in iteration 3. So f[7] = 3 code[f[7]] = code[3] = 6 = parent[7] code = 7768338

Constraints for R Simple restrictions on the range of the structures (R2) For 1 ≤ i ≤ n – 2: 1 ≤ code[i] ≤ n and code[n – 1] = n (R3) (i) For 1 ≤ i ≤ n – 1: 1 ≤ f[i] ≤ n – 1 (R4) For all i: z[i] = max j such that code[j] = i Definition of z

Constraints for R (R5) For all i: z[i] ≠ 0  f[i] = z[i] + 1 Captures preference given to parent when its degree becomes one 8 6 3 4 7 1 2 5 Node 7 occurs last in code at position 2. Hence, z[7] = 2. Also, f[7] = 3. f[7] = z[7] + 1 code = 7768338

Maintaining R - Constraint R4 For all i: z[i] = maximum j such that code[j] = i Split the constraint into two different constraints (E1) z[i] ≠ 0  code[z[i]] = i (E2) code[j] = i  z[i] ≥ j z code 1 2 3 4 5 2 3 1 5 4

Maintaining R - Constraint R4 For all i: z[i] = maximum j such that code[j] = i Split the constraint into two different constraints (E1) z[i] ≠ 0  code[z[i]] = i (E2) code[j] = i  z[i] ≥ j 4 z code 1 2 3 4 5 2 3 (E1) code ? 1 5 4

Maintaining R - Constraint R4 For all i: z[i] = maximum j such that code[j] = i Split the constraint into two different constraints (E1) z[i] ≠ 0  code[z[i]] = i (E2) code[j] = i  z[i] ≥ j z code 1 2 3 4 5 2 3 E1 violated ! (E1) 1 5 4

Maintaining R - Constraint R4 For all i: z[i] = maximum j such that code[j] = i Split the constraint into two different constraints (E1) z[i] ≠ 0  code[z[i]] = i (E2) code[j] = i  z[i] ≥ j z code 1 3 2 4 5 2 3 (E1) 1 5 4

Maintaining R - Constraint R4 For all i: z[i] = maximum j such that code[j] = i Split the constraint into two different constraints (E1) z[i] ≠ 0  code[z[i]] = i (E2) code[j] = i  z[i] ≥ j z code 1 3 2 4 5 2 3 check z ≥ 3 z = max {0,3,4} (E2) 1 check z ≥ 4 5 4

Maintaining R - Constraint R4 For all i: z[i] = maximum j such that code[j] = i Split the constraint into two different constraints (E1) z[i] ≠ 0  code[z[i]] = i (E2) code[j] = i  z[i] ≥ j z code 1 4 3 2 5 2 3 (E2) 1 5 4

Maintaining R - Other Constraints Local checks: Can be checked and corrected without contacting any other node (R2) , (R3) (i), (R5) (R1) For all i: code[f[i]] = parent[i] Inquire node f[i] to get code[f[i]] and match with parent[i] On mismatch, reset parent[i] to agree with code[f[i]]

Analysis of Algorithm for maintaining R Theorem: The algorithm requires O(1) time per node and O(1) messages per node on average in one cycle Theorem: The algorithm stabilizes in O(d) time, where d is the upper bound on the number of times a node appears in the code With high probability, a random code assignment would have d = O(log n/ log log n)

Conclusion Self stabilization algorithm for spanning tree Requires O(1) messages per node on average Provides fast stabilization Allows changing root node and systematic modification of the tree

Future Work Remove the restriction on topology and labels Apply the strategy of core and non-core states to other problems

Questions ?

Neville’s code → Spanning Tree x = least node with degree 1 for i = 1 to n-1 parent[x] = code[i] degree[x]--; degree[parent[x]]--; If (degree[parent[x]] == 1) x = code[i] else

Round vs Bounded Delivery Time Round: Every process takes atleast one step Definition allows one process to send/receive multiple messages in one time unit

Self Stabilization using Neville’s code Need to maintain “parent” for each node Auxiliary data structures for efficient detection code[i] : Neville’s code f[i] : Iteration in which node i was selected as x z[i] : last occurrence of node i in code Node i maintains ith components of data structures Put constraints on these data structures so that the parent pointers give a valid tree

Constraints (R1) For all i: code[f[i]] = parent[i] (R2) 1 <= i <= n-2, 1 <= code[i] <= n and code[n – 1] = n (R3) (i) 1 <= f[i] <= n – 1 (ii) f is a permutation on [1…n] (R4) For all i: z[i] = max. j such that code[j] = i (R5) For all i: z[i] != 0 => f[i] = z[i] + 1

Two sets of constraints R = { R1, R2, R3(1), R4, R5} Resulting spanning tree may differ from the one given by code in the leaves Self-stabilization is easier and more efficient C = { R1, R2, R3, R4, R5} Resulting spanning tree is isomorphic to the one given by code Self-stabilization is harder and becomes inefficient

One interesting constraint For all i: z[i] = maximum j such that code[j] = I Split the constraint into two different constraints (E1) z[i] ≠ 0  code[z[i]] = i (E2) code[j] = i  z[i] ≥ j For (E1), node i queries the node z[i] to get code[z[i]] and matches it against i For (E2), every node j with code[j] = i sends a message to node i containing j Node i then sets z[i] = max { z[i], j }

References 1. Y. Afek, S. Kutten, and M. Yung. Memory-efficient self stabilizing protocols for general networks. In Proc. of the 4th Int’l Workshop on Distributed Algorithms, pages 15–28. Springer- Verlag, 1991. 2. S. Aggarwal and S. Kutten. Time optimal self-stabilizing spanning tree algorithm. In Proc. of the 13th Conference on Foundations of Software Technology and Theoretical Computer Science, pages 400–410, 1993. 3. G. Antonoiu and P. Srimani. Distributed self-stabilizing algorithm for minimum spanning tree construction. In European Conference on Parallel Processing, pages 480–487, 1997. 4. A. Arora and M. Gouda. Distributed reset. IEEE Transactions on Computers, 43(9):1026– 1038, 1994. 5. B. Awerbuch, B. Patt-Shamir, and G. Varghese. Self-stabilization by local checking and correction (extended abstract). In IEEE Symposium on Foundations of Computer Science, pages 268–277, 1991. 6. Z. Collin and S. Dolev. Self-stabilizing depth-first search. Information Processing Letters, 49(6):297–301, 1994. 8. E. W. Dijkstra. Self-stabilizing systems in spite of distributed control. Communications of the ACM, 17:643–644, 1974. 9. S. Dolev, A. Israeli, and S. Moran. Self-stabilization of dynamic systems assuming only read/write atomicity. In Proc. of the ninth annual ACM symposium on Principles of Distributed Computing, pages 103–117. ACM Press, 1990. 10. S. Huang and N. Chen. A self stabilizing algorithm for constructing breadth first trees. Information Processing Letters, 41:109–117, 1992. 11. C. Johnen. Memory efficient, self-stabilizing algorithm to construct bfs spanning trees. In Proc. of the sixteenth annual ACM symposium on Principles of Distributed Computing, page 288. ACM Press, 1997. 12. E. H. Neville. The codifying of tree-structure. Proceedings of Cambridge Philosophical Society, 49:381–385, 1953.