A Hybrid Large Neighborhood Search Method for Minimizing Makespan on Unrelated Parallel Batch Processing Machines with Incompatible Job Families

Abstract

This paper studies a scheduling problem with non-identical job sizes, arbitrary job ready times, and incompatible family constraints for unrelated parallel batch processing machines, where the batches are limited to the jobs from the same family. The scheduling objective is to minimize the maximum completion time (makespan). The problem is important and has wide applications in the semiconductor manufacturing industries. This study proposes a mixed integer programming (MIP) model, which can be efficiently and optimally solved by commercial solvers for small-scale instances. Since the problem is known to be NP-hard, a hybrid large neighborhood search (HLNS) combined with tabu strategy and local search is proposed to solve large-scale problems, and a lower bound is proposed to evaluate the effectiveness of the proposed algorithm. The proposed algorithm is evaluated on numerous compatible benchmark instances and newly generated incompatible instances. The results of computational experiments indicate that the HLNS outperforms the commercial solver and the lower bound for incompatible problems, while for compatible problems, the HLNS outperforms the existing algorithm. Meanwhile, the comparison results indicate the effectiveness of the tabu and local search strategies.

1. Introduction

Batch processing machines (BPMs) have many applications across many industries, such as semiconductors, garment industries, food processing, and transportation. Due to the ever-growing manufacturing industries, scheduling suffers increasing stress, and the immaturity of scheduling methods has become the bottleneck in processing. Enhancing the efficiency of batch processing operations becomes urgent for the manufacturing industry to maintain or raise its market share, giving rise to batch processing machines scheduling problems [1]. The batch processing scheduling problem can be addressed by solving two independent subproblems: grouping the jobs into batches and scheduling the batches on the machines. The batch formation subproblem for jobs from multiple job families often occurs in the diffusion operation [2]. The jobs can be grouped as a batch as long as the total size does not exceed the machine capacity. When a batch is formed, the batch ready time is the largest ready time of all the jobs in the batch, and the batch processing time is the longest processing time of all the jobs in the batch. A job family is a subset of jobs that need the same recipe and can be processed together as a batch. In this paper, we address a scheduling problem for unrelated parallel BPMs with unequal capacities, where jobs have different processing times on different machines. A batch is composed of a set of jobs from the same family such that the total size of the jobs does not exceed the machine capacity. The objective is to minimize the makespan of machines.

The research on batch processing machines with incompatible job families can be roughly divided into a single batch processing machine scheduling problem and a parallel batch processing machine scheduling problem. Scheduling on a single batch processing machine consists of two independent subproblems: grouping the jobs into batches and scheduling the batches on the machines. For heuristic methods, Uszoy [2] introduced the single batch processing problem with incompatible job families. An efficient algorithm to minimize makespan, maximum lateness, and total weight completion time was proposed, where both the static and dynamic job arrivals scenarios were investigated. Koh et al. [3] designed a heuristic algorithm named Biggest Weight First (BWF) and a hybrid genetic algorithm (GA) to minimize makespan, total completion time, and total weighted completion time. Comparisons were made with a lower bound. Jolai [4] aimed to minimize the number of tardy jobs on a single batch processing machine. They showed that the problem was NP-hard and presented a dynamic programming algorithm that had polynomial time complexity when the number of job families and the batch machine capacity were fixed. Kashan and Karimi [5] investigated the scheduling problem with arbitrary job sizes and weights, and an ant colony optimization (ACO) algorithm was presented afterward. The ACO was compared with GA and BWF in [3], and the results showed ACO’s superior solving ability in most cases. Dauzère-Pérès and Mönch [6] minimized the weighted and unweighted numbers of tardy jobs and proposed two different mixed integer linear programming (MILP) formulations and a random key genetic algorithm (RKGA) to solve the problem. Cheng et al. [7] introduced a batch processing problem with arbitrary job sizes and showed that the problem of minimizing makespan and total completion time were both NP-hard. A MILP model and two polynomial time heuristics based on the longest processing time (LPT) rule and first fit (FF) rule were presented to handle the problem. Li et al. [8] studied unequal job sizes, and the objective was to minimize the maximum lateness. They presented a mathematical model, a lower bound, and several heuristics. All the studies mentioned above solve the batch processing problem by splitting it into different sub-problems such as the batch formation subproblem and batch scheduling subproblem [2,3,4,5,6,7,8]. These sub-problems are solved by independent designed heuristics, and the problem is solved through the continuous interaction of the independent designed heuristics iteratively.

There are some studies using exact methods to solve the single batch processing machine scheduling problems. Azizogla and Webster [9] considered arbitrary job weights and sizes. To handle this problem, a branch and bound method was proposed, and experiments showed that the algorithm yielded optimal solutions for problem instances with up to 25 jobs. Tangudu and Kurz [10] considered the scenario of dynamic job arrivals for minimizing the total weighted tardiness and developed a branch and bound algorithm. The algorithm was capable of solving problems with up to 32 jobs. Yao et al. [11] considered arbitrary ready times and proposed a branch and bound method to handle the problem. Computational results suggested that the method can figure out the test problems with up to 60 jobs and six families.

A growing number of studies have paid attention to scheduling methods on identical parallel batch processing machines. According to the requirement of real-world manufacturing, the single-objective problems mainly optimize the total weight tardiness, total flow time, total weight completion time, and makespan. To minimize total weight tardiness, Balasubramanian et al. [12] proposed two different versions of genetic algorithms (GAs), and the first GA was applied to assign batches on the machine, while the second GA was used to handle jobs assignment. Mönch et al. [13] considered dynamic job arrivals and used different heuristics to optimize batch formation, assignment, and sequence separately. Chiang et al. [14] solved the same problem as in [13] and proposed a memetic algorithm with a new genome encoding scheme to search for the optimal or near-optimal batch formation and batch sequence simultaneously. Machine assignment was resolved in the proposed decoding scheme. Through extensive experiments, the algorithm demonstrated its advantages over the memetic algorithm [13] regarding solution quality and computational burden. Almeder and Mönch [15] devised an ACO and a variable neighborhood search (VNS) approach to solve the problem, and the computational results showed that VNS outperformed the ACO and GA [12] with respect to computational costs and solution quality. Venkataramana and Srinivas Raghavan [16] divided the problem into batch formation and batch scheduling and proposed three ACOs. Experiment results showed that ACO-based algorithms performed better than GA [12]. Lausch and Mönch [17] designed a GA approach, an ACO approach, and a large neighborhood search (LNS) approach for the same problem, as in [15]. The LNS outperformed the GA and the ACO, which was comparable with the VNS proposed in [15]. To minimize the total flow time, Cakici et al. [18] added arbitrary ready times and unequal job sizes to the problem and presented a mathematical model and several different VNS variants. Ham et al. [19] only considered non-identical job sizes and formulated a MIP model and a constraint programming (CP) model. Then, the models’ performances were compared with those of a VNS heuristic [18], and the computational results demonstrated that the CP model outperformed VNS regarding solution quality and computational time. Jiang et al. [20] studied the scheduling problem of jobs with non-identical sizes and ready times. They proposed a MILP and a CP model for small-scale instances, batch-based local search, and the iterated greedy (IG) algorithm for large-scale instances. To minimize total weight completion time, Huang et al. [21] proposed a MILP model and an approximation algorithm. Numerical results demonstrated that the proposed algorithm can obtain high-quality solutions. As for minimizing the makespan, Koh et al. [22] added non-identical job sizes to the problem, and proposed several heuristics and a GA algorithm. Jia et al. [23] studied the problem of scheduling a set of jobs with non-identical job sizes and proposed a Max-Min Ant System (MMAS) algorithm. Computational results demonstrated the superiority of the proposed MMAS over GA [22]. Sun et al. [24] considered deteriorating jobs and module changes simultaneously, they proposed a hybrid algorithm combining self-adaptive differential evolution (SADE) and artificial fish swarm algorithm (AFSA) to tackle the problem. Computational experiments were conducted to evaluate the performance of the proposed algorithm. Similarly, most of the studies above solve problems by the heuristic interaction between the parts (such as batches formation and batches scheduling) to search for better solutions of the problems iteratively.

All of the studies above focus on scheduling on identical machines, where jobs have the same processing speeds on machines. However, new and old machines usually co-exist in practical manufacturing, resulting in different processing speeds for jobs, which leads to unrelated parallel batch processing machines. Meanwhile, most of the research mentioned above assumes all jobs are the same size or ignores that the jobs are available at different times. As it is practically motivated, we address the problem of scheduling on unrelated parallel batch processing machines with non-identical job sizes and dynamic job arrivals. The performance metric of the problem is minimizing makespan, which can reflect the utilization of the limited resource and is the most commonly used performance metric in the literature [25]. To the best of our knowledge, research on optimizing the makespan of the parallel batch processing machines scheduling problems with incompatible job families is still very limited.

A conventional way to tackle batch processing scheduling problems is to split them into two subproblems and solve them through heuristic interaction, which complicates the solving mechanism. In order to avoid decomposing the batch processing scheduling problem and improve the computational efficiency, we propose a hybrid large neighborhood search (HLNS) from the perspective of discrete combinatorial optimization and optimize batch formation and batch scheduling simultaneously.

