Multithreading Parallel Robust Approach for the VRPTW with Uncertain Service and Travel Times

Abstract

The objective of this paper is to consider the vehicle routing problem with time windows under two uncertainties: service and travel times. We introduce new resolution approaches for the robust problem and an efficient parallel procedure for the generation of all possible scenarios. The best robust solution of each scenario can be achieved by using a parallel adaptive large neighborhood search metaheuristic. Through our analysis, we expect to find the best compromise between the reduced running time and a best good solution, which leads to four distinct combinations of parallel/sequential approaches. The computational experiments are performed and tested on Solomon’s benchmark and large randomly generated instances. Furthermore, our results can be protected against delay in service time in a reasonable running time especially for large instances.

1. Introduction

Over the past few decades, the Vehicle Routing Problem (VRP) and its variants have been the subject of massive investigations in operations research. This fact is due to the importance of its applications in different domains, such as logistics, supply chain management, scheduling, inventory, finance, etc. The main purpose of the vehicle routing problem is to find a set of least cost routes, beginning and ending at a depot, that together cover a set of customers (see, e.g., [1,2,3]). In real-world applications, several operational constraints must be taken into account, as for example considering the travel and service times with time-window limitations [4]. Then, the considered problem becomes the Vehicle Routing Problem with Time Windows (VRPTW) [5].

A challenging topic in solving the VRPTW problem consists of considering uncertain parameters. Different approaches have been proposed in order to handle uncertain events in a VRPTW, in demand, displacement time, and service time. From the literature, we distinguish between stochastic and robust approaches. The stochastic variant can be regarded as a methodology that aims at finding a near-best solution for the objective function responding to all uncertain events that are characterized by their probability distributions [6,7,8]. On the other hand, the purpose of the robust approach is to find a solution that protects against the impact of data uncertainties, taking into consideration several technical criteria challenges such as the worst case, best case, min-max deviation, etc. The choice of a mathematical model of uncertain data is a crucial step to provide robust solutions. This kind of approach was the subject of a series of papers (see, e.g., [9]). In this context, Rouky et al. [10] introduced the uncertainties to the travel times of locomotives and the transfer times of shuttles as a model of the Rail Shuttle Routing Problem (RSRP) at Le Havre port. The authors proposed the Robust Ant Colony Optimization (RACO) as an efficient technique to deal with the problem. In the same spirit, Wu et al. [11] proposed a robust model tested on a set of random instances for the vehicle routing problem with uncertain travel time to improve the robustness of the solution, which enhances its quality compared with the worst case in a majority of scenarios. For instance, we split the resolution methods of this last approach into two major categories: exact and heuristic methods.

Due to the NP-hard nature of such problems, we cannot expect to use exact methods for the resolution (see, e.g., [12,13]). Indeed, the heuristics are solution methods that yield very good solutions in a limited time at the expense of ensuring the optimal solution. A generic class called the metaheuristic is used to exploit the best capabilities to achieve better solutions to solve a wide range of problems, since the mechanism to avoid getting trapped in local minima is present. In this regard, the literature covers a considerable number of metaheuristics conceived of to solve the VRPTW such as Simulated Annealing (SA) [14,15], Variable Neighborhood Search (VNS) [16,17], Ant Colony Optimization Algorithm (ACO) [18,19], Genetic Algorithm (GA) [20], and Tabu Search (TS) [21,22,23].

The need for parallel computing becomes inevitable despite the good results obtained with metaheuristics, due to the huge scale of the input data and the unexpected way of its change, which makes the objective function time-consuming. However, it is important to notice that the quality of the solution can be influenced. For instance, the major challenge is to find a parallelization strategy that solves larger problem instances in reasonable computing times and offers a consistently high level of performance over a wide variety of problem characteristics. In this context, several authors have proposed parallel techniques to tackle the combinatorial problems. Following these ideas, Bouthillier et al. [24] proposed a multi-thread parallel cooperative multi-search method founded on a solution warehouse strategy to deal with the deterministic VRPTW. Their method is based mainly on two cooperating classes of heuristics, namely tabu search and the evolutionary algorithms. In this regard, Røpke (2009) [25] applied a parallel ALNS to the traveling salesman problem with pickup and delivery and the capacitated vehicle routing problem such that each worker thread obtains a copy of the current solution and performs destroy and repair operations on its local copy in order to produce the best global solution. In the same spirit, Hemmelmayr (2014) [26]) proposed a parallel variant of the Large Neighborhood Search (LNS) to solve the periodic location routing problem. On the same topic, Pillac [27] presented a parallel version of the ALNS by adding a set covering post-optimization model that combines the tours generated throughout the search to assemble a better solution. It is worth mentioning here that the longer a heuristic is run, the better the quality of the solution is. Our contribution in this work is to study the balance between the quality of the solution and the corresponding execution time. Therefore, we suggest through our investigation a compromise between the required running time and the objective function. This can be viewed as a multi-criteria optimization problem.

Thus, the goal of this work is to study the effect of multithreading parallelization of the resolution approach blocks on the running time and the objective function. The optimization problem considered here is a variant of the Robust Vehicle Routing Problem with Time Windows (RVRPTW) including both uncertainties in travel and service times. Our contribution to all previous works lies first on the choice of the efficient Parallel Adaptive Large Neighborhood Search (PALNS) metaheuristic of Ropke [25], which leads to a reduced running time. Moreover, we used our parallel version of the Metropolis Monte Carlo algorithm to generate all possible realizations and to transform the problem under uncertainties to a set of deterministic sub-problems. For more detail about this splitting process, see for instance the previous work [9] and the references therein. Based on the efficient implementation of [25], different combinations (sequential/parallel) of the Monte Carlo algorithm and ALNS are performed. In this way, our strategy offers to decision makers the choice of the combination depending on their preferences and the situation at hand.

