1. Lecture 7 Overview

2. Two Key Network-Layer Functions forwarding: move packets from router’s input to appropriate router output routing: determine route taken by packets from source to dest. – routing algorithms Analogy – routing: process of planning trip from source to destination – forwarding: process of getting through single interchange CPE 401/601 Lecture 7 : Routing 2

3. 1 2 3 local forwarding table header value output link 0100 0101 0111 1001 32213221 routing and forwarding 0111 value in arriving packet’s header routing algorithm CPE 401/601 Lecture 7 : Routing 3

4. Connection setup 3 rd important function in some architectures – ATM, frame relay, X.25 before datagrams flow, two end hosts and intervening routers establish virtual connection – routers get involved network vs transport layer connection service: – network: between two hosts may also involve intervening routers in case of VCs – transport: between two processes CPE 401/601 Lecture 7 : Routing 4

5. Network layer service models Network Architecture Internet ATM Service Model best effort BR VBR ABR UBR Bandwidth none constant rate guaranteed rate guaranteed minimum none Loss no yes no Order no yes Timing no yes no Congestion feedback no (inferred via loss) no congestion no congestion yes no Guarantees ? CPE 401/601 Lecture 7 : Routing 5

6. Virtual Circuit Implementation A Virtual Circuit consists of – path from source to destination – VC numbers one number for each link along path – entries in forwarding tables in routers along path Each packet carries VC identifier – VC number can be changed on each link Every router on source-dest path maintains “state” for each passing connection CPE 401/601 Lecture 7 : Routing 6

7. Forwarding table 12 22 32 1 2 3 VC number interface number Incoming interface Incoming VC # Outgoing interface Outgoing VC # 1 12 3 22 2 63 1 18 3 7 2 17 1 97 3 87 … … Forwarding table in northwest router: Routers maintain connection state information! CPE 401/601 Lecture 7 : Routing 7

8. Virtual circuits: signaling protocols used to setup, maintain teardown VC used in ATM, frame-relay, X.25 not used in today’s Internet application transport network data link physical application transport network data link physical 1. Initiate call 2. incoming call 3. Accept call 4. Call connected 5. Data flow begins 6. Receive data CPE 401/601 Lecture 7 : Routing 8

9. Datagram networks no call setup at network layer routers: no state about end-to-end connections – no network-level concept of “connection” packets forwarded using destination host address – packets between same src-dst pair may take different paths application transport network data link physical application transport network data link physical 1. Send data 2. Receive data CPE 401/601 Lecture 7 : Routing 9

10. Forwarding table Destination Address Range Link Interface 11001000 00010111 00010000 00000000 through 0 11001000 00010111 00010111 11111111 11001000 00010111 00011000 00000000 through 1 11001000 00010111 00011000 11111111 11001000 00010111 00011001 00000000 through 2 11001000 00010111 00011111 11111111 otherwise 3 4 billion possible entries CPE 401/601 Lecture 7 : Routing 10

11. Longest prefix matching Network Layer 4-11 Prefix Match Link Interface 11001000 00010111 00010 0 11001000 00010111 00011000 1 11001000 00010111 00011 2 otherwise 3 DA: 11001000 00010111 00011000 10101010 Examples DA: 11001000 00010111 00010110 10100001 Interface 0 Interface 1

12. Datagram or VC network: why? Internet (datagram) – data exchange among computers “elastic” service, no strict timing requirement – “smart” end systems (computers) can adapt, perform control, error recovery simple inside network, complexity at “edge” – many link types different characteristics uniform service difficult CPE 401/601 Lecture 7 : Routing 12

13. Datagram or VC network: why? ATM (VC) – evolved from telephony – human conversation: strict timing, reliability requirements need for guaranteed service – “dumb” end systems telephones complexity inside network CPE 401/601 Lecture 7 : Routing 13

14. Lecture 8 Routing Algorithms CPE 401 / 601 Computer Network Systems slides are modified from Dave Hollinger slides are modified from J. Kurose & K. Ross

15. Graph abstraction u y x wv z 2 2 1 3 1 1 2 5 3 5 Graph: G = (N,E) N = set of routers = { u, v, w, x, y, z } E = set of links ={ (u,v), (u,x), (v,x), (v,w), (x,w), (x,y), (w,y), (w,z), (y,z) } Graph abstraction is useful in other network contexts Example: P2P, where N is set of peers and E is set of TCP connections CPE 401/601 Lecture 8 : Routing Algorithms 15