The HLNS is based on the large neighborhood search [26] framework, which searches for better solutions iteratively by a destroy operator and a repair operator designed exclusively according to the characteristics of the target problem. Based on the tardiness of jobs, we design a tardiness-related removal operator in this paper. Meanwhile, in order to avoid unexpected repetitive explorations, the tabu strategy is integrated into the removal operator, then proposing the tabu-based tardiness-related removal operator. Furthermore, to improve the local search ability of the method, a local search algorithm will be applied to the current solution if no better solution is achieved after a fixed number of iterations. The proposed HLNS combines the advantages of LNS, tabu strategy, and local search strategy, which has superior exploration ability and can guide the search process towards a better region. To prove the effectiveness of the algorithm, a MIP model is presented which can solve the small-scale instances optimally, and a lower bound is proposed to evaluate large-scale instances. Furthermore, experiments were conducted using 180 benchmark instances, and the results are compared with the heuristic method reported in [27,28,29,30].

The main contributions of the work can be summarized as follows:

(i).

For the first time, we present a MIP model for the unrelated parallel batch processing machines problem with incompatible job families (UPBPMIJF), which can solve small-scale instances optimally;

(ii).

A hybrid large neighborhood search (HLNS) approach combined with a tabu and local search strategy is proposed to solve the scheduling problem efficiently;

(iii).

To verify the effectiveness of the proposed algorithm, two sets of instances, including incompatible job families and compatible job families, are used to conduct the experiments, and the results obtained by the HLNS are compared with that of a MIP model, a lower bound, and four previously published heuristic methods in [27,28,29,30]. Numerous computational experiments are conducted, which cogently demonstrate the advantages of the HLNS algorithm.

The rest of the paper is organized as follows: Section 2 introduces UPBPMIJF and presents a MIP model and a lower bound. The framework of the proposed HLNS for UPBPMIJF and its implementation procedure is described in Section 3. Section 4 provides numerical results, comparisons, and analyses. Finally, concluding remarks are made in Section 5.

2. Mathematical Model and Lower Bound

The scheduling problem of interest can be formally defined as follows: Given a set of $n$ jobs, $J=\left\{1,\dots ,n\right\}$, to be processed on $m$ unrelated parallel batch processing machines (UPBPMs), $M=\left\{1,\dots ,m\right\}$, and each machine has a capacity denoted by ${\mathcal{C}}_m$. The jobs are divided into $f$ families, and the set of families is $F=\left\{1,2,\dots ,f\right\}$. Only jobs from the same family can be grouped into a batch. Furthermore, each job $j$ is associated with a size $s_j$, a ready time $r_j$ and a corresponding processing time $p_{jm}$ on the machine $m$. A batch-processing machine can process a group of jobs simultaneously as long as the capacity of the machine ${\mathcal{C}}_m$ is not exceeded. We assume that the size of each job does not exceed the largest machine capacity $\overline{\mathcal{C}}=\underset{m\in M}{\max }{\left\{\mathcal{C}\right\}}_m \left(s_j\le \overline{\mathcal{C}}, \forall j\in J\right)$. The ready time of a batch is the time when all jobs in the batch are available to be processed, and the processing time of a batch is determined by the longest processing time of the jobs in the batch.

2.1. Mathematical Model

The following symbols will be used throughout the rest of this paper:

Sets

$J$	Set of jobs, indexed by $j$.
$M$	Set of machines, indexed by $m$.
$B$	Set of batches, indexed by $b$.
F	Set of job families, index by $f$.

Parameters

$s_j$	Size of job $j$, $j\in J$.
$r_j$	Ready time of job $j$, $j\in J$.
$p_{jm}$	Processing time of job $j$ on machine $m$, $j\in J$,$m\in M$.
${\mathcal{C}}_m$	Capacity of machine $m$,$m\in M$.
$Z_{jf}$	Binary variable, $Z_{jf}=1$ if job $j$ is in family $f$, otherwise 0.

Variables

$S_{bm}$	Starting time of batch $b$ on machine $m$.
$P_{bm}$	Processing time of batch $b$ on machine $m$.
$x_{jb}$	binary variable, $x_{jb}=1$ if job $j$ is in batch $b$, otherwise 0.
$y_{bm}$	binary variable, $y_{bm}=1$ if batch $b$ is processed on machine $m$, otherwise 0.
${\delta }_{bf}$	binary variable, ${\delta }_{bf}=1$ if batch $b$ is in family $f$, otherwise 0.
$C_{max}$	Makespan of the schedule.

The mathematical model of the problem can be formulated as follows:

$$\mathrm{Minimize}{C}_{max}$$

(1)

$${{\displaystyle \sum }}_{b\in B}{x}_{jb}=1, \forall j\in J$$

(2)

$${{\displaystyle \sum }}_{m\in M}{y}_{bm}=1, \forall b\in B$$

(3)

$${{\displaystyle \sum }}_{j\in J}{x}_{jb}{s}_j{y}_{bm}\le {\mathcal{C}}_m, \forall b\in B, \forall m\in M$$

(4)

$$S_{bm}\ge r_j{x}_{jb}{y}_{bm}, \forall j\in J, \forall b\in B, \forall m\in M$$

(5)

$$S_{bm}\ge S_{\left(b-1\right)m}+P_{\left(b-1\right)m},\forall j\in J, \forall b\in B, b>1,\forall m\in M$$

(6)

$$P_{bm}\ge p_{jm}{x}_{jb}{u}_{bm},\forall j\in J, \forall b\in B,\forall m\in M$$

(7)

$$C_{max}\ge P_{bm}+S_{bm}, \forall b\in B, \forall m\in M$$

(8)

$$x_{jb}{z}_{jf}\le {\delta }_{bf}, \forall j\in J, \forall b\in B, \forall f\in F$$

(9)

$${\delta }_{bf}\le {{\displaystyle \sum }}_{j\in J}{x}_{jb}{z}_{jf},\forall b\in B, \forall f\in F$$

(10)

$${\delta }_{bf}\in \left\{0,1\right\}$$

(11)

$$x_{jb}\in \left\{0,1\right\}$$

(12)

$$y_{bm}\in \left\{0,1\right\}$$

(13)

Objective (1) is minimizing the makespan. Constraint sets (2) and (3) are assignment constraints, which determine jobs assigned to batches and, subsequently, batches assigned on machines. Constraint set (4) ensures that the size of a batch processed on the machine does not exceed its capacity. Constraints (5) and (6) define the starting time of a batch, which is the maximum value between the latest arrival job and the completion time of the previous batch. Constraint (7) defines the processing time of a batch. Constraint (8) defines the makespan as the completion time of the last batch. Constraints (9) and (10) ensure that each batch only belongs to one family. The types and bounds of variables are defined by constraints (11) to (13).

2.2. Lower Bound

The work in [27] addressed an algorithm to compute the lower bound ($LB$) for scheduling unrelated BPMs with unequal job sizes, arbitrary job ready times, and compatible job families, so as to minimize makespan. In this paper, we adapt this lower bound for the UPBPMIJF. For ease of explanation, we assume that there are only two different machine capacities and let the two machine capacities be denoted by ${\mathcal{C}}_1$ and ${\mathcal{C}}_2$ (assuming ${\mathcal{C}}_1 \le {\mathcal{C}}_2$). The number of machines with capacity ${\mathcal{C}}_i$ is denoted as $m_i$ ($i=1,2$), and the machine sets can be grouped into two subsets, represented by $M_1$ and $M_2$. Similarly, the job sets can be divided into 2 subsets, denoted by $J_1$ and $J_2$, where the jobs in $J_1$ can be scheduled on any machine in $M_1{\displaystyle \cup }{M}_2$, while the jobs in $J_2$ can only be scheduled on any machine in $M_2$. One lower bound for the problem is given by $\underset{j\in J}{\max }\left\{r_j+\underset{m\in M}{\min }\left\{p_{jm}\right\}\right\}$. Other lower bounds can be obtained by cutting each job $j$ into $p_j\times s_j$ unit jobs. For example, when the unitized jobs of $J_2$ are processed on the machines in $M_2$, a possible lower bound can be obtained. Note that the jobs are from different families, and $J_2^f$ represents the jobs in $J_2$ of family $f$, a lower bound for the number of batches of the family is ${\displaystyle \left[\frac{{{\displaystyle \sum }}_{j\in J_2^f}\left\{s_j\right\} }{m_2\times {\mathcal{C}}_2}\right]}$. Therefore, a lower bound for the total processing time of all the jobs in the family $f$ is ${\displaystyle \left[\frac{{{\displaystyle \sum }}_{j\in J_2^f}\left\{s_j\right\} }{m_2\times {\mathcal{C}}_2}\right]}\times \underset{m\in M_2}{\min }{p}_{jm}$. The earliest time that the batches can be processed is $\underset{j\in J_2}{\min }\left\{r_j\right\}$. Thus, a possible lower bound is ${\displaystyle [{{\displaystyle \sum }}_{f\in F}{\displaystyle \left[\frac{{{\displaystyle \sum }}_{j\in J_2^f}\left\{s_j\right\} }{m_2\times {\mathcal{C}}_2}\right]}\times \underset{m\in M_2}{\min }{p}_{jm}]}+\underset{j\in J_2}{\min }\left\{r_j\right\}$. The equation of the lower bound is given as follows.

