lowest-cost routing

1

Lowest-Cost Routing

EE 122: Intro to Communication Networks

Fall 2010 (MW 4-5:30 in 101 Barker)

Scott Shenker

TAs: Sameer Agarwal, Sara Alspaugh, Igor Ganichev, Prayag Narula

http://inst.eecs.berkeley.edu/~ee122/

Materials with thanks to Jennifer Rexford, Ion Stoica, Vern Paxsonand other colleagues at Princeton and UC Berkeley

2

Announcements

• Revision to lecture schedule– Advanced topics on routing

• Revision to homework schedule– 3a: get midterm questions right– 3b: new topics

• Changes to class structure– 5 minute “technology break”– Administrivia right after break– Group problem solving (when possible)

o Sit next to smart people

3

Goals of Today’s Lecture

• Routing overview:–Routing vs. forwarding–Routing topics

• Link-state routing (Dijkstra’s algorithm)

• Distance-vector routing (Bellman-Ford)

4

Forwarding vs. Routing

• Forwarding: “data plane”–Directing a data packet to an outgoing link–Individual router using a forwarding table

• Routing: “control plane”–Computing paths the packets will follow–Routers talking amongst themselves–Jointly creating a forwarding table

5

Why Does Routing Matter?

• Routing provides connectivity!– Without routing, the network doesn’t function

• Routing finds “good” paths– Propagation delay, throughput, packet loss

• Routing allows network to tolerate failures– Limits packet loss during disruptions

• Routing can also provide “Traffic Engineering”– Balance traffic over the routers and links– Avoid congestion by directing traffic to lightly-loaded links– (Not covered today)

Three Lectures on Routing

• Today: Lowest-cost routing– Simple algorithms, basic issues

• Wednesday: Policy-based routing– Interdomain routing

• Monday: Advanced topics– Traffic engineering– Improved resilience– What future routing algorithms might look like….

6

7

• Centralized global state– Single entity knows the complete network structure– Can calculate all routes centrally– Problems with this approach?

• Distributed global state– Every router knows the complete network structure– Independently calculates routes– Problems with this approach?

• Distributed global computation– Every router knows only about its neighboring routers– Participates in global joint calculation of routes– Problems with this approach?

Routing Requires Knowing Network

Link State RoutingE.g. Algorithm: Dijkstra

E.g. Protocol: OSPF

Distance Vector RoutingE.g. Algorithm: Bellman-Ford

E.g. Protocol: RIP

8

Modeling a Network

• Modeled as a graph– Routers nodes– Link edges

o Possible edge costs• Hop• Delay • Congestion level• ….

• Goal of Routing– Determine “good” path from source to destination– “Good” usually means the lowest “cost” path– Where cost is usually hop-count or latency

A

ED

CB

F

2

2

13

1

1

2

53

5

From Model to Reality

• In reality, attach prefixes to nodes

• Calculate routing tables in terms of prefixes

• But ignore this for now…..– Just calculate paths between routers

9

Why Isn’t All Routing Lowest-Cost?

• Lowest-cost routing assumes all nodes evaluate paths the same way– i.e., use same “cost” metric

• Interdomain routing:– Different domains care about different things– Can exercise general “policy” goals

• Requires very different route computation– Talk about on Wednesday….

10

11

• Each router has complete network picture– Topology– Link costs

• How does each router get the global state?–Each router reliably floods information about its

neighbors to every other router (more later)

• Each router independently calculates the shortest path from itself to every other router– Using, for example, Dijkstra’s Algorithm

Link State Routing

12

Link State: Control Traffic• Each node floods its local information• Each node ends up knowing the entire network topology node

Host A

Host BHost E

Host D

Host C

N1 N2

N3

N4

N5

N7N6

13

Link State: Node State

Host A

Host BHost E

Host D

Host C

N1 N2

N3

N4

N5

N7N6

A

BE

DC

A

BE

DC A

BE

DC

A

BE

DC

A

BE

DC

A

BE

DC

A

