1. 1 David Liben-Nowell, Hari Balakrishnan, David Karger Analysis of the Evolution of Peer-to-Peer Systems Speaker: Jan Conrad

2. 2 Overview  Introduction  Problems  Lower bound for maintenance effort  Chord Background on Chord Analysis of Chord  Conclusion

3. 3 Introduction Definition Peer-to-peer (P2P): Peer-to-peer (P2P) systems are distributed systems without any centralized control or hierarchical organization, where the software running at each node is equivalent in functionality.

4. 4 Problems  P2P network is a continously evolving system, wich nodes are continuously joining and leaving  What happens if many joins (or leaves) occure concurrently?

5. 5 Problems  Need some kind of maintenance protocol that continously repairs the index  The network almost never will be in “ideal state” but it must behave correctly

6. 6 Problems But how to find a proper performance measure for the maintenance protocols? The measure running time is not possible The measure bandwith is infinite

7. 7 Problems  We evaluate the rate at wich each node must expend network bandwith in the maintenance protocol. Network bandwith is presently the most limited resource in P2P systems (and not storage space or computation time).

8. 8 Half-life lower bound The half-life lower bound is a general lower bound for the bandwidth of maintenance messages in P2P systems, based on the rate of node joins and departures.

9. 9 Half-Life Lower bound Assume there are N Nodes  doubling time from time t (dt (t)): is the time that elapses before N additional nodes arrive  halving time from time t (ht (t)): is the time required for half of the nodes alive at time t to depart  half-life from time t (hlt(t)): hlt(t) = min {dt(t),ht(t)}  half-life (hl) hl = min U t  T hlt(t)

10. 10 Half-Life Lower bound  Consider a Poisson-distribution of the arrival of nodes with rate λ  dt = N/ λ  Consider that nodes depart the system according to an exponential distribution with rate parameter μ (the probability P that a node fails in time τ is 1- 1/e μτ )  Expected node life time 1/μ  ht = (1/μ) ln 2  hl = min ( ln2/μ,N/ λ)  N = μ / λ if network in steady state  hl = ln2 / μ

11. 11 Theorem Any N-node P2P network, that remains connected with disconnection probability O(1/N) for any sequence of joins and leaves with half-life rate hl must notify every node with an average of Ω(log N) nodes per hl time.

12. 12 Lemma There exists a sequence of joins and leaves such that any node that at any time, has received an average of fewer than k notifications per half-life will be disconnected from the network with probability ≥ (1- 1/e-1) k ≈ 0.418 k

13. 13 Lemma → Theorem  P(disconnection) = 0.418 k 1/N= 0.418 k log 0.418 (1/N) = k -log (1/N)= k -log(1) + log (N) = k log (N)= k

14. 14 Overview  Introduction  Problems  Lower bound for maintenance effort  Chord Background on Chord Analysis of Chord  Conclusion

15. 15 Background on Chord  Pictorially, keys and nodes are mapped onto a circle  a key k is assigned to the node whose identifier is ≥ to the key‘s identifier  the successor(k) is the first node clockwise from k.

16. 16 Background on Chord To speed the search, we define the ith finger of a node n  Each node n contains a routing table with up to m entries (m: number of bits of the identifiers) => finger table  The i th entry in the table at node n contains the first node s that succeds n by at least 2 i-1  s = successor (n + 2 i-1 )  s is called the i th finger of node n

17. 17 Background on Chord Idealization protocol:  Idealize(): n asks its successor for its predecessor p and decides whether p should be n‘s successor instead (this is the case if p recently joined the system).  Notify(): notifies n‘s successor of its existence, so it can change its predecessor to n  Fix_fingers(): updates finger tables

18. 18 Background on Chord Idealization protocol:  Idealize(): n asks its successor for its predecessor p and decides whether p should be n‘s successor instead (this is the case if p recently joined the system).  Notify(): notifies n‘s successor of its existence, so it can change its predecessor to n  Fix_fingers(): updates finger tables

19. 19 Background on Chord Idealization protocol:  Idealize(): n asks its successor for its predecessor p and decides whether p should be n‘s successor instead (this is the case if p recently joined the system).  Notify(): notifies n‘s successor of its existence, so it can change its predecessor to n  Fix_fingers(): updates finger tables

20. 20 Background on Chord  We need to plan for unexpected failures which cannot cleanup  In the description above, if a node´s successor fails, the ring is broken  Each node keeps an successor list

21. 21 What could go wrong  By changing multiple successor pointers concurrently, we might cause the network to split into two or more separate components and cause any data stored in one component to become inaccessible to nodes in the other.

22. 22 What could go wrong A Chord network is called -Weakly ideal if for al nodes u in the system holds (u.successor).predecessor = u -Strongly ideal if it is weakly ideal and for each node u there is no node v, so that u < v < successor.u -Loopy if it is weakly ideal but not strongly ideal

