*Distance-Vector Algorithm*

Views (1742)

On March 21, 2015, In The Network Layer by Admin

### Distance-Vector Algorithm: Link-Cost Changes and Link Failure

When a node running the DV algorithm detects a change in the link cost from itself to a neighbor (Lines 10-11), it updates its distance vector (Lines 13-14) and, if there's a change in the cost of the least-cost path, informs its neighbors (Lines 16-17) of its new distance vector, Figure 1(a) shows a scenario where the link cost from y to x changes from 4 to 1. We focus here only on y' and z's distance table entries to destination x. The DV algorithm causes the following sequence of events to occur:

● At time t

_{0}, y detects the link-cost change (the cost has changed from 4 to 1), updates its distance vector, and informs its neighbors of this change since its distance vector has changed.

● At time t

_{1}, z receives the update from y and updates its table. It computes a new least cost to x (it has decreased from a cost of 5 to a cost of 2) and sends its new distance vector to its neighbors.

● 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. The algorithm comes to a quiescent state.

Therefore, only two iterations are required for the DV algorithm to reach a quiescent state. The good news about the decreased cost between x and y has propagated quickly through the network.

Let's now examine what can happen when a link cost increases. Suppose that the link cost between x and y increases from 4 to 60, as shown in Figure 1(b).

1. Before the link cost changes, D

_{y}(x) = 4, D

_{y}(z) = 1, D

_{z}(y) = 1, and D

_{z}(x) = 5. At time t

_{0}, y detects the link-cost change (the cost has changed from 4 to 60). y computes its new minimum-cost path to x to have a cost of

**D**

_{y}(x) = min{c(y,x) + D_{x}(x), c(y,z) + D_{z}(x)} = min[60 +0, 1 + 5] = 6Of course, with our global view of the network, we can see that this new cost via z is wrong. But the only information node y has is that its direct cost to x is 60 and that z has last told y that z could get to x with a cost of 5. So in order to get to x, y would now route through z, fully expecting that z will be able to get to x with a cost of 5. As of t

_{1}we have a routing loop - in order to get to x, y routes through z and z routes through y. A routing loop is like a black hole - a packet destined for x arriving at y or z as of t

_{1}will bounce back and forth between these two nodes forever (or until the forwarding tables are changed).

2. Since node y has computed a new minimum cost to x, it informs z of its new distance vector at time t

_{1}.

3. Sometime after t

_{1}, z receives y's new distance vector, which indicates that y's minimum cost to x is 6. z knows it can get to y with a cost of 1 and hence computes a new least cost to x of D

_{z}(x) = min{50 + 0,1 + 6} = 7. Since z's least cost to x has increased, it then informs y of its new distance vector at t

_{2}.

4. In a similar manner, after receiving z's new distance vector, y determines D

_{y}(x) = 8 and sends z its distance vector. z then determines D

_{z}(x) = 9 and sends y its distance vector, and so on.

How long will the process continue? You should convince yourself that the loop will persist for 44 iterations (message exchanges between y and z) - until z finally computes the cost of its path via y to be greater than 50. At this point, z will (finally!) determine that its least-cost path to x is via its direct connection to x. y will then route to x via z. The result of the bad news about the increase in link cost has indeed traveled slowly! What would have happened if the link cost c(y, x) had changed from 4 to 10,000 and the cost c(z, x) had been 9,999? Because of such scenarios, the problem we have seen is sometimes referred to as the count-to-infinity problem.

### Distance-Vector Algorithm: Adding Poisoned Reverse

The specific looping scenario just explained can be avoided using a technique known as poisoned reverse. The idea is simple - if z routes through y to get to destination x, then z will advertise to y that its distance to x is infinity, that is, z will advertise to y that D

_{z}(x) = ∞ (even though z knows D

_{z}(x) = 5 in truth). z will continue telling this little white lie to y as long as it routes to x via y. Since y believes that z has no path to x, y will never attempt to route to x via z, as long as z continues to route to x via y (and lies about doing so).

Let's now see how poisoned reverse solves the particular looping problem we encountered before in Figure 2(b). As a result of the poisoned reverse, y's distance table indicates D