BE

DC

Dijkstra’s Shortest Path Algorithm

• INPUT:– Network topology (graph), with link costs

• OUTPUT:– Least cost paths from one node to all other nodes– Produces “tree” of routes (why?)

14

15

Notation

• c(i,j): link cost from node i to j; cost infinite if not direct neighbors; ≥ 0

• D(v): current value of cost of path from source to destination v

• p(v): predecessor node along path from source to v, that is next to v

• S: set of nodes whose least cost path definitively known

A

ED

CB

F

2

2

13

1

1

2

53

5

Source

16

Dijsktra’s Algorithm

1 Initialization: 2 S = {A};3 for all nodes v 4 if v adjacent to A 5 then D(v) = c(A,v); 6 else D(v) = ;7 8 Loop 9 find w not in S such that D(w) is a minimum; 10 add w to S; 11 update D(v) for all v adjacent to w and not in S: 12 if D(w) + c(w,v) < D(v) then // w gives us a shorter path to v than we’ve found so far 13 D(v) = D(w) + c(w,v); p(v) = w;14 until all nodes in S;

∞

• c(i,j): link cost from node i to j

• D(v): current cost source v

• p(v): predecessor node along path from source to v, that is next to v

• S: set of nodes whose least cost path definitively known

17

Example: Dijkstra’s Algorithm

Step012345

start SA

D(B),p(B)2,A

D(C),p(C)5,A

D(D),p(D)1,A

D(E),p(E) D(F),p(F)

A

ED

CB

F

2

2

13

1

1

2

53

5

∞ ∞

1 Initialization: 2 S = {A};3 for all nodes v 4 if v adjacent to A 5 then D(v) = c(A,v); 6 else D(v) = ;…

∞

18


Step012345

start SA

D(B),p(B)2,A

D(C),p(C)5,A

…8 Loop 9 find w not in S s.t. D(w) is a minimum; 10 add w to S; 11 update D(v) for all v adjacent to w and not in S: • If D(w) + c(w,v) < D(v) then• D(v) = D(w) + c(w,v); p(v) = w;14 until all nodes in S;

A

ED

CB

F

2

2

13

1

1

2

53

5

D(D),p(D)1,A

D(E),p(E) D(F),p(F)∞ ∞

19


Step012345

start SA

AD

D(B),p(B)2,A

D(C),p(C)5,A

D(D),p(D)1,A

D(E),p(E) D(F),p(F)

A

ED

CB

F

2

2

13

1

1

2

53

5

∞ ∞


20


Step012345

start SA

AD

D(B),p(B)2,A

D(C),p(C)5,A4,D

D(D),p(D)1,A

D(E),p(E)

2,D

D(F),p(F)

A

ED

CB

F

2

2

13

1

1

2

53

5

∞ ∞


21


Step012345

start SA

ADADE

D(B),p(B)2,A

D(C),p(C)5,A4,D3,E

D(D),p(D)1,A

D(E),p(E)

2,D

D(F),p(F)

4,E

∞ ∞

A

ED

CB

F

2

2

13

1

1

2

53

5…8 Loop 9 find w not in S s.t. D(w) is a minimum; 10 add w to S; 11 update D(v) for all v adjacent to w and not in S: • If D(w) + c(w,v) < D(v) then• D(v) = D(w) + c(w,v); p(v) = w;14 until all nodes in S;

22


Step012345

start SA

ADADE

ADEB

D(B),p(B)2,A

D(C),p(C)5,A4,D3,E

D(D),p(D)1,A

D(E),p(E)

2,D

D(F),p(F)

4,E

∞ ∞

A

ED

CB

F

2

2

13

1

1

2

53


23


Step012345

start SA

ADADE

ADEBADEBC

D(B),p(B)2,A

D(C),p(C)5,A4,D3,E

D(D),p(D)1,A

D(E),p(E)

2,D

D(F),p(F)

4,E

∞ ∞

A

ED

CB

F

2

2

13

1

1

2

53


24


