The Chord P2P Network

1
The Chord P2P Network

• Some slides taken from the original presentation
  by the authors

2
Main features of Chord

• Load balancing via Consistent Hashing
• Small routing tables log n
• Small routing delay log n
• Fast join/leave protocol

3
Consistent Hashing
Assigns both nodes and objects from an m-bit
key. Order these nodes around an identifier
circle according to the order of their keys (0
.. 2m-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)
4
Consistent Hashing
(0)
D120
N105
D20
N128 Circular 7-bit ID space
N32
N90
D80
Example Node 90 is the successor of document
80.
5
Consistent Hashing
Property 1 If there are N nodes and K keys, then
with high probability, each node is responsible
for (1? )K/N keys. (? O(log N) Property
2 When an (N1) 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.
6
Consistent hashing Karger 97
Key 5
K5
Node 105
N105
K20
Circular 7-bit ID space
N32
N90
K80
A key is stored at its successor node with next
higher ID
7
The log N Fingers
(0)
1/4
1/2
Distance of N80s neighbors from N80
Circular (log N)-bit ID space
1/8
1/16
1/32
1/64
1/128
N80
Each node knows of only log N other nodes.
8
Finger i points to successor of n2i
N120
112
½
¼
1/8
1/16
1/32
1/64
1/128
N80
9
Chord Finger Table
N32s Finger Table
(0)
N113
33..33 N40 34..35 N40 36..39 N40 40..47 N40 48..63
N52 64..95 N70 96..31 N102
N102
N128
N32
N85
N40
N80
N79
N52
Finger table actually contains ID and IP address
N70
N60
Node ns i-th entry first node ? n 2i-1
10
Lookup
N70s Finger Table
71..71 N79 72..73 N79 74..77 N79 78..85 N80 86..10
1 N102 102..5 N102 6..69 N32
Greedy routing
(0)
N113
N32s Finger Table
N102
33..33 N40 34..35 N40 36..39 N40 40..47 N40 48..63
N52 64..95 N70 96..31 N102
N80s Finger Table
N32
N85
81..81 N85 82..83 N85 84..87 N85 88..95 N102 96..1
11 N102 112..15 N113 16..79 N32
N40
N80
N52
N79
N60
N70
Node 32, lookup(82) 32 ? 70 ? 80 ? 85.
11
New Node Join
N20s Finger Table
(0)
N113
N20
1 21..21 2 22..23 3 24..27 4 28..35 5 36..51
6 52..83 7 84..19
N102
N32
N40
N80
N52
N60
N70
Assume N20 knows one of the existing nodes.
12
New Node Join (2)
N20s Finger Table
(0)
N113
N20
21..21 N32 22..23 N32 24..27 N32 28..35 N32 36..5
1 N40 52..83 N52 84..19 N102
N102
N32
N40
N80
N52
N60
N70
Node 20 asks that node for successor to 21, 22,
, 52, 84.
13
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.
14
Steps in join
Linked list insert
n
n
id
id
Successor(n)
Finally
But the transition does not happen immediately
15
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_no
de(id) for i log N downto 1 if (fingeri ?
(n,id) return fingeri
16
Example
N20 wants to find out the successor of key 65
(0)
N113
N20
N102
N32
N40
N80
N52
N70
N60
K65
17
After join move objects
(0)
N20s Finger Table
N113
N20
21..21 N32 22..23 N32 24..27 N32 28..35 N32 36..5
1 N40 52..83 N52 84..19 N102
N102
D114..20
N32
N40
N80
N52
Notify nodes that must include N20 in their
table. N1131N20, not N32.
N60
N70
Node 20 moves documents from node 32.
18
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.
N1101 N20, not N32. Step 3. Transfer
objects to the new node as appropriate.
(Knowledge of predecessor is useful in
stabilization)
19
Concurrent Join
n1
n1
New node n
New node n
New node n
New node n
n2
n2
Before
After
20
Stabilization
Periodic stabilization is needed to integrate the
new node into the network and restore the
invariant.
n1
New node n
New node n
n2
n2
Predecessor.successor(n1) ? n1, so n1
adopts predecessor.successor(n1) n as its new
successor
21
The complexity of join
With high probability, any node joining or
leaving an N-node Chord network will use O(log
2N) messages to re-establish the Chord routing
invariants and finger tables.
22
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.