_{z}(x) = ∞. When the cost of the (x, y) link changes from 4 to 60 at time t

_{0}, y updates its table and continues to route directly to x, albeit at a higher cost of 60, and informs z of its new cost to x, that is, D

_{y}(x) = 60. After receiving the update at t

_{1}, z immediately shifts its route to x to be via the direct (z, x) link at a cost of 50. Since this is a new least-cost path to x, and since the path no longer passes through y, z now informs y that D

_{z}(x) = 50 at t

_{2}. After receiving the update from z, y updates its distance table with Dy(x) = 51. Also, since z is now on y's least-cost path to x, y poisons the reverse path from z to x by informing z at time t

_{3}that D

_{y}(x) = ∞ (even though y knows that D

_{y}(x) = 51 in truth).

Does poisoned reverse solve the general count-to-infinity problem? It does not. You should convince yourself that loops involving three or more nodes (rather than simply two immediately neighboring nodes) will not be detected by the poisoned reverse technique.

### A Comparison of LS and DV Routing Algorithms

The DV and LS algorithms take complementary approaches towards computing routing. In the DV algorithm, each node talks to only its directly connected neighbors, but it provides its neighbors with least-cost estimates from itself to all the nodes (that it knows about) in the network. In the LS algorithm, each node talks with all other nodes (via broadcast), but it tells them only the costs of its directly connected links. Let's conclude our study of LS and DV algorithms with a quick comparison of some of their attributes. Remember that N is the set of nodes (routers) and E is the set of edges (links).

**● Message complexity.**We have seen that LS requires each node to know the cost of each link in the network. This requires O(|N| |E|) messages to be sent. Also, whenever a link cost changes, the new link cost must be sent to all nodes. The DV algorithm requires message exchanges between directly connected neighbors at each iteration. We have seen that the time required for the algorithm to converge can depend on many factors. When link costs change, the DV algorithm will propagate the results of the changed link cost only if the new link cost results in a changed least-cost path for one of the nodes attached to that link.

**● Speed of convergence.**We have seen that our implementation of LS is an O(|N|

^{2}) algorithm requiring O(|N| |E|)) messages. The DV algorithm can converge slowly and can have routing loops while the algorithm is converging. DV also suffers from the count-to-infinity problem.

**● Robustness.**What can happen if a router fails, misbehaves, or is sabotaged? Under LS, a router could broadcast an incorrect cost for one of its attached links (but no others). A node could also corrupt or drop any packets it received as part of an LS broadcast. But an LS node is computing only its own forwarding tables; other nodes are performing similar calculations for themselves. This means route calculations are somewhat separated under LS, providing a degree of robustness. Under DV, a node can advertise incorrect least-cost paths to any or all destinations. (Indeed, in 1997, a malfunctioning router in a small ISP provided national backbone routers with erroneous routing information. This caused other routers to flood the malfunctioning router with traffic and caused large portions of the Internet to become disconnected for up to several hours [Neumann 1997].) More generally, we note that, at each iteration, a node's calculation in DV is passed on to its neighbor and then indirectly to its neighbor's neighbor on the next iteration. In this sense, an incorrect node calculation can be diffused through the entire network under DV.

In the end, neither algorithm is an obvious winner over the other; indeed, both algorithms are used in the Internet.

### Other Routing Algorithms

The LS and DV algorithms we have studied are not only extensively used in practice, they are essentially the only routing algorithms used in practice today in the Internet. However, many routing algorithms have been proposed by researchers over the past 30 years, ranging from the very simple to the very sophisticated and complex. A broad class of routing algorithms is based on viewing packet traffic as flows between sources and destinations in a network. In this approach, the routing problem can be formulated mathematically as a constrained optimization problem known as a network flow problem [Bertsekas 1991]. Yet another set of routing algorithms we mention here are those derived from the telephony world. These circuit-switched routing algorithms are of interest to packet-switched data networking in cases where per-link resources (for instance, buffers, or a fraction of the link bandwidth) are to be reserved for each connection that is routed over the link. While the formulation of the routing problem might appear quite different from the least-cost routing formulation we have seen in this section, there are many similarities, at least as far as the path-finding algorithm (routing algorithm) is concerned.