CS455 Sylabus

The "Counting to Infinity" problem

There is a very nasty and notorious problem with the distance vector routing algorithm that makes it unsuitable for large scale deployment.
The problem has the interesting name of "Counting to Infinity". It is cause by link failures that partitions a network.
I will illustrate the problem with the following example:
Again, from the original network after the distance vector completed constructing the routing table:
Suppose link AE fails:
- Notice that the failure of link AE will partition the network into 2 unconnected portions ({A,B,C,D,F,G} and {E}).
- Such failures - as you will see - is detrimental to distance vector routing...
Let's see what will happen next.
First, node A detects the link failure and updates its routing table:
When node A incorporates the update, it will result in a change in the routing cost to destination E:
```
   Before:           After:

   To    Cost        To    Cost
  ------------      ------------
    E     1           E     3
```
Because the routing cost to E has changed, node A schedules the following route update and send to its neighbors:
- Notice that A does not know that there is no route to E by going to B, that's because B uses A to route to E and A does not know that.
- So node A still believe there is a route to E, with cost 3...
- This is clearly wrong, the cost to send to node E is infinite, no matter to which node A will forward the packet next - simply because node E is cut off from the rest of the network.
- This fact is true not only for node A, but also for other nodes B, C, D, F and G. The cost in their routing table to node E should be equal to infinite.
- You will see how the nodes A, B, C, D, F and G collectively "count" towards infinitity by sending each other "bogus" update messages...
Suppose B incorporate A's update first:
- The update will cause a route cost change in B's table:
```
   Before:           After:

   To    Cost        To    Cost
  ------------      ------------
    E     2           E     3     (via C !!!)
```
- Subsequently, B schedules a route update message (B, E, 3).
- This route update message reaches A
  Now this update message will only change the distance table and does not increase the cost from A to C (because of the entry for C)...
  But when A receives C's update message, it will change the cost A -> E to 4 and schedule an update message....
- You can more or less see what will happen:
  - Routing cost towards E in the tables at nodes A, B, C, D, F and G will increase "step wise" (increase by a small amount) towards infinity...
  - Why will it goes to infinity ?? Well, E is cut off from the network... so the cost is infinite...
    We know the algorithm will converge to the true value... unfortunately, it take infinite time to get to the true value if it is infinite...
- The name of this behavior is rightfully known as "counting to infinity"
You can see the "counting to infinity" problem clearly in the smaller example...
Before link failure, the content of the routing tables are as follows:
Suppose links AC and BC fail....
- Nodes A detects link AC failure, sets the cost to C to infinity.
- This causes a route change and A schedules an route update message..
- Nodes B detects link BC failure, sets the cost to C to infinity.
- This causes a route change and B schedules an route update message..
- Suppose A's message is sent first:
Nodes B and D processes A's update message:
- Route change in nodes B and D
- Nodes B and D schedules update messages
- Suppose B's message is transmitted first.... (see figure below)
Next, nodes A and D processes B's update message:
- Node A and D process B's update message.
- Causes a route change in node A, but no (further) route change in D
- Suppose node D can update its scheduled message, it can set the cost of the update message with the latest value: (D,C,3).
- Node A schedules an update message
- Suppose D's message scheduled earlier is transmitted first.... (see figure below)
and so on... you can see clearly in this small example, that the nodes keep updating each other with increasing distance values and the distance will keep running up without end.
There are a number of solutions proposed to alleviate this "counting towards infinity" problem:
- Use a relatively small integer value to represent infinity
  - In a small routing domain (e.g., within Emory) where the diameter (maximum distance between any 2 routers) is small (say 20), we can assign a small integer to represent "infinity".
  - The distance cannot be greater than the assigned (small) integer and the distance vector can converge to that small integer value reasonably quickly.
  - This solution was at one time very popular in small companies and universities
- Split Horizon:
  - If the route to a destination X is via A, do not send the update (Me, X, MyCost) to A.
- Split Horizon with poison reverse:
  - If the route to a destination X is via A, send the update message (Me, X, Infinite) to A.
Historical note: RIP (Routing Information Protocol) is now rarely used... R.I.P. (Rest In Peace)...