The $LB$ can be obtained by computing $q+1$ lower bounds:

$$LB=\max \left\{L{B}_0, L{B}_1,\dots ,L{B}_q\right\}$$

(14)

where

$$L{B}_0=\underset{j\in J}{\max }\left\{r_j+\underset{m\in M}{\min }\left\{p_{jm}\right\}\right\}$$

(15)

$$L{B}_1={\displaystyle \left[{{\displaystyle \sum }}_{f\in F}{\displaystyle \left[\frac{{{\displaystyle \sum }}_{j\in J_q^f}\left\{s_j\right\}\times \underset{m\in M_q}{\min }{p}_{jm} }{m_q\times {\mathcal{C}}_q}\right]}\right]}+\underset{j\in J_q}{\min }\left\{r_j\right\}$$

(16)

$$L{B}_2={\displaystyle \left[{{\displaystyle \sum }}_{f\in F}{\displaystyle \left[\frac{{{\displaystyle \sum }}_{j\in J_{q-1}^f{\displaystyle \cup }{J}_q^f}\left\{s_j\right\}\times \underset{m\in M_{q-1}{\displaystyle \cup }{M}_q}{\min }{p}_{jm}}{m_q\times {\mathcal{C}}_q+m_{q-1}\times {\mathcal{C}}_{q-1}}\right]}\right]}+\underset{j\in J_{q-1}{\displaystyle \cup }{J}_q}{\min }\left\{r_j\right\}$$

(17)

$$\dots ,L{B}_q={\displaystyle \left[{{\displaystyle \sum }}_{f\in F}{\displaystyle \left[\frac{{{\displaystyle \sum }}_{j\in J^f}\left\{s_j\times \underset{m\in M}{\min }{p}_{jm}\right\} }{m_1\times {\mathcal{C}}_1+m_2\times {\mathcal{C}}_2+\dots +m_q\times {\mathcal{C}}_q}\right]}\right]}+\underset{j\in J}{\min }\left\{r_j\right\}$$

(18)

3. Hybrid Large Neighborhood Search Algorithm

The generality of MIP methods is limited to solving small-scale instances, and heuristic methods are usually used to solve large-scale problems more efficiently. As such, this study presents a hybrid large neighborhood search (HLNS), a heuristic method, to solve the UPBPMIJF. The LNS framework has shown excellent results in discrete/combinatorial optimization problems [31,32], which shows powerful global searching ability due to a large neighborhood reconstruction mechanism. This study adopts the LNS framework and improves its performance by incorporating tabu search and local search strategies according to the characteristics of the UPBPMIJF.

In order to explain the search process of the HLNS intuitively, a small-scale instance is presented in Figure 1. There are eight jobs and two machines. Figure 1a shows family $f$ of job $j$. After obtaining the initial solution, the destroy operator is applied to remove some jobs from the initial solution. In the example, $j_1$ and $j_8$ are removed, as shown in Figure 1b. Then, the removed jobs are reinserted into the existing batches or a new batch to obtain a new solution. Here, $j_1$ is inserted into a new batch and $j_8$ is inserted into an existing batch, as shown in Figure 1c. After a pre-defined number of iterations, if a better solution cannot be obtained, a local search algorithm is applied to the solution to swap the positions of two jobs. As shown in Figure 1d, $j_1$ and $j_2$ swap the positions trying to obtain a maybe better solution.

This section presents the proposed hybrid large neighborhood search (HLNS) method for solving the UPBPMIJF. In particular, a dynamic solution structure of UPBPMIJF is proposed, which contains the job-to-machine assignment information of each parallel batch. By exploiting the solution structure, the problem decomposition can be avoided; therefore, the proposed HLNS can optimize batch formation and batch scheduling simultaneously. We define a solution structure $S$ as follows:

$$S=\left[\begin{array}{cccc}{J}_1 \left(1\right)& J_1\left(2\right)& \cdots & J_1\left(\left|B_1\right|\right)\\ J_2\left(1\right)& J_2\left(2\right)& \cdots & J_2\left(\left|B_2\right|\right)\\ ⋮& ⋮& \ddots & ⋮\\ J_{\left|M\right|}\left(1\right)& J_{\left|M\right|}\left(2\right)& \cdots & J_{\left|M\right|}\left(\left|B_{\left|M\right|}\right|\right)\end{array}\right]$$

(19)

We use $M$ to represent the set of machines and $\left|M\right|$ to represent the number of machines. $B_m$ denotes the set of batches that are assigned to machine $m$, and $\left|B_m\right|$ the number of batches. Term $J_m\left(b\right)$, ($m\in M$, $b\in B_m$) represents the subset of jobs assigned to batch $b$ (i.e., $J_m\left(b\right)=\left\{j|j\in J, x_{jb}=1,y_{bm}=1\right\}$). When the solution structure in (19) is determined, each batch’s starting time and processing time can be easily determined, and thus the objective value of the solution can be obtained accordingly. Based on this, we can destroy and repair the solution structure and determine the quality of the scheduling scheme by evaluating the solution structure.

The proposed HLNS seeks the optimal solution by manipulating the solution structure. At each iteration, $d$ jobs will be removed by a tabu-based removal operator, which will be reinserted into the solution by a repair operator. At every $i_{\mathrm{t}}$ iteration, the quality of the solution will be checked, and if the best solution is not improved during the past $i_{\mathrm{t}}$ iterations, a local search algorithm will be applied to the current solution. The framework of HLNS is depicted in Algorithm 1. The algorithm starts from an initial solution and searches for a better solution through the destroy-and-repair operations iteratively. In each iteration, the reconstructed solution is examined together with the original solution by an acceptance criterion extracted from simulated annealing ($T$ is temperature, $\alpha$ is cooling rate), and the accepted solution will be preserved for the next iteration. The process will not stop until a predefined termination condition is met.

Algorithm 1: Hybrid large neighborhood search for the UPBPMIJF

Require: A feasible initial solution $x_0$ 1: Set $\overline{x}=x_0,$ $x^{*}=x_0, T=T_0$. Initialize the tabu list 2: while stopping criteria not met do 3:    $\widehat{x}=$ Tabu-based Tardiness-related removal ($\overline{x}$) 4:     $x=$ Greedy insertion ($\widehat{x}$) 5:        if local search criteria met do 6:                   $x^{\prime }=$ Local search ($x$) 7:                   $x=x^{\prime }$ 8:        end if 9:        if $O_b\left(x\right)<O_b\left(\overline{x}\right)$ then //$O_b\left(x\right)$ denotes the objective value of solution $x$ 10:                   $\overline{x}=x$; //update the current solution 11:                    if $O_b\left(x\right)<O_b\left( x^{*}\right)$then 12:                                $x^{*}=x$; //update the best solution 13:                   end if 14:    else 15:                    Add the removed jobs to the tabu list with a certain probability $p_t$ 16:                    if $random\left(0, 1\right)<e^{\frac{{\left(O\right)}_b\left(\overline{x}\right)-O_b\left(x\right)}{T}}$ 17:                                $\overline{x}=x$; //a worse solution is accepted 18:                    end if 19:    end if 20:       $T=\alpha T_0$ 21: end while

3.1. Initialization

In this work, the initial solution is constructed by a greedy algorithm (called H3_FF) proposed in [27] with some adjustments. The procedure for obtaining an initial solution structure is listed as follows:

Step 1: Sort the jobs in ascending order of their ready times to get list $\mathrm{L}$;

Step 2: Assign the first job of list $\mathrm{L}$ to the best insertion position with the smallest increment of objective value. Then remove the job from list $\mathrm{L}$;

Step 3: Repeat Step 2, an initial solution is obtained until list $\mathrm{L}$ is empty.

3.2. Destroy and Repair Operators

The core part of the HLNS is the destruction and reconstruction operations, which directly determine the search efficiency. At each iteration, $d$ jobs are removed from the current solution $S$ by an exclusively designed tabu-based tardiness-related removal operator and a partial solution $S_p$ is obtained, and these $d$ jobs will be added back to the $S_p$ according to a certain rule by a greedy insertion operator. The details of the key mechanisms are further discussed in the following.

3.2.1. Tabu-Based Tardiness-Related Removal Operator

The tardiness-related removal operator was first proposed by Shaw [26] for vehicle routing problems, which removes similar customer orders according to evaluation criteria. In this paper, we take the tardiness of jobs as a metric of relatedness. The tardiness of jobs is defined as $T_i=\left|c_i-r_i\right|$, where $c_i$ represents the completion time of job $i$, and $r_i$ represents the ready time of job $i$. Then, the relatedness metric $R\left(i,j\right)$ is computed by Formula (20). A smaller the similarity value indicates higher similarity of the two jobs.

