Skip to main content
An Overview of Peer-to-Peer

         Sami Rollins
           11/14/02
Outline
• P2P Overview
  – What is a peer?
  – Example applications
  – Benefits of P2P
• P2P Content Sharing
  – Challenges
  – Group management/data placement approaches
  – Measurement studies
What is Peer-to-Peer (P2P)?
• Napster?
• Gnutella?
• Most people think of P2P as music sharing
What is a peer?
• Contrasted with
  Client-Server model
• Servers are centrally
  maintained and
  administered
• Client has fewer
  resources than a server
What is a peer?
• A peer’s resources are
  similar to the
  resources of the other
  participants
• P2P – peers
  communicating
  directly with other
  peers and sharing
  resources
Levels of P2P-ness
• P2P as a mindset
  – Slashdot
• P2P as a model
  – Gnutella
• P2P as an implementation choice
  – Application-layer multicast
• P2P as an inherent property
  – Ad-hoc networks
P2P Application Taxonomy

                          P2P Systems




Distributed Computing File Sharing   Collaboration   Platforms
     SETI@home          Gnutella        Jabber         JXTA
P2P Goals/Benefits
•   Cost sharing
•   Resource aggregation
•   Improved scalability/reliability
•   Increased autonomy
•   Anonymity/privacy
•   Dynamism
•   Ad-hoc communication
P2P File Sharing
• Content exchange
  – Gnutella
• File systems
  – Oceanstore
• Filtering/mining
  – Opencola
P2P File Sharing Benefits
•   Cost sharing
•   Resource aggregation
•   Improved scalability/reliability
•   Anonymity/privacy
•   Dynamism
Research Areas
•   Peer discovery and group management
•   Data location and placement
•   Reliable and efficient file exchange
•   Security/privacy/anonymity/trust
Current Research
• Group management and data placement
  – Chord, CAN, Tapestry, Pastry
• Anonymity
  – Publius
• Performance studies
  – Gnutella measurement study
Management/Placement Challenges
•   Per-node state
•   Bandwidth usage
•   Search time
•   Fault tolerance/resiliency
Approaches
• Centralized
• Flooding
• Document Routing
Centralized
                               Bob    Alice


• Napster model
• Benefits:
  – Efficient search
  – Limited bandwidth usage
  – No per-node state
• Drawbacks:
  – Central point of failure   Judy    Jane

  – Limited scale
Flooding
                                  Carl         Jane

• Gnutella model
• Benefits:
  – No central point of failure
  – Limited per-node state
• Drawbacks:                             Bob

  – Slow searches
  – Bandwidth intensive                               Alice
                                  Judy
Document Routing
                                   001                 012


• FreeNet, Chord, CAN,
  Tapestry, Pastry model                       212 ?
                                                             212 ?
• Benefits:
                                         332
   – More efficient searching
                                                                212
   – Limited per-node state       305

• Drawbacks:
   – Limited fault-tolerance vs
     redundancy
Document Routing – CAN
• Associate to each node and item a unique id in an
  d-dimensional space
• Goals
   – Scales to hundreds of thousands of nodes
   – Handles rapid arrival and failure of nodes
• Properties
   – Routing table size O(d)
   – Guarantees that a file is found in at most d*n1/d steps,
     where n is the total number of nodes

          Slide modified from another presentation
CAN Example: Two
              Dimensional Space
• Space divided between nodes
                                  7
• All nodes cover the entire      6
  space
                                  5
• Each node covers either a
                                  4
  square or a rectangular area of
  ratios 1:2 or 2:1               3
                                              n1
• Example:                        2

   – Node n1:(1, 2) first node that   1

     joins  cover the entire space   0

                                          0    1   2   3   4   5   6   7



            Slide modified from another presentation
CAN Example: Two
            Dimensional Space
• Node n2:(4, 2) joins  space
                                  7
  is divided between n1 and n2
                                  6

                                   5

                                   4

                                   3
                                           n1           n2
                                   2

                                   1

                                  0

                                       0    1   2   3   4    5   6   7



           Slide modified from another presentation
CAN Example: Two
            Dimensional Space
• Node n2:(4, 2) joins  space
                                  7
  is divided between n1 and n2
                                  6
                                                    n3
                                   5

                                   4

                                   3
                                           n1            n2
                                   2

                                   1

                                  0

                                       0    1   2    3   4    5   6   7



           Slide modified from another presentation
CAN Example: Two
            Dimensional Space
• Nodes n4:(5, 5) and n5:(6,6)
                                  7
  join
                                  6                                n5
                                                    n3        n4
                                   5

                                   4

                                   3
                                           n1            n2
                                   2

                                   1

                                  0

                                       0    1   2    3   4     5    6   7



           Slide modified from another presentation
CAN Example: Two
             Dimensional Space
• Nodes: n1:(1, 2); n2:(4,2); n3:
                                  7
  (3, 5); n4:(5,5);n5:(6,6)
                                  6                                       n5
• Items: f1:(2,3); f2:(5,1); f3:                          n3        n4
                                  5                                            f4
  (2,1); f4:(7,5);
                                    4
                                                 f1
                                    3
                                            n1                 n2
                                    2
                                                 f3
                                    1

                                   0                                 f2

                                        0    1        2    3   4     5     6        7



            Slide modified from another presentation
