Lezione 5 Domande: Laverage path length di Chord con 2^b identificatori e N=2^b nodi è (giustificare la risposta) Laverage path length di Chord con 2^b identificatori e N=2^b nodi è (giustificare la risposta) (b) (b/2) (log(N)) (Nessuna delle precedenti) Dimostrare che x -> ax+b (mod N) non è una funzione hash consistente Dimostrare che x -> ax+b (mod N) non è una funzione hash consistente Descrivere la famiglia dei protocolli F-Chord (suggerimento: mostrare semplicemente le differenze rispetto a Chord) Descrivere la famiglia dei protocolli F-Chord (suggerimento: mostrare semplicemente le differenze rispetto a Chord)

Riepilogo alcune definizioni Sistema distribuito nel quale ogni nodo ha identiche capacità e responsabilità e tutte le comunicazioni sono potenzialmente simmetriche; Siamo interessati ai sistemi P2P di seconda generazione, quelli che supportano DHT (Distributed Hash Table); P2P Puro; Analizzeremo alcuni protocolli Chord like; Si basano sul ring; Si basano sul ring; Utilizzano consistent hashing; Utilizzano consistent hashing; Join/Leave uguali a Chord; Join/Leave uguali a Chord; Cambiano i vicini (finger) e lalgoritmo di routing; Cambiano i vicini (finger) e lalgoritmo di routing; Es: Chord

P2P: Scalabilità Il lavoro richiesto a un determinato nodo nel sistema non deve crescere (o almeno cresce lentamente) in funzione del numero di nodi nel sistema; La scalabilità di un protocollo dipende: dalla topologia della rete; dalla topologia della rete; dallalgoritmo di routing. dallalgoritmo di routing.Obiettivi: Minimizzare il numero di messaggi necessari per fare lookup; Minimizzare il numero di messaggi necessari per fare lookup; Minimizzare, per ogni nodo, le informazioni relative agli altri nodi; Minimizzare, per ogni nodo, le informazioni relative agli altri nodi;

Dal punto di vista topologico Consideriamo una rete P2P come un grafo G=(V,E), dove V è linsieme dei nodi nel sistema e E rappresenta linsieme delle interconnessioni fra essi: Minimizzare, per ogni nodo, le informazioni relative agli altri nodi: Minimizzare, per ogni nodo, le informazioni relative agli altri nodi: minimizzare il grado dei nodi; minimizzare il grado dei nodi; Minimizzare il numero di messaggi necessari per fare lookup: Minimizzare il numero di messaggi necessari per fare lookup: Minimizzare il diametro; Minimizzare laverage path lenght (APL), vale a dire, la distanza media fra due nodi nel grafo. Condizioni necessarie ma non sufficienti

Es. Chord Consideriamo un anello con n=2 b nodi; Ogni nodo x ha un etichetta a b bit che denotiamo con id(x); I vicini del nodo x sono i nodi (x+2 i ) mod 2 b i = 0,1,…,b-1; jump b=3

Es. Chord Quanto valgono: grado? grado? diametro? diametro? average path lenght? average path lenght? b=3 Il grado è b = log n

Es. Chord Dati due nodi x e y la loro distanza d(x,y) è uguale al numero di 1 che ci sono nella stringa binaria (y-x) mod 2 b. Infatti i jump necessari per passare dal nodo x al nodo y sono quelli relativi alla posizione degli 1 nella stringa binaria (y-x) mod 2 b b=3

Es. Chord Calcoliamo la distanza tra il nodo 3 e il nodo 6: (6-3) mod 8 = 3 = 011 (un jump da 2 e uno da 1). (6-3) mod 8 = 3 = 011 (un jump da 2 e uno da 1). Calcoliamo la distanza tra il nodo 6 e il nodo 3: (3-6) mod 8 = 5 = 101 (un jump da 4 e uno da 1). (3-6) mod 8 = 5 = 101 (un jump da 4 e uno da 1) b=3 d(x,y) può essere diverso da d(y,x) Chord non è simmetrico Il diametro è b = log n

grado diametro 1 1 n -1 O(log n) Chord e altri Grafo completo Anello n è il numero dei peer;

Es. Chord Quanto vale laverage path lenght? b=3 N denota linsieme dei nodi

Sistemi P2P uniformi Denotiamo con J x,i liesimo jump del nodo x; Un sistema P2P viene detto uniforme, se per ogni coppia di nodi x e y, si ha J x,i = J y,i i =1,2,…,k. Chord è uniforme? APL sistemi uniformi: Si k=grado l=diametro a è un generico nodo N Per semplicità consideriamo un sistema Chord like

Sistemi P2P uniformi Vantaggi: Facili da implementare e da analizzare; Facili da implementare e da analizzare; Algoritmo di routing semplice (greedy); Algoritmo di routing semplice (greedy); Routing locale, la procedura di lookup interessa solo i nodi che si trovano fra sorgente e destinazione; Routing locale, la procedura di lookup interessa solo i nodi che si trovano fra sorgente e destinazione; Non cè congestione sui nodi, vale a dire il traffico generato dai messaggi di lookup è più o meno uguale per tutti i nodi. Non cè congestione sui nodi, vale a dire il traffico generato dai messaggi di lookup è più o meno uguale per tutti i nodi. Fast bootstrap: Fast bootstrap: Poiché tutti i nodi utilizzano gli stessi jump, è possibile utilizzare la tabella di routing del proprio predecessore per velocizzare notevolmente loperazione di join; Svantaggi: Sfortunatamente non sono gli algoritmi più efficienti. Sfortunatamente non sono gli algoritmi più efficienti. Lo vediamo fra un pò

Es. Chord Quanto vale laverage path lenght? Scegliamo come nodo sorgente il nodo a=00…0; La distanza fra a e il generico nodo x è uguale al numero di bit a 1 nella codifica binaria di x; b=3 a 00…0 00…1 … 11…0 11…1

Fault tolerance and degree Il grado di una rete P2P soggetta a fallimenti deve essere almeno Ω(log n). Infatti, Ω(log n) risulta essere il minimo valore che permette alla rete di rimanere connessa anche nelle condizioni più proibitive; Sketch: Supponiamo che tutti i nodi della rete possono fallire con probabilità ½; Supponiamo che tutti i nodi della rete possono fallire con probabilità ½; Ovviamente un nodo rimane disconnesso se tutti i suoi vicini si disconnettono contemporaneamente; Ovviamente un nodo rimane disconnesso se tutti i suoi vicini si disconnettono contemporaneamente; Vogliamo che la probabilità che un nodo non si disconnetta sia 1- 1/n; Vogliamo che la probabilità che un nodo non si disconnetta sia 1- 1/n; Pr[un nodo non si disconnette]=1-(1/2) k 1-1/n Pr[un nodo non si disconnette]=1-(1/2) k 1-1/n 1/n (1/2) k 2 k n k log n In realtà la prova è un po più complicata, ma questa rende bene lidea k=grado l=diametro

