1 / 135

CS 347: Parallel and Distributed Data Management Notes 08: P2P Systems

CS 347: Parallel and Distributed Data Management Notes 08: P2P Systems. Hector Garcia-Molina. Peer To Peer Systems. Distributed application where nodes are: Autonomous Very loosely coupled Equal in role or functionality Share & exchange resources with each other. Related Terms.

howardballard
Download Presentation

CS 347: Parallel and Distributed Data Management Notes 08: P2P Systems

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 347: Parallel and DistributedData ManagementNotes 08: P2P Systems Hector Garcia-Molina Notes08

  2. Peer To Peer Systems • Distributed application where nodes are: • Autonomous • Very loosely coupled • Equal in role or functionality • Share & exchangeresources with each other Notes08

  3. Related Terms • File Sharing • Ex: Napster, Gnutella,Kaaza, E-Donkey,BitTorrent, FreeNet,LimeWire, Morpheus • Grid Computing • Autonomic Computing Notes08

  4. Search in a P2P System Resources:R3,1, R3,2, ... Query: Who has X? Resources:R2,1, R2,2, ... Resources:R1,1, R1,2, ... Notes08

  5. Search in a P2P System Resources:R3,1, R3,2, ... Query: Who has X? Resources:R2,1, R2,2, ... answers Resources:R1,1, R1,2, ... Notes08

  6. Search in a P2P System Resources:R3,1, R3,2, ... Query: Who has X? Resources:R2,1, R2,2, ... answers receive resource request resource Resources:R1,1, R1,2, ... Notes08

  7. Distributed Lookup • Have <k, v> pairs • Given k, find matching values v k lookup(4) = {a, d} 1 a 1 b 4 a 7 c 3 a 1 a 4 d Notes08

  8. Data Distributed Over Nodes • N nodes • Each holds some <k,v> data Notes08

  9. Notation • X.func(params) means RPC ofprocedure func(params) at node X • X.A means send message to X to getvalue of A • If X omitted, we refer to local procedureor data structures ... B := X.A A := X.f(B) ... node Y data: A, B... node X data: A, B... Notes08

  10. Distributed Hashing • Chord • Replicated HT Chord Paper: Ion Stoica, Robert Morris, David Liben-Nowell, David R. Karger, M. Frans Kaashoek, Frank Dabek, Hari Balakrishnan,Chord: A Scalable Peer-to-peer Lookup Protocol for Internet Applications.IEEE/ACM Transactions on Networking http://pdos.csail.mit.edu/chord/papers/paper-ton.pdf Notes08

  11. Hashing Values and Nodes • H(v) is m-bit number (v is value) • H(X) is m-bit number (X is node id) • Hash function is “good” H(k) 2m - 1 0 H(Y) H(X) stored at Y k v Notes08

  12. Chord Circle m=6 N1 N56 N8 K54 N51 K10 N14 N48 N21 N42 K38 N38 K24, K30 N32 Notes08

  13. Rule • Consider nodes X, Y such that Y follows X clockwise • Node Y is responsible for keys k such that H(k) in ( H(X), H(Y) ] use hashedvalues...e.g., N54 is nodewhose id hashesto 54. N54 N3 stores K55, K56, ... K3 Notes08

  14. Succ, pred links m=6 N1.pred N1 N56 N8 N1.succ N51 N14 N48 N21 N42 N38 N32 Notes08

  15. Search using succ links m=6 N1 N56 N8 N51.find_succ(K52) N14.find_succ(K52) N51 =N56 N14 N48 N21 N42 N38 N32 Notes08

  16. Code • X.find_succ(k) if k in (X, succ] return succ else return succ.find_succ(k); Notes08

  17. Notation: Use of Hashed Values • X.find_succ(k) if k in (X, succ] return succ else return succ.find_succ(k); should be • X.find_succ(k) if H(k) in (H(X), H(succ)] return succ else return succ.find_succ(k); Notes08

  18. Code • X.find_succ(k) if k in (X, succ] return succ else return succ.find_succ(k); • Note: What happens if k stored by X? • Case 1: k< X • Case 2: k=X Notes08

  19. Looking Up Data • X.DHTlookup(k) Y := find_succ(k); S := Y.lookup(k); return S; • Y.lookup(k) returns local values associated with k Notes08

  20. Another Version • X.DHTlookup(k) X.find_succ(k, X); wait[ans(k, S)]: return S; • X.find_succ(k, Y) if k in (X, succ] Y.ans(k, succ.lookup(k)) else succ.find_succ(k, Y); combines find and lookup; avoids chain of returns Notes08

  21. Inserting Data • X.DHTinsert(k, v) Y := find_succ(k); Y.insert(k, v); • Y.insert(k, v) inserts [k,v] in local storage Notes08

  22. Another Version • X.DHTinsert(k, v) if k in (X, succ] succ.insert(k,v) else succ.DHTinsert(k, v); Notes08

  23. Finger Table m=6 finger table for N8 N1 N8+1 N14 N56 N8 N8+2 N14 N51 N8+4 N14 N14 N48 N8+8 N21 N8+16 N32 N8+32 N42 N21 N42 N38 N32 Notes08

  24. Finger Table m=6 finger table for N8 N1 N8+1 N14 N56 N8 N8+2 N14 N51 N8+4 N14 N14 N48 N8+8 N21 N8+16 N32 N8+32 N42 N21 N42 N38 Node responsible forkey 8+32 = 40 N32 Notes08

  25. Example N1 find_succ(K54) N56 N8 N51 N14 N48 N21 N42 N38 N32 Notes08

  26. Example N1 find_succ(K54) N56 N8 N51 N14 N48 N21 N42 N38 N32 Notes08

  27. Example N1 find_succ(K54) N56 N8 K54 N51 N14 N48 N21 N42 N38 N32 Notes08

  28. Code • X.find_succ(id) if id in (X, succ] return succ else Y := closest_preceed(id); return Y.find_succ(id); • X.closest_preceed(id) for i := m downto 1 if finger[i] in (X,id) return finger[i]; return X; Notes08

  29. Another Example N1 find_succ(K7) N56 N8 N51 N14 N48 N21 N42 N38 N32 Notes08

  30. Example N1 find_succ(K7) N56 N8 N51 N14 N48 N21 N42 N38 N32 Notes08

  31. Example return N8 N1 K7 find_succ(K7) N56 N8 N51 N14 N48 N21 N42 N38 N32 Notes08

  32. Yet Another Example N1 find_succ(K8) N56 N8 N51 N14 N48 N21 N42 N38 N32 Notes08

  33. there seems to be a bug in code of Slide 26 (which is the same as Figure 5 of Chord paper). Yet Another Example N1 find_succ(K8) N56 N8 return N8 N51 N14 N48 N21 N42 N38 N32 Notes08

  34. Adding Nodes to Circle • need to • update links • move data N1 N56 N8 K54 N51 K10 N14 N48 joining node N26 N21 N42 for now, assume nodes never die K38 N38 K24, K30 N32 Notes08

  35. New Node X Joins • Node Y is known to be in ring • X.join(Y) pred := nil; succ := Y.find_succ(X); Notes08

  36. Periodic Stabilization • X.stabilize() Y := succ.pred; if Y in (X, succ) succ := Y; succ.notify(X); • X.notify(Z) if pred = nil OR Z in (pred, X) pred := Z; Notes08

  37. Periodic Finger Check • X.fix_fingers() next := next + 1; if next > m next := 1; finger[next] := find_succ(X+2next-1) Notes08

  38. Join Example Nx Np Ns Notes08

  39. Join Example after join: nil Nx Np Ns Notes08

  40. Join Example after Nx.stabilize: Y= Np nil Nx Np Ns Notes08

  41. Join Example after Np.stabilize: Y= Nx Nx Np Ns Notes08

  42. Moving Data: When? keys in (Np, Nx] keys in (Np, Ns] Nx Np Ns Notes08

  43. Move Data After Ns.notify(Nx) nil Nx Np Ns send all keys in range (Np, Nx] when Ns.prev is updated... Notes08

  44. Periodic Stabilization • X.notify(Z) if pred = nil OR Z in (pred, X) Z.give(data in range (pred ,Z] ) pred := Z X.remove(data in range (pred ,Z] ) Question: What data do we give when pred=nil? Note: We are glossing over concurrency issues,e.g., what happens to lookups while we are moving data? Notes08

  45. Lookup May be at Wrong Node! resp. for (Np, Nx] nil Nx resp. for (Nx, Ns] Np Ns lookup for k in (Np, Nx]directed to Ns! Notes08

  46. Looking Up Data (Revised) • X.DHTlookup(k) ok := false while not ok do Y := find_succ(k) [ok, S] := Y.lookup(k) return S • Y.lookup(k) if k in (pred, Y] return [true, local values for k] else return [false, {}] Notes08

  47. Inserting Data (Revised) • X.DHTinsert(k, v) ok := false while not ok do Y := find_succ(k) ok := Y.insert(k, v) • Y.insert(k, v) if k in (pred, Y] insert [k,v] in local storage return true else return false Notes08

  48. Why Does This Work? • pred, succ links eventually correct • data ends up at correct node key k is at node X where k in (X.prev, X] • finger pointers speed up searchesbut do not cause problems Notes08

  49. Results for N Node System • With high probability, the number of nodes that must be contacted to find a successor is O(log N) • Although finger table contains room for m entries, only O(log N) need to be stored • Experimental results show average lookup time is (log N)/2 Notes08

  50. Node Failures k7 v7 data at Nx: k8 v8 k9 v9 Nx Np Ns Nx dies!! - links screwed up - data lost Notes08

More Related