Outline. General. Chord ID Space. Lookup Algorithm Properties. Chapter 5: Peer-to-Peer Systems. Chord. Systems. Chapter 5: Case study: Chord

Transcription

1 Peer-to to-peer (P2P) Systems Chapter 5: Case study: Outline 1. Basic design 2. Routing algorithms 3. Dynamics 4. Enhancements Dmitry G. Korzun, Dmitry G. Korzun, General : A Scalable Peer-to-Peer Lookup Service for Internet Applications Authors: Ion Stoica Robert Morris David Liben-Nowell David R. Karger M. Frans Kaashoek Frank Dabek Hari Balakrishnan Unidirectional ring-based topology Dmitry G. Korzun, Basic design Load balance: acts as a distributed hash function, spreading keys evenly over the nodes; this provides a degree of natural load balance. Decentralization: is fully distributed: no node is more important than any other. This improves robustness and makes appropriate for looselyorganized peer-to-peer applications. Scalability: The cost of a lookup grows as the log of the number of nodes, so even very large systems are feasible. No parameter tuning is required to achieve this scaling. Availability: automatically adjusts its internal tables to reflect newly joined nodes as well as node failures, ensuring that, barring major failures in the underlying network, the node responsible for a key can always be found. This is true even if the system is in a continuous state of change. Flexible naming: places no constraints on the structure of the keys it looks up: the key-space is flat. This gives applications a large amount of flexibility in how they map their own names to keys. Dmitry G. Korzun, Lookup Algorithm Properties Interface: lookup(key) -> IP address Efficient: O(log N) messages per lookup N is the total number of servers Scalable: O(log N) state per node Robust: survives massive failures Simple to analyze ID Space IDs are ordered in an identifier circle modulo 2 m m is the number of bits (m-bit IDs) Key ID = SHA-1(key) Node ID = SHA-1(IPaddr) SHA-1 1 distributes IDs uniformly Dmitry G. Korzun, Dmitry G. Korzun,

2 Assigning keys to nodes Key k is assigned to the first node whose ID is equal or follows k in the ID space (clockwise) Successor: : node with next higher ID Successors Successor node for k Succ(k) Succ(k) ) is the first alive node clockwise from k Succ(.) works both for keys and node IDs Dmitry G. Korzun, Dmitry G. Korzun, Dynamics Nodes join and leave minimal disruption of the overlay When node s joins, certain keys of succ(s) become assigned to s When s leaves, all of its keys are reassigned to succ(s) No other changes in key assignment Consistent hashing With high probability the hash function balances load nodes receive roughly the same number of keys With high probability, when an Nth node joins (or leaves) the network, only O(1/N) keys are moved to a different location the minimum necessary to maintain a balanced load Let s consider an example Dmitry G. Korzun, Dmitry G. Korzun, Consistent hashing Theorem. For any set of N nodes and K keys, with high probability: 1. Each node is responsible for at most (1+e)K/N keys, where e=o(log N) 2. When a node (N+1) joins or leaves the network, responsibility for O(K/N) keys changes (and only to or from the joining or leaving node) 2. Routing algorithms Simple Key Location, O(N) Scalable Key Location, O(log N) Dmitry G. Korzun, Dmitry G. Korzun,

3 Simple Key Location (a) Pseudocode (b) Path 8 -> > 56 for lookup with key 54 Simple lookup #hops is linear in N O(N) Node s immediate successor is a shortrange contact Correctness depends only on successors Additional information is needed to accelerate lookups Dmitry G. Korzun, Dmitry G. Korzun, distance metric Distance ρ(u,v) is length (the number of all possible IDs) of the ring arc between u and v in clockwise direction fingers Routing table is predecessors + successors + fingers Finger[k]=succ(n+2 k-1 ) Finger[2..m] are long-range contacts Dmitry G. Korzun, Dmitry G. Korzun, Long-range contacts Scalable Key Location Finger[k]=succ(n+2 k-1 ) Distances of powerof-two intervals 1/8 ¼ ½ Small routing state at a node Predecessors, p=3 (not used at basic routing) Successors&Fingers, m=log N Distances of power-of-two intervals Geometrically progressive routing 1/16 1/32 1/64 1/128 Node Dmitry G. Korzun, Dmitry G. Korzun,