P2P: grado e diametro Abbiamo visto che il grado di una rete P2P soggetta a fallimenti deve essere almeno Ω(log n). Esistono in letteratura molti protocolli che hanno grado e diametro pari a O(log n). E possibile fare di meglio? Fissiamo il grado pari O(log n), qual è il minimo diametro che riusciamo ad ottenere? Fissiamo il grado pari O(log n), qual è il minimo diametro che riusciamo ad ottenere? Fissiamo il grado pari O(log n), qual è il minimo APL che riusciamo ad ottenere? Fissiamo il grado pari O(log n), qual è il minimo APL che riusciamo ad ottenere? Stiamo cercando dei Lower Bound Chord, tapestry, pasty …

P2P: Lower Bound Teorema Dato un grafo G=(V,E) con |V| = n e grado k = O(log n), allora il diametro l = Ω(log n / log (log n)). Prova Dato che il grado è k e il diametro è l, ogni nodo può raggiungere al massimo altri nodi (compreso il nodo stesso). Poiché il grafo deve essere connesso, allora k l+1 > n Poiché il grafo deve essere connesso, allora k l+1 > n l > log k (n) - 1 = Ω(log n / log (log n)). l > log k (n) - 1 = Ω(log n / log (log n)). Con argomentazioni analoghe si può dimostrare che anche lAPL è Ω(log n / log (log n)) in quanto la maggior parte dei nodi si trova a distanza l- O(1). Ma allora Chord non è ottimale!!! k=grado l=diametro

P2P: Lower Bound (Esempio 1) k = log n; Ogni nodo ha grado k (k-1 figli e la radice dellalbero); r raggiunge qualsiasi nodo in al più log k-1 n = O(log n / log (log n)) passi. Il diametro è 1 + log k-1 n =O(log n / log (log n)). … …… k-1 r Il grado in ingresso della radice è n-1

P2P: Lower Bound (Esempio 2) k = log n; Ogni nodo ha grado(entrante più uscente) k ( k/2 -1 ai figli e 1 al padre (x2)); r raggiunge qualsiasi nodo in al più log k/2 -1 n = O(log n / log (log n)) passi. Ogni nodo raggiunge r in al più log k/2 -1 n = O(log n / log (log n)) passi Il diametro è O(log n / log (log n)). … …… k/2 -1 r

P2P: Lower Bound (Esempio 3) k = 6; Ogni nodo ha grado(entrante più uscente) 6 ( 2 ai figli e 1 al padre (x2)); r raggiunge qualsiasi nodo in al più log n passi. Ogni nodo raggiunge r in al più log n passi Il diametro è 2 log n. …… 2 r La mole di traffico che spetta al nodo r è nettamente maggiore rispetto agli altri nodi La rete si disconnette se uno qualsiasi dei nodi (escluse le foglie) fallisce