To the best of our knowledge, this contribution is the first work to be devoted to the study of VRPTW considering the uncertainties on travel times and service times for different sizes of instances in terms of both the execution time and the objective value.

The outline of this paper is organized as follows. The problem statement and mathematical model is provided in the second section. The sequential robust approach used to solve the problem is the subject of the third section. Within Section 4, we present the parallel Monte Carlo algorithm to generate all possible scenarios and the parallel ALNS algorithm to solve each sub-problem corresponding to each scenario. Finally, a detailed computational and comparative study is given before the concluding remarks and perspectives.

2. Problem Statement

The mathematical formulation of the problem can be represented on a graph $G=(N,A)$, where $N=\{0,1,...,n\}$ is the set of nodes and $A=\{(i,j):i,j\in A,i\ne j\}$ is the set of arcs. The node o represents the depot, and each other node is affected by a customer i. Each arc $(i,j)$ is assigned to the travel cost $c_{ij}$, which, in general, is proportional to the travel time $t_{ij}$ or the distance $d_{ij}$ between i and j. For the rest of this paper, we consider only the travel time cost $t_{ij}$. It is worth mentioning that this travel time $t_{ij}$ is subject to uncertainty ${\Delta }_{ij}$. The nominal service time is denoted by $P_i^k$ for each vehicle k and node i within the time window $[a_i,b_i]$ and depends on uncertainty ${\delta }_i$. According to the work of [9], we identify the uncertainty sets related to these times by:

$$U_t=\{\stackrel{\sim }{t}\in {\mathbb{R}}^{\mid A\mid }/\stackrel{\sim }{t_{ij}}=t_{ij}+{\Delta }_{ij}{ϵ}_{ij},\sum _{(i,j)\in A}{ϵ}_{ij}\le \Gamma ,0\le {ϵ}_{ij}\le 1,\forall (i,j)\in A\}$$

and

$$U_P=\{\stackrel{\sim }{P}\in {\mathbb{R}}^{\mid N\mid }/\stackrel{\sim }{P_i}=P_i+{\delta }_i{\omega }_i,\sum _{i\in N}{\omega }_i\le \Lambda ,0\le {\omega }_i\le 1,\forall i\in N\}$$

We denote the subset of arcs that are dependent on uncertainty by $\Psi$ with a cardinal $\Gamma$ and the subset of nodes depending on uncertainty by $\theta$ with a cardinal $\Lambda$.

The binary decision variables $x_{ij}^k$ take the value one if vehicle k travels between the pairs of nodes $(i,j)$ and zero otherwise.

We introduce the model of our problem, which tries to find a solution optimizing the total travel time taking into account the minimization of the worst evaluation over all scenarios:

$${\displaystyle \mathrm{Min} (\sum _{k\in V}\sum _{(i,j)\in A}{x}_{ij}^k{t}_{ij}+\underset{\{\Psi /\Psi \subset A,\mid \Psi \mid =\Gamma \}}{max}\sum _{k\in V}\sum _{(i,j)\in \Psi }{x}_{ij}^k{\Delta }_{ij})}$$

subject to:

$$\begin{array}{ccc}\hfill \sum _{k\in V}\sum _{j\in N}{x}_{ij}^k& =& 1\forall (i\in N)\hfill \end{array}$$

(1)

$$\begin{array}{ccc}\hfill \hspace{1em}\sum _{j\in N}{x}_{0j}^k& =& 1\forall (k\in V)\hfill \end{array}$$

(2)

$$\begin{array}{ccc}\hfill \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\sum _{i\in N}{x}_{ih}^k& =& \sum _{j\in N}{x}_{hj}^k\forall (h\in N)\forall (k\in V)\hfill \end{array}$$

(3)

$$\begin{array}{ccc}\hfill \hspace{1em}\sum _{i\in N}{x}_{i0}^k& =& 1\forall (k\in V)\hfill \end{array}$$

(4)

$$a_i\le P_i^k\le b_i\forall (i\in N)\forall (k\in V)$$

(5)

$$P_i^k+t_{ij}+{\delta }_i{\nu }_i^{\theta }+{\Delta }_{ij}{\mu }_{ij}^{\Psi }-P_j^k\le (1-x_{ij}^k)M,$$

(6)

$$\forall (i\in N),\forall (j\in N\backslash \{0\}),\forall (k\in V)\forall (\theta \subset N)\mid \theta \mid =\Lambda ,\forall (\Psi \subset A)\mid \Psi \mid =\Gamma$$

where M is a great value and ${\nu }_i^{\theta }$ and ${\mu }_{ij}^{\Psi }$ are two indicator functions. When $i\in \theta$, ${\nu }_i^{\theta }$ takes the value of one. When $(i,j)\in \Psi$, ${\mu }_{ij}^{\Psi }$ takes one.

