Robert Morris, M.

Frans Kaashoek, David Karger, Hari Balakrishnan,

Ion Stoica, David Liben-Nowell, Frank Dabek

Chord:
A scalable peer-to-peer
look-up protocol for
internet applications
Acknowledgement
Taken slides from University of California, berkely and
Max planck institute
Overview
 Introduction
 The Chord Algorithm
 Construction of the Chord ring
 Localization of nodes
 Node joins and stabilization
 Failure of nodes
 Applications
 Summary
 Questions
 The lookup problem

N2
N1 N3

Key=“title” Internet
Value=MP3 data…
Publisher

N4 N6
N5 ?
Client
Lookup(“title”)
What is Chord?
 In short: a peer-to-peer lookup service

 Solves problem of locating a data item in a collection

of distributed nodes, considering frequent node
arrivals and departures

 Core operation in most p2p systems is efficient

location of data items

 Supports just one operation: given a key, it maps the

key onto a node
Chord characteristics
 Simplicity, provable correctness, and provable
performance

 Each Chord node needs routing information about only a

few other nodes

 Resolves lookups via messages to other nodes

(iteratively or recursively)

 Maintains routing information as nodes join and leave

the system
Addressed Difficult Problems
(1)

 Load balance: distributed hash function, spreading keys evenly

over nodes

 Decentralization: chord is fully distributed, no node more important

than other, improves robustness

 Scalability: logarithmic growth of lookup costs with number of

nodes in network, even very large systems are feasible

6
Addressed Difficult Problems
(2)

 Availability: chord automatically adjusts its internal tables to ensure

that the node responsible for a key can always be found

 Flexible naming: no constraints on the structure of the keys – key-

space is flat, flexibility in how to map names to Chord keys

7
Overview
 Introduction
 The Chord Algorithm
 Construction of the Chord ring
 Localization of nodes
 Node joins and Stabilization
 Failure/Departure of nodes
 Applications
 Summary
 Questions
The Base Chord Protocol
 Specifies how to find the locations of keys

 How new nodes join the system

 How to recover from the failure or planned

departure of existing nodes
The Chord algorithm –
Construction of the Chord ring
 Hash function assigns each node and key an m-bit identifier using a
base hash function such as SHA-1
 ID(node) = hash(IP, Port)
 ID(key) = hash(key)
 Both are uniformly distributed
 Both exist in the same ID space

 Properties of consistent hashing:

 Function balances load: all nodes receive roughly the same number of keys
– good?

 When an Nth node joins (or leaves) the network, only an O(1/N) fraction of
the keys are moved to a different location
The Chord algorithm –
Construction of the Chord ring

 identifiers are arranged on a identifier circle

m
modulo 2 => Chord ring
 a key k is assigned to the node whose identifier
is equal to or greater than the key‘s identifier
 this node is called successor(k) and is the first
node clockwise from k.
The Chord algorithm –
Construction of the Chord ring
identifier
node
6
X key
1
0 successor(1) = 1
7 1

identifier
successor(6) = 0 6 6 circle 2 2 successor(2) = 3

5 3
4
2

12
Node Joins and Departures

6 1
successor(6) = 7 0
7 1 successor(1) = 3

6 2

5 3
4
2 1

13
The Chord algorithm –
Simple node localization
// ask node n to find the successor of id
n.find_successor(id)
if (id (n; successor])
return successor;
else
// forward the query around the
circle
return successor.find_successor(id);

=> Number of messages linear in

the number of nodes !
The Chord algorithm –
Scalable node localization
 Additional routing information to accelerate
lookups
 Each node n contains a routing table with up
to m entries (m: number of bits of the
identifiers) => finger table
 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
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization

Finger table:
finger[i] =
successor (n + 2 i-1 )
The Chord algorithm –
Scalable node localization
Important characteristics of this scheme:
 Each node stores information about only a
small number of nodes (m)
 Each nodes knows more about nodes closely
following it than about nodes farer away
 A finger table generally does not contain
enough information to directly determine the
successor of an arbitrary key k
The Chord algorithm –
Scalable node localization
 Search in finger table
for the nodes which
most immediatly
precedes id
 Invoke
find_successor
from that node

=> Number of
messages O(log N)!
The Chord algorithm –
Scalable node localization
 Search in finger table
for the nodes which
most immediatly
precedes id
 Invoke
find_successor
from that node

=> Number of
messages O(log N)!
The Chord algorithm –
Node joins and stabilization
The Chord algorithm –
Node joins and stabilization
The Chord algorithm –
Node joins and stabilization
The Chord algorithm –
Node joins and stabilization
 To ensure correct lookups, all successor