P2P: Lower Bound sistemi uniformi Teorema Consideriamo un sistema P2P uniforme con n nodi, sia k il numero dei vicini che ogni nodo mantiene, allora il lower bound per il diametro è 1/2 log n (l 1/2 log n ) se k 1/2 log n. Prova Sia J = { i k Sia J = {J i } 1 i k Consideriamo senza perdita di generalità un nodo x e calcoliamo tutte le n path fra x e tutti gli altri nodi.

P2P: Lower Bound sistemi uniformi Sia P = { Sia P = {tutte le path da x agli altri n nodi} P (N {0}) k+1 Sia f: P (N {0}) k+1 p P denotiamo con a p,i il numero di jump di taglia J i usati nella path p con 1 i k. p P denotiamo con a p,i il numero di jump di taglia J i usati nella path p con 1 i k. Es Sia J={1,4,15} Sia J={1,4,15} Sia p una path dal nodo 0 al nodo 9, (es ). Sia p una path dal nodo 0 al nodo 9, (es ). Allora a p,1 = 1, a p,2 = 2 e a p,3 = 0. Allora a p,1 = 1, a p,2 = 2 e a p,3 = 0. x compreso

P2P: Lower Bound sistemi uniformi Sia P = { Sia P = {tutte le path da x agli altri n nodi} P (N {0}) k+1 Sia f: P (N {0}) k+1 Ovviamente poiché l è il diametro della rete. Definiamo f(p):=(a p,0,a p,1,…a p,k ). x compreso

P2P: Lower Bound sistemi uniformi Claim f è iniettiva (one to one) Prova Per assurdo supponiamo che esistano p e q P tali che a p,i = a q,i 0 i k. Quindi partendo dal nodo x, entrambe le path terminano nello stesso nodo destinazione. Assurdo: per definizione le path in P terminano in nodi diversi. DominioCodominio P = { P = {tutte le path da x agli altri n nodi} P (N {0}) k+1 f: P (N {0}) k+1 f(p):=(a p,0,a p,1,…a p,k )

P2P: Lower Bound sistemi uniformi Poiché f è iniettiva, la dimensione del codominio è maggiore o uguale alla dimensione del dominio (vale a dire |C| |D|=n). Quanto vale la dimensione del codominio? La dimensione del codominio è uguale al numero di vettori (a 0,a 1,…,a k ) tali che a 0 +a 1 +…+a k =l La dimensione del codominio è uguale al numero di vettori (a 0,a 1,…,a k ) tali che a 0 +a 1 +…+a k =l

P2P: Lower Bound sistemi uniformi Supponiamo di avere l biglie uguali e k+1 contenitori diversi. La dimensione del codominio è uguale al numero di modi in cui è possibile disporre l biglie identiche in k+1 contenitori diversi. … … k+1 l

P2P: Lower Bound sistemi uniformi Rappresentiamo con 0 le biglie e separiamo con 1 i contenitori Con k 1 possiamo rappresentare k+1 contenitori, mentre con l 0 possiamo rappresentare l biglie; Alcuni esempi 6 contenitori e 12 biglie Primo contenitore vuoto Secondo contenitore 3 biglie Terzo contenitore 1 biglia Quarto contenitore 1 biglia Quinto contenitore 2 biglie Sesto contenitore 5 biglie

P2P: Lower Bound sistemi uniformi La dimensione del codominio è uguale al numero di combinazioni di k elementi su l+k; La dimensione del codominio è uguale al numero di combinazioni di l elementi su l+k; Alcuni esempi 6 contenitori e 12 biglie

P2P: Lower Bound sistemi uniformi Sappiamo che Ci rimane da dimostrare che se k 1/2 log n allora l 1/2 log n.

P2P: Lower Bound sistemi uniformi Proviamo che lk Per assurdo l<k E facile osservare che è crescente in l, quindi Assurdo Stirling approx Per ipotesi k 1/2 log n.

P2P: Lower Bound sistemi uniformi Proviamo che l 1/2 log n Proviamo che l 1/2 log n Per assurdo l < 1/2 log n Per assurdo l < 1/2 log n E facile osservare che è crescente in k, quindi Assurdo, quindi l 1/2 log n CVD.

P2P: Lower Bound sistemi uniformi Teorema Consideriamo un sistema P2P uniforme con n nodi, sia k il numero dei vicini che ogni nodo mantiene, allora il diametro è Ω(log n) se k = O(log n). Prova La prima parte è identica al teorema precedente Solo conti, abbastanza noiosi.

grado diametro 1 1 n -1 O(log n) Chord e altri Grafo completo Anello n è il numero dei peer; LB O(log n/ log(log n))

Grafico funzione binomiale x y 1n/2 n-1

Come scegliere l e k? Supponiamo di avere un limite sulla somma di grado e diametro Es l+k = 16 Quali sono i valori di l e k ottimali? l=k è la scelta migliore

Alcune osservazioni Chord è asintoticamente ottimo Uniforme Uniforme Facili da implementare e da analizzare; Algoritmo di routing semplice (greedy); Non cè congestione sui nodi; Fast bootstrap: Routing locale; GAP GAP Chord (log n, log n) Chord (log n, log n) LB (½ log n, ½ log n) LB (½ log n, ½ log n) E possibile fare meglio di Chord, si può arrivare a ( log n, log n)

Lezione 5 Domande: Consideriamo un sistema P2P con N nodi e grado k = O(log N), quale delle seguenti affermazioni è vera. (giustificare la risposta) il diametro è (log N) il diametro è (log N) il diametro è almeno ½ log N il diametro è almeno ½ log N il diametro è (log N / log log N) il diametro è (log N / log log N) Nessuna delle precedenti Nessuna delle precedenti Dato un sistema P2P uniforme con N nodi, grado k e diametro l, (giustificare la risposta) k è O(log N) se l è O(log N) k è O(log N) se l è O(log N) l è (log N) se k è O(log N) l è (log N) se k è O(log N) l è (log N/ log log N) se k è O(log N) l è (log N/ log log N) se k è O(log N) Nessuna delle precedenti Nessuna delle precedenti (*) (*)

Lezione 5 Domande: Quale delle seguenti affermazioni è vera (giustificare la risposta) Quale delle seguenti affermazioni è vera (giustificare la risposta) I protocolli P2P uniformi sono più efficienti I protocolli P2P uniformi sono più efficienti Non esiste un sistema P2P asintoticamente ottimo Non esiste un sistema P2P asintoticamente ottimo Chord è un sistema non uniforme Chord è un sistema non uniforme Nessuna delle precedenti Nessuna delle precedenti Consideriamo linsieme dei protocolli P2P uniformi, quale delle seguenti affermazioni è vera. (giustificare la risposta) Consideriamo linsieme dei protocolli P2P uniformi, quale delle seguenti affermazioni è vera. (giustificare la risposta) Chord è un sistema P2P asintoticamente ottimo (rispetto al tradeoff grado - diametro) Chord è un sistema P2P asintoticamente ottimo (rispetto al tradeoff grado - diametro) Non esiste un sistema P2P asintoticamente ottimo (rispetto al tradeoff grado - diametro) Non esiste un sistema P2P asintoticamente ottimo (rispetto al tradeoff grado - diametro) Non esiste un sistema che offre prestazioni migliori del protocollo Chord (rispetto al tradeoff grado - diametro) Non esiste un sistema che offre prestazioni migliori del protocollo Chord (rispetto al tradeoff grado - diametro) Nessuna delle precedenti Nessuna delle precedenti (*) (*)

Fine Lezione 5

Lezione 6

Ricapitolando…. Sistemi P2P puri Sistemi UniformiSistemi Non uniformi Abbiamo detto abbastanza KoordeNeighbor of Neighbor routing (NON)

Koorde E un protocollo chord like E un protocollo chord like ring ring consistent hashing per mappare le chiavi nei nodi consistent hashing per mappare le chiavi nei nodi De Bruijn graph De Bruijn graph APL O(log n) con grado costante APL O(log n) con grado costante APL O(log n / log(log n)) con grado O(log n) APL O(log n / log(log n)) con grado O(log n)

de Bruijn graph Un de Bruijn graph ha un nodo per ogni numero binario di b bits Ogni nodo ha due archi uscenti, in particolare il nodo m ha un link al nodo 2m mod 2 b ; un link al nodo 2m mod 2 b ; un link al nodo 2m+1 mod 2 b ; un link al nodo 2m+1 mod 2 b ; In altre parole dato un nodo m per ottenere i suoi due vicini basta fare lo shift a sinistra della codifica binaria di m (eliminando il bit più significativo) e poi aggiungere 0 e 1;

de Bruijn graph Es.: supponiamo di voler conoscere i vicini del nodo 011 allora facciamo lo shift a sinistra di 011 e otteniamo 0110; facciamo lo shift a sinistra di 011 e otteniamo 0110; eliminiamo il bit più significativo e otteniamo 110; eliminiamo il bit più significativo e otteniamo 110; i due vicini sono quindi: i due vicini sono quindi: = = 111 Denotiamo con m 0 il primo vicino di m m 1 il secondo vicino di m b=3

de Bruijn graph Routing Supponiamo di voler passare dal nodo s=(s 0,s 1,…,s b-1 ) al nodo t=(t 0,t 1,…,t b-1 ) Supponiamo di voler passare dal nodo s=(s 0,s 1,…,s b-1 ) al nodo t=(t 0,t 1,…,t b-1 ) passo 1: s s 1 = s t 0 s 1 =(s 1,s 2,…,t 0 ) passo 2: s 1 s 2 = s 1 t 1 s 2 =(s 2,…, t 0,t 1 ) passo 3: s 2 s 3 = s 2 t 2 s 3 =(…, t 0,t 1,t 2 ) passo b: s b-1 s b = s b-1 t b-1 s b =(t 0,t 1,…, t b-1 )=t b=3 b passi diametro = b = log n

de Bruijn graph Routing Es.: b=3 vogliamo passare dal nodo 011 al nodo 100 Es.: b=3 vogliamo passare dal nodo 011 al nodo 100 Passo 1: da 011 a 111 Passo 2: da 111 a 110 Passo 3: da 110 a b=

de Bruijn graph m.lookup(k,ks) if k=m return m else t=m topbit(ks) return t.lookup(k,ks<<1) b=3 m nodo sorgente k nodo destinazione La prima chiamata è m.lookup(k,k )

de Bruijn graph Routing ottimizzato Calcolo la dimensione j del più grande suffisso del nodo sorgente s che è anche prefisso del nodo destinazione t. Calcolo la dimensione j del più grande suffisso del nodo sorgente s che è anche prefisso del nodo destinazione t. Il routing inizia al passo j+1 Il routing inizia al passo j+1 Es.: b=3 vogliamo passare dal nodo s=011 al nodo t=100 Es.: b=3 vogliamo passare dal nodo s=011 al nodo t=100 Passo 2: da 011 a 110 Passo 3: da 110 a b=

de Bruijn graph m.lookup(k,ks) if k=m return m else t=m topbit(ks) return t.lookup(k,ks<<1) b=3 m nodo sorgente k nodo destinazione <<j La prima chiamata è m.lookup(k,k <<j)

de Bruijn graph b= b=3 E difficile da guardare figuriamoci da implementare secondo vicino primo vicino

de Bruijn graph b=3 La maggior parte delle applicazioni usa un numero di nodi effettivo molto più piccolo di 2 b. Evitare collisioni nellassegnare chiavi; In generale il sistema deve poter evolversi (n deve poter variare). E se manca un nodo? E se ne mancano tanti? b è di solito 160 (SHA) Gli indirizzi IP sono 2 32

de Bruijn graph: Koorde b=160 Aggiungiamo due ulteriori link per ogni nodo: Un link al successore nellanello Un link al predecessore di 2m mod 2 b Consideriamo ora un ring non completo Il nodo m ha due link ai nodi immaginari: 2m mod 2 b 2m+1 mod 2 b m Link a nodi effettivi

Koorde b=160 La nuova procedura di routing, invece di attraversare i nodi del grafo di de Bruijn ne attraversa i predecessori; 2 fasi Cerca il predecessore di s i Passa al nuovo nodo s i b=3

Koorde m.lookup(k,ks) if k=m return m else t=m topbit(ks) return t.lookup(k,ks<<1) m.lookup(k,ks,i) if k (m, m.successor] return successor else if i (m, m.successor] return d.lookup(k,ks<<1, i topbit(ks)) else else return m.successor.lookup(k,ks,i) Abbiamo raggiunto la destinazione ? Abbiamo raggiunto il predecessore del nodo immaginario? d è il link al predecessore di 2m mod 2 b

Koorde m.lookup(k,ks,i) 1if k (m, m.successor] return successor 2else if i (m, m.successor] 3 return d.lookup(k,ks<<1, i topbit(ks)) 4 else 5 return m.successor.lookup(k,ks,i) Cerchiamo il predecessore del nodo immaginario? Passiamo al nuovo nodo del grafo di de Bruijn Il passo 3 viene eseguito al massimo b volte Quante volte eseguiamo il passo 5, vale a dire quanto impieghiamo per trovare il predecessore di un nodo immaginario?

Koorde Lemma Il numero medio di passi, durante una operazione di lookup in Koorde è 3b Prova Nel passare dal nodo immaginario i al nodo immaginario i topbit(ks), ci muoviamo dal nodo m=predecessor(i) al nodo m.d (predecessor di 2m mod 2 b ) e poi ci spostiamo usando i successor pointer fino a raggiungere il predecessor del nodo immaginario i topbit(ks), Le frecce gialle sono b Quante sono le frecce verdi? Ogni hop su un grafo di de Bruijn si traduce in una path in koorde. Quanto è lunga questa path in media?

Koorde I nodi attraversati fra due frecce gialle sono i nodi che si trovano fra 2m e 2i+1 Quanti nodi ci sono nellintervallo I =(2m,2i+1)? |I|=(2i-2m)/(2 b /n) Sapendo che il valore atteso di i-m 2 b /n I (2 2 b /n )/(2 b /n) =2 In totale dunque per ogni freccia gialla vi sono in media 2 frecce verdi In totale 3b passi m i 2m 2i 2i+1 2 b /n Distanza media fra due nodi 2 b /n

Koorde m.lookup(k,ks,i) 1if k (m, m.successor] return successor 2else if i (m, m.successor] 3 return d.lookup(k,ks<<1, i topbit(ks)) 4 else 5 return m.successor.lookup(k,ks,i) Poiché m è responsabile di tutti i nodi immaginari che vanno da m e m.successor è possibile migliorare ulteriormente lalgoritmo. La distanza fra m e il suo successore è con alta probabilità maggiore di 2 b /n 2

Koorde Claim La distanza fra m e il suo successore è con alta probabilità maggiore di 2 b /n 2 Prova (Sketch) Fissato un nodo la probabilità che un altro nodo qualsiasi sia più vicino di 2 b /n 2 è (2 b /n 2 )/2 b = 1/n 2. La probabilità che nessuno degli altri n-1nodi sia più vicino di 2 b /n 2 è (1-1/n 2 ) n-1 >1-1/n. Distanza media 2 b /n Distanza 2 b /n 2

Koorde Abbiamo dimostrato che la distanza fra m e il suo successore è con alta probabilità maggiore di 2 b /n 2 Questo significa che il nodo m è responsabile di nodi immaginari con tutte le possibili combinazioni degli ultimi log(2 b /n 2 )= b-2logn bit. Scegliendo come nodo immaginario iniziale il nodo che ha gli ultimi b-2logn bit uguali a i primi b-2logn del nodo destinazione, dobbiamo effettuare alla fine soltanto (b-(b-2logn))*3 passi = 6logn passi circa.

Koorde Koorde (base 2) Koorde (base 2) Ha APL O(log n) con grado costante Ha APL O(log n) con grado costante Si può dimostrare che anche il diametro è con alta probabilità (WHP) O(log n). Si può dimostrare che anche il diametro è con alta probabilità (WHP) O(log n). Koorde (base k) Utilizziamo i grafi di de Bruijn base k Utilizziamo i grafi di de Bruijn base k Scegliamo k = log n Scegliamo k = log n

de Bruijn graph base k Per ogni k, in un grafo di de Bruijn base k, ogni nodo m è connesso a altri k nodi: km mod k b km mod k b km+1 mod k b km+1 mod k b … km+(k-1) mod k b km+(k-1) mod k bEsempio k=4, b=3, n=k b =64 e m=321 4 = 57 k=4, b=3, n=k b =64 e m=321 4 = 57 Il primo vicino è =36 Il secondo vicino è =37 Il terzo vicino è =38 Il quarto vicino è = b=3 k=2 Diametro O(log k n)

de Bruijn graph base k Esempio k=3, b=2, n=k b =9 k=3, b=2, n=k b =9 b= b=2 k=

Koorde base k k+1 nuovi link Il link al successore nellanello Il link al successore nellanello k link ai predecessori dei vicini k link ai predecessori dei vicini Epossibile fare routing con grado k e APL O(log k n) b= b=2 k=

Koorde base k Scegliendo k = O(log n): Grado = O(log n) Grado = O(log n) APL = O(log n / log (log n)) APL = O(log n / log (log n))Svantaggi Bisogna stimare n a priori; Bisogna stimare n a priori; Non è possibile cambiare il grado in un sistema attivo; Non è possibile cambiare il grado in un sistema attivo; E molto complicato stabilizzare la rete; E molto complicato stabilizzare la rete; b=2 k=

Ricapitolando…. Sistemi P2P puri Sistemi UniformiSistemi Non uniformi KoordeNeighbor of Neighbor routing (NON)

Fine lezione 6

lezione 7

Domande Consideriamo un grafo di de bruijn con base k, ed N = k^b nodi, quale delle seguenti affermazioni è vera (giustificare la risposta) Il grado di un nodo è sempre log N Il grado di un nodo è sempre log N Il grado di un nodo è al più k Il grado di un nodo è al più k Il grado di un nodo è b Il grado di un nodo è b Nessuna delle precedenti Nessuna delle precedenti Consideriamo un grafo di de bruijn con base k, ed N = k^b nodi, quale delle seguenti affermazioni è vera (giustificare la risposta) Il diametro del grafo è sempre log N Il diametro del grafo è sempre log N Il diametro del grafo è al più k Il diametro del grafo è al più k Il diametro del grafo è b Il diametro del grafo è b Nessuna delle precedenti Nessuna delle precedenti (*)

Il numero di passi, durante una operazione di lookup in Koorde (con base 2, e 2^b identificatori) è (giustificare la risposta) al più log N al più log N 3b nel caso peggiore 3b nel caso peggiore 3b nel caso medio 3b nel caso medio Nessuna delle precedenti Nessuna delle precedenti Quale delle seguenti affermazioni è falsa (giustificare la risposta) Koorde è un protocollo P2P non uniforme Koorde è un protocollo P2P non uniforme Koorde è un protocollo P2P asintoticamente ottimo Koorde è un protocollo P2P asintoticamente ottimo La lookup del protocollo koorde è locale (interessa solo i nodi fra sorgente e destinazione) La lookup del protocollo koorde è locale (interessa solo i nodi fra sorgente e destinazione) Nessuna delle precedenti Nessuna delle precedenti Domande (*)

Neighbor of Neighbor routing(NON) The Small World Phenomena The six degree of separation experiment S. Milgram [M67]. The six degree of separation experiment S. Milgram [M67]. The sociological experiment relied on social networks to transmit a letter from a person to unfamiliar targets by passing the letter only via acquaintances. Only a small number (around 6) of steps was needed. Recent work [DRW03], shows that, in the first steps the message was forwarded to a person P by using a guess on who P knew or, in other words, on his/her neighbors. Recent work [DRW03], shows that, in the first steps the message was forwarded to a person P by using a guess on who P knew or, in other words, on his/her neighbors.

Neighbor of Neighbor routing(NON) Sia d(x,y) una metrica per i nodi nella rete. Greedy routing 1. Supponiamo che il nostro messaggio si trovi sul nodo u t (destinazione). 2. Sia V = {v 1, v 2, …, v k } linsieme dei vicini del nodo u. 3. Fra questi k nodi, supponiamo sia z il più vicino alla destinazinone (rispetto alla metrica d). 4. Inviamo il messaggio al nodo z. Nel nostro caso è la distanza sullanello in senso orario Può essere iterativo o ricorsivo

Neighbor of Neighbor routing(NON) Greedy routing ut

Neighbor of Neighbor routing(NON) 1. Supponiamo che il nostro messaggio si trovi sul nodo u t (destinazione). 2. Sia V = {v 1, v 2, …, v k } linsieme dei vicini del nodo u. 3. Per ogni 1 i k, siano w i1, w i2, …, w ik I vicinin di v i and sia W= { w ij 1 i, j k} linsieme dei vicini dei vicini di u. 4. Fra questi k 2 +k nodi, supponiamo sia z il più vicino alla destinazinone (rispetto alla metrica d). 5.1 Se z V inviamo il messaggio al nodo z, altrimenti z = w ij, per qualche i e j, e inviamo il messaggio a z attraverso v i. 5.2 Se z V inviamo il messaggio al nodo z, altrimenti z = w ij, per qualche i e j, e inviamo il messaggio a v i. 2 fasi 1 fase

Neighbor of Neighbor routing(NON) Greedy routing NON routing ut ut

Neighbor of Neighbor routing(NON) Chord Sia n=2 b, per ogni 0 i < b, il nodo x è connesso ai nodi (x+2 i ) mod 2 b ; Sia n=2 b, per ogni 0 i < b, il nodo x è connesso ai nodi (x+2 i ) mod 2 b ; Il grado è b; Il grado è b; Il diametro è b; Il diametro è b; APL è b/2; APL è b/2; R-Chord n=2 b [MNW04] Sia n=2 b, per ogni 0 i < b, sia r x (i) un intero scelto in maniera casuale dallintervallo [0,2 i ), il nodo x è connesso ai nodi (x+2 i +r x (i)) mod 2 b ; Sia n=2 b, per ogni 0 i < b, sia r x (i) un intero scelto in maniera casuale dallintervallo [0,2 i ), il nodo x è connesso ai nodi (x+2 i +r x (i)) mod 2 b ; Il grado è b; Il grado è b; E un sistema uniforme?

Neighbor of Neighbor routing(NON) R-Chord n=2 b [MNW04] Sia n= 2 b, per ogni 0 i < b, sia r x (i) un intero scelto in maniera casuale dallintervallo [0,2 i ), il nodo x è connesso ai nodi (x+2 i +r x (i)) mod 2 b ; Sia n= 2 b, per ogni 0 i < b, sia r x (i) un intero scelto in maniera casuale dallintervallo [0,2 i ), il nodo x è connesso ai nodi (x+2 i +r x (i)) mod 2 b ; Il grado è b; Il grado è b; x2i2i 2 i+1 y 2i2i R-Chord non è uniforme

Neighbor of Neighbor routing(NON) Abbiamo visto Una nuova strategia di routing (NoN routing) Una nuova strategia di routing (NoN routing) Una nuova topologia (R-Chord) Una nuova topologia (R-Chord) Ci poniamo delle domande: Quali sono le prestazioni del NoN routing con Chord? Quali sono le prestazioni del NoN routing con Chord? Quali sono le prestazioni del greedy routing con R-Chord? Quali sono le prestazioni del greedy routing con R-Chord? Quali sono le prestazioni del NoN routing con R-Chord? Quali sono le prestazioni del NoN routing con R-Chord? Chord è uniforme, lalgoritmo greedy è ottimale, quindi NoN routing non ci da nessun vantaggio

Neighbor of Neighbor routing(NON) Quali sono le prestazioni del NoN routing con Chord? s t d(s,t)= s t d(s,t)=

Neighbor of Neighbor routing(NON) Abbiamo visto Una nuova strategia di routing (NoN routing) Una nuova strategia di routing (NoN routing) Una nuova topologia (R-Chord) Una nuova topologia (R-Chord) Ci poniamo delle domande: Quali sono le prestazioni del NoN routing con Chord? Quali sono le prestazioni del NoN routing con Chord? Quali sono le prestazioni del greedy routing con R-Chord? Quali sono le prestazioni del greedy routing con R-Chord? Quali sono le prestazioni del NoN routing con R-Chord? Quali sono le prestazioni del NoN routing con R-Chord?

Neighbor of Neighbor routing(NON) Denotiamo con (n) laverage path length Teorema (n) = (log n) hops for greedy routing in R-Chord (n) = (log n) hops for greedy routing in R-ChordProva Bisogna mostrare che (n) = O(log n) e (n) = (log n) 1) (n) = O(log n) Consideriamo tutte le possibili topologie che derivano da R- Chord. Mostriamo che a ogni singolo hop, se la distanza fra il nodo corrente e il nodo destinazione è d, dopo il jump la distanza è minore di 3/4d. x t d(x,t)=2 p+1 -2

Neighbor of Neighbor routing(NON) x t d(x,t)=2 p+1 -2 Consideriamo il caso peggiore Il salto (p+1) che può essere compreso fra [2 p,2 p+1 ) è lungo 2 p In questo caso il salto va oltre la destinazione è quindi non può essere effettuato. Il salto (p+1) che può essere compreso fra [2 p,2 p+1 ) è lungo 2 p In questo caso il salto va oltre la destinazione è quindi non può essere effettuato. Il salto (p) che può essere compreso fra [2 p-1,2 p ) è lungo 2 p-1. Il salto (p) che può essere compreso fra [2 p-1,2 p ) è lungo 2 p-1. La distanza fra x e t si riduce da d=2 p+1 -2 a 2 p p-1. La distanza fra x e t si riduce da d=2 p+1 -2 a 2 p p-1. Ma 2 p p-1 = 3*2 p-1 -2 = ¾ 2 p+1 -2 < ¾ d. Ma 2 p p-1 = 3*2 p-1 -2 = ¾ 2 p+1 -2 < ¾ d. Ad ogni passo nel caso peggiore passiamo da una distanza d a una distanza ¾ d. Quindi il numero dei passi totale è minore di log 4/3 d. Ad ogni passo nel caso peggiore passiamo da una distanza d a una distanza ¾ d. Quindi il numero dei passi totale è minore di log 4/3 d. Nel caso peggiore d=n-1. Quindi (n) < log 4/3 (n-1) = O(log n). Nel caso peggiore d=n-1. Quindi (n) < log 4/3 (n-1) = O(log n).

Neighbor of Neighbor routing(NON) Denotiamo con (n) laverage path length Teorema (n) = (log n) hops for greedy routing in R-Chord (n) = (log n) hops for greedy routing in R-ChordProva Bisogna mostrare che (n) = O(log n) e (n) = (log n) 2) (n) = (log n) ….. In pratica in base ai risultati di numerose simulazioni R-Chord si comporta esattamente allo stesso modo di Chord APL = b/2 = (log n)/2. APL = b/2 = (log n)/2. Questa prova ve la risparmio

Neighbor of Neighbor routing(NON) Abbiamo visto Una nuova strategia di routing (NoN routing) Una nuova strategia di routing (NoN routing) Una nuova topologia (R-Chord) Una nuova topologia (R-Chord) Ci poniamo delle domande: Quali sono le prestazioni del NoN routing con Chord? Quali sono le prestazioni del NoN routing con Chord? Quali sono le prestazioni del greedy routing con R-Chord? Quali sono le prestazioni del greedy routing con R-Chord? Quali sono le prestazioni del NoN routing con R-Chord? Quali sono le prestazioni del NoN routing con R-Chord?

Neighbor of Neighbor routing(NON) Denotiamo con (n) laverage path length Teorema (n) = (log n / log (log n)) hops for NON routing in R- Chord (n) = (log n / log (log n)) hops for NON routing in R- ChordProva Bisogna mostrare che (n) = O(log n / log (log n)) e (n) = (log n / log (log n)) 1) (n) = (log n / log (log n)) Labbiamo già dimostrato nella prima lezione (slide 16).

Neighbor of Neighbor routing(NON) Denotiamo con (n) laverage path length Teorema (n) = (log n / log (log n)) hops for NON routing in R- Chord (n) = (log n / log (log n)) hops for NON routing in R- ChordProva 2) (n) = O(log n / log (log n)) Consideriamo un nodo s che intende spedire un messaggio a un nodo t a distanza d(s,t)=d. s t d(s,t)=d Consideriamo il ring pieno