16. Graph abstraction: costs u y x wv z 2 2 1 3 1 1 2 5 3 5 c(x,x’) = cost of link (x,x’) - e.g., c(w,z) = 5 cost could always be 1, or inversely related to bandwidth, or inversely related to congestion Cost of path (x 1, x 2, x 3,…, x p ) = c(x 1,x 2 ) + c(x 2,x 3 ) + … + c(x p-1,x p ) Question: What’s the least-cost path between u and z ? Routing algorithm: algorithm that finds least-cost path CPE 401/601 Lecture 8 : Routing Algorithms 16

17. Routing Algorithm classification Global or decentralized information? Global: link state algorithms – all routers have complete topology, link cost info Decentralized: distance vector algorithms – router knows physically-connected neighbors link costs to neighbors – iterative process of computation, exchange of info with neighbors CPE 401/601 Lecture 8 : Routing Algorithms 17

18. Routing Algorithm classification Static or dynamic? Static: – routes change slowly over time Dynamic: – routes change more quickly periodic update in response to link cost changes CPE 401/601 Lecture 8 : Routing Algorithms 18

19. Dijkstra’s Algorithm

20. Dijkstra’s algorithm A Link-State Routing Algorithm – Topology, link costs known to all nodes – accomplished via “link state broadcast” – all nodes have same info Compute least cost paths from source node to all other nodes – produces forwarding table for that node Iterative: – after k iterations, know least cost path to k dests CPE 401/601 Lecture 8 : Routing Algorithms 20

21. Dijkstra’s Algorithm Notation: c(x,y): link cost from node x to y; – ∞ if not direct neighbors D(v): current value of cost of path from source to dest v p(v): predecessor node along path from source to v N': set of nodes whose least cost path definitively known CPE 401/601 Lecture 8 : Routing Algorithms 21

22. Dijsktra’s Algorithm 1 Initialization: 2 N' = {u} 3 for all nodes v 4 if v adjacent to u 5 then D(v) = c(u,v) 6 else D(v) = ∞ 7 8 Loop 9 find w not in N' such that D(w) is a minimum 10 add w to N' 11 update D(v) for all v adjacent to w and not in N' : 12 D(v) = min( D(v), D(w) + c(w,v) ) 13 /* new cost to v is either old cost to v or known 14 shortest path cost to w plus cost from w to v */ 15 until all nodes in N‘ CPE 401/601 Lecture 8 : Routing Algorithms 22

23. Dijkstra’s algorithm: example Step 0 1 2 3 4 5 N' u ux uxy uxyv uxyvw uxyvwz D(v),p(v) 2,u D(w),p(w) 5,u 4,x 3,y D(x),p(x) 1,u D(y),p(y) ∞ 2,x D(z),p(z) ∞ 4,y u y x wv z 2 2 1 3 1 1 2 5 3 5 CPE 401/601 Lecture 8 : Routing Algorithms 23

24. Dijkstra’s algorithm: example u y x wv z Resulting shortest-path tree from u: v x y w z (u,v) (u,x) destination link Resulting forwarding table in u: CPE 401/601 Lecture 8 : Routing Algorithms 24

25. Dijkstra’s algorithm, discussion Algorithm complexity: – n nodes – each iteration: need to check all nodes, w, not in N – n(n+1)/2 comparisons: O(n 2 ) more efficient implementations possible: O(nlogn) CPE 401/601 Lecture 8 : Routing Algorithms 25

26. Oscillations possible: – e.g., link cost = amount of carried traffic Dijkstra’s algorithm, discussion A D C B 1 1+e e 0 e 1 1 0 0 initially A D C B 2+e 0 0 0 1+e 1 … recompute routing A D C B 0 2+e 1+e 1 0 0 … recompute A D C B 2+e 0 e 0 1+e 1 … recompute CPE 401/601 Lecture 8 : Routing Algorithms 26

27. Distance Vector Algorithm

28. Bellman-Ford Equation dynamic programming Define d x (y) := cost of least-cost path from x to y Then d x (y) = min v {c(x,v) + d v (y) } where min is taken over all neighbors v of x CPE 401/601 Lecture 8 : Routing Algorithms 28

29. Bellman-Ford example u y x wv z 2 2 1 3 1 1 2 5 3 5 Clearly, d v (z) = 5, d x (z) = 3, d w (z) = 3 d u (z) = min { c(u,v) + d v (z), c(u,x) + d x (z), c(u,w) + d w (z) } = min {2 + 5, 1 + 3, 5 + 3} = 4 Node that achieves minimum is next hop in shortest path ➜ forwarding table B-F equation says: CPE 401/601 Lecture 8 : Routing Algorithms 29

