Neighbor of Neighbor routing(NON)

Ricapitolando….
Sistemi P2P puri
Sistemi Uniformi
Sistemi Non uniformi
Koorde
Neighbor of Neighbor
routing (NON)
Neighbor of Neighbor routing(NON)
The Small World Phenomena

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.
Neighbor of Neighbor routing(NON)
Nel nostro caso è la
distanza sull’anello in
senso orario
Sia d(x,y) una metrica per i nodi nella rete.
Può essere iterativo o
ricorsivo
 Greedy routing
1. Supponiamo che il nostro messaggio si trovi sul nodo u ≠
t (destinazione).
2. Sia V = {v1, v2, …, vk} l’insieme 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.
Neighbor of Neighbor routing(NON)

Greedy routing
u
t
Neighbor of Neighbor routing(NON)
1. Supponiamo che il nostro messaggio si trovi sul nodo u ≠
t (destinazione).
2. Sia V = {v1, v2, …, vk} l’insieme dei vicini del nodo u.
3. Per ogni 1 ≤ i ≤ k, siano wi1, wi2, …, wik I vicinin di vi and
sia W= { wij  1 ≤ i, j ≤ k} l’insieme dei vicini dei vicini di
u.
4. Fra questi k2+k nodi, supponiamo sia
z il più vicino alla
2 fasi
destinazinone (rispetto alla metrica d).
5.1 Se z  V inviamo il messaggio al nodo z, altrimenti z =
wij, per qualche i e j, e inviamo il messaggio a z
attraverso vi.
1 fase
5.2 Se z  V inviamo il messaggio al nodo z, altrimenti z =
wij, per qualche i e j, e inviamo il messaggio a vi.
Neighbor of Neighbor routing(NON)

Greedy routing
u

t
NON routing
u
t
Neighbor of Neighbor routing(NON)
Chord

Sia n=2b, per ogni 0 ≤ i < b, il nodo x è
connesso ai nodi (x+2i) mod 2b;
Il grado è b;
Il diametro è b;
APL è b/2;
E’ un sistema
uniforme?
R-Chord n=2b [MNW04]

Sia n=2b, per ogni 0 ≤ i < b, sia rx(i) un intero
scelto in maniera casuale dall’intervallo [0,2i),
il nodo x è connesso ai nodi (x+2i+rx(i)) mod
2 b;
Il grado è b;
Neighbor of Neighbor routing(NON)
R-Chord n=2b [MNW04]

Sia n= 2b, per ogni 0 ≤ i < b, sia rx(i) un intero
scelto in maniera casuale dall’intervallo [0,2i),
il nodo x è connesso ai nodi (x+2i+rx(i)) mod
2b;
Il grado è b;
R-Chord non è
uniforme
x
2i
y
i
2i+1
i+1
000
111
001
110
010
101
011
100
Neighbor of Neighbor routing(NON)
Abbiamo visto


Una nuova strategia di routing (NoN routing)
Una nuova topologia (R-Chord)
Ci poniamo delle domande:



Quali sono le prestazioni del NoN routing con Chord?
Quali sono le prestazioni del greedy routing con R-Chord?
Quali sono le prestazioni del NoN routing con R-Chord?
Chord è uniforme, l’algoritmo greedy
è ottimale, quindi NoN routing non ci
da nessun vantaggio
Neighbor of Neighbor routing(NON)
Quali sono le prestazioni del NoN routing con Chord?
32
16
16 8
8
4
8
16
32
32
4
4
s
t
d(s,t)=41
36
29
18
12
5
11
7
s
t
d(s,t)=41
Neighbor of Neighbor routing(NON)
Abbiamo visto


Una nuova strategia di routing (NoN routing)
Una nuova topologia (R-Chord)
Ci poniamo delle domande:



Quali sono le prestazioni del NoN routing con Chord?
Quali sono le prestazioni del greedy routing con R-Chord?
Quali sono le prestazioni del NoN routing con R-Chord?
Neighbor of Neighbor routing(NON)
Denotiamo con (n) l’average path length
Teorema
(n) = (log n) hops for greedy routing in R-Chord
Prova
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
d(x,t)=2p+1-2
t
Neighbor of Neighbor routing(NON)
x
d(x,t)=2p+1-2
t
Consideriamo il caso peggiore






Il salto (p+1) che può essere compreso fra [2p,2p+1) è lungo 2p+1-1. In
questo caso il salto va oltre la destinazione è quindi non può essere
effettuato.
Il salto (p) che può essere compreso fra [2p-1,2p) è lungo 2p-1.
La distanza fra x e t si riduce da d=2p+1-2 a 2p+1-2 - 2p-1.
Ma 2p+1-2 - 2p-1 = 3*2p-1-2 = ¾ 2p+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¾ d.
Nel caso peggiore d=n-1. Quindi (n) < log¾ (n-1) = O(log n).
Neighbor of Neighbor routing(NON)
Denotiamo con (n) l’average path length
Teorema
(n) = (log n) hops for greedy routing in R-Chord
Prova
Bisogna mostrare che (n) = O(log n) e (n) = (log n)
2) (n) = (log n)
Questa prova ve la
…..
risparmio 
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.
Neighbor of Neighbor routing(NON)
Abbiamo visto