4 Scalable lookup Theorem. With high probability the number of nodes that must be contacted to find a successor is O(log N). Example lookup(54) started at N8, completed at N56 (a) (b) Intuitively: Initially, there are at most N=2 m hops between source and destination nodes Routing halves the distance at each hop u -> [u+2 i-1, u+2 i ] Within m hops the distance will be one On average, ½ log N hops (also by experiments) Dmitry G. Korzun, Dmitry G. Korzun, Dynamics Stabilization protocol join() stabilize() notify() fix_fingers() check_predecessor() Node joins and stabilization must ensure that each finger is up to date Stabilization protocol It aims to guarantee that, for any node u, the predecessor of the successor of node u is the node u itself Dmitry G. Korzun, Dmitry G. Korzun, Stabilization Pseudocode for stabilization The join() function join() asks n to find the immediate successor of n it does not make the rest of the network aware of n Dmitry G. Korzun, Dmitry G. Korzun,

5 The stabilize() function Every node runs stabilize() periodically to learn about newly joined nodes Each time node n runs stabilize(), it asks its successor for the successor s predecessor p, and decides whether p should be n s successor instead e.g., if node p recently joined the system In addition, stabilize() notifies node n s successor of n s existence, giving the successor the chance to change its predecessor to n The successor does this only if it knows of no closer predecessor than n The fix_fingers() function Each node periodically calls fix_fingers() to make sure its finger table entries are correct new nodes initialize their finger tables existing nodes incorporate new nodes into their finger tables Dmitry G. Korzun, Dmitry G. Korzun, The check_predecessor() function Each node also runs check_predecessor() periodically, to clear the node s predecessor pointer if n.predecessor has failed accepting a new predecessor in notify Node joins (a) (b) (c) (d) Node 26 joins the system between nodes 21 and 32. The arcs represent the successor relationship. (a) Initial state: node 21 points to node 32; (b) node 26 finds its successor (i.e., node 32) and points to it; (c) node 26 copies all keys between 26 and 22 from node 32; (d) stabilize procedure updates the successor of node 21 to node 26 Dmitry G. Korzun, Dmitry G. Korzun, Invariant cyclic topology Theorem. If any sequence of join operations is executed interleaved with stabilizations, then at some time after the last join the successor pointers will form a cycle on all the nodes in the network In other words, after some time each node is able to reach any other node in the network by following successor pointers Dmitry G. Korzun, Node departures Stabilization protocol also helps when nodes voluntarily leave the network Two enhancements can improve performance Node n that is about to leave may transfer its keys to its successor before it departs Node n may notify its predecessor p and successor s before leaving node p will remove n from its successor list, and add the last node in n s successor list to its own list Node s will replace its predecessor with n s predecessor p Dmitry G. Korzun,

6 Discussion Play a role of nodes (each student acts as a node) Joining Routing Leaving Don t forget about the stabilization! 4. Enhancements Node s routing table: successors (r) fingers (m or log N) predecessors (p) Improvements robustness failures Replication strong stabilization Dmitry G. Korzun, Dmitry G. Korzun, Weak stabilization Strong stabilization It aims to guarantee that, for any node u, the predecessor of the successor of node u is the node u itself A local consistency condition that is necessary, but not sufficient, for proper behavior in a network A weakly stable loopy network Extend the weak stabilization protocol by allowing each node u to maintain a second successor pointer The 2 nd successor is generated by self-search and improved in the same way as in the 1 st one Pseudocode for strong stabilization Dmitry G. Korzun, Dmitry G. Korzun, Extensions to routing table Three parts of routing table 1. Immediate predecessors 2. Immediate successors 3. Fingers Power-of-two intervals but more freedom (not only succ(s+2 i-1 )) Additionally, other long-distance contacts are possible Applications Fault tolerance (backup predecessors and successors) Alternatives for the next hop Optimization Successor List Length (short-range range contacts) Assume 1/2 of nodes fail P(successor list all dead) = (1/2) r i.e., P(this node breaks the ring) Independent failures P(no broken nodes) = (1 (1/2) r ) N r = 2log(N) makes prob. = 1 1/N Dmitry G. Korzun, Dmitry G. Korzun,