pointers must be up to date
 => stabilization protocol running periodically
in the background
 Updates finger tables and successor pointers
The Chord algorithm –
Node joins and stabilization
Stabilization protocol:
 Stabilize(): 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
The Chord algorithm –
Node joins and stabilization
The Chord algorithm –
Node joins and stabilization

• N26 joins the system

• N26 aquires N32 as its successor

• N26 notifies N32

• N32 aquires N26 as its predecessor

The Chord algorithm –
Node joins and stabilization

• N26 copies keys

• N21 runs stabilize() and asks its

successor N32 for its predecessor
which is N26.
The Chord algorithm –
Node joins and stabilization

• N21 aquires N26 as its successor

• N21 notifies N26 of its existence

• N26 aquires N21 as predecessor

 Node Joins – with Finger
Tables
finger table keys
start int. succ. 6
1 [1,2) 1
2 [2,4) 3
4 [4,0) 0
6

finger table keys

0 start int. succ. 1

7 1 2 [2,3) 3
3 [3,5) 3
5 [5,1) 0
6
finger table keys
start int. succ. 6 2
7 [7,0) 0
0 [0,2) 0 finger table keys
2 [2,6) 3
5 3 start int. succ. 2
4 [4,5) 6
0
4 5 [5,7) 0
6
7 [7,3) 0

38
 Node Departures – with Finger Tables
finger table keys
start int. succ.
1 [1,2) 3
1
2 [2,4) 3
4 [4,0) 0
6

finger table keys

0 start int. succ. 1

7 1 2 [2,3) 3
3 [3,5) 3
5 [5,1) 0
6
finger table keys
start int. succ. 6 6 2
7 [7,0) 0
0 [0,2) 0 finger table keys
2 [2,6) 3
5 3 start int. succ. 2
4 [4,5) 6
4 5 [5,7) 6
7 [7,3) 0

39
The Chord algorithm –
Impact of node joins on lookups
 All finger table entries
are correct =>
O(log N) lookups
 Successor pointers
correct, but fingers
inaccurate =>
correct but slower
lookups
The Chord algorithm –
Impact of node joins on lookups
 Incorrect successor pointers => lookup might
fail, retry after a pause
 But still correctness!
The Chord algorithm –
Impact of node joins on lookups
 Stabilization completed => no influence on
performence
 Only for the negligible case that a large
number of nodes joins between the target‘s
predecessor and the target, the lookup is
slightly slower
 No influence on performance as long as
fingers are adjusted faster than the network
doubles in size
The Chord algorithm –
Failure of nodes
 Correctness relies on
correct successor
pointers
 What happens, if N14,
N21, N32 fail
simultaneously?
 How can N8 aquire
N38 as successor?
The Chord algorithm –
Failure of nodes
 Correctness relies on
correct successor
pointers
 What happens, if N14,
N21, N32 fail
simultaneously?
 How can N8 aquire
N38 as successor?
The Chord algorithm –
Failure of nodes
 Each node maintains a successor list of size r
 If the network is initially stable,
and every node fails with probability ½,
find_successor still finds the closest living
successor to the query key and
the expected time to execute find_succesor is
O(log N)
Experimental Results

 Latency grows slowly with the total

number of nodes

 Path length for lookups is about ½

log2N

 Chord is robust in the face of

multiple node failures

46
The Chord algorithm –
Failure of nodes
Massive failures have little impact
1,4
Failed Lookups (Percent)

1,2 (1/2)6 is 1.6%

1
0,8
0,6
0,4
0,2
0
5 10 15 20 25 30 35 40 45 50

Failed Nodes (Percent)

Overview
 Introduction
 The Chord Algorithm
 Construction of the Chord ring
 Localization of nodes
 Node joins and stabilization
 Failure/Departure of nodes
 Applications
 Summary
 Questions
Applications:
Time-shared storage
 for nodes with intermittent connectivity
(server only occasionally available)
 Store others‘ data while connected, in return
having their data stored while disconnected
 Data‘s name can be used to identify the live
Chord node (content-based routing)
Applications:
Chord-based DNS
 DNS provides a lookup service
keys: host names values: IP adresses
Chord could hash each host name to a key
 Chord-based DNS:
 no special root servers
 no manual management of routing information
 no naming structure
 can find objects not tied to particular machines
Summary
 Simple, powerful protocol
 Only operation: map a key to the responsible
node
 Each node maintains information about O(log
N) other nodes
 Lookups via O(log N) messages
 Scales well with number of nodes
 Continues to function correctly despite even
major changes of the system