The constraint (1) stipulates that each customer must be visited once. The constraint (2) guarantees that each tour starts from the depot. The constraint (3) ensures that the same vehicle arrives and leaves from each node it serves. The constraint (4) ensures that each tour ends at the depot. The constraint (5) guarantees that the service time $P_i^k$ at any customer i by vehicle k starts inside a specified time interval $[a_i,b_i]$. The last constraint (6) prohibits the violation of the time windows. Then, if the vehicle arrives ahead of time at a customer i, it must wait until the time window $[a_i,b_i]$ opens, and besides, it is not allowed to arrive late.

3. Robust Optimization

In real-world applications of operations research, we cannot ignore the fact that in the presence of uncertainties, an optimal solution could become worse or even unreachable from a practical point of view. Therefore, the need to develop models that immunize against those uncertainties has become indispensable.

In general, the uncertain parameters are represented by closed, convex, and bounded uncertainty sets, which can be also estimated from the historic data. Thereby, constructing the adequate uncertainty set has a crucial role in identifying the conservativeness of the model.

In this section, we present briefly the most important sets of uncertainties and the corresponding robust optimization models.

In this regard, we consider the following uncertain linear programming problem:

$$\begin{array}{c}min{c}^{\top }x\\ s.tAx\le B\end{array}$$

For the remainder of this section, only the coefficients ${\stackrel{\sim }{a}}_{ij}$ of the matrix A are the object of uncertainties, and their values belong to a bounded set of uncertainties called U. Accordingly, ${\stackrel{\sim }{a}}_{ij}$ takes a value in the interval $[a_{ij}-{\stackrel{-}{a}}_{ij},a_{ij}+{\stackrel{-}{a}}_{ij}]$ where $a_{ij}$ is the nominal value and ${\stackrel{-}{a}}_{ij}$ represents the maximum positive deviation. Therefore, we can define ${\stackrel{\sim }{a}}_{ij}$ as:

$${\stackrel{\sim }{a}}_{ij}=a_{ij}+{\zeta }_{ij}{\stackrel{-}{a}}_{ij}$$

Generally, ${\zeta }_{ij}$ is a random variable that is subject to uncertainty and varies between −1 and one.

For instance, three types of uncertainty sets can be distinguished [28].

3.1. Box Uncertainty Set

The box uncertainty set is an uncertainty structure that takes its name from the box formed by the interaction of perturbations. It aims at finding a conservative solution for a robust problem where the value of all uncertain coefficient perturbations is less than a perturbation bound ${\Psi }_i$ (see, e.g., [29]). Its uncertainty set can be described as follows:

$$U^A=\{{\stackrel{\sim }{a}}_{ij}=a_{ij}+{\zeta }_{ij}{\stackrel{-}{a}}_{ij}|\mid {\zeta }_{ij}\mid \le {\Psi }_i,\forall i\}$$

The robust counterpart of the problem is given by the following:

$$\begin{array}{c}min{c}^{\top }x\\ s.t\sum _j{a}_{ij}{x}_j+{\Psi }_i\sum _j{\stackrel{-}{a}}_{ij}{y}_j\le b_i\forall i\\ -y_j\le x_j\le y_j\forall j\\ y\ge 0\end{array}$$

It is worth pointing out that the problem becomes more conservative as the value of ${\Psi }_i$ increases.

3.2. Ellipsoidal Uncertainty Set

The ellipsoidal uncertainty set comes to avoid over conservativeness and to limit the uncertainty space by eliminating a subset of uncertainty. The level of robustness can be controlled by modifying the value of the parameter $\Omega$, which defines the borders of the set [30]. This uncertainty set can be given as:

$$U^A=\{{\stackrel{\sim }{a}}_{ij}=a_{ij}+{\zeta }_{ij}{\stackrel{-}{a}}_{ij}|\sum _j{\zeta }_{ij}^2\le {\Omega }_i^2,\forall i\}$$

The robust counterpart model is expressed in the following way:

$$\begin{array}{c}min{c}^{\top }x\\ s.t\sum _j{a}_{ij}{x}_j+\sum _j{\stackrel{-}{a}}_{ij}{y}_j+{\Omega }_i\sqrt{\sum _j{\stackrel{-}{a}}_{ij}^2{z}_{ij}^2}\le b_i\forall i\\ -y_{ij}\le x_j-z_{ij}\le y_{ij}\forall j\\ y\ge 0\end{array}$$

The inconvenience of this robust counterpart model lies in the generation of a convex nonlinear programming problem, with a greater computational requirement in contrast to linear models.

3.3. Polyhedral Uncertainty Set

The polyhedral uncertainty set corresponds to the most frequent case of uncertainty sets defined as the set of solutions, which are protected against all situations in which at most ${\Gamma }_i$ coefficients of the ith constraints are perturbed. In this case, the robust counterpart is equivalent to a linear optimization problem.

$$U^A=\{{\stackrel{\sim }{a}}_{ij}=a_{ij}+{\zeta }_{ij}{\stackrel{-}{a}}_{ij}|\sum _j\mid {\zeta }_{ij}\mid \le {\Gamma }_i,\forall i\}$$

The robust counterpart of the problem can be defined as below:

$$\begin{array}{c}min{c}^{\top }x\\ s.t\sum _j{a}_{ij}{x}_j+\underset{\{S_i\cup \{t_i\}\mid S_i\subseteq J_i,\mid S_i\mid =\mid {\Gamma }_i\mid ,t_i\in J_i\backslash S_i\}}{max}\{\sum _{j\in S_i}{\stackrel{-}{a}}_{ij}{y}_j+({\Gamma }_i-\mid {\Gamma }_i\mid ){\stackrel{-}{a}}_{it}{y}_t\}\le b_i\forall i\\ -y_j\le x_j\le y_j\forall j\\ y\ge 0\end{array}$$

