rami ramo

Reti di Trasporto
Algoritmi e protocolli di Routing
Ing. Alessio Botta
e-mail: [email protected]
Le slides relative a questi argomenti sono quasi integralmente tratte dal corso di
Sistemi di Commutazione del prof. Marco Listanti e dalle relative esercitazioni preparate
dall’ing. Luca Veltri. Ad entrambi va il mio ringraziamento.
[http://net.infocom.uniroma1.it/sdc/sdc.htm]
1
Teoria dei Grafi
• Un grafo G(V,E) è dato da
» un insieme V di nodi
» un insieme E di rami, ogni ramo connette una coppia di nodi
• Due vertici i e j sono detti adiacenti se sono connessi da un
ramo (i,j)
• Il ramo (i,j) è detto incidente ai nodi i e j
• La cardinalità |V| dell’insieme dei nodi è detta ordine del grafo
G
• La cardinalità |E| dell’insieme dei rami è detta dimensione del
grafo G
2
Teoria dei Grafi
• Un grafo può essere rappresentato dalla Matrice di Adiacenza
A di dimensioni |V| x |V|
1
aij = 
0
A = [ aij ]
V3
V2
V1
V6
V5
V4
if (i, j) ∈ E
otherwise
V1
V2
V3
V4
V5
V6
V1
0
1
1
1
0
0
V2
1
0
1
1
0
0
V3
1
1
0
1
1
1
V4
1
1
1
0
1
0
V5
0
0
1
1
0
1
V6
0
0
1
0
1
0
3
Teoria dei Grafi
• Un cammino tra due nodi i e j è una sequenza di nodi e rami a
•
•
•
•
partire dal nodo i al nodo j tale che ogni ramo è incidente al
nodo precedente e successivo
Un cammino in cui ogni nodo e ogni ramo appare una sola
volta è detto cammino semplice (simple path)
Il minimo numero di rami che compone un cammino tra due
nodi i e j è detta distanza tra i due nodi
Un ciclo è un cammino semplice in cui il nodo di partenza
coincide con il nodo di arrivo
Un grafo G è detto connesso se esiste un cammino tra
qualsiasi coppia di nodi
4
Teoria dei Grafi
• Un grafo orientato è un grafo in cui i rami hanno un verso di
percorrenza
• Un grafo pesato è un grafo in cui a ciascun ramo (i,j) è
associato un numero wij (peso del ramo)
• La matrice di adiacenza di un grafo orientato pesato è data da
• La lunghezza di un cammino in un grafo pesato è data dalla
somma dei pesi associati ai rami del cammino
w
aij =  ij
 0
A = [ aij ]
if (i, j) ∈ E
otherwise
5
Teoria dei Grafi
• Esempio
V3
3
V2
8
Matrice di adiacenza
6
8
5
3
2
2
V6
5
3
2
4
1
2
3
1
1
V1
1
7
V4
1
V5
V1
V2
V3
V4
V5
V6
V1
0
2
5
1
0
0
V2
3
0
3
2
0
0
V3
8
6
0
3
1
5
V4
7
2
3
0
1
0
V5
0
0
1
1
0
2
V6
0
0
8
0
4
0
Grafo Pesato
6
Teoria dei Grafi
• Una qualsiasi rete a pacchetto può essere modellata come un
grafo orientato pesato
» i nodi sono i commutatori e/o router
» i rami sono le linee trasmissive o le sotto-reti
• L’instradamento (routing) di un pacchetto equivale alla
•
ricerca di un cammino nel grafo associato della rete
Ricerca del cammino a minima distanza
» grafo non pesato
• Ricerca del cammino a minima lunghezza
» grafo pesato (costo, congestione, capacità, ecc.)
7
Alberi
• Un grafo T è detto albero (tree) se
» tra ogni coppia di nodi i e j, esiste un solo cammino semplice
» detto N il numero di nodi, il numero di rami è N-1 ed il grafo è connesso
senza cicli
• Ogni nodo di un albero può essere denominato radice
• Un albero può essere sempre raffigurato disponendo i nodi in
livelli successivi a partire dalla radice
• In una raffigurazione di un albero a livelli
» ogni nodo, tranne la radice, ha un solo nodo padre
» ogni nodo ha zero o più nodi figli
» se un nodo non ha figli è detto foglia dell’albero
8
Spanning Tree
• Un sottografo di un grafo G(V,E) è un grafo ottenuto dal grafo
G
» scegliendo un sotto insieme di rami e di nodi appartenenti a G
» per ogni ramo scelto devono essere compresi, nel sottoinsieme dei nodi,
i nodi in cui il ramo è incidente
• Un sottografo T di un grafo G è chiamato Spanning Tree di G
se
» T è un albero
» T include tutti i nodi di G
• Uno spanning tree di un grafo G è un sottografo connesso in
cui sono stati rimossi tutti i possibili cicli
9
Spanning Tree
Spanning Tree 1
Grafo G
V3
V2
V2
V6
V6
V1
V1
V3
V4
V5
V5
V4
V2
• Lo Spanning Tree di un
grafo non è unico
V1
V3
V6
V5
V4
Spanning Tree 2
10
Ricerca di uno Spanning Tree
• Breadth-First Search (BFS) algorithm
• Si basa sulla classificazione dei nodi in livelli a partire da
un nodo radice
• Algoritmo
» si individua un nodo radice (nodo x)
» si individuano tutti i nodi adiacenti a x (nodi di livello 1)
» per ogni nodo appartenente al livello 1 si individuano i nodi adiacenti
non precedentemente raggiunti (nodi di livello 2)
» il processo si itera sino a che non sono stati raggiunti tutti i nodi del
grafo
11
Breadth-First Search
1 v3
v2
1
v1 0
1
v4
v6
v5
1 v3
v2
1
v1 0
1
v2
v1 0
1
1
v4
T={1,2,3,4}
v5
v2
v6
v5
1 v3
v2
v1 0
1
1
v4
T={1,2,3,4,5}
v6
1
v1 0
1
T={1,2}
T={1}
1 v3
v4
v6
1 v3
v5
v4
T={1,2,3}
2 v6
2 v
5
1 v3
v2
v1 0
2 v6
1
1
v4
2 v
5
T={1,2,3,4,5,6}
12
Breadth-First Search
• L’algoritmo BFS individua i cammini a distanza minima tra il
•
•
nodo radice e tutti gli altri nodi del grafo
Un cammino a distanza minima (shorthest path length) δ(s,v)
tra un nodo s ed un nodo v è dato dal cammino con il minimo
numero di rami tra i due nodi
La complessità computazionale dell’algoritmo BFS è
proporzionale a |V| ed |E| [o(|V|.|E|)]
13
Dijkstra’s Algorithm
• L’algoritmo di Dijkstra individua il cammino a lunghezza minima
•
tra un nodo s e tutti gli altri nodi di un grafo G procedendo in
modo da aumentare progressivamente la distanza
L’algoritmo procede a passi successivi
» al passo k-mo sono individuati i k nodi raggiungibili dal nodo sorgente
tramiti i cammini a costo più basso
» tali k nodi formano l’insieme T
» al passo k+1-mo è aggiunto un ulteriore nodo all’insieme T caratterizzato
dal cammino dal costo più basso dal nodo s che transita esclusivamente
nei nodi dell’insieme T
» l’algoritmo termina quando si sono esplorati tutti i nodi
14
Dijkstra’s Algorithm
Viene aggiunto all’insieme Tk-1
il nodo n caratterizzato dal
cammino di lunghezza minima
con il nodo sorgente s che
transita esclusivamente in nodi
dell’insieme Tk-1
Xk-2
x2
n
xi
x1
s
Insieme
Tk-1
Insieme
Tk
Situazione al passo k
15
Dijkstra’s Algorithm
• Notazioni:
»
»
»
»
N : insieme dei nodi del grafo
s : nodo sorgente
Tk : insieme dei nodi raggiunti dall’algoritmo al passo k
w(i,j) : peso (costo) del ramo (i,j)
» w(i,i) = 0
» w(i,j) ≥ 0
se i vertici i e j sono connessi direttamente
» w(i,j) = ∞
se i vertici i e j non sono connessi direttamente
» Lk(n) : costo del cammino a costo minimo, individuato dall’algoritmo al
passo k, tra il nodo s ed il generico nodo n
16
Dijkstra’s Algorithm
• Inizializzazione (k=1)
» T1 = {s}
» L1(n) = w(s,n)
per n ≠ s
• Aggiunta di un nodo (passo k)
» trovare x ∉ T tale che
Lk −1( x ) = min Lk −1( j)
j∉T
» aggiungere all’insieme Tk-1 il nodo x ed il ramo incidente a x
• Aggiornamento dei cammini minimi
» Lk(n) = min [Lk-1(n), Lk-1(x) + w(x,n)] per tutti i valori di n ∉ T
17
Dijkstra’s Algorithm
• L’algoritmo termina quando tutti i nodi sono stati aggiunti
•
all’insieme T, ovvero T=N
Al termine
» l’insieme T è uno spanning tree del grafo di partenza contenente i cammini
a costo minimo tra il nodo sorgente e tutti gli altri nodi del grafo
» LN(n) indica il costo del cammino a costo minimo tra il nodo s ed il nodo n
• Si noti che
» al passo k-mo viene aggiunto all’insieme T il k-mo nodo ed è individuato il
cammino a costo minimo tra il tale nodo ed il nodo sorgente
» questo cammino transita esclusivamente attraverso i nodi sinora compresi
nell’insieme T
• La complessità dell’algoritmo è o(|V|2)
18
Esempio Dijkstra Algorithm - 1(2)
8
V3
3
V2 2
6
2
2
4
1
3
8
6
2
3
2
3
2
8
0
2
3
V1
1
1
1
7
1
0
1
V4
V5
V3
3
V2 2
4
6
2
2
3
2
V5
T2 = {1,4}
8
5
3
2
1
V4
V6
5
1
1
7
V1
T1 = {1}
8
4
1
1
1
V6
5
4
5
2
3
2
V3
3
V2 2
8
5
3
V6
5
5
4
1
2
3
1
T3 = {1,2,4}
1
0
1
1
7
V1
2
1
V4
V5
19
Esempio Dijkstra Algorithm - 2(2)
8
V3
3
V2 2
6
2
2
3
2
4
8
5
3
V6
5
3
4
1
8
6
2
3
2
8
0
2
3
2
V1
1
1
1
7
2
1
V4
V3
6
3
2
2
3
2
V4
1
2
1
V5
T5 = {1,2,3,4,5}
4
8
5
3
V6
5
1
7
V1
3
V2 2
1
0
V5
T4 = {1,2,4,5}
8
4
4
1
3
1
1
V6
5
3
5
2
3
V3
3
V2 2
4
1
2
3
1
0
V1
1
1
7
V4
1
2
1
T6 = {1,2,3,4,5,6}
V5
20
Bellman-Ford Algorithm
• L’algoritmo di Bellman-Ford individua il cammino a lunghezza
•
minima tra un nodo s e tutti gli altri nodi di un grafo G
L’algoritmo procede a passi
» al primo passo individua i cammini minimi tra il nodo sorgente e gli altri
nodi con il vincolo che i cammini devono avere al massimo 1 ramo
» al secondo passo si trovano i cammini minimi tra il nodo sorgente e gli
altri nodi con il vincolo che i cammini devono avere al massimo 2 rami
» si itera il procedimento sino al valore massimo di rami in un cammino
21
Bellman-Ford Algorithm
• Notazioni
» N : insieme dei nodi del grafo
» s : nodo sorgente
» h : massimo numero di rami in un cammino correntemente
consentito dall’algoritmo
» w(i,j) : peso (costo) del ramo (i,j)
» w(i,i) = 0
» w(i,j) ≥ 0
se i vertici i e j sono connessi direttamente
» w(i,j) = ∞
se i vertici i e j non sono connessi direttamente
» Lh(n) : costo del cammino a costo minimo correntemente
individuato dall’algoritmo, tra il nodo s ed il nodo n, con il vincolo
di un numero di rami sia non superiore a h
22
Bellman-Ford Algorithm
• Inizializzazione
» L0(n) = ∞
» Lh(s) = 0
per tutti i valori di n ≠ s
per tutti i valori di h
• Aggiornamento
» per tutti i valori successivi di h≥0, calcolare
Lh+1(n) = min [Lh ( j) + w ( j, n)]
j
» connettere il nodo n con il nodo precedessore j che raggiunge il minimo
ed eliminare le connessioni di n con altri nodi precedessori individuati in
precedenti iterate
• La complessità dell’algoritmo è o(|V|.|E|), ovvero nel caso
peggiore, in cui |E|=|V|2, si ha o(|V|3)
23
Esempio Bellman-Ford Algorithm
8
V3
3
V2 2
6
2
2
4
1
3
6
2
3
2
8
0
h=1
2
3
2
V1
V2 2
8
1
V4
V3
3
6
3
2
2
3
2
V5
1
0
h=2
8
4
V1
4
1
8
V4
3
2
3
2
3
2
8
h=3
V1
1
1
7
V4
4
4
1
2
3
1
0
V5
V6
5
5
2
3
6
2
1
V3
3
V2 2
1
1
7
V6
5
5
3
1
1
1
7
10
4
1
3
1
1
V6
5
4
5
2
3
2
8
V3
3
V2 2
8
5
3
V6
5
5
1
1
2
1
V5
h=4
0
V1
1
1
7
V4
1
2
1
V5
24
Bellman-Ford Algorithm
• La soluzione dell’algoritmo di Bellman-Ford può essere anche
scritta
» detto L(n) il cammino a lunghezza minima tra il nodo s ed il nodo n
L(n) = min [L(j) + w(j,n) ]
j
• La precedente espressione implica che il camminino a
lunghezza minima tra il noso s ed il nodo n è dato dalla
composizione di
» un cammino a lunghezza minima tra il nodo s ed un nodo j adiacente al
nodo n
» il ramo incidente ai nodi j e n
25
Confronto
• I due algoritmi convergono alla stessa soluzione
• L’algoritmo di Bellman-Ford, nel caso peggiore, è più
complesso; in molti casi pratici i due algoritmi si equivalgono
• L’algoritmo di Dijkstra richiede che un nodo conosca l’intera
topologia della rete e il peso (stato) di tutti i rami
» necessità di colloquio tra tutti i nodi
• L’algoritmo di Bellman-Ford richiede la conoscenza dello
stato dei rami uscenti da un nodo insieme alle informazioni
provenienti dai nodi vicini
» possibilità di colloquio solo tra nodi adiacenti (implementazione
distribuita)
26
Esercizio 1 (1/3)
• Si consideri il grafo mostrato in figura in cui i rami sono
bidirezionali con peso uguale in entrambe le direzioni. Si
determini, applicando l’algoritmo di Dijkstra, lo spanning tree a
costo minimo avente come radice il nodo 1 e si completi la tabella
sottostante.
V2
V3
3
2
1
1
V4
1
V1
4
4
1
V5
V6
Passo
1
2
3
4
5
6
T
1
L(2)
1
Path
1-2
L(3)
∞
Path
---
L(4)
∞
Path
---
L(5)
∞
Path
---
L(6)
4
Path
1-6
27
Esercizio 1 (2/3)
V2
V3
3
43
1
1
1
2
56
1
V4
V1
0
4
4
1
2
V5
34
V6
Passo
T
L(2)
1
1
1
2
1,2
1
3
1,2,5
1
4
1,2,5,6
1
5
1,2,5,6,3
1
6
1,2,5,6,3,4 1
Path
1-2
1-2
1-2
1-2
1-2
1-2
L(3)
∞
4
3
3
3
3
Path
L(4)
Path
L(5)
----∞
∞
1-2-3
--2
∞
1-2-5-3
6
1-2-5-4
2
1-2-5-3
6
1-2-5-4
2
1-2-5-3
5 1-2-5-3-4 2
1-2-5-3
5 1-2-5-3-4 2
Path
--1-2-5
1-2-5
1-2-5
1-2-5
1-2-5
L(6)
4
4
3
3
3
3
Path
1-6
1-6
1-2-5-6
1-2-5-6
1-2-5-6
1-2-5-6
28
Esercizio 1 (3/3)
• Si consideri lo stesso grafo dell’esercizio precedente. Si
determini, applicando, questa volta, l’algoritmo di Bellman-Ford,
lo spanning tree a costo minimo avente come radice il nodo 1 e
si completi la tabella sottostante.
V2
V3
3
2
1
1
V4
1
V1
4
4
1
V5
V6
h
0
1
2
3
4
5
Lh(2)
∞
Path
---
Lh(3)
∞
Path
---
Lh(4)
∞
Path
---
Lh(5)
∞
Path
---
Lh(6)
∞
Path
---
29
Esercizio 2 (1/2)
• Si consideri il grafo mostrato in figura in cui i rami sono
bidirezionali con peso uguale in entrambe le direzioni. Si
determini, applicando l’algoritmo di Djikstra, lo spanning tree a
costo minimo avente come radice il nodo A e si completi la
tabella sottostante.
C
B
1
2
5
1
A
D
1
G
1
6
2
4
F
Passo
1
2
3
4
5
6
7
T
A
L(B)
1
Path
A-B
L(C)
∞
Path
---
L(D)
∞
1
E
Path
---
L(E)
∞
Path
---
L(F)
∞
Path
---
L(G)
1
Path
A-G
30
Esercizio 2 (2/2)
• Si consideri lo stesso grafo dell’esercizio precedente. Si
determini, applicando l’algoritmo di Bellman-Ford, lo spanning
tree a costo minimo avente come radice il nodo A e si completi la
tabella sottostante.
B
C
1
2
5
1
A
D
1
G
1
6
2
F
h
0
1
2
3
4
5
Lh(B)
∞
Path
---
Lh(C)
∞
Path
---
Lh(D)
∞
Path
---
1
E
Lh(E)
∞
4
Path
---
Lh(F)
∞
Path
---
Lh(G)
∞
Path
---
31