Step012345

start SA

ADADE

ADEBADEBC

ADEBCF

D(B),p(B)2,A

D(C),p(C)5,A4,D3,E

D(D),p(D)1,A

D(E),p(E)

2,D

D(F),p(F)

4,E

∞ ∞

A

ED

CB

F

2

2

13

1

1

2

53


25


Step012345

start SA

ADADE

ADEBADEBC

ADEBCF

D(B),p(B)2,A

D(C),p(C)5,A4,D3,E

D(D),p(D)1,A

D(E),p(E)

2,D

D(F),p(F)

4,E

∞ ∞

A

ED

CB

F

2

2

13

1

1

2

53

5To determine path A C (say), work backward from C via p(v)

26

• Running Dijkstra at node A gives the shortest path from A to all destinations

• We then construct the forwarding table

The Forwarding Table

A

ED

CB

F

2

2

13

1

1

2

53

5Destination Link

B (A,B)

C (A,D)

D (A,D)

E (A,D)

F (A,D)

27

Complexity

• How much processing does running the Dijkstra algorithm take?

• Assume a network consisting of N nodes–Each iteration: check all nodes w not in S–N(N+1)/2 comparisons: O(N2)–More efficient implementations: O(N log(N))

28

Obtaining Global State

• Flooding– Each router sends link-state information out its links– The next node sends it out through all of its links

o except the one where the information arrivedo Note: need to remember previous msgs & suppress duplicates!

X A

C B D

(a)

X A

C B D

(b)

X A

C B D

(c)

X A

C B D

(d)

29

Flooding the Link State

• Reliable flooding–Ensure all nodes receive link-state information–Ensure all nodes use the latest version

• Challenges–Packet loss–Out-of-order arrival

• Solutions–Acknowledgments and retransmissions–Sequence numbers

30

When to Initiate Flooding

• Topology change–Link or node failure–Link or node recovery

• Configuration change–Link cost change–Potential problems with making cost dynamic!

• Periodically–Refresh the link-state information–Typically (say) 30 minutes–Corrects for possible corruption of the data

31

Oscillating Load-Dependent Routing• Assume link cost = amount of carried traffic

– All traffic sent to A

A

D

C

B

1 1+e

e0

e

1 1

0 0

initially

A

D

C

B2+e 0

001+e1

… recomputerouting

A

D

C

B0 2+e

1+e10 0

… recompute

A

D

C

B2+e 0

e01+e1

… recompute

Very Hard to Avoid Oscillations!

A

D

C

B

0 0

0 0

32

Detecting Topology Changes

• Beaconing–Periodic “hello” messages in both directions–Detect a failure after a few missed “hellos”

• Performance trade-offs–Detection speed–Overhead on link bandwidth and CPU–Likelihood of false detection

“hello”

33

Convergence

• Getting consistent routing information to all nodes– E.g., all nodes having the same link-state database

• Consistent forwarding after convergence– All nodes have the same link-state database– All nodes forward packets on shortest paths– The next router on the path forwards to the next hop

34

Convergence Delay

• Time elapsed before every router has a consistent picture of the network

• Sources of convergence delay– Detection latency– Flooding of link-state information– Recomputation of forwarding tables

• Performance during convergence period– Lost packets due to blackholes and TTL expiry– Looping packets consuming resources– Out-of-order packets reaching the destination

• Very bad for VoIP, online gaming, and video

35

Reducing Convergence Delay

• Faster detection– Smaller hello timers– Link-layer technologies that can detect failures

• Faster flooding– Flooding immediately– Sending link-state packets with high-priority

• Faster computation– Faster processors on the routers– Incremental Dijkstra algorithm

• Faster forwarding-table update– Data structures supporting incremental updates

36

• Inconsistent link-state database–Some routers know about failure before others–The shortest paths are no longer consistent–Can cause transient forwarding loops

Transient Disruptions

A

ED

CB

F A

ED

CB

F

A and D think that thisis the path to C

E thinks that thisis the path to C