Una nuova strategia di routing (NoN routing)
Una nuova topologia (R-Chord)
Ci poniamo delle domande:



Quali sono le prestazioni del NoN routing con Chord?
Quali sono le prestazioni del greedy routing con R-Chord?
Quali sono le prestazioni del NoN routing con R-Chord?
Neighbor of Neighbor routing(NON)
Denotiamo con (n) l’average path length
Teorema
(n) = (log n / log (log n)) hops for NON routing in RChord
Prova
Bisogna mostrare che (n) = O(log n / log (log n)) e (n)
=  (log n / log (log n))
1) (n) =  (log n / log (log n))
L’abbiamo già dimostrato nella prima lezione (slide 16).
Neighbor of Neighbor routing(NON)
Denotiamo con (n) l’average path length
Teorema
(n) = (log n / log (log n)) hops for NON routing in RChord
Prova
Consideriamo il
ring pieno
2) (n) = O(log n / log (log n))
s
d(s,t)=d
t
Consideriamo un nodo s che intende spedire un
messaggio a un nodo t a distanza d(s,t)=d.
Neighbor of Neighbor routing(NON)
2) (n) = O(log n / log (log n))
2p
2p+1
s
t
d
Sia p un intero tale che 2p ≤ d < 2p+1
p

log
d
Consideriamo due casi :
1.
p ≤ (log n) / log (log n)
In questo caso bastano O(p) jump per raggiungere la
destinazione anche se si usa solo l’algoritmo greedy.
Cioè avvicinandoci di ¾ ad ogni passo.
Il numero di passi infatti è
log¾ d < log¾ 2((log n) / log (log n))+1 = O((log n) / log (log n)).


Neighbor of Neighbor routing(NON)
2) (n) = O(log n / log (log n))
I
2p
2p+1
d-d’
s
t
d
Sia p un intero tale che 2p ≤ d < 2p+1
Consideriamo due casi :

2.
p > (log n) / log (log n) 
  d log log n 
d
Sia I = (d-d’,d] dove d’=  log n   



 log log n 
Ovviamente |I|=d’

log n

Neighbor of Neighbor routing(NON)
2) (n) = O(log n / log (log n))
I
2p
s
d
2p+1
t
2p ≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 
Quanti vicini di s ci sono fra s e t?
 log n 
I primo vicino si trova fra 20 a 21 -1
Il secondo si trova fra 21 a 22 -1
Il terzo si trova fra 22 a 23 -1
Il p-esimo si trova fra 2p-1 a 2p -1
Poichè 2p è minore di d, fra s e t ci sono almeno p vicini.
Sia si l’iesimo vicino di s, e sia S={s1, s2, …, sp} l’insieme
dei primi p vicini di s. Allora |S|=p.
Neighbor of Neighbor routing(NON)
2) (n) = O(log n / log (log n))
I
2p
2p+1
s
d
Denotiamo con Jk(si)=si+2k+rs (k) il k-esimo
jump/vicino di si.
i
t
2p ≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 


log n


|S|=p
Il nostro obiettivo è calcolare la probabilità
che almeno uno dei vicini dei vicini di s abbia un jump in I.
P=Pr[Jk(si)I per qualche 1 ≤ i ≤ p e 0 ≤ k < b]
I primi p vicini
Un jump qualsiasi
n=2b
Neighbor of Neighbor routing(NON)
I
Claim
2p
s
d
Per ogni nodo si  S, la probabilità che un
vicino di si  I è almeno d’/2p.
P’=Pr[Jk(si)I per qualche 0 ≤ k < b] ≥ d’/2p
Prova
Consideriamo il generico vicino di s, si.
Denotiamo con di la distanza fra si e t.
Sia pi tale che 2pi ≤ di < 2pi+1
di
Due casi:
2p
1. d-d’≥si+2pi
s
2p+1
2p ≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 

log n
|S|=p
di≤d
pi≤p
i
i
s
d

2pi+1
d-d’ I
t
Neighbor of Neighbor routing(NON)
I
Claim
2p
s
d
Per ogni nodo si  S, la probabilità che un
vicino di si  I è almeno d’/2p.
P’=Pr[Jk(si)I per qualche 0 ≤ k < b] ≥ d’/2p
di
Prova
1. d-d’≥si+2pi
2p+1
2p ≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 

log n
|S|=p
di≤d, pi≤p
2pi
si
s

