View
226
Download
5
Category
Preview:
Citation preview
Lezione 8Lezione 8
Chernoff Bound
Siano XSiano X11,…X,…Xn n n variabili casuali indipendenti tali che n variabili casuali indipendenti tali che
Pr[XPr[Xi i =1]=p=1]=pii
Pr[XPr[Xi i =0]=1-p=0]=1-pii
E[XE[Xii]= p]= pii
Consideriamo la variabile casuale Consideriamo la variabile casuale e poniamoe poniamo
= E[X]= = E[X]=
Allora abbiamo Allora abbiamo > 0 > 0
0<pi<1
n
iiXX
1
2
2
1
])1(Pr[
)1(])1(Pr[
eX
eX
n
iip
1
Chernoff Bound
EsempioEsempio
Supponiamo di lanciare 100 volte una monetaSupponiamo di lanciare 100 volte una moneta
Sia XSia Xii la variabile casuale la variabile casuale
Abbiamo quindi Pr[XAbbiamo quindi Pr[Xii=1]=1/2 e E[X=1]=1/2 e E[Xii]=1/2 per tutte le i.]=1/2 per tutte le i.
Allora conta il numero delle teste in 100 lanci.Allora conta il numero delle teste in 100 lanci.
=E[X]=50=E[X]=50
Calcoliamo un upper bound sulla probabilità che X>60Calcoliamo un upper bound sulla probabilità che X>60
Pr[X>60]=Pr[X>(1+0.2) Pr[X>60]=Pr[X>(1+0.2) ]<(e]<(e0.20.2/1.2/1.21.21.2))50500.3930.393
n
iiXX
1
croce; lancio iesimol',0
testa;lancio iesimol',1
iX
2
2
1
])1(Pr[
)1(])1(Pr[
eX
eX
Chernoff Bound
Nella lezione precedente ci siamo posti una domandaNella lezione precedente ci siamo posti una domanda
Quanti nodi ci sono in Quanti nodi ci sono in 22bb/n identificatori?/n identificatori?
Nel nostro sistema ci sono n nodiNel nostro sistema ci sono n nodi..
Pr[XPr[Xii=1]=(2=1]=(2bb/n)/2/n)/2bb=1/n=1/n
Pr[XPr[Xii=0]=1- Pr[X=0]=1- Pr[Xii=1]=(n-1)/n=1]=(n-1)/n
E[XE[Xii]=1/n]=1/n
T; a appartienenon nodo iesimol',0
T; a appartiene nodo iesimol',1
iX
2
2
1
])1(Pr[
)1(])1(Pr[
eX
eX
22bb/n/n
T
22bb/n/n
T
Chernoff Bound
X conta quanti nodi cadono in TX 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.Proviamo che non ci sono più di O(logn / log log n) nodi.
n
iiXX
1
T; a appartienenon nodo iesimol',0
T; a appartiene nodo iesimol',1
iX
2
2
1
])1(Pr[
)1(])1(Pr[
eX
eX
2
ln2ln42/1
ln41
lnln
lnlnln
ln4
lnln
lnlnln
ln4
lnlnlnlnln
ln4
lnlnlnlnlnlnln
ln4ln
lnlnln
lnln
ln4
lnln
ln4
lnln
ln4lnln
ln4
lnln
ln4
lnln
ln4
lnln
ln4
1lnln
ln4
1
ln
lnln
ln4
lnln
lnlnln4
lnlnln4
lnlnln4lnln
ln4Pr
neee
e
e
e
eee
n
n
n
ne
nne
nn
e
nn
e
n
nX
nnn
n
n
n
n
n
n
nn
n
nnn
nn
n
n
n
n
n
n
nn
n
n
n
n
n
n
n
n
n
Chernoff bound =1 e/4<1
n>e2e
4 ln n / ln ln n =O(log n / log log n)
H-ChordChordChord Sia n=2Sia n=2bb, per ogni 0 , per ogni 0 ≤ i < b, il nodo x è connesso ai nodi ≤ i < b, il nodo x è connesso ai nodi
((x+2x+2ii) mod 2) mod 2bb;; Il grado è b;Il grado è b;
Il diametro è b;Il diametro è b;
APL è b/2; APL è b/2;
R-Chord n=2R-Chord n=2b b [MNW04][MNW04] Sia n=2Sia n=2bb, per ogni 0 , per ogni 0 ≤ i < b, sia≤ i < b, sia r rxx(i) un intero scelto in (i) un intero scelto in
maniera casuale dall’intervallo [0,2maniera casuale dall’intervallo [0,2 ii), il ), il nodo x è connesso nodo x è connesso ai nodi (ai nodi (x+2x+2ii+r+rxx(i)) mod 2(i)) mod 2bb;;
H-Chord H-Chord Sia H() una funzione di hash (es SHA) che mappa un Sia H() una funzione di hash (es SHA) che mappa un
identificatore in nell’intervallo [0,1), il nodo x è connesso identificatore in nell’intervallo [0,1), il nodo x è connesso con i nodi x+2con i nodi x+2ii++H(x)2H(x)2ii mod 2 mod 2bb;;
H-ChordR-Chord vs H-ChordR-Chord vs H-Chord
R-Chord 2i 2i+1
H-Chord
2i+2
2i 2i+12i+2
H-ChordClaimClaim
Per ogni nodo sPer ogni nodo sii S, la probabilità che un S, la probabilità che un
vicino di svicino di si i I I è almeno d’/2è almeno d’/2pp..
P’=Pr[P’=Pr[JJkk(s(sii))I I per qualche 0 ≤ k < bper qualche 0 ≤ k < b] ≥ ] ≥ d’/2d’/2pp
ProvaProva
Consideriamo il generico vicino di s, sConsideriamo il generico vicino di s, s ii..
Denotiamo con dDenotiamo con dii la distanza fra s la distanza fra s ii e t. e t.
Sia pSia pii tale che 2 tale che 2ppii ≤ ≤ ddi i < 2< 2ppii+1+1
Due casi:Due casi:
1.1. d-d’≥d-d’≥ssii+2+2ppii
22pp ≤ d < 2≤ d < 2p+1p+1
p > (log n) / log (log n)p > (log n) / log (log n)II = (d-d’, d] = (d-d’, d]d’=d’=
|S|=p|S|=p
n
nd
log
loglog
sd
2p 2p+1
I
s td
2pi 2pi+1
Isi
ddii
d-d’
pi≤p
di≤d
ClaimClaim
Per ogni nodo sPer ogni nodo sii S, la probabilità che un S, la probabilità che un
vicino di svicino di si i I I è almeno d’/2è almeno d’/2pp..
P’=Pr[P’=Pr[JJkk(s(sii))I I per qualche 0 ≤ k < bper qualche 0 ≤ k < b] ≥ ] ≥ d’/2d’/2pp
ProvaProva
1.1. d-d’≥d-d’≥ssii+2+2ppii
L’unico jump di sL’unico jump di sii che può cadere in che può cadere in II è il jump (p è il jump (pii+1)-esimo, infatti il +1)-esimo, infatti il
jump (pjump (pii+1)-esimo +1)-esimo [s[sii+2+2ppii, s, sii+2+2ppii+1+1).).
In particolare il jump (pIn particolare il jump (pii+1)-esimo appartiene a +1)-esimo appartiene a I I con probabilità |con probabilità |II|/2|/2ppii = =
d’/2d’/2ppi i ≥≥ d’/2d’/2pp
sd
2p 2p+1
I
s td
2pi 2pi+1
Isi
ddii
d-d’
pi≤p
22pp ≤ d < 2≤ d < 2p+1p+1
p > (log n) / log (log n)p > (log n) / log (log n)II = (d-d’, d] = (d-d’, d]d’=d’=
|S|=p|S|=pddii≤d, ≤d, pi≤p
n
nd
log
loglog
H-Chord
ClaimClaim
Per ogni nodo sPer ogni nodo sii S, la probabilità che un S, la probabilità che un
vicino di svicino di si i I I è almeno d’/2è almeno d’/2pp..
P’=Pr[P’=Pr[JJkk(s(sii))I I per qualche 0 ≤ k < bper qualche 0 ≤ k < b] ≥ ] ≥ d’/2d’/2pp
ProvaProva
2.2. d-d’<d-d’<ssii+2+2ppii
sd
2p 2p+1
I
s t
d
2pi 2pi+1
Isi
ddii
d-d’
22pp ≤ d < 2≤ d < 2p+1p+1
p > (log n) / log (log n)p > (log n) / log (log n)II = (d-d’, d] = (d-d’, d]d’=d’=
|S|=p|S|=pddii≤d, ≤d, pi≤p
n
nd
log
loglog
H-Chord
ClaimClaim
Per ogni nodo sPer ogni nodo sii S, la probabilità che un S, la probabilità che un
vicino di svicino di si i I I è almeno d’/2è almeno d’/2pp..
P’=Pr[P’=Pr[JJkk(s(sii))I I per qualche 0 ≤ k < bper qualche 0 ≤ k < b] ≥ ] ≥ d’/2d’/2pp
ProvaProva
2.2. d-d’<d-d’<ssii+2+2ppii
In questo caso sia il jump p-esimo che il jump (p+1)-esimo In questo caso sia il jump p-esimo che il jump (p+1)-esimo possono cadere in possono cadere in I.I.
Sia Sia I = A I = A B B dove A=(d-d’, sdove A=(d-d’, sii+2+2ppii) e B=[s) e B=[sii+2+2ppii,d],d]
Ovviamente |A|+|B|=d’.Ovviamente |A|+|B|=d’.
s t
d
2pi 2pi+1
Isi
ddii
d-d’
22pp ≤ d < 2≤ d < 2p+1p+1
p > (log n) / log (log n)p > (log n) / log (log n)II = (d-d’, d] = (d-d’, d]d’=d’=
|S|=p|S|=pddii≤d, ≤d, pi≤p
n
nd
log
loglog
A B
H-Chord
ClaimClaim
Per ogni nodo sPer ogni nodo sii S, la probabilità che un S, la probabilità che un
vicino di svicino di si i I I è almeno d’/2è almeno d’/2pp..
P’=Pr[P’=Pr[JJkk(s(sii))I I per qualche 0 ≤ k < bper qualche 0 ≤ k < b] ≥ ] ≥ d’/2d’/2pp
ProvaProva
2.2. d-d’<d-d’<22ppii
Sia C l’insieme (Sia C l’insieme (ssii+2+2pi+1pi+1 – 2|A| – 2|A|,,ssii+2+2pi+1pi+1))
In H-Chord se il (pIn H-Chord se il (pii+1)-esimo jump di s+1)-esimo jump di sii cade in C allora cade in C allora
il pil pii-esimo jump di s-esimo jump di si i cade in A.cade in A.
Siamo interessati a calcolare la probabilità che il (pSiamo interessati a calcolare la probabilità che il (p ii+1)-esimo jump di s+1)-esimo jump di sii cade cade
in C o in B.in C o in B.
s t
d
2pi 2pi+1
Isi
ddii
d-d’
22pp ≤ d < 2≤ d < 2p+1p+1
p > (log n) / log (log n)p > (log n) / log (log n)II = (d-d’, d] = (d-d’, d]d’=d’=
|S|=p|S|=pddii≤d, ≤d, pi≤p
A=(d-d’, sA=(d-d’, sii+2+2pipi))
B=[sB=[sii+2+2pipi,d],d]
n
nd
log
loglog
A B C
H-Chord
ClaimClaim
Per ogni nodo sPer ogni nodo sii S, la probabilità che un S, la probabilità che un
vicino di svicino di si i I I è almeno d’/2è almeno d’/2pp..
P’=Pr[P’=Pr[JJkk(s(sii))I I per qualche 0 ≤ k < bper qualche 0 ≤ k < b] ≥ ] ≥ d’/2d’/2pp
ProvaProva
2.2. d-d’<d-d’<22ppii
Sia Sia QQ l’evento “il (p l’evento “il (pii+1)- esimo jump di s+1)- esimo jump di sii cade in C” cade in C”
Sia Sia RR l’evento “il (p l’evento “il (pii+1)-esimo jump di s+1)-esimo jump di sii cade in B” cade in B”
Siamo interessati a calcolare la Pr[QSiamo interessati a calcolare la Pr[QR]=Pr[Q]+Pr[R]-Pr[QR]=Pr[Q]+Pr[R]-Pr[QR]R]
s t
d
2pi 2pi+1
Isi
ddii
d-d’
22pp ≤ d < 2≤ d < 2p+1p+1
p > (log n) / log (log n)p > (log n) / log (log n)II = (d-d’, d] = (d-d’, d]d’=d’=
|S|=p|S|=pddii≤d, ≤d, pi≤p
A=(d-d’, si+2pi)A=(d-d’, si+2pi)
n
nd
log
loglog
A B
Q RQR
C
Ma questa volta QQR è vuoto.R è vuoto.
H-Chord
ClaimClaim
Per ogni nodo sPer ogni nodo sii S, la probabilità che un S, la probabilità che un
vicino di svicino di si i I I è almeno d’/2è almeno d’/2pp..
P’=Pr[P’=Pr[JJkk(s(sii))I I per qualche 0 ≤ k < bper qualche 0 ≤ k < b] ≥ ] ≥ d’/2d’/2pp
ProvaProva
2.2. d-d’<d-d’<22ppii
Pr[QPr[QR]= R]= Pr[Q]+Pr[R]-Pr[QPr[Q]+Pr[R]-Pr[QR]R] = =Pr[Q]+Pr[R]Pr[Q]+Pr[R]
s t
d
2pi 2pi+1
Isi
ddii
d-d’
22pp ≤ d < 2≤ d < 2p+1p+1
p > (log n) / log (log n)p > (log n) / log (log n)II = (d-d’, d] = (d-d’, d]d’=d’=
|S|=p|S|=pddii≤d, ≤d, pi≤p
A=(d-d’, si+2pi)A=(d-d’, si+2pi)
n
nd
log
loglog
A B C
pppp
ddBABCiii 2
'
2
'
2
2
2
H-Chord
Perchè H-Chord e non R-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 un nodo x, x conosce il suo vicino y, dato y, x può calcolare H(y) e quindi può dato y, x può calcolare H(y) e quindi può calcolare per ogni 0calcolare per ogni 0≤≤i<b i<b y+2y+2ii++H(y)2H(y)2ii..
Tuttavia, quando il ring non è pieno, x non Tuttavia, quando il ring non è pieno, x non conosce l’esatta posizione dei vicini dei vicini conosce l’esatta posizione dei vicini dei vicini ma ne ha una buona stima.ma ne ha una buona stima.
La funzione di hash è uguale per tutti i nodi
H-Chord 2i 2i+12i+22i+1
H-Chord
H-Chord
0123456789
10
2 4 6 8 10 12 14 16 18
log N
ho
ps
Chord
R-ChordGreedyR-Chord NoN
R-Chord SP
H-ChordGreedyH-Chord NoN
H-Chord SP
H-Chord
0
1
2
3
4
5
6
7
8
9
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
log N
ho
ps
Chord
R-ChordGreedyR-Chord NoN
R-Chord SP
H-ChordGreedyH-Chord NoN
H-Chord SP
Perchè H-Chord e non 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 uniformiVantaggi: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 Routing locale, la procedura di lookup interessa solo i nodi
che si trovano fra sorgente e destinazione; che si trovano fra sorgente e destinazione; Non c’è congestione sui nodi, vale a dire il traffico generato Non c’è congestione sui nodi, vale a dire il traffico generato
dai messaggi di lookup è più o meno uguale per tutti i nodi.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 Poiché tutti i nodi utilizzano gli stessi jump, è possibile utilizzare la tabella di routing del proprio predecessore per velocizzare la tabella di routing del proprio predecessore per velocizzare notevolmente l’operazione di join;notevolmente l’operazione di join;
Svantaggi:Svantaggi: Sfortunatamente non sono gli algoritmi più efficienti.Sfortunatamente non sono gli algoritmi più efficienti.
Koorde base k
Scegliendo k = O(log n):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))
SvantaggiSvantaggi 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;
00
0112
11
10 b=2
k=3
02
2221
20
R-Chord
Vantaggi: Algoritmo di routing locale Algoritmo di routing semplice Efficiente Non è necessaria la stima di log n L’algoritmo 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 L’algoritmo di stabilizzazione è identico a
quello di Chord
Svantaggi No fast bootstrap ????
Hc-Chord
Recommended