$$R\left(i,j\right)=\left|T_i-T_j\right|$$

(20)

The first job $i$ to be removed is randomly chosen, and other jobs will be selected according to the similarity to the randomly chosen job. To enhance the efficiency and avoid short-term repetition of the search, a tabu-based search strategy is incorporated into the tardiness-related removal operator. Specifically, if a worse solution is produced, the removed jobs are added to a tabu list with a predefined probability $p_{t }$ and prohibited from being removed for $\theta$ iterations. The procedure of tabu-based worst removal is described in Algorithm 2.

Algorithm 2: Tabu-based Tardiness-related removal

Require: Current solution $S$, destruction level $d$ and tabu list 1: Remove a random job $i$ that are not in the tabu list from $S$, set $R_j=\left\{i\right\}$//$R_j$ represents the set of removed jobs 2: While $\left|R_j\right|<d$ do 3:          Remove job $j=argmi{n}_{j\in J-R_j} R\left(i, j\right)$ from $S$ that is not in the tabu list 4:          $R_j=R_j{\displaystyle \cup }\left\{j\right\}$ 5: end while

3.2.2. Greedy Insertion

The insertion operator needs to make two decisions for reinserting the removed jobs: (1) the insertion position of the removed jobs; (2) the insertion order of the removed jobs. Each job $j$, $j\in R_j$ can not only be inserted into the existing batches but can also be inserted into the $S_p$ as a newly formed batch. The implementation of greedy insertion concerning the UPBPMIJF is described in the following steps:

Step 1: For the first job in list $R_j$ and the corresponding alternative insertion position, examine whether the job can be inserted into the position without violating the capacity. The job will be inserted into the best position with minimal makespan increment. Then the job is removed from list $R_j$;

Step 2: Repeat Step 1 until the list $R_j$ is empty.

In each iteration, the removed job is attempted to be inserted into every feasible position (i.e., the existing batches and newly formed batches), and the objective increment is calculated as long as the batch size does not exceed the machine capacity. It is worth mentioning that the newly formed batch is inserted into the appropriate position on the machine so that the batches still satisfy the ascending order of their ready times so as to reduce repeated computation. Each job has multiple feasible positions to insert, and among these positions, the best insertion position (with minimal makespan increment) is kept for the next iteration.

3.3. Local Search Procedure

Algorithms based on local search are used to solve various combinatorial optimization problems and work well [33]. In particular, when no better solution is obtained after each $i_{\mathrm{t}}$ iteration, local search (LS) is applied to the newly generated solution after the destroy-and-repair phases to avoid falling into local optimality. The LS is in view of swapping two randomly selected jobs in the current solution as long as the two jobs meet the exchange requirement (i.e., the machine capacity cannot be violated, and the two jobs have to be in the same family). If a better solution is obtained after the local search, the newly generated solution is preserved as the current solution, and the iteration counter is reset to 0; otherwise, the iteration counter will increment by 1. The local search does not evaluate the entire exchange neighborhood, and it will stop if the iteration counter reaches $n$ ($n$ is the number of jobs). The overview of the LS procedure is presented in Algorithm 3.

Algorithm 3: Local search

Require: Current solution $x$ 1: Set iteration counter = 0; 2: While iteration counter $<n$ do 3:          Select a random job family $f$ 4:          Select two random jobs $j_1$ and $j_2$ from different batches of family $f$ 5:          if exchange condition met do \\ the corresponding machines’ capacities cannot be violated 6:                   $x^{\prime }=$ exchange jobs $j_1$ and $j_2$ in solution $x$; 7:                   if $O_b\left(x^{\prime }\right)<O_b\left(x\right)$ then 8:                         $x=x^{\prime }$; 9:                            iteration counter = 0; 10:                   else 11:                            iteration counter = iteration counter + 1; 12:                   end if 13:          end if 14: end while 15: Return $x$;

3.4. Acceptance Criterion

After searching for a better solution, an acceptance criterion is applied to determine whether the new solution $S_{new}$ is accepted as the current solution $S$ for the next iteration. In this algorithm, a simulated annealing acceptance criterion, which accepts a worse solution with the probability $\exp \left(\left(O_b \left(S\right)-O_b \left(S_{new}\right)\right)/T\right)$ is used. The parameter temperature $T$ influences the acceptance probability, which starts at $T_0$ and decreases in every iteration at a cooling rate $\alpha$.

3.5. Stopping Conditions

In this algorithm, two stopping conditions are used to force the termination of the proposed HLNS: (i) When the makespan value of the best solution achieved by HLNS equals the lower bound or the optimal makespan value obtained by a commercial optimization solver; (ii) when the number of iterations reaches a pre-specified number. If either of these two stopping conditions is met, the HLNS algorithm stops.

4. Numerical Experiments

In this section, we start by describing the design of the experiments. Then we explain how we determine the parameters of the proposed HLNS. The computational results are recorded and analyzed in Section 4.3 and Section 4.4, and the advantages of the proposed tabu and local search strategies are discussed at the end of this section.

4.1. Design of Experiments

Two sets of instances are used to validate the efficacy and efficiency of the proposed HLNS heuristic. The jobs in Set 1 are compatible, while those in Set 2 are incompatible. The characteristics of the two datasets are described as follows.

Set 1. In [27], the authors provided the benchmark instances of the scheduling problem under unrelated parallel BPMs context with unequal job sizes, dynamic job arrivals, and compatible job families, which can be found at http://www.dpi.ufv.br/projetos/scheduling/upbpm.htm (accessed on 1 April 2022). It provides 10 sub-sets of instances, and the instances in each sub-set obey the same random distribution. This paper only selects the instances from the fifth sub-set to verify the effectiveness of the proposed algorithm, resulting in 72 small-scale instances and 108 large-scale instances. We introduce the generation rules of the instances briefly. Each instance of Set 1 has six different characteristics, namely the number of jobs $\left(n\right)$, number of machines $\left(m\right)$, job size $\left(s_j\right)$, job ready time $\left(r_j\right)$, machine capacities $\left({\mathcal{C}}_m\right)$, and processing time $\left(p_{jm}\right)$. The processing times $p_{jm}$ are uniformly distributed in $k$ disjoint but interrelated intervals, $I_i=\left[a_i,b_i\right]$, where $a_1=10; a_i=b_{i-1}+10,i\in \left\{2,\dots ,k\right\}; b_i=a_i+20, i\in \left\{1,\dots ,k\right\}.$ Job ready times $r_j$ are generated based on the processing time, which are uniformly distributed in the range $U\left[1,\mu P\right]$, where $P=\left({{\displaystyle \sum }}_{j\in J}{{\displaystyle \sum }}_{m\in M}{p}_{jm}/\left|M\right|\right) ,\mu \in \left\{0.05, 0.1, 0.3\right\}$. Job sizes ($s_j$) are generated according to uniform distribution and the capacity of the machine $\left({\mathcal{C}}_m\right)$ is randomly generated based on the number of machines $\left(m\right)$. The factor and characteristics of the instances provided in the literature are shown in

Table 1. Experimental design used to generate the random instances.

Factor	Levels
$n$	20, 30, 40, 50 (small-scale instances); 100, 150, 200, 250 (large-scale instances)
$m\left(n\right)$	2, 3 ($n\in \left\{20,30,40,50\right\}$); 3, 4, 5($n\in \{$100,150,200,250})
${\mathcal{C}}_m\left(m\right)$	${\mathcal{C}}_m\in \left\{30,50\right\}$($m=2$);${\mathcal{C}}_m\in \left\{30,40,50\right\}\left(m=3\right)$; ${\mathcal{C}}_m\in \left\{20,30,40,50\right\} \left(m=4\right);$ ${\mathcal{C}}_m\in \left\{20,30,40,50,60\right\}\left(m=5\right)$
$s_j$	$U\left[1,15\right], U\left[15,50\right], U\left[1,50\right]$ (represented by $S_1, S_2, S_3$, respectively)
$r_j$	$U\left[1,0.05P\right],U\left[1,0.1P\right],U\left[1,0.3P\right]$ (represented by $R_1, R_2, R_3$, respectively)

.

Set 2. The instances in Set 2 are adopted from Set 1, and we randomly generated the attributes of job families. The jobs of small-scale instances are divided into three families, whereas the jobs of large-scale instances are divided into four families. Set 2 also contains 72 small-scale instances and 108 large-scale instances. Notably, the instances in Set 2 (with incompatible job families) are generalized cases of the instances in Set 1 (with compatible job families), except that the jobs in Set 2 are divided into multiple job families according to the scale; the rest of the parameters (i.e., $s_j$, $r_j$,${\mathcal{C}}_m$, $p_{jm}$) are the same as those in Set 1.

4.2. Parameter Settings

All experiments are coded in Python 3.8 and run on a PC with 3.0GHz with 8 GB memory running 64-bit Windows 10 and a 64-bit version of Gurobi 9.1.2 under an academic license. The MIP model was implemented in Gurobi with a time limit of 1 h (3600 s).