Neighbor of Neighbor routing(NON) 2) (n) = O(log n / log (log n)) Sia p un intero tale che 2 p d < 2 p+1 Consideriamo due casi : p (log n) / log (log n) p (log n) / log (log n) In questo caso bastano O(p) jump per raggiungere la destinazione anche se si usa solo lalgoritmo greedy. Cioè avvicinandoci di ¾ ad ogni passo. Il numero di passi infatti è log 4/3 d < log 4/3 2 ((log n) / log (log n))+1 = O((log n)/log (log n)). s t d 2p2p 2 p+1

Neighbor of Neighbor routing(NON) 2) (n) = O(log n / log (log n)) Sia p un intero tale che 2 p d < 2 p+1 Consideriamo due casi : p > (log n) / log (log n) p > (log n) / log (log n) Sia I = (d-d,d] dove d= Ovviamente |I|=d s t d 2p2p 2 p+1 I d-d

Neighbor of Neighbor routing(NON) 2) (n) = O(log n / log (log n)) Quanti vicini di s ci sono fra s e t? I primo vicino si trova fra 2 0 a Il secondo si trova fra 2 1 a Il terzo si trova fra 2 2 a Il p-esimo si trova fra 2 p-1 a 2 p -1 Poichè 2 p è minore di d, fra s e t ci sono almeno p vicini. Sia s i liesimo vicino di s, e sia S={s 1, s 2, …, s p } linsieme dei primi p vicini di s. Allora |S|=p. s t d 2p2p 2 p+1 I 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=