30. Distance Vector Algorithm D x (y) = estimate of least cost from x to y – Node x knows cost to each neighbor v: c(x,v) – Node x maintains distance vector D x = [D x (y): y є N ] Node x also maintains its neighbors’ distance vectors – For each neighbor v, x maintains D v = [D v (y): y є N ] CPE 401/601 Lecture 8 : Routing Algorithms 30

31. Distance vector algorithm Basic idea: – From time-to-time, each node sends its own distance vector estimate to neighbors – Asynchronous When a node x receives new DV estimate from neighbor, it updates its own DV using B-F Under minor, natural conditions, the estimate D x (y) converge to the actual least cost d x (y) D x (y) ← min v {c(x,v) + D v (y)} for each node y ∊ N CPE 401/601 Lecture 8 : Routing Algorithms 31

32. Distance Vector Algorithm Iterative, asynchronous: – each local iteration caused by local link cost change DV update message from neighbor Distributed: – each node notifies neighbors only when its DV changes – neighbors then notify their neighbors if necessary wait for (change in local link cost or msg from neighbor) recompute estimates if DV to any dest has changed, notify neighbors Each node: CPE 401/601 Lecture 8 : Routing Algorithms 32

33. x y z x y z 0 2 7 ∞∞∞ ∞∞∞ from cost to from x y z x y z 0 from cost to x y z x y z ∞∞ ∞∞∞ cost to x y z x y z ∞∞∞ 710 cost to ∞ 2 0 1 ∞ ∞ ∞ 2 0 1 7 1 0 time x z 1 2 7 y node x table node y table node z table D x (y) = min{c(x,y) + D y (y), c(x,z) + D z (y)} = min{2+0, 7+1} = 2 D x (z) = min{c(x,y) + D y (z), c(x,z) + D z (z)} = min{2+1, 7+0} = 3 32 CPE 401/601 Lecture 8 : Routing Algorithms33

34. CPE 401/601 Lecture 8 : Routing Algorithms34 x y z x y z 0 2 7 ∞∞∞ ∞∞∞ from cost to from x y z x y z 0 2 3 from cost to x y z x y z 0 2 3 from cost to x y z x y z ∞∞ ∞∞∞ cost to x y z x y z 0 2 7 from cost to x y z x y z 0 2 3 from cost to x y z x y z 0 2 3 from cost to x y z x y z 0 2 7 from cost to x y z x y z ∞∞∞ 710 cost to ∞ 2 0 1 ∞ ∞ ∞ 2 0 1 7 1 0 2 0 1 7 1 0 2 0 1 3 1 0 2 0 1 3 1 0 2 0 1 3 1 0 2 0 1 3 1 0 time x z 1 2 7 y node x table node y table node z table D x (y) = min{c(x,y) + D y (y), c(x,z) + D z (y)} = min{2+0, 7+1} = 2 D x (z) = min{c(x,y) + D y (z), c(x,z) + D z (z)} = min{2+1, 7+0} = 3

35. Link cost changes Link cost changes: – node detects local link cost change – updates routing info, recalculates distance vector – if DV changes, notify neighbors CPE 401/601 Lecture 8 : Routing Algorithms 35 “good news travels fast” x z 1 4 50 y 1 At time t 0, y detects the link-cost change, updates its DV, and informs its neighbors. At time t 1, z receives the update from y and updates its table. It computes a new least cost to x and sends its neighbors its DV. At time t 2, y receives z’s update and updates its distance table. y’s least costs do not change and hence y does not send any message to z.

36. Link cost changes Link cost changes: – good news travels fast – bad news travels slow “count to infinity” problem! – 44 iterations before algorithm stabilizes Poisoned reverse: – If Z routes through Y to get to X : Z tells Y its (Z’s) distance to X is infinite – so Y won’t route to X via Z – will this completely solve count to infinity problem? CPE 401/601 Lecture 8 : Routing Algorithms 36 x z 1 4 50 y 60

37. LS vs DV Message complexity – LS: with n nodes, E links, O(nE) msgs sent – DV: exchange between neighbors only Speed of Convergence – LS: O(n 2 ) algorithm requires O(nE) msgs may have oscillations – DV: convergence time varies may be routing loops count-to-infinity problem CPE 401/601 Lecture 8 : Routing Algorithms 37

38. LS vs DV Robustness: what happens if router malfunctions? LS: – node can advertise incorrect link cost – each node computes only its own table DV: – DV node can advertise incorrect path cost – each node’s table used by others error propagate thru network CPE 401/601 Lecture 8 : Routing Algorithms 38