For the HLNS, we test different parameter settings on eight randomly chosen instances in Set 2, one for each number of jobs. Each parameter is set to a value in a certain range. Through experiments, we found that some parameters are not sensitive to the performance of the proposed algorithm, which has been recorded in

Table 2. List of parameters.

Parameter	Meaning	Value
$\theta$	Number of iterations forbidden to remove	20
$p_t$	Probability of removals resulting in worst solutions being added to the tabu list	0.5
$T_0$	Initial temperature	0.1 $O_b\left(S_{ini}\right)$
$\alpha$	Cooling rate	0.995
$i_{\mathrm{t}}$	Number of iterations to decide whether to conduct a local search	100

, where $O_b\left(S_{ini}\right)$ represents the objective value of the initial solution. Three parameters contribute more to the performance, namely the number of iterations ${\mathsf{\Pi }}_i$, the number of jobs to be removed $d$, and the length of the tabu list $l_t$. Additionally, we need to adjust the above three parameters according to the scales of instances. We conduct a factorial experiment with the ${\mathsf{\Pi }}_i$, $d$ and $l_t$. Each parameter is tested at a certain range, and we compare the solution quality under the different parameter settings. It is found that when $d$ is uniformly distributed in $U\left[5,10\right]$,$l_t$ is set to $0.5\times n$ and ${\mathsf{\Pi }}_i$ is set to 10,000 for small-scale instances, and $d$ is uniformly distributed in $U\left[10,20\right]$,$l_t$ is set to $0.7\times n$ and ${\mathsf{\Pi }}_i$ is set to 20,000 for large-scale instances in our work, providing a good trade-off between solution quality and computational time.

4.3. Comparison between Gurobi, Lower Bound, and HLNS Methods

In the first experiments, the proposed HLNS is compared with the Gurobi solver and the lower bound through the instances in Set 2 (with incompatible job families). The experiments with the MIP model (see Section 3.1) were performed with the commercial solver Gurobi, and the computational time to solve each instance was limited to 3600 s. However, large-scale instances can seldom be solved to a feasible solution within 3600 s. The results from the HLNS of large-scale instances with that of the lower bound are compared. In particular, the HLNS method was executed 10 times for each instance to overcome the stochastic differences in the results.

In the comparative analysis, we record the best and the average solution among 10 trials for each instance. The results are grouped by the number of machines ($m$), the number of jobs ($n$), and the combination of job sizes ($S_i$) and job ready times ($R_i$), $i=1,2,3$. $S_1$, $S_2$, $S_3$ represent the instances with small, large, and mixed job sizes. $R_1$, $R_2$, $R_3$ denote the problems with short, medium, and long ready times.

Table 3. Results for instances with $n=20$ and $n=30$.

		$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=20$					$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=30$
Machine		Gurobi		HLNS			Gurobi		HLNS
$\mathit{m}$		Value	Gap (%)	Best	Avg	SD	Value	Gap (%)	Best	Avg	SD
2	$S_1{R}_1$	113	39.23	113	113	0.00	133	54.14	133	133.2	0.60
	$S_1{R}_2$	132	3.79	132	132.1	0.30	166	38.55	157	158.4	2.06
	$S_1{R}_3$	226	0.00	226	226	0.00	354	0.00	354	354	0.00
	$S_2{R}_1$	475	0.00	475	475	0.00	608	0.82	608	608	0.00
	$S_2{R}_2$	418	0.00	418	418	0.00	575	0.00	575	575	0.00
	$S_2{R}_3$	386	0.00	386	386	0.00	588	0.00	588	588	0.00
	$S_3{R}_1$	253	3.95	253	253	0.00	523	0.00	523	523	0.00
	$S_3{R}_2$	278	0.00	278	278	0.00	434	6.01	434	434	0.00
	$S_3{R}_3$	307	23.61	307	307	0.00	387	15.76	387	387	0.00
3	$S_1{R}_1$	101	7.00	101	101	0.00	114	0.00	114	114	0.00
	$S_1{R}_2$	135	0.00	135	135	0.00	193	0.00	193	193.1	0.30
	$S_1{R}_3$	319	0.00	319	319	0.00	431	0.00	431	431	0.00
	$S_2{R}_1$	267	41.57	267	268.1	2.47	477	0.00	477	477	0.00
	$S_2{R}_2$	308	5.84	308	308	0.00	384	7.16	384	384	0.00
	$S_2{R}_3$	291	0.00	291	291	0.00	624	0.80	624	624	0.00
	$S_3{R}_1$	524	0.00	524	524	0.00	252	37.70	252	253.1	3.30
	$S_3{R}_2$	272	0.00	272	272	0.00	366	18.03	365	366	0.89
	$S_3{R}_3$	322	0.00	322	322	0.00	533	0.00	533	533	0.00

Note: The bold numbers denote that the problem is solved optimally or reaches the best-known solution by the corresponding algorithm.

and

Table 4. Results for instances with $n=40$ and $n=50$.

		$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=40$					$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=50$
Machine		Gurobi		HLNS			Gurobi		HLNS
$\mathit{m}$		Value	Gap (%)	Best	Avg	SD	Value	Gap (%)	Best	Avg	SD
2	$z^{\prime }$	151	94.70	151	153.9	4.44	198	100.00	190	196.7	3.03
	$S_1{R}_2$	192	66.67	192	196	3.90	240	100.00	240	241.5	0.67
	$S_1{R}_3$	454	0.00	454	454	0.00	543	0.00	543	543	0.00
	$S_2{R}_1$	624	56.55	624	624	0.00	1097	87.97	1097	1097	0.00
	$S_2{R}_2$	933	0.00	933	933	0.00	1017	77.19	1017	1017	0.00
	$S_2{R}_3$	737	0.00	737	737	0.00	1030	44.47	1030	1030	0.00
	$S_3{R}_1$	778	2.60	778	778	0.00	590	28.51	590	590	0.00
	$S_3{R}_2$	514	0.59	514	514	0.00	827	13.02	827	827	0.00
	$S_3{R}_3$	581	10.60	581	581	0.00	728	23.49	728	728	0.00
3	$S_1{R}_1$	148	80.27	148	148.5	1.50	167	17.96	167	168.2	2.40
	$S_1{R}_2$	250	14.80	250	250.3	0.90	273	6.59	273	274.2	0.98
	$S_1{R}_3$	607	0.00	607	607	0.00	734	0.00	734	734	0.00
	$S_2{R}_1$	466	16.34	464	465.7	2.19	1038	0.00	1038	1038	0.00
	$S_2{R}_2$	521	10.75	521	522.4	0.92	701	5.99	701	701	0.00
	$S_2{R}_3$	712	8.85	706	707.5	1.69	841	9.04	841	841	0.00
	$S_3{R}_1$	397	33.75	397	397.3	0.90	586	4.44	586	586	0.00
	$S_3{R}_2$	550	5.64	550	550	0.00	628	2.87	628	638.7	4.88
	$S_3{R}_3$	612	0.00	612	612	0.00	822	3.89	812	813.6	2.50

Note: The bold numbers denote that the problem is solved optimally or reaches the best-known solution by the corresponding algorithm.

represent the computational results for instances with 20–30 jobs and 40–50 jobs.

For the Gurobi solver, the objective value of the obtained solution within 3600 s and the Gap (%) are recorded. The Gap returned by Gurobi is computed as Gap (%) $=\left|O_{lb}-O_b \left(S\right)\right|/\left(O_b \left(S\right) \right)\times 100$, where $O_{lb}$ is the relaxed lower bound of the MIP model, and $O_b\left(S\right)$ is the objective of the obtained solution. Among the 72 small-scale instances, 27 instances are solved optimally within 3600s by Gurobi. However, When the scale (the number of jobs) of instances rises, the performance of Gurobi declines significantly with respect to solution quality and computational time, and even in some instances, Gaps obtained by Gurobi are 100%. As we can see, for all the instances that can be solved optimally by Gurobi, HLNS can also yield optimal solutions. Meanwhile, for those instances that cannot be solved optimally by Gurobi, HLNS can find better solutions than Gurobi with less computational burden. In addition, the standard deviation (SD) of the makespan value obtained by HLNS is calculated in 10 trials for each instance, and it can be observed that over 70% (51 out of 72) SDs are calculated to be 0, and the average SD is less than 0.60.

In the experiment, large-scale instances can hardly be solved by Gurobi to a feasible solution. Therefore, we only list the results of lower bound and HLNS for large-scale instances.

Table 5. Results for instances with $n=100$ and $n=150$.

		$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=100$				$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=150$
Machine		Lower Bound	HLNS			Lower Bound	HLNS
$\mathit{m}$			Best	Avg	SD		Best	Avg	SD
3	$S_1{R}_1$	272	332	337.1	3.21	399	440	443.6	3.95
	$S_1{R}_2$	526	564	564	0.00	770	799	799.4	1.20
	$S_1{R}_3$	1503	1503	1503	0.00	2289	2289	2289	0.00
	$S_2{R}_1$	1480	1628	1628	0.00	1780	2016	2025	3.63
	$S_2{R}_2$	1547	1723	1723	0.00	2163	2410	2410	0.00
	$S_2{R}_3$	1532	1918	1918	0.00	2269	2512	2512	0.00
	$S_3{R}_1$	808	990	997.6	4.41	1151	1429	1442.2	8.13
	$S_3{R}_2$	1403	1566	1566	0.00	1207	1475	1487.6	5.18
	$S_3{R}_3$	1528	1581	1581	0.00	2289	2352	2353.3	1.95