Neighbor of Neighbor routing(NON) 2) (n) = O(log n / log (log n)) Denotiamo con J k (s i )=s i +2 k +r s i (k) il k-esimo jump/vicino di s i. Il nostro obiettivo è calcolare la probabilità che almeno uno dei vicini dei vicini di s abbia un jump in I. P=Pr[J k (s i ) I per qualche 1 i p e 0 k < b] s t d 2p2p 2 p+1 I 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p I primi p vicini Un jump qualsiasi n=2 b

Neighbor of Neighbor routing(NON) Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[J k (s i ) I per qualche 0 k < b] d/2 p Prova Consideriamo il generico vicino di s, s i. Denotiamo con d i la distanza fra s i e t. Sia p i tale che 2 p i d i < 2 p i +1 Due casi: d-ds i +2 p i d-ds i +2 p i 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p s d 2p2p 2 p+1 I s t d 2pi2pi 2 p i +1 I sisi didididi d-d pippip diddid

Neighbor of Neighbor routing(NON) Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[J k (s i ) I per qualche 0 k < b] d/2 p Prova d-ds i +2 p i d-ds i +2 p i Lunico jump di s i che può cadere in I è il jump (p i +1)-esimo, infatti il jump (p i +1)-esimo [s i +2 p i, s i +2 p i +1 ). In particolare il jump (p i +1)-esimo appartiene a I con probabilità |I|/2 p i = d/2 p i d/2 p s d 2p2p 2 p+1 I s t d 2pi2pi 2 p i +1 I sisi didididi d-d pippip 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p

