A simple universal shortest-path routing scheme is to have each of the N number of nodes in a network maintain a routing table with an entry for the shortest-path to every other node. The per-node memory requirements for these tables scales no worse than O (N log N ), as each node can obviously can be differentiated with
O (log N ) labels (i.e. addresses), and each node stores O (N ) vectors composed of
some constant number of fields subject to the bound on the label, e.g. the destination label and an output port.
Such shortest-path routing tables grow supra-linearly as the network grows with nodes, in the worst case [45, 27]. Further, any universal shortest-path routing scheme for arbitrary graphs will use at least Ω (N2log ∆) routing state summed
across all nodes, where ∆ is the maximum degree in the network [27]. This implies routing state locally at each node requires Θ (N log ∆), i.e. intuitively the per-node memory requirements must more or less average out to this. Hence, no universal shortest-path routing scheme can exist that can scale sub-linearly. It may be that shortest-path schemes could be designed to be compact on specific classes of networks, however no such scheme can be compact universally on all networks. The proof of Gavoille and Pérennès [27] proceeds by characterising the
shortest-paths in graphs (which any shortest-path scheme must be capable of relating to in some way) as matrices of constraints on graphs. In characterising the memory required to describe the shortest-path constraint matrices, the paper argues this then must also describe the minimum memory requirements of any shortest-path routing function. The paper then goes on to describe bounded systems of constructions of shortest-path constraints and their graphs, from which follows the bounded memory requirements on the size of shortest-path routing schemes.
2.5 Routing Table Scalability 33
Such supra-linear scaling means that the memory in each node must grow as the network grows so as to be able to hold this routing state. Increased routing state may imply increased communication between nodes, if they must synchronise this extra state. All this may happen even as the network immediately around the node stays unchanged. Adding new nodes to the network then may require having to add hardware to all nodes, as Awerbuch et al. [7] put it.
This supra-linear scaling of the routing tables in each node may become infeasibly expensive as a system becomes large – the Internet possibly may be such a system. In such cases, having the routing tables scale sub-linearly as the network grows would be desirable[52]. Routing schemes with such sub-linear scaling of per-node routing state in the worst-case (i.e. “compact state”), and where the node label or address are bounded logarithmically, are known as “compact routing schemes”. As sub-linear scaling can not be achieved with guaranteed shortest-path routing, achieving this requires conceding that at least some routes between nodes may be longer than the shortest-path – they are “stretched”. That is, some amount of shortest path routing must be traded away to gain state scalability and compactness of routing tables.
Figure 2.10: A (3/2, 1)-stretch
path, shown in red. This stretch can be quantified
as either multiplicative (the ratio of the actual path length to the shortest path length) or additive (the number of extra hops taken, relative to the shortest path). Stretch can be given for specific nodes, for the best or worst cases in a scheme, or the average of a scheme. Some papers have used an (α, β) notation for stretch, where α is the multiplicative stretch, and β the additive stretch of a path or routing scheme, such as in Thorup and Zwick [68].
Generally it is the worst-case, multiplicative stretch of a routing scheme that is the most interesting measure and so that is what is meant here when talking about the “stretch” of some routing scheme, unless specifically stated otherwise.
Initial attempts at reducing routing stable state sought to group nodes together, into a hierarchy of clusters. The hierarchy forms a tree, and the clusters and nodes are typically labelled in accordance with it. The clusters can be used to abstract away the nodes within them. The routing tables then need only store shortest-path vectors for nodes within the same lowest-level cluster, and for a limited set of all the other clusters, such as sibling clusters in the hierarchy. This hierarchical
routing potentially allows a great number of routing entries to be eliminated,
Figure 2.11: Compact routing bounds and results
network – though, of course, at the expense of non-shortest-path routing. In Kleinrock and Kamoun [43] it was shown that in the limit of network growth, the
average stretch of hierarchical routing schemes becomes insignificant, while the
routing table savings can be very significant. This result depends on the diameter of the network growing along with the size of the network, something which need not happen with any significance with small-world networks like the Internet[50]. Hierarchical routing is examined in further detail below, in Section 2.7.
Insignificant average stretch unfortunately still allows for very bad worst-case stretch. A routing scheme with high or unbounded worst-case stretch may never be practical, even if it leads to compact tables. Trivial average stretch may be of no comfort to nodes forced to communicate over highly-stretched paths. This may even lead some nodes, if the routing scheme allows it, to over-ride the scheme in some way to add back routing state to reduce the worst-case stretch, undoing the state scaling benefits of the scheme!
This led to the development of compact routing schemes whose worst-case stretch (simply referred to as stretch from here-on) is bounded by a constant. Gavoille and Gengler [26] showed that schemes with a stretch below 3 can, in the best case, achieve only linearly-scaling growth in routing table state. Thus, any compact routing scheme must have a stretch of 3 or greater. More generally, Peleg and Upfal [59] showed that any general routing scheme with a stretch factor of k ≥ 1 must use at least ΩN1+1/(2k+4) amount of state over the sum of all nodes.