4	$S_1{R}_1$	346	361	363	4.10	506	513	515.3	6.90
	$S_1{R}_2$	662	662	662	0.00	994	996	996.6	1.80
	$S_1{R}_3$	1935	1940	1940	0.00	2930	2930	2930	0.00
	$S_2{R}_1$	1737	1921	1921	0.00	2853	3225	3225	0.00
	$S_2{R}_2$	1444	1545	1551.6	3.07	2836	3173	3173	0.00
	$S_2{R}_3$	1946	2180	2180	0.00	2937	3094	3094	0.00
	$S_3{R}_1$	891	1025	1032.4	6.23	2117	2335	2335	0.00
	$S_3{R}_2$	1212	1297	1297	0.00	2074	2318	2318	0.00
	$S_3{R}_3$	1953	2026	2026	0.00	2928	3088	3088	0.00
5	$S_1{R}_1$	415	442	442	0.00	623	643	644.3	0.78
	$S_1{R}_2$	797	800	800	0.00	1221	1221	1221	0.00
	$S_1{R}_3$	2389	2389	2389	0.00	3610	3610	3610	0.00
	$S_2{R}_1$	673	1052	1064	6.05	896	1408	1424.7	9.45
	$S_2{R}_2$	823	963	968.7	6.00	1220	1348	1371.2	17.77
	$S_2{R}_3$	2422	2535	2535	0.00	3628	3643	3643	0.00
	$S_3{R}_1$	418	707	724.9	11.53	650	1197	1217	8.89
	$S_3{R}_2$	805	973	991	13.48	1233	1278	1291	8.22
	$S_3{R}_3$	2430	2430	2430	0.00	3566	3606	3606	0.00

and

Table 6. Results for instances with $n=200$ and $n=250$.

		$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=200$				$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=250$
Machine		Lower Bound	HLNS			Lower Bound	HLNS
$\mathit{m}$			Best	Avg	SD		Best	Avg	SD
3	$S_1{R}_1$	522	591	595.3	2.28	655	688	702.6	12.40
	$S_1{R}_2$	1024	1053	1053	0.00	1256	1270	1270	0.00
	$S_1{R}_3$	2998	2998	2998	0.00	3779	3779	3779	0.00
	$S_2{R}_1$	2392	2734	2737.8	2.27	3587	3999	4001.1	1.64
	$S_2{R}_2$	1972	2410	2425.1	9.13	3133	3564	3575.5	6.14
	$S_2{R}_3$	3022	3236	3251.3	12.17	3791	4085	4104.5	8.49
	$S_3{R}_1$	1825	2130	2147.3	10.54	2347	2633	2641.1	5.15
	$S_3{R}_2$	2019	2340	2346.2	4.14	2422	2774	2784.3	3.77
	$S_3{R}_3$	3025	3114	3115.4	0.92	3768	3781	3781	0.00
4	$S_1{R}_1$	680	723	733	4.31	838	873	879.5	4.98
	$S_1{R}_2$	1303	1303	1303	0.00	1647	1647	1647	0.00
	$S_1{R}_3$	3871	3871	3871	0.00	4880	4880	4880	0.00
	$S_2{R}_1$	3303	3616	3616	0.00	3378	3885	3891.6	7.27
	$S_2{R}_2$	4105	4507	4507	0.00	3578	4165	4175.9	5.75
	$S_2{R}_3$	3909	3935	3935	0.00	4812	4812	4812	0.00
	$S_3{R}_1$	2889	3184	3184	0.00	3856	4172	4172	0.00
	$S_3{R}_2$	2695	2955	2958.4	4.22	3403	3730	3730.2	0.60
	$S_3{R}_3$	3875	3970	3972.9	3.08	4866	5031	5031	0.00
5	$S_1{R}_1$	807	819	819	0.00	999	1017	1017	0.00
	$S_1{R}_2$	1615	1619	1619	0.00	2022	2022	2022	0.00
	$S_1{R}_3$	4804	4816	4816	0.00	5981	5981	5981	0.00
	$S_2{R}_1$	1264	2009	2026.3	13.98	1554	2643	2657.1	9.84
	$S_2{R}_2$	1612	1978	1994.2	10.72	2011	2216	2246.3	19.24
	$S_2{R}_3$	4769	4777	4780.1	4.87	6009	6114	6114	0.00
	$S_3{R}_1$	892	1437	1466.4	14.45	1013	1753	1777.5	16.04
	$S_3{R}_2$	1612	1633	1648.3	20.28	2013	2141	2176.6	19.14
	$S_3{R}_3$	4822	4854	4854	0.00	6001	6001	6001	0.00

show the experimental results for 100–150 jobs and 200–250 jobs, respectively. From the presented results, 18 instances reach the lower bound. However, for the rest of the instances, the results obtained by the HLNS are far from the results achieved by the lower bound. It can be concluded that it is not a very tight lower bound of the problem and is used as a termination condition (see Section 3.5). Additionally, we calculate the SDs of the 108 large-scale instances, among which 57 instances’ SDs are 0. The average SD is 3.44, which is quite small compared to the corresponding objective values. Take the largest SD (20.28), for instance; it is just 1.23% of the corresponding average makespan.

Figure 2a shows the average computational time of HLNS for each small-scale (with 20, 30, 40, and 50 jobs), which indicates that the computational time of HLNS is relatively shorter than that of the Gurobi solver. Figure 2b shows the average computational time for each large-scale (with 100, 150, 200, and 250 jobs). We can see that the average computational time of HLNS does not exceed 10 s for small-scale instances and is shorter than 260 s for large-scale instances. To sum up, HLNS shows its advantage in finding optimal or near-optimal solutions stably within a short computing time for instances of Set 2 (with incompatible job families).

4.4. Comparison among CPLEX, 4 Meta-Heuristics, and HLNS

In this subsection, we present the experimental results of the instances in Set 1 (compatible job families), where jobs can be processed together. We compare the results among CPLEX, IG [27], SA [28], GA [29], ACO [30], and HLNS, and the corresponding results from CPLEX and four existing meta-heuristics can be found in http://www.dpi.ufv.br/projetos/scheduling/upbpm.htm (accessed on 1 April 2022).

First, we list the numerical results of small-scale instances.

Table 7. Best results for instances with $n=20$ and $n=30$.

Machine		$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=20$						$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=30$
$\mathit{m}$		CPLEX	HLNS	IG	SA	GA	ACO	CPLEX	HLNS	IG	SA	GA	ACO
2	$S_1{R}_1$	90	90	90	92	97	90	111	110	110	115	119	113
	$S_1{R}_2$	98	98	98	110	98	98	134	134	135	139	139	138
	$S_1{R}_3$	209	209	209	209	209	209	339	339	339	339	339	339
	$S_2{R}_1$	475	475	475	475	475	475	608	608	608	608	608	608
	$S_2{R}_2$	418	418	418	418	418	418	575	575	575	575	575	575
	$S_2{R}_3$	386	386	386	386	386	397	588	588	588	588	588	588
	$S_3{R}_1$	245	245	245	245	245	245	523	523	523	523	523	523
	$S_3{R}_2$	278	278	278	278	278	278	434	434	434	434	434	434
	$S_3{R}_3$	300	300	300	300	307	320	384	384	384	384	389	391
3	$S_1{R}_1$	80	80	80	85	80	94	98	98	98	98	109	98
	$S_1{R}_2$	120	120	120	120	120	120	170	170	170	170	170	170
	$S_1{R}_3$	319	319	319	319	319	319	431	431	431	431	431	431
	$S_2{R}_1$	259	259	259	259	259	259	477	477	477	477	477	499
	$S_2{R}_2$	308	308	308	308	308	316	378	378	378	378	405	395
	$S_2{R}_3$	291	291	291	291	291	306	624	624	624	624	624	624
	$S_3{R}_1$	524	524	524	524	524	524	244	244	244	244	260	245
	$S_3{R}_2$	272	272	272	272	272	342	358	358	358	358	370	370
	$S_3{R}_3$	322	322	322	322	322	335	533	533	533	533	533	542

Note: The bold numbers denote that the problem is solved optimally or reaches the best-known solution by the corresponding algorithm.

and

Table 8. Best results for instances with $n=40$ and $n=50$.

