Concurrent node joins and Stabilization

1
Concurrent node joins and Stabilization

• ?a???s?as? ????? ??eµµ?d??
• ????? S??ßa??da?

2
Stabilization

• Correctness of lookups guaranteed by
  stabilization protocol used to keep successor
  pointers up to date.
• Finger tables can always be verified.
• Each node runs stabilization protocol,
  periodically, to update successors and finger
  tables.

3
Lookup issue

• Lookup before stabilization has finished
• Finger table entries reasonably current Lookup
  finds correct successor in O(logN) steps.
• Successor pointers correct but fingers
  inaccurate Correct lookups but slower.
• Incorrect successor pointers or incorrect mapping
  (keys to nodes) Lookup may fail, higher layer
  software retries lookup optionally.

4
Stabilization algorithm (1/2)

• Stabilization protocol
• join()
• stabilize()
• notify()
• fix_fingers()

5
Stabilization algorithm (2/2)

• When n joins, it calls join(n) where n any
  node.
• join asks n to find immediate successor of n.
• Every node runs stabilize() periodically
• When n runs stabilize(), it asks ns successor
  for successors predecessor p and decides whether
  p should be ns successor.
• notify(n) notifies ns successor k of ns
  existence, so that n becomes ks predecessor
  (only if k knows not of a closer predecessor).
• fix_fingers() adjusts old nodes finger table
  entries and initializes new nodes finger tables.

6
Stabilization example
7
Stabilization theorems

• THEOREM 4. Once a node can successfully resolve a
  given query, it will always be able to do so in
  the future.
• THEOREM 5. At some time after the last join all
  successor pointers will be correct.
• THEOREM 6. If we take a stable network with n
  nodes, and another set of up to n nodes joins the
  network with no finger pointers (but with correct
  successor pointers), then lookups will still take
  O(logN) time with high probability.

8
Thats all

• Thank You!