Neighbor of Neighbor routing(NON) Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[J k (s i ) I per qualche 0 k < b] d/2 p Prova d-d<s i +2 p i d-d<s i +2 p i s d 2p2p 2 p+1 I st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p

Neighbor of Neighbor routing(NON) Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[J k (s i ) I per qualche 0 k < b] d/2 p Prova d-d<s i +2 p i d-d<s i +2 p i In questo caso sia il jump p-esimo che il jump (p+1)-esimo possono cadere in I. Sia I = A B dove A=(d-d, s i +2 p i ) e B=[s i +2 p i,d] Ovviamente |A|+|B|=d. st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p AB

Neighbor of Neighbor routing(NON) Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[J k (s i ) I per qualche 0 k < b] d/2 p Prova d-d<2 p i d-d<2 p i Sia Q levento il p i -esimo jump di s i cade in I Sia R levento il (p i +1)-esimo jump di s i cade in I Siamo interessati a calcolare la Pr[Q R]=Pr[Q]+Pr[R]-Pr[Q R] st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p AB QR Q R

Neighbor of Neighbor routing(NON) Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[J k (s i ) I per qualche 0 k < b] d/2 p Prova d-d<2 p i d-d<2 p i Caso 2.a |B|>2 p i -1 Valutimo solo Pr[R] Pr[Q R] Pr[R]=|B|/2 p i >1/2>d/2 p st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p AB QR Q R

