Announcement r Project 2 due next week r

Announcement r Project 2 due next week! r Homework 3 available soon, will put it online r Recitation tomorrow on Minet and project 2

Outline r Introduction and Network Service Models r Routing Principles m Link State Algorithm m Distance Vector Algorithm

Network layer functions r transport packet from sending to receiving hosts r network layer protocols in every host, router three important functions: r path determination: route taken by packets from source to dest. Routing algorithms r forwarding: move packets from router’s input to appropriate router output r call setup: some network architectures require router call setup along path before data flows application transport network data link physical network data link physical network data link physical application transport network data link physical

Virtual circuits “source-to-dest path behaves much like telephone circuit” m m performance-wise network actions along source-to-dest path r call setup, teardown for each call before data can flow r each packet carries VC identifier (not destination host ID) r every router on source-dest path maintains “state” for each passing connection

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

Datagram networks: the Internet model r no call setup at network layer r routers: no state about end-to-end connections m no network-level concept of “connection” r packets forwarded using destination host address m packets between same source-dest pair may take different paths application transport network data link 1. Send data physical application transport 2. Receive data network data link physical

Datagram or VC network: why? Internet r data exchange among ATM r evolved from telephony computers r human conversation: m “elastic” service, no strict m strict timing, reliability timing requirements r “smart” end systems (computers) r “dumb” end systems m can adapt, perform m telephones control, error recovery m complexity inside m simple inside network, network complexity at “edge” r many link types m different characteristics m uniform service difficult

Outline r Introduction and Network Service Models r Routing Principles m Link State Algorithm m Distance Vector Algorithm

Router Architecture Overview Two key router functions: r run routing algorithms/protocol (RIP, OSPF, BGP) r forwarding datagrams from incoming to outgoing link

Graph abstraction 5 2 u 2 1 Graph: G = (N, E) v x 3 w 3 1 5 z 1 y 2 N = set of routers = { u, v, w, x, y, z } E = set of links ={ (u, v), (u, x), (v, w), (x, y), (w, z), (y, z) } Remark: Graph abstraction is useful in other network contexts Example: P 2 P, where N is set of peers and E is set of TCP connections

Graph abstraction: costs 5 2 u v 2 1 x • c(x, x’) = cost of link (x, x’) 3 w 3 1 5 z 1 y - e. g. , c(w, z) = 5 2 • cost could always be 1, or inversely related to bandwidth, or inversely related to congestion Cost of path (x 1, x 2, x 3, …, xp) = c(x 1, x 2) + c(x 2, x 3) + … + c(xp-1, xp) Question: What’s the least-cost path between u and z ? Routing algorithm: algorithm that finds least-cost path

Routing Algorithm classification Global or decentralized information? Global: r all routers have complete topology, link cost info r “link state” algorithms Decentralized: r router knows physicallyconnected neighbors, link costs to neighbors r iterative process of computation, exchange of info with neighbors r “distance vector” algorithms Static or dynamic? Static: r routes change slowly over time Dynamic: r routes change more quickly m periodic update m in response to link cost changes

A Link-State Routing Algorithm Dijkstra’s algorithm r net topology, link costs known to all nodes m accomplished via “link state broadcast” m all nodes have same info r computes least cost paths from one node (‘source”) to all other nodes m gives routing table for that node r iterative: after k iterations, know least cost path to k dest. ’s Notation: r c(i, j): link cost from node i to j. cost infinite if not direct neighbors r D(v): current value of cost of path from source to dest. V r p(v): predecessor node along path from source to v, that is next v r N: set of nodes whose least cost path definitively known

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'

Dijkstra’s algorithm: example Step 0 1 2 3 4 5 N' u ux uxyvwz D(v), p(v) D(w), p(w) 2, u 5, u 2, u 4, x 2, u 3, y D(x), p(x) 1, u 5 2 u v 2 1 x 3 w 3 1 5 z 1 y 2 D(y), p(y) ∞ 2, x D(z), p(z) ∞ ∞ 4, y

Dijkstra’s algorithm: example (2) Resulting shortest-path tree from u: v w u z x Resulting forwarding table in u: destination link v x (u, v) (u, x) y (u, x) w (u, x) z (u, x) y

Dijkstra’s algorithm, discussion Algorithm complexity: n nodes r each iteration: need to check all nodes, w, not in N r n*(n+1)/2 comparisons: O(n^2) r more efficient implementations possible: O(nlogn) Oscillations possible: r e. g. , link cost = amount of carried traffic D 1 1 0 A 0 0 C e 1+e e initially B 1 2+e A 0 D 1+e 1 B 0 0 C … recompute routing 0 D 1 A 0 0 C 2+e B 1+e … recompute 2+e A 0 D 1+e 1 B e 0 C … recompute

Distance Vector Algorithm Bellman-Ford Equation (dynamic programming) Define dx(y) : = cost of least-cost path from x to y Then dx(y) = min {c(x, v) + dv(y) } v where min is taken over all neighbors v of x

Bellman-Ford example 5 2 u v 2 1 x 3 w 3 1 5 z 1 y Clearly, dv(z) = 5, dx(z) = 3, dw(z) = 3 2 B-F equation says: du(z) = min { c(u, v) + dv(z), c(u, x) + dx(z), c(u, w) + dw(z) } = min {2 + 5, 1 + 3, 5 + 3} = 4 Node that achieves minimum is next hop in shortest path ➜ forwarding table