Loop!

37

Scaling Link-State Routing• Overhead of link-state routing

– Flooding link-state packets throughout the network– Running Dijkstra’s shortest-path algorithm– Becomes unscalable when 100s of routers

• Introducing hierarchy through “areas”

Area 0

Area 1 Area 2

Area 3 Area 4

areaborderrouter

38

Link-State Routing Is Conceptually Simple

• Each router keeps track of its incident links– Link cost, and whether the link is up or down

• Each router broadcasts the link state– To give every router a complete view of the graph

• Each router runs Dijkstra’s algorithm– Compute shortest paths, then construct forwarding table

• Example protocols– Open Shortest Path First (OSPF)– Intermediate System – Intermediate System (IS-IS)

• Challenges: scaling, transient disruptions– Any ideas for improvement?

Question

• Why use different routing algorithms at L2 and L3?– Is Link-State “plug-and-play”?– Could we make it “plug-and-play?”

39

40

5 Minute Break

Questions Before We Proceed?

Feedback on Course

• Course moving:– Too slowly: 13%– Too quickly: 30%– OK: 57%

• Lectures should be:– Harder: 18%– Easier: 26%– Same: 56%

• Homework should be:– Harder: 33%– Easier: 13%– Same: 54%

• Include History/Politics:– Yes: 76%

• Include worked ex’s:– Yes: 82%

• Project is:– Too easy: 11%– Too hard: 33%– OK: 56%

• Support in Section– Yes: 80%– Don’t go: 12%

41

Selected Comments

• Use newsgroups

• Weekly homeworks

• Relate project to course

• Don't skip break

• Test too easy

• Bspace is evil

• “Cancel the project and final, buy us dinner”

• “Make lectures less boring”42

More Scalable Routing Algorithms?

• Avoid need for global state consistency

• Just focus on computing routes

• Distribute the computation, not the state….

43

44

Distance Vector Routing

• Each router knows the links to its neighbors– Does not flood this information to the whole network

• Each router has provisional “shortest path”– E.g.: Router A: “I can get to router B with cost 11 via

next hop router D”

• Routers exchange this information with their neighboring routers– Again, no flooding the whole network

• Routers update their idea of the best path using info from neighbors

• This iterative process converges with set of shortest paths

45

Information Flow in Distance Vector

Host A

Host BHost E

Host D

Host C

N1 N2

N3

N4

N5

N7N6

46


Host A

Host BHost E

Host D

Host C

N1 N2

N3

N4

N5

N7N6

47


Host A

Host BHost E

Host D

Host C

N1 N2

N3

N4

N5

N7N6

Why Is This Different From Flooding?

48

49

Bellman-Ford Algorithm

• INPUT:–Link costs to each neighbor–Not full topology

• OUTPUT:–Next hop to each destination and the

corresponding cost–Does not give the complete path to the

destination

50

Bellman-Ford - Overview

• Each router maintains a table– Row for each possible destination– Column for each directly-attached

neighbor to node– Entry in row Y and column Z of node X

best known distance from X to Y, via

Z as next hop = DZ(X,Y)

• Each local iteration caused by: – Local link cost change – Message from neighbor

• Notify neighbors only if least cost path to any destination changes– Neighbors then notify their neighbors if

necessary

wait for (change in local link cost or msg from neighbor)

recompute distance table

if least cost path to any dest

has changed, notify neighbors

Each node:






A C12

7

B D3

1

B C

B 2 8

C 3 7

D 4 8

Node A

Neighbor (next-hop)

Destinations DC(A, D)






A C12

7

B D3

1

B C

B 2 8

C 3 7

D 4 8

Node A

Smallest distance in row Y = shortestDistance of A to Y, D(A, Y)

53

Distance Vector Algorithm (cont’d)