Neighbor of Neighbor routing(NON) Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[J k (s i ) I per qualche 0 k < b] d/2 p Prova d-d<2 p i d-d<2 p i Caso 2.b |B|2 p i -1 Pr[Q R]= Pr[Q]+Pr[R]-Pr[Q R] = st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p AB QR Q R |B|2 p i -1

Neighbor of Neighbor routing(NON) Dove eravamo rimasti? Il nostro obiettivo è calcolare la probabilità che almeno uno dei vicini dei vicini di s abbia un jump in I. P=Pr[J k (s i ) I per qualche 1 i p e 0 k < b] 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p P=Pr[ J k (s i ) I per qualche 0 k < b ] d/2 p s d 2p2p 2 p+1 I P = 1-e -1 Pd/2 p d2 p p > (log n) / log (log n) (1-1/x) x e -1

Neighbor of Neighbor routing(NON) Con probabilità P= Con probabilità P=1-e -1 in due hop riduciamo lintervallo da d a d * (log log n) / log n Poichè Poichè 1-e -1 > 0.5 funziona in media almeno una volta su due; In media con 2*2= 4 hop riduciamo lintervallo da d a d * (log log n) / log n. Quanti hop ci servono 4 log log n / (log log n) d + O(log n / (log log n)) d al massimo n-1 4 log log n / (log log n) n-1 + O(log n / (log log n)) Il nostro obiettivo è calcolare la probabilità che almeno uno dei vicini dei vicini di s abbia un jump in I. P=Pr[J k (s i ) I per qualche 1 i p e 0 k < b] p (log n) / log (log n) O(log n / (log log n))

Neighbor of Neighbor routing(NON) Nel caso in cui il ring non è pieno? Ridurre la distanza da 2 b -1 a 2 b /n impiega O(log n / log log n) passi. O(log n / log log n) passi. Quanti nodi ci sono in 2 b /n identificatori? Utilizzando il Chernoff bound si può dimostrare che in 2 b /n identificatori ci sono al più O(log n / log log n) nodi WHP. Quindi anche usando solo i successori in totale si effettuano O(log n / log log n) passi.

Neighbor of Neighbor routing(NON) Cost of Neighbor of Neighbor lists: Memory: O(log 2 n) Maintenance: O(log n) must be updated Neighbor lists should be maintained (open connection, pinging, etc.) In practice, a Chord ring will never be in a stable state; instead, joins and departures will occur continuously, interleaved with the stabilization algorithm. The ring will not have time to stabilize before new changes happen. [Chord]

Neighbor of Neighbor routing(NON) Vantaggi: Algoritmo di routing locale Algoritmo di routing semplice Efficiente Non è necessaria la stima di log n Svantaggi Come mantenere la lista dei vicini dei vicini? No fast bootstrap

Fine lezione 7

Lezione 8

Chernoff Bound Siano X 1,…X n n variabili casuali indipendenti tali che Pr[X i =1]=p i Pr[X i =0]=1-p i E[X i ]= p i Consideriamo la variabile casuale e poniamo = E[X]= = E[X]= Allora abbiamo > 0 0<p i <1

Chernoff Bound Esempio Supponiamo di lanciare 100 volte una moneta Sia X i la variabile casuale Abbiamo quindi Pr[X i =1]=1/2 e E[X i ]=1/2 per tutte le i. Allora conta il numero delle teste in 100 lanci. =E[X]=50 =E[X]=50 Calcoliamo un upper bound sulla probabilità che X>60 Pr[X>60]=Pr[X>(1+0.2) ] 60]=Pr[X>(1+0.2) ]<(e 0.2 / )

Chernoff Bound Nella lezione precedente ci siamo posti una domanda Quanti nodi ci sono in 2 b /n identificatori? Nel nostro sistema ci sono n nodi. Pr[X i =1]=(2 b /n)/2 b =1/n Pr[X i =0]=1- Pr[X i =1]=(n-1)/n E[X i ]=1/n 2 b /n T

T Chernoff Bound X conta quanti nodi cadono in T =E[X]=1/n*n=1 =E[X]=1/n*n=1 Proviamo che non ci sono più di O(logn / log log n) nodi. Chernoff bound =1 e/4<1 n>e 2e 4 ln n / ln ln n = O(log n / log log n)

H-Chord Chord Sia n=2 b, per ogni 0 i < b, il nodo x è connesso ai nodi (x+2 i ) mod 2 b ; Sia n=2 b, per ogni 0 i < b, il nodo x è connesso ai nodi (x+2 i ) mod 2 b ; Il grado è b; Il grado è b; Il diametro è b; Il diametro è b; APL è b/2; APL è b/2; R-Chord n=2 b [MNW04] Sia n=2 b, per ogni 0 i < b, sia r x (i) un intero scelto in maniera casuale dallintervallo [0,2 i ), il nodo x è connesso ai nodi (x+2 i +r x (i)) mod 2 b ; Sia n=2 b, per ogni 0 i < b, sia r x (i) un intero scelto in maniera casuale dallintervallo [0,2 i ), il nodo x è connesso ai nodi (x+2 i +r x (i)) mod 2 b ;H-Chord Sia H() una funzione di hash (es SHA) che mappa un identificatore in nellintervallo [0,1), il nodo x è connesso con i nodi x+2 i + H(x)2 i mod 2 b ; Sia H() una funzione di hash (es SHA) che mappa un identificatore in nellintervallo [0,1), il nodo x è connesso con i nodi x+2 i + H(x)2 i mod 2 b ;