Distance Vector Algorithm r Dx(y) = estimate of least cost from x to y r Distance vector: Dx = [Dx(y): y є N ] r Node x knows cost to each neighbor v: c(x, v) r Node x maintains Dx = [Dx(y): y є N ] r Node x also maintains its neighbors’ distance vectors m For each neighbor v, x maintains Dv = [Dv(y): y є N ]

Distance vector algorithm Basic idea: r Each node periodically sends its own distance vector estimate to neighbors r When a node x receives new DV estimate from neighbor, it updates its own DV using B-F equation: Dx(y) ← minv{c(x, v) + Dv(y)} for each node y ∊ N r Under minor, natural conditions, the estimate Dx(y) converge to the actual least cost dx(y)

Distance Vector Algorithm Iterative, asynchronous: each local iteration caused by: r local link cost change r DV update message from neighbor Distributed: r each node notifies neighbors only when its DV changes m neighbors then notify their neighbors if necessary Each node: wait for (change in local link cost of msg from neighbor) recompute estimates if DV to any dest has changed, notify neighbors

Dx(y) = min{c(x, y) + Dy(y), c(x, z) + Dz(y)} = min{2+0 , 7+1} = 2 node x table cost to x y z x ∞∞ ∞ y ∞∞ ∞ z 71 0 from x 0 2 7 y 2 0 1 z 7 1 0 cost to x y z x 0 2 7 y 2 0 1 z 3 1 0 x 0 2 3 y 2 0 1 z 3 1 0 cost to x y z from x ∞ ∞ ∞ y 2 0 1 z ∞∞ ∞ node z table cost to x y z x 0 2 3 y 2 0 1 z 7 1 0 cost to x y z from x 0 2 7 y ∞∞ ∞ z ∞∞ ∞ node y table cost to x y z Dx(z) = min{c(x, y) + Dy(z), c(x, z) + Dz(z)} = min{2+1 , 7+0} = 3 x 0 2 3 y 2 0 1 z 3 1 0 time x 2 y 7 1 z

Distance Vector: link cost changes Link cost changes: r node detects local link cost change r updates distance table (line 15) r if cost change in least cost path, notify neighbors (lines 23, 24) “good news travels fast” 1 X 4 Y 50 1 Z algorithm terminates

Distance Vector: link cost changes Link cost changes: r good news travels fast r bad news travels slow - “count to infinity” problem! 60 X 4 Y 50 1 Z algorithm continues on!

Distance Vector: poisoned reverse If Z routes through Y to get to X : r Z tells Y its (Z’s) distance to X is infinite (so Y won’t route to X via Z) r will this completely solve count to infinity problem? 60 X 4 Y 50 1 Z algorithm terminates

Comparison of LS and DV algorithms Message complexity r LS: with n nodes, E links, O(n. E) msgs sent each r DV: exchange between neighbors only m convergence time varies Speed of Convergence r LS: O(n 2) algorithm requires O(n. E) msgs m may have oscillations r DV: convergence time varies m may be routing loops m count-to-infinity problem Robustness: what happens if router malfunctions? LS: m m node can advertise incorrect link cost each node computes only its own table DV: m m DV node can advertise incorrect path cost each node’s table used by others • error propagate thru network

Backup Slides

Distance Table: example A E D (C, D) D (A, D) E C E cost to destination via D () A B D A 1 14 5 B 7 8 5 C 6 9 4 D 4 11 2 2 8 1 E B E 2 D D = c(E, D) + minw {D (C, w)} = 2+2 = 4 D = c(E, D) + minw {D (A, w)} = 2+3 = 5 loop! B D (A, B) = c(E, B) + minw{D (A, w)} = 8+6 = 14 loop! destination 7 1

Distance table gives routing table E cost to destination via Outgoing link to use, cost B D A 1 14 5 A A, 1 B 7 8 5 B D, 5 C 6 9 4 C D, 4 D 4 11 2 D D, 2 Distance table destination A destination D () Routing table

Distance Vector Algorithm: At all nodes, X: 1 Initialization: 2 for all adjacent nodes v: 3 DX(*, v) = infinity /* the * operator means "for all rows" */ X 4 D (v, v) = c(X, v) 5 for all destinations, y X 6 send min D (y, w) to each neighbor /* w over all X's neighbors */ w

Distance Vector Algorithm (cont. ): 8 loop 9 wait (until I see a link cost change to neighbor V 10 or until I receive update from neighbor V) 11 12 if (c(X, V) changes by d) 13 /* change cost to all dest's via neighbor v by d */ 14 /* note: d could be positive or negative */ 15 for all destinations y: DX(y, V) = DX(y, V) + d 16 17 else if (update received from V wrt destination Y) 18 /* shortest path from V to some Y has changed */ 19 /* V has sent a new value for its minw DV(Y, w) */ 20 /* call this received new value is "newval" */ 21 for the single destination y: DX(Y, V) = c(X, V) + newval 22 23 if we have a new minw DX(Y, w)for any destination Y 24 send new value of min w DX(Y, w) to all neighbors 25 26 forever