where $J_i$ represents the set of coefficients $a_{ij}$ of the ith constraint, which are uncertain. We define for each i a parameter ${\Gamma }_i$ that varies in the interval $[0,\mid J_i\mid ]$. The solution of this model is immunized against all cases where coefficients up to $\mid {\Gamma }_i\mid$ will change, and one coefficient $a_{it}$ changes by $({\Gamma }_i-\mid {\Gamma }_i\mid )a_{it}$ as reported by [31].

4. The Robust Approach for the VRPTW with Uncertain Travel and Service Times

In this section, we present the robust resolution approach proposed by [9] to deal with the VRPTW under uncertain travel and service times. We assume that the uncertainty in travel times and service times is directed by two parameters $\Gamma$ and $\Lambda$, which belong respectively to the intervals $[0,\mid N\mid +\mid V\mid ]$ and $[0,\mid N\mid ]$. Those parameters are called budgets of uncertainty and are defined to control the number of travel times and service times, which are allowed to vary from their nominal values. Thus, the major challenge of this approach is to derive, for each scenario ($\Lambda$, $\Gamma$) considered, a robust solution that protects against time window violation or reduces the waiting times.

In order to explain the robust approach, we define some notations to be used in this approach:

• $R_N^{\Lambda ,\Gamma }$: A possible realization
• $S_{best}$: The best robust solution
• $S_N$: The solution found at the Nth realization
• $TotalCost(.)$: The total traveled time of a solution
• $WorstEva{l}^{\Gamma }(.)$: The worst evaluation of a solution
• $T{r}_k$ = $(c_1=0,c_2,\dots ,c_n=0)$: The tour of the vehicle k
• ${\sigma }_l$ = $(c_1,c_2,\dots ,c_l)$: A path of the tour $T{r}_k$
• $ArcSe{t}^{\Gamma ,l}$: A set of arcs within the $\Gamma$ larger deviations of travel time
• $NodeSe{t}^{\Lambda ,l}$: A set of nodes within the $\Lambda$ larger deviations of service time
• $\xi \left({\sigma }_l\right)=\{c_1,c_2,...,c_h\}$: All of the nodes that constitute ${\sigma }_l$
• $Arc\left({\sigma }_l\right)=\{{\gamma }_1=(c_1,c_2),{\gamma }_2=(c_2,c_3),\dots ,{\gamma }_{l-1}=(c_{l-1},c_l)\}$: The set of the arcs that constitute the path ${\sigma }_l$
• $\stackrel{\_k}{\left(s_l\right)}$: The maximum date of arrival of the vehicle k at customer $c_l$

To understand the idea behind this approach, we propose a simplified presentation in four steps summarized in Algorithm 1:

Algorithm 1. The robust approach algorithm.

Parameters: Set $Solutions$, set $realizations$ Outputs: Solution $solution$ $realizations⟵MonteCarlo\left(\right)$ for each $realization\in realizations$ do $\hspace{1em}solution⟵ALNS\left(realization\right)$    solutions.add(solution) end for for each $solution\in solutions$ do  if $checkRobustness\left(solution\right)\ne True$then   solutions.remove(solution)   return NULL  end if  if $WorstEva{l}^{\Gamma }\left(solution\right)\ne True$then   solutions.remove(solution)   return NULL  end if end for $solution⟵MinObjective\left(solutions\right)$ return$solution$

In the first step, the robust algorithm generates a set of realizations using the Metropolis Monte Carlo sampling. Each realization $R_N^{\Lambda ,\Gamma }$ corresponds to a possible scenario in which $\Gamma$ travel times of a subset of arcs $(\Psi \subset A)$ achieves their maximum values $t_{ij}+{\Delta }_{ij}$, and $\Lambda$ service times related to a subset of vehicles $(\theta \subset V)$ take their maximum values $P_i+{\delta }_i$; whereas the other arcs and nodes take respectively their $t_{ij}$ and $P_i$ nominal values.

The objective of the second step is to obtain for each realization $R_N^{\Lambda ,\Gamma }$ a feasible solution $So{l}_N$ that satisfies the related sub-problem. For this purpose, we apply the Adaptive Large Neighborhood Search (ALNS) metaheuristic [32], which presents an adaptive specialization of the notion of local search, so-called large neighborhoods. It aims to enhance an incumbent solution by diversifying the search process on large neighborhoods. This can be done by applying a pair of destroy and repair operators to the solution and then accepting or rejecting the new solution. In this context, we use three different destroy operators, which contribute to ruin a part of the current solution, namely: the proximity operator, the route portion operator, and the longest detour operator. Then, we recreate a complete solution using the greedy insertion heuristic. The destroy and repair neighborhoods are selected by a roulette wheel mechanism that uses the search history of each operator to favor the best performing one.

The third step depicts a mechanism conceived of to verify the feasibility of the solution achieved by using the ALNS approach in the preceding step, by examining the time windows associated with each visited customer. The last step is devoted to the evaluation of the robustness of the solution, according to the worst case criterion. In practice, we evaluate the solution $S_N$ on the worst of possible cases, which relates to the realization where the $\Gamma$ travel times of this solution reach at the same time their maximum values. The pseudocodes of those methods are shown in Algorithms 2 and 3, respectively.

Algorithm 2. Check for robustness.

