A constraint-based parallel local search for the edge-disjoint rooted distance-constrained minimum spanning tree problem

Abstract

Many network design problems arising in areas as diverse as VLSI circuit design, QoS routing, traffic engineering, and computational sustainability require clients to be connected to a facility under path-length constraints and budget limits. These problems can be seen as instances of the rooted distance-constrained minimum spanning-tree problem (RDCMST), which is NP-hard. An inherent feature of these networks is that they are vulnerable to a failure. Therefore, it is often important to ensure that all clients are connected to two or more facilities via edge-disjoint paths. We call this problem the edge-disjoint RDCMST (ERDCMST). Previous work on the RDCMST has focused on dedicated algorithms and therefore it is difficult to use these algorithms to tackle the ERDCMST. We present a constraint-based parallel local search algorithm for solving the ERDCMST. Traditional ways of extending a sequential algorithm to run in parallel perform either portfolio-based search in parallel or parallel neighbourhood search. Instead, we exploit the semantics of the constraints of the problem to perform multiple moves in parallel by ensuring that they are mutually independent. The ideas presented in this paper are general and can be adapted to other problems as well. The effectiveness of our approach is demonstrated by experimenting with a set of problem instances taken from real-world passive optical network deployments in Ireland, Italy, and the UK. Our results show that performing moves in parallel can significantly reduce the elapsed time and improve the quality of the solutions of our local search approach.

Appendix

The node and subtree operators are general enough to tackle both RDCMST and ERDCMST. In this appendix we provide experimental results of the local search approach and dedicated algorithms for the RDCMST problem.

PBH and KBH (Ruthmair and Raidl 2009) are two dedicated heuristics to tackle the RDCMST. The former, inspired in the Prim’s algorithm, iteratively adds nodes in the solution using the cheapest edge connecting the node and the current solution. The latter, inspired in the Kruskal algorithm, starts by sorting the list of edges and iteratively adds an edge if no cycles is created in the solution. Additionally, the authors perform local moves to improve the solution, these moves rely in a pre-computed backup route from the root node to any node. We recall that these local moves cannot be applied to the ERDCMST as the pre-computed route from the root node to a certain node might not be available due to the disjoint constraint.

BKRUS (Oh et al. 1997) is a well-known heuristic for solving RDCMST the cost function and the delay function in RDCMST are equivalent and follow the Triangle inequality property (i.e., given three points a, b, and c then $d(a,b)\,+\,d(b,c) > d(a,c)$). The overall complexity of BKRUS is cubic in terms of number of nodes, which hinders its scalability when the bound on the path-length is tight. Although there are approaches that are better than BKRUS (Leitner et al. 2011; Ruthmair and Raidl 2010), our aim is not to claim superiority over the RDCMST approaches since we are solving a more general problem for which these approaches would not be applicable. Instead, our aim is to show that although our approach is not specialised for RDCMST, it still provides very good quality solutions.

1.1 Experiments for the RDCMST problem

We experimented with the following two set of instances for the RDCMST problem:

• Real-life In this scenario we report results on a set of real-life instances combing from our industrial partner in Ireland, each instance contains |E| $\in$ $\{$200, 300, $\ldots$, 800$\}$ clients, and for each instance we report the median time across 11 executions with 10 min cutoff for the subtree operator.

• Random In this scenario we consider two sets of instances from Ruthmair and Raidl (2009).⁵ Each set (|U| $\in$ $\{$500, 1000$\}$) contains 30 complete graphs with integer edge cost and lengths uniformly distributed in [1,99]. Similar to the work of Ruthmair and Raidl (2009) each instance was executed 30 times with 10 min cutoff for the subtree operator.

We limit our attention for the PBH and KBH to random instances due to these two algorithms are not available online.⁶ The random set of instances does not satisfy the Triangle inequality property required for BKRUS and therefore for this dataset we only consider CPLEX, PBH, KBH, and our CBLS algorithm. For the real-life instances we consider CPLEX, BKRUS, and our CBLS algorithm.

To generate the initial solution for the CBLS algorithm in these experiments we used a similar approach as Ruthmair and Raidl (2009) by iteratively adding nodes in the solution using Prim’s algorithm, and for nodes violating the distance constraint we use the shortest path from the root to the node to reconnect the node and generate a valid initial solution.

Table 10 reports detailed results of the cost and GAP percentage with respect to the lower bound. Here we observe that the GAP for CPLEX increases considerably as the number of clients increases. On the other hand, for the difficult case ($\lambda =415$) LS (subtree operator) reports better upper bounds than CPLEX and BKRUS in all 7 instances, and the quality of the solution with respect to the lower bound does not degrade with the problem size.

Table 10 Results for RDCMST instances from the Irish dataset

Table 11 Results for RDCMST random instances from Ruthmair and Raidl (2009) for two dedicated algorithms and the proposed LS algorithm using the subtree operators

Table 11 shows results of the second experimental scenario with random instances. In this table we report the results for different length limits ($\lambda$ $\in$ $\{$6, 10, 20, 40$\}$) for two dedicated algorithms for the RDCMST problem: PBH [Prim’s based algorithm (Salama et al. 1997)] and KBH [Kruskal’s based algorithm (Ruthmair and Raidl 2009)]. Due to the subtree operator usually outperforms the node operator, in this experiments we focus our attention to the former one. We would like to recall that our claim is not to be superior over existing dedicated algorithms for the RDCMST, instead we propose a generic constraint-based local search framework where adding more constraints is a straightforward process.

In this experiment we observe that LS reports a close performance to the dedicated algorithms, and the solution quality (with respect to the best between PBH and KBH) is between 2.6 and 4.7% for $|E|=500$ and between 12.7 and 21.9% for $|E|=10{,}000$. Indeed, the local search algorithm outperforms at least one of the dedicated algorithm in four out of the eight random scenarios. As pointed out in Ruthmair and Raidl (2009) the runtime of the dedicated algorithms is on average up to 3 min, while we use 10 min for each experiment. An important part of the time reduction in Ruthmair and Raidl (2009) consists in removing an important number of edges (up to 88% of the original problem for these instances) in a pre-processing phase. In this paper we omit pre-processing since an important number of the edges can not be removed as they might be relevant to satisfy other constraints (e.g., disjointness).