1 Initialization: 2 for all neighbors V do3 if V adjacent to A 4 D(A, V) = c(A,V);• else • D(A, V) = ∞;• send D(A, Y) to all neighbors loop: 8 wait (until A sees a link cost change to neighbor V /* case 1 */9 or until A receives update from neighbor V) /* case 2 */10 if (c(A,V) changes by ±d) /* case 1 */11 for all destinations Y that go through V do 12 DV(A,Y) = DV(A,Y) ± d 13 else if (update D(V, Y) received from V) /* case 2 */ /* shortest path from V to some Y has changed */ 14 DV(A,Y) = DV(A,V) + D(V, Y); /* may also change D(A,Y) */15 if (there is a new minimum for destination Y)16 send D(A, Y) to all neighbors 17 forever

• c(i,j): link cost from node i to j

• DZ(A,V): cost from A to V via Z

• D(A,V): cost of A’s best path to V

Example:1st Iteration (C A)

A C12

7

B D3

1

B C

B 2 8

C ∞ 7

D ∞ 8

Node A

A C D

A 2 ∞ ∞

C ∞ 1 ∞

D ∞ ∞ 3

Node B

Node C

A B D

A 7 ∞ ∞

B ∞ 1 ∞

D ∞ ∞ 1

B C

A ∞ ∞

B 3 ∞

C ∞ 1

Node D7 loop: …13 else if (update D(A, Y) from C) 14 DC(A,Y) = DC(A,C) + D(C, Y);15 if (new min. for destination Y)16 send D(A, Y) to all neighbors 17 forever

DC(A, B) = DC(A,C) + D(C, B) = 7 + 1 = 8

DC(A, D) = DC(A,C) + D(C, D) = 7 + 1 = 8

Example: 1st Iteration (B A)

A C12

7

B D3

1

B C

B 2 8

C 3 7

D 5 8

Node A

A C D

A 2 ∞ ∞

C ∞ 1 ∞

D ∞ ∞ 3

Node B

Node C

A B D

A 7 ∞ ∞

B ∞ 1

D ∞ ∞ 1

Node D7 loop: …13 else if (update D(A, Y) from B) 14 DB(A,Y) = DB(A,B) + D(B, Y);15 if (new min. for destination Y)16 send D(A, Y) to all neighbors 17 forever

DB(A, C) = DB(A,B) + D(B, C) = 2 + 1 = 3

DB(A, D) = DB(A,B) + D(B, D) = 2 + 3 = 5

B C

A ∞ ∞

B 3 ∞

C ∞ 1

Example: End of 1st Iteration

A C12

7

B D3

1

B C

B 2 8

C 3 7

D 5 8

Node A Node B

Node C

A B D

A 7 3 ∞

B 9 1 4

D ∞ 4 1

Node D

B C

A 5 8

B 3 2

C 4 1

End of 1st Iteration All nodes knows the best two-hop

paths

A C D

A 2 3 ∞

C 9 1 4

D ∞ 2 3

Example: 2nd Iteration (A B)

A C12

7

B D3

1

B C

B 2 8

C 3 7

D 5 8

Node A Node B

Node C

A B D

A 7 3 ∞

B 9 1 4

D ∞ 4 1

Node D

B C

A 5 8

B 3 2

C 4 1

A C D

A 2 3 ∞

C 5 1 4

D 7 2 3

7 loop: …13 else if (update D(B, Y) from A) 14 DA(B,Y) = DA(B,A) + D(A, Y);15 if (new min. for destination Y)16 send D(B, Y) to all neighbors 17 forever

DA(B, C) = DA(B,A) + D(A, C) = 2 + 3 = 5

DA(B, D) = DA(B,A) + D(A, D) = 2 + 5 = 7

Example: End of 2nd Iteration

A C12

7

B D3

1

B C

B 2 8

C 3 7

D 4 8

Node A

A C D

A 2 3 11

C 5 1 4

D 7 2 3

Node B

Node C

A B D

A 7 3 6

B 9 1 4

D 12 4 1

Node D

B C

A 5 4

B 3 2

C 4 1

End of 2nd Iteration All nodes knows the

best three-hop paths

Example: End of 3rd Iteration

A C12

7