Machine		$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=40$						$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=50$
$\mathit{m}$		CPLEX	HLNS	IG	SA	GA	ACO	CPLEX	HLNS	IG	SA	GA	ACO
2	$S_1{R}_1$	129	129	129	135	146	130	173	152	152	155	176	178
	$S_1{R}_2$	161	161	161	161	164	164	233	212	212	216	220	226
	$S_1{R}_3$	454	454	454	454	454	454	541	541	541	541	541	541
	$S_2{R}_1$	623	623	623	623	626	628	1097	1097	1097	1097	1097	1097
	$S_2{R}_2$	933	933	933	933	933	953	1017	1017	1017	1017	1017	1017
	$S_2{R}_3$	737	737	737	737	737	737	1066	1030	1030	1030	1030	1030
	$S_3{R}_1$	778	778	778	778	778	778	590	590	590	590	604	590
	$S_3{R}_2$	514	514	514	514	514	514	827	827	827	827	827	827
	$S_3{R}_3$	581	581	581	581	581	583	732	728	728	728	728	728
3	$S_1{R}_1$	131	125	125	130	130	130	146	146	146	146	146	148
	$S_1{R}_2$	223	223	223	241	248	223	259	259	259	259	263	263
	$S_1{R}_3$	604	604	604	604	604	604	734	734	734	734	734	734
	$S_2{R}_1$	489	457	457	458	473	473	1038	1038	1038	1038	1038	1038
	$S_2{R}_2$	533	521	521	534	523	564	703	701	701	701	710	761
	$S_2{R}_3$	725	701	701	716	709	733	848	841	841	841	841	841
	$S_3{R}_1$	397	397	397	397	402	416	586	586	586	586	586	591
	$S_3{R}_2$	550	550	550	550	550	550	644	628	632	644	644	670
	$S_3{R}_3$	612	612	612	612	612	612	818	812	812	818	818	829

Note: The bold numbers denote that the problem is solved optimally or reaches the best-known solution by the corresponding algorithm.

record the best solutions in 10 trials of each algorithm for instances with 2030 jobs and 40–50 jobs. Therein, 29 out of 72 instances have reached the optimal solutions by CPLEX, from which 29 (100%), 29 (100%), 26 (89.66%), 27 (93.10%), and 21 (72.41%) optimal solutions are yielded by algorithms HLNS, IG, SA, GA, and ACO, respectively. For 72 small-scale instances, HLNS, IG, SA, GA, and ACO obtained 72, 70, 57, 47, and 39 best-known solutions, respectively. The proposed HLNS method manages to find better solutions than IG for two instances; the average improvement is 0.69%, and the maximum improvement is 0.74%.

The average results of the five meta-heuristics (the proposed HLNS and the other four existing meta-heuristics) over 10 trials are depicted in Figure 3 (the specific results of average solutions in 10 trials will be given in Appendix A). Note that the effect of the number of machines ($m$) is not considered when presenting the average results. For each category in Figure 3 ($S_i{R}_i,i=1,2,3$), the recorded value represents the average value of the categories of different machines (the result is the average result of the same category $S_i{R}_i$ among $m=2$ and $m=3$ for small-scale instances). Figure 3 illustrates distinctly that HLNS achieves better average results over 10 trials than the other four meta-heuristics for almost all instances. In particular, HLNS, IG, SA, GA, and ACO reach 68, 57, 39, 41, and 32 instances with the best average solutions for a total of 72 small-scale instances. Among all instances, the HLNS outperforms IG for 15 instances with better average results, with an average improvement of 1.00%, while IG performs better than the HLNS for only 4 instances, with an average improvement of 0.52%.

For large-scale instances, we must address the comparison of the result generated by the five algorithms HLNS, IG, SA, GA, and ACO.

Table 9. Best results for instances with $n=100$ and $n=150$.

Machine		$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=100$					$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=150$
$\mathit{m}$		HLNS	IG	SA	GA	ACO	HLNS	IG	SA	GA	ACO
3	$S_1{R}_1$	291	303	320	320	311	399	412	428	428	421
	$S_1{R}_2$	537	537	537	537	537	772	772	782	772	772
	$S_1{R}_3$	1503	1503	1503	1503	1503	2289	2289	2289	2289	2289
	$S_2{R}_1$	1628	1628	1639	1628	1653	2015	2016	2030	2051	2070
	$S_2{R}_2$	1723	1723	1723	1723	1776	2410	2410	2410	2410	2440
	$S_2{R}_3$	1918	1918	1918	1918	1932	2512	2512	2512	2540	2562
	$S_3{R}_1$	989	986	1093	1033	1066	1414	1421	1512	1485	1588
	$S_3{R}_2$	1566	1566	1566	1566	1578	1469	1474	1501	1544	1555
	$S_3{R}_3$	1581	1581	1581	1581	1581	2342	2342	2364	2381	2381
4	$S_1{R}_1$	346	346	353	352	352	506	506	511	506	511
	$S_1{R}_2$	662	662	662	662	662	994	994	994	994	994
	$S_1{R}_3$	1935	1935	1935	1935	1935	2930	2930	2930	2930	2930
	$S_2{R}_1$	1921	1921	1941	1921	1931	3225	3225	3225	3225	3348
	$S_2{R}_2$	1552	1552	1599	1565	1664	3173	3173	3173	3173	3213
	$S_2{R}_3$	2180	2180	2180	2180	2207	3094	3094	3094	3094	3102
	$S_3{R}_1$	1016	1030	1050	1049	1100	2335	2335	2357	2377	2387
	$S_3{R}_2$	1297	1297	1297	1320	1422	2318	2318	2318	2318	2411
	$S_3{R}_3$	2026	2026	2026	2047	2026	3088	3088	3088	3088	3171
5	$S_1{R}_1$	415	415	415	416	415	626	626	626	626	626
	$S_1{R}_2$	800	800	800	800	800	1221	1221	1221	1221	1221
	$S_1{R}_3$	2389	2389	2389	2389	2389	3610	3610	3610	3610	3610
	$S_2{R}_1$	1057	1052	1106	1120	1157	1410	1407	1459	1460	1529
	$S_2{R}_2$	956	949	1010	1025	1019	1333	1333	1435	1483	1500
	$S_2{R}_3$	2535	2535	2535	2535	2543	3643	3643	3643	3643	3643
	$S_3{R}_1$	693	701	763	767	738	1197	1213	1290	1355	1375
	$S_3{R}_2$	963	963	1043	1063	1050	1269	1256	1256	1297	1299
	$S_3{R}_3$	2430	2430	2430	2430	2430	3606	3606	3606	3606	3606

Note: The bold numbers denote that the problem is solved optimally or reaches the best-known solution by the corresponding algorithm.

and

Table 10. Best results for instances with $n=200$ and $n=250$.

Machine		$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=200$					$\mathbf{Number} \mathbf{of} \mathbf{Jobs} \mathit{n}=250$
$\mathit{m}$		HLNS	IG	SA	GA	ACO	HLNS	IG	SA	GA	ACO
3	$S_1{R}_1$	542	565	592	566	594	659	686	681	696	687
	$S_1{R}_2$	1024	1024	1024	1024	1024	1265	1265	1266	1265	1265
	$S_1{R}_3$	2998	2998	2998	2998	2998	3779	3779	3779	3779	3779
	$S_2{R}_1$	2720	2723	2783	2785	2808	3994	3999	4026	4012	4077
	$S_2{R}_2$	2404	2407	2431	2516	2568	3570	3571	3606	3659	3679
	$S_2{R}_3$	3236	3224	3247	3285	3332	4090	4073	4079	4096	4113
	$S_3{R}_1$	2121	2135	2222	2224	2247	2621	2647	2716	2711	2747
	$S_3{R}_2$	2333	2335	2366	2386	2435	2770	2785	2825	2864	2915
	$S_3{R}_3$	3104	3104	3116	3116	3142	3781	3781	3781	3781	3781
4	$S_1{R}_1$	698	701	703	714	706	849	850	851	857	849
	$S_1{R}_2$	1303	1303	1303	1303	1303	1647	1647	1647	1647	1647
	$S_1{R}_3$	3871	3871	3871	3871	3871	4880	4880	4880	4880	4880
	$S_2{R}_1$	3616	3616	3616	3616	3684	3884	3887	3915	3931	3981
	$S_2{R}_2$	4507	4507	4507	4507	4507	4169	4170	4179	4199	4374
	$S_2{R}_3$	3935	3935	3935	3935	3935	4812	4812	4812	4824	4874
	$S_3{R}_1$	3184	3184	3184	3184	3265	4172	4172	4172	4172	4172
	$S_3{R}_2$	2955	2955	2968	2990	3078	3730	3730	3761	3761	3832
	$S_3{R}_3$	3970	3970	3970	3991	3970	5031	5031	5031	5031	5031
5	$S_1{R}_1$	810	810	810	811	810	1008	1008	1008	1008	1008
	$S_1{R}_2$	1615	1615	1615	1615	1615	2022	2022	2022	2022	2022
	$S_1{R}_3$	4804	4804	4804	4804	4804	5981	5981	5981	5981	5981
	$S_2{R}_1$	1982	1991	2099	2174	2230	2627	2645	2686	2910	3039
	$S_2{R}_2$	1970	1966	2044	2167	2231	2210	2226	2353	2572	2488
	$S_2{R}_3$	4775	4775	4777	4819	4801	6114	6114	6114	6141	6114
	$S_3{R}_1$	1424	1447	1609	1748	1671	1735	1767	2004	2047	2010
	$S_3{R}_2$	1633	1633	1633	1693	1700	2113	2150	2282	2355	2331
	$S_3{R}_3$	4854	4854	4854	4854	4854	6001	6001	6001	6001	6001