$feasible\leftarrow true$ for$k\leftarrow 1$ to $\mid V\mid$ do  for $l\leftarrow 2$ to $\mid \xi \left(T{r}_k\right)\mid$ do    calculate $ArcSe{t}^{\Gamma ,l}$ and $NodeSe{t}^{\Lambda ,l-1}$    for $\lambda \leftarrow 1$ to $l-1$ do     if $l>\Gamma +1$ and ${\gamma }_{\lambda }\notin ArcSe{t}^{\Gamma ,l}$ then       $t_{{\gamma }_{\lambda }}\leftarrow t_{{\gamma }_{\lambda }}$     else       $t_{{\gamma }_{\lambda }}\leftarrow t_{{\gamma }_{\lambda }}+{\Delta }_{{\gamma }_{\lambda }}$     end if    end for    for $i\leftarrow 1$ to $l-1$ do      if $l>\Lambda$ and $c_i\notin NodeSe{t}^{\Lambda ,l-1}$ then       $P_{c_i}\leftarrow P_{c_i}+{\delta }_{c_i}$      end if     end for     $\stackrel{\_k}{\left(s_l\right)}\leftarrow 0$     for $i\leftarrow 2$ to l do      $\stackrel{\_k}{\left(s_l\right)}\leftarrow max(\stackrel{\_k}{\left(s_l\right)}+t_{{\gamma }_{i-1}}+P_{c_{i-1}},a_{c_i})$     end for     if $\stackrel{\_k}{\left(s_l\right)}>b_{c_l}$then      feasible takes false, and the algorithm ends     end if    end for   end for

Algorithm 3. Evaluation on the worst case.

$WorstEva{l}^{\Gamma }\left(S_N\right)\leftarrow 0$ put in descending order all the arcs of $\gamma \left(S_N\right)$ according to their maximum deviations. for$i\leftarrow 1$ to $\Gamma$ do  $WorstEva{l}^{\Gamma }\left(S_N\right)\leftarrow WorstEva{l}^{\Gamma }\left(S_N\right)+t_{{\gamma }_i}+{\Delta }_{{\gamma }_i}$ end for for$i\leftarrow \Gamma +1$ to $\gamma \left(S_N\right)$ do  $WorstEva{l}^{\Gamma }\left(S_N\right)\leftarrow WorstEva{l}^{\Gamma }\left(S_N\right)+t_{{\gamma }_i}$ end for return$WorstEva{l}^{\Gamma }\left(S_N\right)$

For a detailed description of this robust approach, we refer the reader to the study of [9] and the references therein.

5. The Parallel Robust Approach for the VRPTW with Uncertain Travel and Service Times

In this section, we provide a detailed exposition of the multi-threading parallel approach used in this paper. We start by giving some insights into the motivation before handling the complete description of the proposed approach.

The first challenge of such an approach is to derive the best robust solution that responds to to all uncertainties with a reduced running time. However, the sequential robust approach suffers from lengthy computational times; partly because the generation of scenarios is time-consuming, as well as the research of the solution block. Unlike those blocks, the check of robustness and the evaluation of the worst case blocks are not time-consuming, generally because they are restricted to evaluating the obtained solution.

Table 1. The execution time of the sequential robust approach blocks in ms.

Instance Size	Monte Carlo Block/Iteration	ALNS Block/Iteration	Check of Robustness Block/Iteration	Worst Case Evaluation Block/Iteration
1000 _ 100 _ 100	210	258	46	30
1500 _ 100 _ 100	325	409	85	52
2000 _ 100 _ 100	478	632	217	96
2500 _ 100 _ 100	621	867	377	163
3000 _ 100 _ 100	1042	1436	510	294
3500 _ 100 _ 100	1893	2229	682	325
4000 _ 100 _ 100	2365	3538	793	549
4500 _ 100 _ 100	2901	4428	907	703

confirms our assertion that the Monte Carlo and the ALNS blocks take considerable time compared to the other blocks. This can be explained by the fact that the first phase is responsible for generating all the possible scenarios in which $\Gamma$ displacement times take their maximum values and $\Lambda$ service times take their maximum values. The ALNS block is also time-consuming, since it chooses at each iteration a neighborhood to explore, based on a score that reflects its past performance. This is possible by the application of several destroy and repair operators. Oppositely, the other blocks are not time-consuming, considering that the first mechanism verifies the feasibility of our solution by investigating the related time windows of each visited customer, and the second mechanism is dedicated to the evaluation of the robustness of the solution based on the worst case robust criterion. As an alternative to overcome this impediment, we propose a multithreading parallelization of the costly blocks as detailed in the next subsections.

5.1. The Parallel Monte Carlo Sampling

The parallel Metropolis Monte Carlo algorithm described below is a scenario generation technique that uses a defined number of worker threads to generate in a parallel way a predefined number n of independent identically distributed scenarios. In practice, each worker thread produces a realization $R_l^{\Lambda ,\Gamma }$ that corresponds to a deterministic VRPTW problem, in which $\Gamma$ displacement times and $\Lambda$ service times reach simultaneously their maximum values. The pseudocodes of this parallel method is shown in Algorithm 4:

Algorithm 4. Parallel Monte Carlo.