B D3

1

B C

B 2 8

C 3 7

D 4 8

Node A

A C D

A 2 3 6

C 5 1 4

D 7 2 3

Node B

Node C

A B D

A 7 3 5

B 9 1 4

D 11 4 1

Node D

B C

A 5 4

B 3 2

C 4 1

End of 2nd Iteration: Algorithm

Converges!

60

Distance Vector: Link Cost Changes

A C14

50

B1

“goodnews travelsfast”

A C

A 4 6

C 9 1

Node B

A B

A 50 5

B 54 1

Node C

Link cost changes heretime

Algorithm terminates

loop: 8 wait (until A sees a link cost change to neighbor V9 or until A receives update from neighbor V) /10 if (c(A,V) changes by ±d) /* case 1 */11 for all destinations Y that go through V do 12 DV(A,Y) = DV(A,Y) ± d 13 else if (update D(V, Y) received from V) /* case 2 */14 DV(A,Y) = DV(A,V) + D(V, Y); 15 if (there is a new minimum for destination Y)16 send D(A, Y) to all neighbors 17 forever

A C

A 1 6

C 9 1

A B

A 50 5

B 54 1

A C

A 1 6

C 9 1

A B

A 50 2

B 51 1

A C

A 1 3

C 3 1

A B

A 50 2

B 51 1

61

DV: Count to Infinity Problem

A C14

50

B60

“badnews travelsslowly”

Node B

Node C

Link cost changes heretime

…

loop: 8 wait (until A sees a link cost change to neighbor V9 or until A receives update from neighbor V) /10 if (c(A,V) changes by ±d) /* case 1 */11 for all destinations Y that go through V do 12 DV(A,Y) = DV(A,Y) ± d 13 else if (update D(V, Y) received from V) /* case 2 */14 DV(A,Y) = DV(A,V) + D(V, Y); 15 if (there is a new minimum for destination Y)16 send D(A, Y) to all neighbors 17 forever

A C

A 4 6

C 9 1

A B

A 50 5

B 54 1

A C

A 60 6

C 9 1

A B

A 50 5

B 54 1

A C

A 60 6

C 9 1

A B

A 50 7

B 101 1

A C

A 60 8

C 9 1

A B

A 50 7

B 101 1

62

Distance Vector: Poisoned Reverse

A C14

50

B60• If B routes through C to get to A:

- B tells C its (B’s) distance to A is infinite (so C won’t route to A via B)

- Will this completely solve count to infinity problem?

Node B

Node C

Link cost changes here; C updates D(C, A) = 60 as

B has advertised D(B, A) = ∞

timeAlgorithm terminates

A C

A 4 6

C 9 1

A B

A 50 5

B ∞ 1

A C

A 60 6

C 9 1

A B

A 50 5

B ∞ 1

A C

A 60 6

C 9 1

A B

A 50 ∞

B ∞ 1

A C

A 60 51

C 9 1

A B

A 50 ∞

B ∞ 1

A C

A 60 51

C 9 1

A B

A 50 ∞

B ∞ 1

63

Routing Information Protocol (RIP)

• Simple distance-vector protocol– Nodes send distance vectors every 30 seconds– … or, when an update causes a change in routing

• Link costs in RIP– All links have cost 1– Valid distances of 1 through 15– … with 16 representing infinity– Small “infinity” smaller “counting to infinity” problem

• RIP is limited to fairly small networks– E.g., campus

Question

• Can we solve the count-to-infinity problem?

• Do we need to solve the count-to-infinity problem?

64

65

Summary

• Routing is a distributed algorithm– Different from forwarding– React to changes in the topology– Compute the shortest paths

• Two main shortest-path algorithms– Dijkstra link-state routing (e.g., OSPF, IS-IS)– Bellman-Ford distance-vector routing (e.g., RIP)

• Convergence process– Changing from one topology to another– Transient periods of inconsistency across routers

• Next time: BGP– Reading: K&R 4.6.3

lowest-cost routing

Documents