H-Chord R-Chord vs H-Chord R-Chord 2i2i 2 i+1 H-Chord 2 i+2 2i2i 2 i+1 2 i+2

H-Chord Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[ J k (s i ) I per qualche 0 k < b ] d/2 p Prova Consideriamo il generico vicino di s, s i. Denotiamo con d i la distanza fra s i e t. Sia p i tale che 2 p i d i < 2 p i +1 Due casi: 1.d-ds i +2 p i 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p s d 2p2p 2 p+1 I s t d 2pi2pi 2 p i +1 I sisi didididi d-d pippip diddid

Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[ J k (s i ) I per qualche 0 k < b ] d/2 p Prova 1.d-ds i +2 p i Lunico jump di s i che può cadere in I è il jump (p i +1)- esimo, infatti il jump (p i +1)-esimo [s i +2 p i, s i +2 p i +1 ). In particolare il jump (p i +1)-esimo appartiene a I con probabilità | I |/2 p i = d/2 p i d/2 p s d 2p2p 2 p+1 I s t d 2pi2pi 2 p i +1 I sisi didididi d-d pippip 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p H-Chord

Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[ J k (s i ) I per qualche 0 k < b ] d/2 p Prova 2.d-d<s i +2 p i s d 2p2p 2 p+1 I st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p H-Chord

Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[ J k (s i ) I per qualche 0 k < b ] d/2 p Prova 2.d-d<s i +2 p i In questo caso sia il jump p-esimo che il jump (p+1)-esimo possono cadere in I. Sia I = A B dove A=(d-d, s i +2 p i ) e B=[s i +2 p i,d] Ovviamente |A|+|B|=d. st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p AB H-Chord

Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[ J k (s i ) I per qualche 0 k < b ] d/2 p Prova 2.d-d<2 p i Sia C linsieme ( s i +2 pi+1 – 2|A|, s i +2 pi+1 ) In H-Chord se il (p i +1)-esimo jump di s i cade in C allora il p i -esimo jump di s i cade in A. Siamo interessati a calcolare la probabilità che il (p i +1)-esimo jump di s i cade in C o in B. st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p A=(d-d, s i +2 pi ) B=[s i +2 pi,d] ABC H-Chord

Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[ J k (s i ) I per qualche 0 k < b ] d/2 p Prova 2.d-d<2 p i Sia Q levento il (p i +1)- esimo jump di s i cade in C Sia R levento il (p i +1)-esimo jump di s i cade in B Siamo interessati a calcolare la Pr[Q R]=Pr[Q]+Pr[R]-Pr[Q R] st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p A=(d-d, si+2pi) AB QR Q R C Q R è vuoto. Ma questa volta Q R è vuoto. H-Chord

Claim Per ogni nodo s i S, la probabilità che un vicino di s i I è almeno d/2 p. P=Pr[ J k (s i ) I per qualche 0 k < b ] d/2 p Prova 2.d-d<2 p i Pr[Q R]= Pr[Q]+Pr[R]-Pr[Q R] =Pr[Q]+Pr[R] st d 2pi2pi 2 p i +1 I sisi didididi d-d 2 p d < 2 p+1 p > (log n) / log (log n) I = (d-d, d] d=|S|=p d i d, d i d, p i p A=(d-d, si+2pi) ABC H-Chord

Perchè H-Chord e non R-Chord? Svantaggi R-Chord Come mantenere la lista dei vicini dei vicini? No fast bootstrap In H-Chord non cè nessun fattore random, in particolare ogni nodo conoscendo il suo vicino conosce i vicini del suo vicino. O almeno può stimare le posizioni dei vicini del nostro vicino H-Chord

Dato un nodo x, x conosce il suo vicino y, dato y, x può calcolare H(y) e quindi può calcolare per ogni 0i<b y+2 i + H(y)2 i. Tuttavia, quando il ring non è pieno, x non conosce lesatta posizione dei vicini dei vicini ma ne ha una buona stima. La funzione di hash è uguale per tutti i nodi H-Chord 2i2i 2 i+1 2 i+2 2 i+1 H-Chord

Perchè H-Chord e non Chord? Svantaggi R-Chord Come mantenere la lista dei vicini dei vicini? No fast bootstrap Non è possibile fare fast bootstrap perché le tabelle di routing sono diverse, tuttavia se due nodi x, y generano due valori hash abbastanza vicini (H(x) H(y)) allora le loro tabelle sono simili. I problemi sono: Cosa vuol dire abbastanza vicini Come trovare un vicino con hash abbastanza vicino H-Chord

Sistemi P2P uniformi Vantaggi: Facili da implementare e da analizzare; Facili da implementare e da analizzare; Algoritmo di routing semplice (greedy); Algoritmo di routing semplice (greedy); Routing locale, la procedura di lookup interessa solo i nodi che si trovano fra sorgente e destinazione; Routing locale, la procedura di lookup interessa solo i nodi che si trovano fra sorgente e destinazione; Non cè congestione sui nodi, vale a dire il traffico generato dai messaggi di lookup è più o meno uguale per tutti i nodi. Non cè congestione sui nodi, vale a dire il traffico generato dai messaggi di lookup è più o meno uguale per tutti i nodi. Fast bootstrap: Fast bootstrap: Poiché tutti i nodi utilizzano gli stessi jump, è possibile utilizzare la tabella di routing del proprio predecessore per velocizzare notevolmente loperazione di join; Svantaggi: Sfortunatamente non sono gli algoritmi più efficienti. Sfortunatamente non sono gli algoritmi più efficienti.

Koorde base k Scegliendo k = O(log n): Grado = O(log n) Grado = O(log n) APL = O(log n / log (log n)) APL = O(log n / log (log n))Svantaggi Bisogna stimare n a priori; Bisogna stimare n a priori; Non è possibile cambiare il grado in un sistema attivo; Non è possibile cambiare il grado in un sistema attivo; E molto complicato stabilizzare la rete; E molto complicato stabilizzare la rete; b=2 k=

R-Chord Vantaggi: Algoritmo di routing locale Algoritmo di routing semplice Efficiente Non è necessaria la stima di log n Lalgoritmo di stabilizzazione è identico a quello di Chord Svantaggi Come mantenere la lista dei vicini dei vicini? No fast bootstrap

H-Chord Vantaggi Algoritmo di routing locale Algoritmo di routing semplice Efficiente Non è necessaria la stima di log n Lalgoritmo di stabilizzazione è identico a quello di Chord Svantaggi No fast bootstrap ???? H c -Chord