Input: $\Lambda$, $\Gamma$, n Output: scenarios for$l\leftarrow 1$ to n in parallel do  for $k\leftarrow 1$ to $\Gamma$ do   Select randomly two clients i and j   $\stackrel{\sim }{t_{ij}}\leftarrow t_{ij}+{\Delta }_{ij}$  end for  for $k\leftarrow 1$ to $\Lambda$ do    Select randomly a client i    $\stackrel{\sim }{P_i}\leftarrow P_i+{\delta }_i$  end for  Generate a scenario $R_l^{\Lambda ,\Gamma }$  $t\left(R_l^{\Lambda ,\Gamma }\right)\leftarrow \stackrel{\sim }{t}\left(R_l^{\Lambda ,\Gamma }\right)$  $P\left(R_l^{\Lambda ,\Gamma }\right)\leftarrow \stackrel{\sim }{P}\left(R_l^{\Lambda ,\Gamma }\right)$  Add $R_l^{\Lambda ,\Gamma }$ to $scenarios$ end for return$scenarios$

5.2. The Parallel ALNS

In this subsection, we present the Parallel Adaptive Large Neighborhood Search (PALNS) method developed by [25]. This method can be presented in three phases (see Figure 1).

At the first level, we generate an initial feasible solution by using the greedy insertion metaheuristic [33]. The main idea behind this method is to select the best feasible insertion place in the incumbent route for each non-inserted node taking into account two major factors: the increase in total cost of the current route after the insertion and the delay of the service start time of the customer succeeding the newly inserted customer.

The second phase is related to a set of destroy and repair operators designed to enhance the incumbent solution. In this context, each worker thread deals with a copy of the current solution and executes destroy and repair methods on this local copy in order to improve it.

The third phase collects the routes of different local solutions that each thread has obtained, for the purpose of combining it into a new better temporary global solution and sending it to be improved. At this stage, we will accept or reject the generated solution, based on a hill climbing acceptance criterion. It is worth mentioning that only the current and global best solutions are shared between worker threads, in order to update them as necessary by repeating the process until a stop criterion is met.

We should point out here that the ALNS uses a flexible layer with a set of destruction heuristics (proximity operator, route portion operator, and longest detour operator) and an insertion heuristic (the greedy insertion) and applies them by a roulette wheel selection that highlights the corresponding performance obtained during the search. On the other hand, the LNS heuristic does not use this scoring mechanism.

For a completed description of the used PALNS, we refer the reader to the study of [25] and the references therein.

6. Computational Experiments

In this section, we summarize a few of the results obtained by evaluating different robust approaches conceived of to solve the vehicle routing problem with time windows with uncertain service and travel times.

We explore the effect of applying the thread parallelism to the Monte Carlo and ALNS blocks, on the execution time and the objective value. This leads to four different robust combinations: the sequential approach that uses sequential Monte Carlo and sequential ALNS (MC sequential and ALNS sequential), the approach employing sequential Monte Carlo and parallel ALNS (MC sequential and ALNS parallel), the approach that uses parallel Monte Carlo and sequential ALNS (MC parallel and ALNS sequential), and the parallel approach combining parallel Monte Carlo and parallel ALNS (MC parallel and ALNS parallel). We should note here that the sequential approach (MC sequential and ALNS sequential) coincides with the only method from the literature [9] that deals with the considered problem.

It is important to mention that the notion of thread parallelism used in our context can be defined as the capability of a processing unit to execute multiple processes contemporaneously or with time slicing. By means of a thread, the smallest unit of processing can be performed in an operating system in order to accelerate the execution time and manage the code over time. In our study, we use four threads in order to establish the comparison between the different approaches. The choice of four threads is not restrictive, and we can use as many threads as possible. Our assumption is that using more threads leads to the improvement of the average execution time, but it slightly decreases the quality of the obtained solution. For more details, see, e.g., [25].

The robust approaches studied in this paper were tested on a classical set of instances in reference to Solomon’s benchmark (1987) [33] and Gehring and Homberger’s benchmark [34]:

• Set R contains problems with randomized customers.
• Set C contains problems with clustered customers.
• Set $RC$ contains problems with both clustered and randomized customers.

In order to simulate the uncertainty of RVRPTW by discrete scenarios, the uncertain travel time and uncertain service time are generated at random, so that they go from 0 to 10. We denote the used instances as follows: $Gr\_\Gamma \_\Lambda$, where $\Gamma$ and $\Lambda$ present respectively the number of travel times and service times considered uncertain and $Gr$ refers to the instance of Solomon and Gehring and Homberger’s benchmark or the size of larger instances.

For small instances (Solomon and Homberger’s instances), we chose 15,600 iterations as a stop criterion in order to diversify the research, which may ameliorate the quality of our solution, because the solution has a greater chance to escape from a local minimum. As far as we are aware, the maximal number of iterations for instances is falling in the literature. With a view toward examining the capability of our approaches for tackling that problem, we judge it based on the average performance over 10 multiple independent runs.

For the set of instances larger than 1000, we generate random representative instances in such a manner that the travel time between each pair of nodes is between 0 and 100, and the same for the service time. The time interval has a capacity of 200 between the start and the end of the service at each customer. We forced a stop condition of about 20 min, which allows a good comparison between the proposed methods in terms of the number of reached iterations for the same time interval. Then, we present the measurements achieved for a single run.

The proposed algorithms were implemented in Java 7, compiled with Intel compiler Celeron 1.80 GHz core i5 with 8 GB RAM.

6.1. Execution Time

Table 2. The execution time of different robust approaches in seconds for 15,600 iterations.