23. 23 What could go wrong So in a loopy network, the find_successor(id) search return possibly two different nodes: n.find_successor(id) if (id  (n, n.successor]) return n.successor; else // forward the query around the circle return successor.find_successor(id); N1 N8 N14 N21 N32 N48 N56

24. 24 The Ideal Chord State 1.Connectivity: There is a path using successor lists and finger tables connecting any two nodes 2.Randomness: All the nodes in the system are independently and uniformly distributed around the identifier circle. 3.Cycle sufficiency: Every node u is on the cycle 4.Non loopiness: For any node u on the cycle, there is no node v in (u, u.successor) 5.Successor list validity: Every u.successor_list contains the first c log N nodes that follow u 6.Finger validity: For every node u and every i, the first node following u + 2 i-1 is stored as u.finger[i]

25. 25 The Ideal Chord State  Previous work has established a number of good properties of this state: Find_successor returns the true successor in time O(log n) even after all nodes fail independently with a constant probability p < 1

26. 26 Cycle With Failures State  Given an N-node ideal network  Suppose that N/2 nodes in the network fail  Cycle with failure state extend the Ideal Chord State to include failures

27. 27 Cycle With Failures State  Connectivity  Cycle sufficiency are still valid  Non loopiness  Randomness  Successor List validity must be relaxed  Finger Validitiy

28. 28 Cycle With Failures State  Ideal Chord State Randomness: All the nodes in the system are independently and uniformly distributed around the identifier circle.  Cycle With Failures State Randomness: As in the Definiton of the Ideal Chord State All nodes in the system are alive with the probability at least 1/3, even conditioned on the liveness of an arbitrary subset of up to N/4 other nodes

29. 29 Cycle With Failures State  Ideal Chord State Successor list validity: Every u.successor_list contains the first c log N nodes that follow u  Cycle With Failures State Successor list validity: For every node u, let L u denote the live entries in u.successor_list Every |L u | ≥ (c/3) log N Every L u contains exactly the first |L u | live nodes that follow the node u

30. 30 Cycle With Failures State  Ideal Chord State Finger validity: For every node u and every i, the first node following u + 2 i-1 is stored as u.finger[i]  Cycle With Failures State Finger validity: For every node u and index i, if u.finger[i] is alive, then it is the first live node following u + 2 i-1.

31. 31 Cycle With Failures State Lemma: Consider an N-node Chord network with failure state, and suppose that up to N/2 oblivious failures occur at any time during the execution of at least Ω(log N) rounds of idealization. Then with high probability,  Throughout this process, find successor(q) returns the first living successor of q and runs in time O(log N)  The resulting network is in the cycle with failures state

32. 32 The Cycle With Appendage State  A pure join model: A Chord network in which nodes can join No node ever departs

33. 33 The Cycle With Appendage State  Appendages are nodes, that have recently joined the network and are not yet in the cycle.  We refer to this rooted tree as u´s appendage and denote it A u

34. 34 The Cycle With Appendage State  Appendages are nodes, that have recently joined the network and are not yet in the cycle.  We refer to this rooted tree as u´s appendage and denote it A u u AuAu

35. 35 The Cycle With Appendage State 1.Connectivity, Randomness 2.Cycle suffifiency A subset ≤ N/2 is uniformly and independendly distributed around the circle U´s appendage is in O(log N) 3.Non loopiness The cycle is non-loopy In every appendage, the path of successors from v is increasing 4.Successor validity: For every node v If v is on the cycle, then v.successor is the first following cycle node If v is in appendage A u then u is the first cycle node following v 5.Finger validity: There is a set S of N/2 nodes on the cycle that are uniformly and independently distributed, so that for every node u and every 1 ≤ i ≤ m, no element S ever falls between u + 2 i-1 and finger [i]

36. 36 The Cycle With Appendage State  Lemma: Consider an N-node Chord network in the cycle with appendage state and suppose that N nodes join the network, each using arbitrary node to bootstrap on, over at least Ω(log² N) rounds of idealization. Then with high probability: Throughout this process, find_successor(q) returns the cycle successor s of q or a node u in A s so that q ≤ u < s and runs in O(log N) time. After this process, the resulting network is in the cycle with appendage state.

37. 37 Cycle with failures and appendages state  In this state, we simultanously consider joins and failures  Most of the conditions were imposed for either the pure join or failure case  Few conditions must be modified slightly to account for interactions between joins and failures

38. 38 Cycle with failures and appendages state Start with a network of N nodes in the cycle with failures and appendages state with successor lists of length c log N, and allow up to N oblivious joins and N/2 oblivious failures at arbitrary times over at least log² N = O(1) rounds of idealization. Then, with high probability. 1.Throughout this process, find_successor(q) returns the first live cycle successor s of q or a node u in As so that q ≤ u < s, and runs in O(log N) time 2.The resulting network is the cycle with failures and appendages state.

39. 39 Conclusion  Limited amount of houskeeping work (down to O(log N)) per node allows the system to resolve queries effeciently  This system postulates that the half life time is known. Is it possible to determine this rate from observation of the others?  What happens if messages are lost?

40. 40 Questions?