Chord: A scalable peer-to-peer lookup sevice for Internet aaplications


Problems

Chord is an elegant, well designed protocol for structured peer to peer
systems. It provides one basic operation--it maps keys to nodes and allows
an efficent lookup operation for this primitive. Lookup is the most common
operation performed in peer to peer systems and it is a challenge to design
a system that will scale well to millions of nodes. Chord
provides a protocol that does just this -- it is decentralized, simple
and scalable.

Strengths and New Ideas

(1) Simplicity--The idea and fundamental design of Chord is simple. It 
provides a mapping operation using consistent hashing of keys to nodes
responsible for those keys. Since this primitive is application independent, 
it can be used by different peer-to-peer applications. The Chord api is simple to use
and easily understood.

(2) Scalability--Chord is easily scalabale as it says that with high
probability locating a node responsible for a key (lookup) only takes O(log N)
messages where N is the number of nodes. This is fast and scales well as N becomes
large.

(3) Decentralized--It uses a Distributed Hash table and each node in Chord keeps 
information only about few other nodes thus requiring a low amount of memory. This 
results in efficiency and scalability(space cost). Each node adapts(updates it's information)
accordingly as the network topography changes with joins, leaves and fails.

(4) Handles Joins and Departures elegantly--Chord is designed to handle
joins and departures elegantly so that the performance guarantees are not
violated. Joins and departures are the trickiest part to handle since
the information must be redistributed to maintain the topography of the
network. During a leave, the information must be redistributed so that
the other nodes can handle lookups for the keys that the old node was
responsible for. During a join, the new node must share the load of
the system so that load is consistently balanced across the system

(5) Each of the operations joins, leaves, lookups are explained in detail
and give a good idea of how Chord is designed and the challenges involved in
designing a decentralized, scalable peer to peer system.

Weaknesses and Extensions

(1) Chord was not implemented in an actual working peer to peer system. It
would be interesting to see the theoretical work put to practice. While
the authors make a convincing argument to support their claims sometimes
results can be different in the actual network environment. It would
interesting to see how a live system responds to concurrent joins and leaves.

(2) WHile the protocol is defined clearly in simple language, the simulation 
results are described in very terse, mathematical terms
and are not easy to understand. The reader has to spend some time trying
to understand the significance of the results presented in the paper.