Instance	MC Sequential and ALNS Sequential	MC Sequential and ALNS Parallel	MC Parallel and ALNS Sequential	MC Parallel and ALNS Parallel
100 _ 10 _ 10	832.24	701.03	725.45	574.24
200 _ 25 _ 25	1007.41	853.11	883.25	669.33
400 _ 25 _ 25	1331.47	1037.98	1101.12	770.91
600 _ 50 _ 50	1402.50	1160.24	1230.64	858.38
800 _ 50 _ 50	1545.39	1302.85	1331.68	979.14
1000 _ 100 _ 100	2687.50	2062.25	2165.74	1340.49
1500 _ 100 _ 100	4519.79	3267.98	3665.37	2413.56
2000 _ 100 _ 100	5606.81	3953.18	4389.74	2736.11

presents a comparison of the execution time for each instance group between different robust approaches with the maximal number of iterations of 15,600. As expected, the results show that the approaches containing the parallel ALNS succeeded by those containing parallel Monte Carlo lead to the improvement of the average execution time compared to other sequential approaches. This can be explained by the fact that the ALNS block succeeded by the Monte Carlo block consumes most of the execution time compared to other blocks.

In the same spirit, we report in

Table 3. Number of iterations reached in 20 min.

Instance	MC Sequential and ALNS Sequential	MC Sequential and ALNS Parallel	MC Parallel and ALNS Sequential	MC Parallel and ALNS Parallel
2500 _ 100 _ 100	3038	4275	3879	5681
3000 _ 100 _ 100	2163	3572	2794	4141
3500 _ 100 _ 100	1375	2992	1985	3709
4000 _ 100 _ 100	912	2401	1386	3124
4500 _ 100 _ 100	594	1994	1078	2300

a comparison of different approaches according to the number of reached iterations when the stopping limit time is about 20 min for the group of instances 2500–4500. The approach containing more parallel blocks attained more iterations for the same time interval since it reduced the execution time of the consuming blocks.

Table 4. Solomon’s instance: Comparison of the runtimes in seconds of different robust approaches.

Instance	MC Sequential and ALNS Sequential	MC Sequential and ALNS Parallel	MC Parallel and ALNS Sequential	MC Parallel and ALNS Parallel
R101 _ 10 _ 10	433	267	378	212
C101 _ 10 _ 10	491	320	434	263
RC101 _ 10 _ 10	468	286	407	225
R201 _ 10 _ 10	487	301	425	239
C201 _ 10 _ 10	563	367	497	301
RC201 _ 10 _ 10	553	338	482	267
R121 _ 25 _ 25	580	277	512	309
C121 _ 25 _ 25	653	442	583	372
RC121 _ 25 _ 25	605	406	539	340
R221 _ 25 _ 25	673	438	595	360
C221 _ 25 _ 25	784	531	700	447
RC221 _ 25 _ 25	707	475	629	397
R141 _ 25 _ 25	668	423	586	341
C141 _ 25 _ 25	775	538	696	459
RC141 _ 25 _ 25	747	504	666	423
R241 _ 25 _ 25	937	629	823	479
C241 _ 25 _ 25	981	683	877	589
RC241 _ 25 _ 25	957	646	854	543
R161 _ 50 _ 50	741	541	675	475
C161 _ 50 _ 50	907	682	832	607
RC161 _ 50 _ 50	825	607	753	535
R261 _ 50 _ 50	923	730	909	640
C261 _ 50 _ 50	1089	814	999	726
RC261 _ 50 _ 50	1051	774	958	681
R181 _ 50 _ 50	923	698	848	623
C181 _ 50 _ 50	942	732	874	664
RC181 _ 50 _ 50	929	706	855	632
R281 _ 50 _ 50	1136	860	1044	768
C281 _ 50 _ 50	1249	971	1157	879
RC281 _ 50 _ 50	1223	925	1123	829
R1101 _ 100 _ 100	1179	764	1040	625
C1101 _ 100 _ 100	1213	817	1081	685
RC1101 _ 100 _ 100	1204	800	1069	665
R2101 _ 100 _ 100	1757	1140	1552	935
C2101 _ 100 _ 100	1815	1224	1618	1027
RC2101 _ 100 _ 100	1775	1181	1577	983

depicts the improvement results in execution time for Solomon’s instances. The conclusion from this table is clear: the running time is much faster for the approaches using parallel ALNS succeeded by those employing the parallel Monte Carlo algorithm.

6.2. Objective Function

Table 5. Comparison of different approaches according to the objective function.

Instance	MC Sequential and ALNS Sequential	MC Sequential and ALNS Parallel	MC Parallel and ALNS Sequential	MC Parallel and ALNS Parallel
1000 _ 100 _ 100	18,612	21,031	18,642	21,075
1500 _ 100 _ 100	25,961	28,557	25,904	28,516
2000 _ 100 _ 100	36,420	38,969	36,408	38,943
2500 _ 100 _ 100	44,981	48,129	44,998	48,161
3000 _ 100 _ 100	52,817	55,986	52,836	56,014
3500 _ 100 _ 100	60,356	63,977	60,321	63,937
4000 _ 100 _ 100	67,675	71,059	67,642	70,986
4500 _ 100 _ 100	75,306	78,318	75,329	78,371

presents the objective function of different robust approaches for the group of instances 2500–4500. When the size of the instance increases, the cost function of the approaches containing parallel and sequential ALNS solution converges. Then, we compute the mean absolute percent deviation (MAPD), which is the absolute difference between the cost function of the approach containing the sequential ALNS and the parallel ALNS divided by the magnitude of the objective function in the approach with sequential ALNS. This indicator (MAPD) goes from $13.05\%$ for the instance of size 1000 to $3.96\%$ for the instance of size 4500. We can conclude that incorporating the parallel ALNS in the approaches is efficient for large instances.