Note: The bold numbers denote that the problem is solved optimally or reaches the best-known solution by the corresponding algorithm.

present the best solutions in 10 trials for instances with 100–150 jobs and 200–250 jobs. Concerning 108 large-scale instances, HLNS, IG, SA, GA, and ACO reach 100, 80, 58, 53, and 43 instances with best-known solutions. In particular, HLNS outperforms IG, SA, GA, and ACO for 28, 49, 55, and 65 instances, and IG outperforms HLNS only for eight instances. On average, the improvement of the HLNS compared to IG is 0.28%, and as the scale of the problem increases, the improvement is more significant.

As for the average results among 10 trials for large-scale instances (see Figure 4), HLNS, IG, SA, GA, and ACO yield 96, 69, 51, 40, and 38 instances, with the best average solutions for a total of 144 instances. Similarly, the influence of the number of machines ($m$) is not reflected in Figure 4, and the result recorded is the average result among the same category $S_i{R}_i$ of $m=3$,$m=4$, and $m=5$. The specific results are given in Appendix A. In particular, the proposed HLNS outperforms IG for 39 instances, and IG outperforms HLNS for 12 instances. The improvement of HLNS compared to IG is 0.89% on average. In conclusion, HLNS outperforms the other four algorithms in solving unrelated parallel BPMs with compatible job families and has a higher probability of obtaining better solutions.

In addition, we have calculated the computational time and SD of HLNS for each instance and present the average value of each scale, as shown in Figure 5. This demonstrates that the average computational time for small-scale instances is less than 10 s, and the average computational time for large-scale instances is less than 270 s. The SD is quite small compared to the value of the makespan. In particular, in 59 out of 72 small-scale instances and 63 out of 108 large-scale instances, SD is equal to 0. Since the specific makespan value obtained by four other meta-heuristics is not given in the literature, the SD cannot be obtained for comparison.

4.5. Discussions of the TALNS

As mentioned earlier, the instances in Set 1 (compatible job families) are special cases of the instances in Set 2 (incompatible job families), where all jobs are in the same family and can be processed together. After carefully observing the results of the two subsections above, there is no significant difference between the average computational time for each scale of the two sets of instances. However, the SDs of incompatible instances (Set 2) are generally larger than the SDs of compatible instances (Set 1). Indeed, 54 out of 180 instances in Set 2 attest to larger SDs than those with compatible job families, while 36 out of 180 instances in Set 1 result in greater SDs than Set 2. The reason for this phenomenon is that the scheduling problem that considers incompatible job families tend to be more difficult to solve, whereby the HLNS has reduced solution stability than solving compatible instances.

In addition, in order to analyze the effectiveness of the proposed tabu-removal operator and local search mechanism, we compare the performances of pure LNS, tabu-based LNS (TLNS), and HLNS under the same parameter settings and stopping conditions.

Table 11. Comparison results of LNS, TLNS, and HLNS.

Job		BestSolution			AvgSolution			SD			AvgTime
$\mathit{n}$		LNS	TLNS	HLNS	LNS	TLNS	HLNS	LNS	TLNS	HLNS	LNS	TLNS	HLNS
20	$S_1{R}_1$	107.0	107.0	107.0	107.7	107.0	107.0	0.9	0.0	0.0	2.7	2.9	3.1
	$S_1{R}_2$	133.5	133.5	133.5	133.5	133.6	133.6	0.0	0.2	0.2	1.1	1.2	1.3
	$S_1{R}_3$	272.5	272.5	272.5	272.5	272.5	272.5	0.0	0.0	0.0	0.0	0.0	0.0
	$S_2{R}_1$	371.0	371.0	371.0	372.8	372.2	371.6	1.9	1.6	1.2	1.8	1.9	2.1
	$S_2{R}_2$	363.0	363.0	363.0	363.0	363.0	363.0	0.0	0.0	0.0	1.9	1.9	2.1
	$S_2{R}_3$	338.5	338.5	338.5	338.5	338.5	338.5	0.0	0.0	0.0	0.0	0.0	0.0
	$S_3{R}_1$	388.5	388.5	388.5	388.5	388.5	388.5	0.0	0.0	0.0	1.7	1.8	2.0
	$S_3{R}_2$	275.0	275.0	275.0	275.0	275.0	275.0	0.0	0.0	0.0	0.0	0.0	0.0
	$S_3{R}_3$	314.5	314.5	314.5	314.6	314.5	314.5	0.2	0.0	0.0	1.7	1.9	2.0
250	$S_1{R}_1$	861.0	857.0	859.3	866.5	863.7	866.4	5.5	4.8	5.8	78.8	82.0	128.5
	$S_1{R}_2$	1646.3	1646.3	1646.3	1646.3	1646.3	1646.3	0.0	0.0	0.0	25.5	27.4	41.4
	$S_1{R}_3$	4880.0	4880.0	4880.0	4880.0	4880.0	4880.0	0.0	0.0	0.0	0.1	0.1	0.1
	$S_2{R}_1$	3509.0	3505.0	3509.0	3519.8	3517.4	3516.6	6.9	7.3	6.3	258.6	264.4	379.5
	$S_2{R}_2$	3321.7	3319.0	3315.0	3343.4	3334.9	3332.6	13.1	11.1	10.4	261.6	266.5	395.4
	$S_2{R}_3$	5008.7	5008.7	5003.7	5012.6	5011.3	5010.2	2.0	1.8	2.8	184.9	186.0	232.7
	$S_3{R}_1$	2858.0	2851.3	2852.7	2868.7	2864.6	2863.5	6.0	8.0	7.1	201.2	207.5	380.3
	$S_3{R}_2$	2884.3	2881.7	2881.7	2900.9	2896.0	2897.0	11.8	6.9	7.8	198.7	208.1	359.9
	$S_3{R}_3$	4937.7	4937.7	4937.7	4937.7	4937.7	4937.7	0.0	0.0	0.0	231.4	150.8	295.0

Note: The bold numbers denote that the problem is solved optimally or reaches the best-known solution by the corresponding algorithm.

shows the best and average results, average times, and SDs in 10 trials of instances with the smallest scale $\left(n=20\right)$ and instances with the largest scale $\left(n=250\right)$. All results are averaged over different numbers of machines. From the table, HLNS and TLNS can always achieve better results than LNS, which shows that the tabu strategy can effectively guide the search toward better regions. Meanwhile, although TLNS outperforms HLNS on the best results in a few instances, HLNS shows superiority in finding high-quality solutions over TLNS in general. This indicates that HLNS combined with a local search strategy can effectively avoid falling into local optimum. Furthermore, the computational time of HLNS is longer than that of TLNS and LNS, and LNS costs less time than TLNS for most categories of instances. This is because the tabu-removal and local search procedure costs extra time.

5. Conclusions

This paper studied the unrelated parallel batch processing machines scheduling problem with non-identical job sizes, dynamic job arrivals, and incompatible job families. A mixed integer programming is proposed to optimally solve the small-scale problem, and a hybrid large neighborhood search algorithm is proposed to solve large-scale problems. The proposed hybrid heuristic follows the basic structure of a large neighborhood search, which incorporates tabu and local search strategies to guide the search toward better regions and enhance the local search ability. Two sets of instances with up to 250 jobs and five machines, including 180 benchmark compatible job family instances and 180 newly generated incompatible job family instances, were used in the experiments to verify the effectiveness of the proposed model and heuristic solution method, with results compared with existing methods.

For 180 instances with incompatible job families, the proposed MIP model can optimally solve small-scale instances quickly, while it is difficult to yield a satisfactory result within a reasonable time for large-scale instances. In contrast, the proposed HLNS can obtain high-quality solutions efficiently for both small- and large-scale instances. In addition, the proposed algorithm performs stably over 10 trials, indicating that the proposed HLNS is efficient and stable in solving problems with incompatible job families. For 180 instances with compatible job families, the HLNS has updated the best-known solutions for two small-scale and 27 large-scale instances, respectively. The comparison results show that the proposed HLNS outperforms the other four existing algorithms (IG, GA, SA, ACO), especially for large-scale instances. Meanwhile, over 65% of instances had SD values of 0, which shows the stability of the proposed HLNS. Numerical results demonstrated that the proposed HLLNS outperforms commercial optimization solver and other meta-heuristics, indicating that the HLNS can efficiently and stably solve compatible and incompatible job family problems. Furthermore, from the comparison results of LNS, TLNS, and HLNS, HLNS can always find better-quality solutions and perform more stably than LNS and TLNS, which indicates the effectiveness of the tabu strategy and local search strategy.

There are several possible pathways to our future research. One is to develop more efficient exact methods for the medium- and large-scale instances of scheduling problems on unrelated parallel batch processing machines with various considerations. Another direction is to consider job-shop and flow-shop environments with batch processing machines. Furthermore, it would also be interesting to tackle the batch processing scheduling problem in stochastic environments.