CAN Example: Two
            Dimensional Space
• Each item is stored by the
                                 7
  node who owns its mapping
  in the space                   6
                                                        n3        n4
                                                                        n5

                                  5                                          f4

                                  4
                                               f1
                                  3
                                          n1                 n2
                                  2
                                               f3
                                  1

                                 0                                 f2

                                      0    1        2    3   4     5     6        7



          Slide modified from another presentation
CAN: Query Example
• Each node knows its
  neighbors in the d-space          7

• Forward query to the              6                                     n5
                                                                    n4
  neighbor that is closest to the   5
                                                          n3
                                                                               f4
  query id                          4
• Example: assume n1 queries        3
                                                 f1

  f4                                        n1                 n2
                                    2
• Can route around some                          f3
                                    1
  failures                                                           f2
                                    0
   – some failures require local
                                        0    1        2    3   4     5     6        7
     flooding
            Slide modified from another presentation
CAN: Query Example
• Each node knows its
  neighbors in the d-space          7

• Forward query to the              6                                     n5
                                                                    n4
  neighbor that is closest to the   5
                                                          n3
                                                                               f4
  query id                          4
• Example: assume n1 queries        3
                                                 f1

  f4                                        n1                 n2
                                    2
• Can route around some                          f3
                                    1
  failures                                                           f2
                                    0
   – some failures require local
                                        0    1        2    3   4     5     6        7
     flooding
            Slide modified from another presentation
CAN: Query Example
• Each node knows its
  neighbors in the d-space          7

• Forward query to the              6                                     n5
                                                                    n4
  neighbor that is closest to the   5
                                                          n3
                                                                               f4
  query id                          4
• Example: assume n1 queries        3
                                                 f1

  f4                                        n1                 n2
                                    2
• Can route around some                          f3
                                    1
  failures                                                           f2
                                    0
   – some failures require local
                                        0    1        2    3   4     5     6        7
     flooding
            Slide modified from another presentation
CAN: Query Example
• Each node knows its
  neighbors in the d-space          7

• Forward query to the              6                                     n5
                                                                    n4
  neighbor that is closest to the   5
                                                          n3
                                                                               f4
  query id                          4
• Example: assume n1 queries        3
                                                 f1

  f4                                        n1                 n2
                                    2
• Can route around some                          f3
                                    1
  failures                                                           f2
                                    0
   – some failures require local
                                        0    1        2    3   4     5     6        7
     flooding
            Slide modified from another presentation
Node Failure Recovery
• Simple failures
  – know your neighbor’s neighbors
  – when a node fails, one of its neighbors takes
    over its zone
• More complex failure modes
  – simultaneous failure of multiple adjacent nodes
  – scoped flooding to discover neighbors
  – hopefully, a rare event

       Slide modified from another presentation
Document Routing – Chord
                                  N5

                                        N10
                           N110              K19
• MIT project                             N20
• Uni-dimensional ID      N99
  space                                       N32
• Keep track of log N
  nodes
                            N80
• Search through log N
  nodes to find desired key       N60
Doc Routing – Tapestry/Pastry
                                   43F
                                                 993
                       13F          E
                                                  E
                        E
• Global mesh
• Suffix-based routing
                               73F                           F99
• Uses underlying network       E                             0
  distance in constructing                 04F
                                            E
  mesh
                                                       999
                             ABF                        0
                              E


                                         239
                                          E                  129
                                                              0
Comparing Guarantees
           Model         Search   State

Chord         Uni-       log N    log N
           dimensional
             Multi-
CAN                      dN1/d    2d
           dimensional

Tapestry   Global Mesh   logbN    b logbN


Pastry      Neighbor     logbN    b logbN + b
              map
Remaining Problems?
• Hard to handle highly dynamic
  environments
• Usable services
• Methods don’t consider peer characteristics
Measurement Studies
•   “Free Riding on Gnutella”
•   Most studies focus on Gnutella
•   Want to determine how users behave
•   Recommendations for the best way to
    design systems
Free Riding Results
• Who is sharing what?
• August 2000
   The top             Share       As percent of whole
   333 hosts (1%)      1,142,645   37%
   1,667 hosts (5%)    2,182,087   70%
   3,334 hosts (10%)   2,692,082   87%
   5,000 hosts (15%)   2,928,905   94%
   6,667 hosts (20%)   3,037,232   98%
   8,333 hosts (25%)   3,082,572   99%
Saroiu et al Study
• How many peers are server-like…client-
  like?
  – Bandwidth, latency
• Connectivity
• Who is sharing what?
Saroiu et al Study
• May 2001
• Napster crawl
  – query index server and keep track of results
  – query about returned peers
  – don’t capture users sharing unpopular content
• Gnutella crawl
  – send out ping messages with large TTL
Results Overview
• Lots of heterogeneity between peers
  – Systems should consider peer capabilities
• Peers lie
  – Systems must be able to verify reported peer
    capabilities or measure true capabilities
Measured Bandwidth
Reported Bandwidth
Measured Latency
Measured Uptime
Number of Shared Files
Connectivity
Points of Discussion
• Is it all hype?
• Should P2P be a research area?
• Do P2P applications/systems have common
  research questions?
• What are the “killer apps” for P2P systems?
Conclusion
• P2P is an interesting and useful model
• There are lots of technical challenges to be
  solved