Shortest Path Algorithms in Practice

1. Having briefly considered the two basic approaches to finding shortest paths in graphs that are used commonly used as network routing algorithms, we now examine the advantages one has over the other.

   • In your typical algorithms course, our concern would probably involve the number of steps and amount of memory required by each algorithm.

   • Instead, we will primarily examine how well the algorithms fit relative to the requirements that network routing be done in a distributed rather than in a centralized fashion and that the routes be changed dynamically to adapt to changes in load or failures in the network.

2. We begin by looking at how one could distribute the computations performed by each of these algorithms.

   • However the actual computation is distributed, there are some simple things one can say about the way the data involved must be distributed through the network.

     • Although data values may be sent across the network to other machines as needed, each value will have a home machine corresponding to the machine that must generate the data or the node that needs the data most for routing.

     • If one keeps in mind the fact that we eventually need to consider how the algorithms will adapt to changes in load, it is clear that the edge costs, d_{i ->j} must originate at the sending edge of the associated link, i.

     • In order to send packets each node ultimately needs information about the best route to every destination in the network. Ultimately, the value of D_{i ->j} is needed at node i to determine the route to node j (at the very least, by checking this value node i can determine if node j is even reachable).

       So, it is natural to try to store the "primary" copy of each D_{i ->j} at node i. travel a single hop!

   • Now, consider the basic step in the iteration of the Bellman-Ford algoritm:

     Dⁿ⁺¹_{i ->j} = min_k ( d_{i ->k} + Dⁿ_{k ->j})

     The node at which one would expect to update D_{i ->j} is i. All of the d_{i ->j} values needed for this update will also be at i.

     The D_{k ->j} values will not be stored at i, but they will all be stored at neighbors of i. Therefore, the packets required to send them to i will only have to

   • This leads to a simple distributed version of the Bellman- Ford algorithm:

     • Each node i keeps just the list of values D_{i ->j} of its best known routes to other nodes. This list is called a distance vector.

     • Periodically (at least within some timeout of and change in a distance vector value or the cost of one of the nodes links), each node sends a packet containing its distance vector to its neighbors.

     • Upon receiving a distance vector from a neighbor n, a node i uses the value of d_{i ->n} together with the D_{n ->j} values in the distance vector to see if any of its D_{i ->j} values should be updated

     • This algorithm ultimately performs the same updates as the sequential Bellman-Ford algorithm (though in a potentially haphazard order). It can be shown to eventually compute the correct values regardless of the initial values chosen.

   • The distribution of data does not work out as well for Dijkstra's Shortest Path First algorithm.

     • In one way, things looks better. Given a source node i, Dijksta's algorithm can be used to compute D_{i ->j} for every j without bothering to compute D_{k ->j} for any k not equal to i.

       By contrast with the Bellman-Ford algorithm given a destination node j, one can compute D_{i ->j} for every i without having to determine D_{i ->k} for any other destination k. This is basically because Dijkstra's algorithm starts building paths from the source working toward the destination while the Bellman-Ford algorithm starts at the destination and works back to sources.

     • Alas, the information required for the basic iteration of Dijkstra's algorithm is not as localized as in the Bellman-Ford algorithm. When a node n is added to W and we attempt to update the values of D^W_{i ->j} for each j that is a neighbor of n, we need the values d_{n ->j}. The shortest path from the source of this information, n, to i may involve many hops.

       Looked at another way, when a d_{n ->j} values changes, the node n will have to make sure to notify not just its neighbors but every node in the graph of the change.