Download presentation

Presentation is loading. Please wait.

Published byJulio Berkey Modified over 5 years ago

1
The Chord P2P Network Some slides have been borowed from the original presentation by the authors

2
Chord vs.Tapestry The topology of the Chord network, as defined by the successor pointers, must satisfy a well-defined structure. Tapestry requires the root of the object to be placed in a designated node, but the object can be placed locally. In contrast, Chord requires the object to be placed at a designated node.

3
Main features of Chord Load balancing via Consistent Hashing Small routing tables: log n Small routing delay: log n hops Fast join/leave protocol (polylog time)

4
Consistent Hashing Assigns both nodes and objects from an m-bit key. Order these nodes around an identifier circle (what does a circle mean here?) according to the order of their keys (0.. 2 m -1). This ring is known as the Chord Ring. Object with key k is assigned to the first node whose key is ≥ k (called the successor node of key k)

5
Consistent Hashing N32 N90 N105 D80 D20 D120 Example: Node 90 is the “successor” of document 80. (0) N=128 Circular 7-bit ID space

6
Consistent Hashing [Karger 97] Property 1 If there are N nodes and K keys, then with high probability, each node is responsible for (1+ )K/N keys. Property 2 When a node joins or leaves the network, the responsibility of at most O(K/N) keys changes hand (only to or from the node that is joining or leaving. When K is large, the impact is quite small.

7
Consistent hashing N32 N90 N105 K80 K20 K5 Circular 7-bit ID space Key 5 Node 105 A key k is stored at its successor (node with key ≥ k)

8
The log N Fingers (0) Each node knows of only log N other nodes. N80 1/8 1/16 1/32 1/64 1/128 Circular (log N)-bit ID space Distance of N80’s neighbors from N80 1/4 1/2

9
Finger i points to successor of n+2 i N80 ½ ¼ 1/8 1/16 1/32 1/64 1/128 112 N120

10
Chord Finger Table (0) N32 N60 N79 N70 N113 N102 N40 N52 33..33N40 34..35N40 36..39N40 40..47N40 48..63N52 64..95N70 96..31N102 Node n’s i-th entry: first node n + 2 i-1 N32’s Finger Table N80 N85 N=128 Finger table actually contains ID and IP address

11
Lookup 33..33N40 34..35N40 36..39N40 40..47N40 48..63N52 64..95N70 96..31N102 N32’s Finger Table Node 32, lookup(82): 32 70 80 85. 71..71N79 72..73N79 74..77N79 78..85N80 86..101N102 102..5N102 6..69N32 N70’s Finger Table (0) N32 N60 N79 N70 N113 N102 N40 N52 N80 N85 81..81N85 82..83N85 84..87N85 88..95N102 96..111N102 112..15N113 16..79N32 N80’s Finger Table Greedy routing

12
New Node Join (0) N32 N60 N80 N70 N113 N102 N40 N52 121..21 222..23 324..27 428..35 536..51 652..83 784..19 N20’s Finger Table N20 Assume N20 knows one of the existing nodes.

13
New Node Join (2) (0) N32 N60 N80 N70 N113 N102 N40 N52 21..21N32 22..23N32 24..27N32 28..35N32 36..51N40 52..83N52 84..19N102 N20’s Finger Table N20 Node 20 asks that node for successor to 21, 22, …, 52, 84.

14
The Join procedure The new node id asks a gateway node n to find the successor of id n.(find_successor(id) if id (n, successor] then return successor else forward the query around the circle fi Needs O(n) messages. This is slow.

15
Steps in join id n Successor(n) id n Finally But the transition does not happen immediately Linked list insert

16
A More Efficient Join // ask n to find the successor of id if id (n, successor] then return successor else n’= closest_ preceding_node (id) return n’.find_successor(id) fi // search for the highest predecessor of id n. closest_preceding_node(id) for i = log N downto 1 if (finger[i] (n,id) return finger[i]

17
Example (0) N32 N60 N80 N70 N113 N102 N40 N52 N20 K65 N20 wants to find out the successor of key 65

18
After join move objects (0) N32 N60 N80 N70 N113 N102 N40 N52 21..21N32 22..23N32 24..27N32 28..35N32 36..51N40 52..83N52 84..19N102 N20’s Finger Table N20 Node 20 moves documents from node 32. D114..20 Notify nodes that must include N20 in their table. N113[1]=N20, not N32.

19
Three steps in join Step 1. Initialize predecessor and fingers of the new node. Step 2. Update the predecessor and the fingers of the existing nodes. ( Thus notify nodes that must include N20 in their table. N110[1] = N20, not N32. Step 3. Transfer objects to the new node as appropriate. ( Knowledge of predecessor is useful in stabilization )

20
Concurrent Join New node n n1 n2 [Before] New node n n2 n1 [After] New node n’

21
Stabilization New node n n2 n1 Predecessor.successor(n1) ≠ n1, so n1 adopts predecessor.successor(n1) = n as its new successor New node n n2 Periodic stabilization is needed to integrate the new node into the network and restore the invariant. n1

22
The complexity of join With high probability, any node joining or leaving an N -node Chord network will use O(log 2 N) messages to re-establish the Chord routing invariants and finger tables.

23
Chord Summary Log(n) lookup messages and table space. Well-defined location for each ID. No search required. Natural load balance. No name structure imposed. Minimal join/leave disruption.

Similar presentations

© 2020 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google