Brute-force search is a general algorithm that consists in exhaustively enumerating all can- didate solutions to a problem and checking whether each candidate satisfies the problem. The literature describes several brute-force algorithms for the MCP problem: usually, exact solutions5 for the MCP problem consider all possible intermediate segments between a given
source and a given target. Then, they combine these segments to form end-to-end paths. The problem of these approaches is that they often consider a prohibitive number of intermediate segments, and thus, their complexity is prohibitive.
The set of all candidate solutions to an optimization problem forms the search-space of the considered problem. Brute-force methods are often applied on a reduced search-space to restrict the enumeration to reasonable candidate solutions. In particular, exact MCP algo- rithms use four main search-space reduction methods, which have been listed by Van Mieghem
3
The term optimal sub-structure is defined in Section 8.2.2 and in [50]
4
To simplify the examples in the thesis, we typically consider only two link weights that take integer values, and the links are undirected.
5
In this dissertation, we use the term exact to refer to the solutions that guarantee to find a feasible path if such path exists in the network.
8.3. EXACT MCP ALGORITHMS 89
Figure 8.4: Dominated paths can be discarded
and Kuipers in [172]. They rely on simple lemmas that we describe in next paragraphs and prove in Appendix B.
The first search-space reduction method uses the fact that when several paths between the same nodes have the same weights, an algorithm can memorize only one of these paths without affecting the weights of the computed end-to-end solution. For example, in Figure 8.3, the paths (b, d)(d, t) and (b, e), (e, t) have the same weight vector ~w= (1, 6)T. Thus, we can consider only the paths that use the segment (b, d)(d, t), without losing the guarantee to find a path that is as far as possible from the request constraints.
Lemma 8.3.1 (Identical weights). If two intermediate paths p1 ∈ Pa→b and p2 ∈ Pa→b have
the same weights ~w(p1) = ~w(p2), then an MCP algorithm can memorize only one of these intermediate paths without losing the guarantee to find an optimal end-to-end path.
Dominance is a widely-used concept, which expresses the idea that a solution is “better” than another, in the context of multi-objective optimization [49] and game theory [79]. Dom- inance is useful to reduce the search-space of MCP problems. A path p is dominated if there is a path p’, with the same source and target, such that wk(p’) ≤ wk(p) for all considered
weights wk, k ∈ [1..K] and such that there is a k in [1..k] for which wk(p’) < wk(p). For
instance, consider the example in Figure 8.4. There are two paths pa∈ Pa→b and pc ∈ Pa→b
between the same nodes and such that ~w(pa) = (5, 4)T and ~w(pc) = (2, 3)T; in this case, pc dominates pa. If a path is not dominated by any path, we say that it is non-dominated or
Pareto optimal. Given a source node s and a target node t, we call Pareto frontier the set of the non-dominated s-t-paths.
Lemma 8.3.2 (Dominated paths). For any two nodes a and b in V , given two intermediate paths p1 ∈ Pa→b and p2 ∈ Pa→b, if p1 dominates p2 then an MCP algorithm can memorize
only p1 without losing the guarantee to find the optimal end-to-end path.
Lemma 8.3.2 implies that MCP algorithms can safely discard every path that contains a dominated segment, and thus, can memorize only non-dominated path segments, which significantly reduces the search-space for most instances of the MCP problem. For example, to solve the MCP problem exactly and efficiently, Samcra [169] and H_mcop [109] consider only the candidate paths on the Pareto frontier.
We use Figure 8.5 to illustrate two additional methods for reducing the search-space. We study a request for a path from s to t subject to the constraints ~W = (7, 15)T. As we consider non-negative additive link-weights, the paths that include a non-feasible segment are necessarily non-feasible. Therefore, MCP algorithms can safely exclude infeasible paths from the search-space. For instance, in Figure 8.5, the segment s = (a, d)(d, t) is infeasible: its weights (8, 9)T infringe the constraint on the first metric. Therefore, any path that includes
90
CHAPTER 8. ANALYSIS OF EXISTING MULTI-CONSTRAINED ROUTING ALGORITHMS
Figure 8.5: An instance of the MCP problem with two integer-valued metrics
Lemma 8.3.3(Infeasible paths). An MCP algorithm can memorize only feasible paths with- out losing the guarantee to find the optimal end-to-end path.
In Figure 8.5, consider the shortest path (a, c)(c, t) from a to t for the weight w1. This path
provides the lower bounds w∗
1,a→t = 6 on w1 for any path between a and t. In addition, the
shortest path from s to a for w1has a weight w∗1,s→a equal to two. Therefore, any path p from
sto t that traverses a has an end-to-end weight w1(p) that is larger than w1,s→a∗ + w∗1,a→t= 8,
and thus, infringes the constraints ~W. Consequently, an MCP algorithm can safely discard any path going through a, which significantly simplifies the problem of finding an MCP from s tot t subject to ~W = (7, 15)T. Certain algorithms, such as H_mcop [109] and Samcra [172], implement this idea. They compute a shortest path from every intermediate node to the target, for every single weight. Then, they use the weights of the computed shortest paths to compute lower bounds on the value of every metric for the end-to-end paths. This way, they avoid memorizing path segments that lead predictably to infeasible end-to-end paths. Van Mieghem et alii [172] name this approach look-ahead.
Lemma 8.3.4 (Predictably infeasible paths). Given a constraint vector ~W and a shortest path segment s∗ ∈ P
a→t for a weight wk. If a path p ∈ Ps→a verifies wk(p) > Wk− wk(s∗),
then an MCP algorithm can discard p without losing the guarantee to find an optimal6
end-to-end path.