Table 6. Solomon’s instance: comparison of the objective value of different robust approaches.

Instance	MC Sequential and ALNS Sequential	MC Sequential and ALNS Parallel	MC Parallel and ALNS Sequential	MC Parallel and ALNS Parallel
R101 _ 10 _ 10	1918.56	2225.52	1926.14	2249.69
C101 _ 10 _ 10	870.46	1009.73	883.01	1025.84
RC101 _ 10 _ 10	1882.76	2145.48	1897.04	2183.92
R201 _ 10 _ 10	1434.99	1663.44	1415.09	1663.24
C201 _ 10 _ 10	666.54	779.27	663.52	761.51
RC201 _ 10 _ 10	1663.38	1895.82	1679.45	1900.11
R121 _ 25 _ 25	5696.41	6379.52	5709.64	6659.85
C121 _ 25 _ 25	3115.86	3519.95	3115.86	3504.38
RC121 _ 25 _ 25	3915.01	4384.80	3919.63	3492.62
R221 _ 25 _ 25	5385.14	6031.35	5385.14	6024.07
C221 _ 25 _ 25	2490.94	2813.70	2496.91	2813.70
RC221 _ 25 _ 25	3657.12	4095.84	3657.12	4106.49
R141 _ 25 _ 25	10,939.12	11,485.95	10,951.24	11,485.95
C141 _ 25 _ 25	8138.18	8463.52	8127.63	8480.31
RC141 _ 25 _ 25	10,673.61	11,099.92	10,697.27	11,080.79
R241 _ 25 _ 25	10,442.34	10,859.68	10,463.29	10,843.81
C241 _ 25 _ 25	4932.06	5129.28	4863.65	5129.28
RC241 _ 25 _ 25	20,917.12	21,690.92	7181.07	21,709.56
R161 _ 50 _ 50	24,277.04	24,714.02	24,277.04	24,703.48
C161 _ 50 _ 50	15,511.06	15,945.30	15,523.45	15,940.06
RC161 _ 50 _ 50	21,917.15	22,245.75	21,937.13	22,291.10
R261 _ 50 _ 50	22,070.80	22,445.19	22,121.72	22,457.14
C261 _ 50 _ 50	10,617.60	10,871.80	10,632.96	10,886.71
RC261 _ 50 _ 50	16,167.74	16,458.00	16,186.14	16,430.92
R181 _ 50 _ 50	39,011.14	39,479.13	38,979.56	39,431.41
C181 _ 50 _ 50	28,491.39	29,117.85	28,491.39	29,117.83
RC181 _ 50 _ 50	35,821.46	36,358.31	35,853.12	36,347.02
R281 _ 50 _ 50	32,289.08	32,870.20	32,271.22	32,870.20
C281 _ 50 _ 50	14,213.43	14,483.04	14,219.34	14,497.15
RC281 _ 50 _ 50	28,307.07	28,788.21	28,307.07	28,805.09
R1101 _ 100 _ 100	60,506.88	62,805.22	60,493.16	62,805.22
C1101 _ 100 _ 100	52,251.98	53,766.83	52,257.48	53,742.30
RC1101 _ 100 _ 100	53,322.91	55,188.27	43,318.10	55,188.27
R2101 _ 100 _ 100	48,103.23	49,449.88	48,103.23	48,463.23
C2101 _ 100 _ 100	20,735.79	21,357.05	20,700.14	21,357.05
RC2101 _ 100 _ 100	43,853.65	44,905.47	43,853.65	44,884.35

depicts the results of the objective value for some of Solomon’s instances. We observe that the ALNS controls the solution quality. Then, the approaches that contain a sequential ALNS yield better results than those that contain parallel ALNS. The ALNS is responsible for finding the solution of each scenario, in contrast with the Monte Carlo algorithm, which is limited to generating the possible scenarios. When we increase the instance size, the quality of the solution of the parallel approach becomes more interesting.

7. Conclusions

In this work, we study the robust vehicle routing problem with time windows where travel times and service times are both the subject of uncertainty. For this purpose, we opt for the robust technique proposed by [9] to deal with the problem. As far as the adopted approach derives the best robust solution that responds to all uncertainties, it still suffer from lengthy computational times; partly because the generation of scenarios, as well as the research of the solution block are time-consuming. As an alternative to remedy this problem, we introduce a procedure for the thread parallelism in the Monte Carlo block, and we use the parallel ALNS proposed by [25]. This leads to four different robust approaches combining the (sequential/parallel) Monte Carlo algorithm and the (sequential/parallel) ALNS.

The considered approaches are tested on Solomon’s benchmark instance of VRPTW and lager instances generated randomly. Accordingly, we can offer a decision-making solution that provides great protection against delays in a reasonable running time. However, we should note that the related counterpart of using the parallel ALNS, which is the objective value, can be influenced, since the parallel ALNS slightly reduces the quality of the solution, especially for small instances.

In future works, we intend to include a pre-processing step based on different clustering techniques such as K-means, K-medoids, density-based spatial, etc., in order to ensure the commitment of the solutions. These techniques will not change the structure of the suggested approach drastically, and our assumption is that they will enhance the solution quality obtained with the parallel ALNS.