2pi+1
d-d’ I
d
t
L’unico jump di si che può cadere in I è il jump (pi+1)esimo, infatti il jump (pi+1)-esimo [si+2pi, si+2pi+1).
In particolare il jump (pi+1)-esimo appartiene a I con
probabilità |I|/2pi = d’/2pi ≥ d’/2p
pi≤p
Neighbor of Neighbor routing(NON)
I
2p
Claim
2p+1
s
2p ≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 
d
Per ogni nodo si  S, la probabilità che un
vicino di si  I è almeno d’/2p.
P’=Pr[Jk(si)I per qualche 0 ≤ k < b] ≥ d’/2p
Prova
d
2. d-d’<si+2pi
di
si
s
2pi
d-d’

log n

|S|=p
di≤d, pi≤p
2pi+1
I
t
Neighbor of Neighbor routing(NON)
2p ≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 
Claim
Per ogni nodo si  S, la probabilità che un
vicino di si  I è almeno d’/2p.
P’=Pr[Jk(si)I per qualche 0 ≤ k < b] ≥ d’/2p
d
Prova
di
2. d-d’<si+2pi
si
2pi
d-d’

log n

|S|=p
di≤d, pi≤p
2pi+1
I
s
t
A B
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’, si+2pi) e B=[si+2pi,d]
Ovviamente |A|+|B|=d’.
Neighbor of Neighbor routing(NON)
2p ≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 
Claim
Per ogni nodo si  S, la probabilità che un
vicino di si  I è almeno d’/2p.
P’=Pr[Jk(si)I per qualche 0 ≤ k < b] ≥ d’/2p
d
Prova
di
2. d-d’<2pi
2pi
d-d’
si

log n

|S|=p
di≤d, pi≤p
2pi+1
I
s
t
A B
Sia Q l’evento “il pi-esimo jump di si cade in I”
Sia R l’evento “il (pi+1)-esimo jump di si cade in I”
Siamo interessati a calcolare la Pr[QR]=Pr[Q]+Pr[R]-Pr[QR]
Q
QR
R
Neighbor of Neighbor routing(NON)
2p ≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 
Claim
Per ogni nodo si  S, la probabilità che un
vicino di si  I è almeno d’/2p.
P’=Pr[Jk(si)I per qualche 0 ≤ k < b] ≥ d’/2p
d
Prova
di
2. d-d’<2pi
2pi
d-d’
si

log n

|S|=p
di≤d, pi≤p
2pi+1
I
s
t
A B
Caso 2.a |B|>2pi-1
Valutimo solo Pr[R] ≤ Pr[QR]
Pr[R]=|B|/2pi>1/2>d’/2p
Q
d ' log log n
log log n 1

per
n

4,

2p
log n
log n
2
QR
R
Neighbor of Neighbor routing(NON)
2p ≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 
Claim
Per ogni nodo si  S, la probabilità che un
vicino di si  I è almeno d’/2p.
P’=Pr[Jk(si)I per qualche 0 ≤ k < b] ≥ d’/2p
d
Prova
di
2. d-d’<2pi
2pi
d-d’
si

log n

|S|=p
di≤d, pi≤p
2pi+1
I
s
t
A B
Caso 2.b |B|≤2pi-1
Pr[QR]= Pr[Q]+Pr[R]-Pr[QR] =
A
2 pi 1

B
2 pi

AB
2 pi 12 pi

A B
2 pi

A
2 pi

AB
2 pi 12 pi

A B
2 pi
|B|≤2pi-1

A 
B 
A B
d'
d'


1




2p
2 pi 
2 pi 1 
2 pi
2 pi


Q
QR
R
Neighbor of Neighbor routing(NON)
I
Dove eravamo rimasti?
2p
Il nostro obiettivo ès
calcolare la probabilità
che almeno uno dei vicini
dei vicini di s abbia un jump
in I.
P’≥d’/2
2p+1
d
≤ d < 2p+1
p > (log n) / log (log n)
I = (d-d’, d]
d’=  d log log n 
2p

log n

|S|=p
P’=Pr[Jk(si)I per qualche 0 ≤ k < b] ≥ d’/2p
p
P=Pr[Jk(si)I per qualche 1 ≤ i ≤ p e 0 ≤ k < b]
d≥2p
p
  d log log n  
d' 

 
1  P  (1  P' )  1  p   1   p


 2 
  2 log n  
S
S
p
 log log n   log log n 
  1 

 1 
log n  
log n 

log n
loglogn
 e 1
p > (log n) / log (log
n)
(1-1/x)x≤e-1
P = 1-e-1
Neighbor of Neighbor routing(NON)
Con probabilità P=1-e-1 in due hop riduciamo
l’intrvallo da d a d * (log log n) / log n
Poichè 1-e-1 > 0.5 funziona in media almeno una
volta su due;
In media con 2*2= 4 hop riduciamo l’intrvallo da d
a d * (log log n) / log n.
p ≤ (log n) / log (log
Quanti hop ci servono
n)
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))
O(log n / (log log n))
Neighbor of Neighbor routing(NON)
Nel caso in cui il ring non è pieno?
Ridurre la distanza da 2b-1 a 2b/n impiega O(log n / log
log n) passi.
Quanti nodi ci sono in 2b/n identificatori?
Utilizzando il Chernoff bound si può dimostrare che in
2b/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(log2n)
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