Scheduling Large-Size Identical Parallel Machines with Single Server Using a Novel Heuristic-Guided Genetic Algorithm (DAS/GA) Approach

Abstract

Parallel Machine Scheduling (PMS) is a well-known problem in modern manufacturing. It is an optimization problem aiming to schedule n jobs using m machines while fulfilling certain practical requirements, such as total tardiness. Traditional approaches, e.g., mix integer programming and Genetic Algorithm (GA), usually fail, particularly in large-size PMS problems, due to computational time and/or memory burden and the large searching space required, respectively. This work aims to overcome such challenges by proposing a heuristic-based GA (DAS/GA). Specifically, a large-scale PMS problem with n independent jobs and m identical machines with a single server is studied. Individual heuristic algorithms (DAS) and GA are used as benchmarks to verify the performance of the proposed combined DAS/GA on 18 benchmark problems established to cover small, medium, and large PMS problems concerning standard performance metrics from the literature and a new metric proposed in this work (standardized overall total tardiness). Computational experiments showed that the heuristic part (DAS-h) of the proposed algorithm significantly enhanced the performance of the GA for large-size problems. The results indicated that the proposed algorithm should only be used for large-scale PMS problems because DAS-h trapped GA in a region of local optima, limiting its capabilities in small- and mainly medium-sized problems.

1. Introduction

In modern manufacturing, the Parallel Machine Scheduling (PMS) problem amounts to scheduling several jobs using various identical machines while fulfilling specific practical requirements, such as minimum total tardiness while executing the jobs [1,2,3,4,5]. Thus, the PMS problem can be formulated as an NP-hard optimization problem that requires sophisticated optimization techniques for scheduling the jobs using the available machines while satisfying some practical constraints [6,7,8,9,10].

Many algorithms have been proposed in the literature to deal with the PMS problem. According to refs. [11,12,13,14,15], the algorithms used in PMS can be globally divided into two main groups: construction and improvement or interchange algorithms. The construction algorithms choose one job at a time and fix it in the available position using dispatching rules. One of the well-known construction rules is the Apparent Tardiness Cost (ATC) rule [16]. Several scholars have used modified versions of ATC to minimize the total tardiness in PMS [17,18,19,20,21,22,23].

On the other hand, the improvement or interchange algorithms work on an initial solution and use local interchanges to improve the solution. Several scholars have used meta-heuristics as improvement algorithms, such as Genetic Algorithms (GAs). GAs have been heavily used as improvement algorithms for PMS problems [24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40]. Simulated Annealing (SA) [41,42], Ant Colony (AC) [43,44,45], Non-dominated Sorting Genetic Algorithm-II (NSGA-II) [7,46,47,48], NSGA-III [1,49,50], and Non-dominated Ranking GA (NRGA) [51] have also been used to optimize PMS as improving algorithms.

For example, Wang et al. [31] proposed modified versions of two meta-heuristics algorithms (GA and SA) to obtain an approximate solution to large-scale PMS problems with unrelated parallel machines. Sharma et al. [52] proposed and evaluated the effectiveness of a multi-step crossover GA on randomly generated PMS problems of different sizes using identical parallel machines. Laha et al. [42] proposed a SA meta-heuristics algorithm for minimizing makespan in identical PMS problems. Jia et al. [45] proposed a fuzzy AC optimization algorithm to obtain better solutions within a convenient time for fuzzy scheduling problems (i.e., jobs characterized by fuzzy processing time) on parallel batch machines with different capacities. Farmand et al. [8] investigated the effectiveness of two meta-heuristic algorithms (Multi-Objective Particle Swarm Optimization (MOPSO) and NSGA-II) on small, medium, and large-scale PMS problems with identical parallel machines.

In this paper, we consider a large-size identical parallel machine scheduling problem $P_m$ with $n$ independent jobs and $m$ identical machines with a single server. Traditional computational algorithms, such as Mix Integer Programming (MIP) and GA, usually fail or perform badly in such large-size problems due to computational time limitations and/or memory limitations and the large search space required, respectively. A meta-heuristic algorithm DAS/GA is developed in this paper to overcome these limitations while further boosting the performance of the GA. The problem can be described as follows: given a sequence of $n$ independent jobs $J=\left\{J_1, J_2, \dots , J_n\right\}$ and a set of $m$ identical machines $M=\left\{M_1, M_2, \dots , M_m\right\}$, the objective is to sequence the jobs on the machines to minimize the total tardiness ${{\displaystyle \sum }}_i{T}_i$ of the schedule. Job $J_i$ is associated with a processing time $P{T}_i$ and a due date $D{D}_i$ with an independent setup time $S{T}_{si}$, which is included in $P{T}_i$. One server $S_1$ exists for dispatching the jobs to the available machines according to the dispatching rules in the algorithm. The standard notation for this problem can be denoted as $P_m, S1\left|S{T}_{si}\right|{{\displaystyle \sum }}_i{T}_i$ according to ref. [53], which is known to be an NP-hard problem [54]. Individual heuristic algorithms (DAS) and GA are used as benchmarks to assess the effectiveness of the proposed combined DAS/GA algorithm on 18 benchmark problems selected to represent small, medium, and large PMS problems.

The assumptions made in this article are as follows: the jobs are independent; each job has a single operation; the processing times include the corresponding setup times, and the setup times are independent of the sequence; machines are identical and have 100% availability and utilization while jobs are waiting; no preemption, no cancelation, and no priority for jobs are allowed; all of the jobs are available at time zero, and the problem is static and deterministic.

The rest of the article is organized as follows: Section 2 presents the framework of the proposed heuristic-guided GA; Section 3 discusses the performance measures used to evaluate the effectiveness of the proposed algorithm to the benchmarks; Section 4 explains the data generation method for the experimentation problems setup; Section 5 discusses the results of the application; and finally, Section 6 concludes the article and highlights future work.

2. The Framework of the Proposed Heuristic-Guided Genetic Algorithm (DAS/GA)

The meta-heuristic algorithm DAS/GA proposed in this article consists of heuristic DAS-h, followed by GA. DAS-h itself consists of 3 heuristics working sequentially: Due Date Tightness heuristic (DDT-h), Apparent Tardiness Cost heuristics (ATC-h), and Swap heuristic (S-h). Figure 1 shows the flowchart of the proposed DAS/GA.

DAS/GA starts with the construction heuristic (DDT-h), which assigns jobs to different machines based on their due dates’ tightness index values. Then, the produced schedule is fed into the modified version of the ATC heuristic (ATC-h) to further improve the schedule. The produced schedule is fed into a third improvement heuristic (S-h), which will fine-adjust the schedule. The output schedule of S-h is used as one chromosome (i.e., schedule) to seed the initial population in the GA. The heuristics and the GA comprising DAS/GA meta-heuristic are discussed in detail in the following sections.

2.1. Due Date Tightness Heuristic (DDT-h)

In DDT-h, jobs are assigned to different machines based on their Due Date Tightness index $I_i^{DD}$ values. This index is calculated by Equation (1), in which the $D{D}_i$ and $P{T}_i$ are the due date and the processing time for job i, respectively. DDT-h sorts the jobs in an ascending order based on their $I_i^{DD}$ values such that a smaller $I_i^{DD}$ value indicates a higher priority job.

$$I_i^{DD}=\frac{D{D}_i-P{T}_i}{P{T}_i}$$

(1)

To illustrate how the DDT-h works, consider 2 machines and 10 jobs along with their processing times and due dates, as shown in

Table 1. Data and $I_i^{DD}$ values for the illustrative example.

Job i	1	2	3	4	5	6	7	8	9	10
$P{T}_i$	45	894	275	840	357	50	653	912	257	224
$D{D}_i$	65	906	321	1528	378	69	692	1490	342	373
$I_i^{DD}$	0.444	0.013	0.167	0.819	0.059	0.380	0.060	0.634	0.331	0.665

. Their $I_i^{DD}$ values were calculated according to Equation (1) and are recorded in Table 1.

The 10 jobs are sorted in ascending order based on their $I_i^{DD}$ values, as reported in

Table 2. Sorted jobs based on $I_i^{DD}$ values.

Job i	2	5	7	3	9	6	1	8	10	4
$I_i^{DD}$	0.013	0.059	0.060	0.167	0.331	0.380	0.444	0.634	0.665	0.819

.

After jobs were sorted, the job with the smallest $I_i^{DD}$ value is dispatched as the first job on the first machine, the job with the second-smallest $I_i^{DD}$ value is dispatched as the first job on the second machine, the job with third-smallest $I_i^{DD}$ value is dispatched as the second job on the first machine, and so on. The resulting schedule is summarized in

Table 3. DDT-h schedule.

Position	1	2	3	4	5
Machine 1	2	7	9	1	10
Machine 2	5	3	6	8	4

.

2.2. Apparent Tardiness Cost Heuristic (ATC-h)

The Apparent Tardiness Cost heuristic (ATC-h) is an iterative heuristic that schedules jobs one at a time from a set of remaining available jobs. The heuristic contains a priority index $I_i\left(t\right)$ that changes dynamically with time $t$. Variations of ATC-h were explained, among other references, in refs. [17,20]. We highlight the main aspects of ATC-h in this article for convenience and modify it to suit the $P_m, S1\left|S{T}_{si}\right|{{\displaystyle \sum }}_i{T}_i$ problem at hand. The $I_i\left(t\right)$ is calculated by multiplying two terms, which are the Weighted Shortest Processing Time ($WSPT$) and the Least Slack (LS), as in Equation (2):

$$I_i\left(t\right)=WSPT\times \mathrm{LS}$$

(2)

The Weighted Shortest Processing Time ($WSPT$) is given by Equation (3):

$$WSPT=\frac{1}{P{T}_i},$$

(3)

and the LS is given by Equation (4):

$$\mathrm{LS}=e^{-\left(\frac{max\left(D{D}_i-P{T}_i-C{T}_k , 0\right)}{\zeta \times {\mu }_{PT}}\right)},$$

(4)

where $C{T}_k$ is the cumulative time for predecessor job k, ${\mu }_{PT}$ is the mean of the processing times for the remaining jobs, and $\zeta$ is a look-ahead parameter, which is determined through experimentation. According to ref. [17], $\zeta$ can be calculated as in Equation (5):

$$\zeta =1.2\times \ln \left(\frac{n}{m}\right)-\frac{\left(\underset{i}{max}D{D}_i-\underset{i}{min}D{D}_i\right)m}{n{\mu }_{PT}}$$

(5)

Substituting Equations (3) and (4) in Equation (2) gives the final equation for $I_j\left(t\right)$ as in Equation (6):

$$I_i\left(t\right)=\frac{1}{P{T}_i}\times e^{-\left(\frac{max\left(D{D}_i-P{T}_i-C{T}_k , 0\right)}{\zeta \times {\mu }_{PT}}\right)},$$

(6)

where $\zeta$ is given by Equation (5). It should be noted that the processing time for a job includes its setup time, and the setup time for the job is independent of the sequence that includes the job, as stated in assumption 3 in this article. Hence, the equations reported in ref. [17], which assume a dependent setup time to derive $I_i\left(t\right)$, should be modified from their original form in ref. [17] to Equations (4)–(6).

As seen in Equation (3), $WSPT$ is the inverse of the processing times. This means that jobs with lower processing times have higher priority (providing everything else remains the same in $\mathrm{LS}$). Moreover, Equation (4) shows that $\mathrm{LS}$ has two possible values: value 1 when the slack value for the job is negative, which indicates that the job is tardy, or any value between 0 and 1 when the slack value is not negative, which indicates that the job is not tardy. This means that a tardy job has the highest possible $\mathrm{LS}$ value and consequently has the highest possible $I_i\left(t\right)$ value among the jobs with equal processing times.

Every time a machine is available, the priority indices values of all the remaining jobs are re-calculated, and the job with the highest $I_i\left(t\right)$ value is chosen to be processed next. The decision is dynamic, as the $I_i\left(t\right)$ value of the job changes over time because it depends on $C{T}_k$, the cumulative time for its predecessor.

The ATC-h needs an initial schedule to work on. This matter makes the final schedule for ATC-h dependent on the initial schedule provided.

Table 4. Initial schedule for ATC-h.

Position	1	2	3	4	5
Machine 1	4	5	6	1	2
Machine 2	10	9	7	8	3

shows a possible initial schedule for ATC-h.

Table 5. $I_i\left(t\right)$ values for data in Table 1 and schedule in Table 4.

Machine 1
Job	4	5	6	1	2	Remarks
Iteration
1	0.0003	0.0027	0.0193	0.0214	0.0011	Job 1 first
2	0.0004	0.0028	0.0200	−1	0.0011	Job 6 second
3	0.0004	0.0028	−1	−1	0.0011	Job 5 third
4	0.0004	−1	−1	−1	0.0011	Job 2 fourth
5	0.0004	−1	−1	−1	−1	Job 4 fifth
Machine 2
Job	10	9	7	8	3	Remarks
Iteration
1	0.0036	0.0034	0.0014	0.0005	0.0034	Job 10 first
2	−1	0.0039	0.0015	0.0006	0.0036	Job 9 second
3	−1	−1	0.0015	0.0009	0.0036	Job 3 third
4	−1	−1	0.0015	0.0011	−1	Job 7 fourth
5	−1	−1	−1	0.001	−1	Job 8 fifth

shows the $I_i\left(t\right)$ values generated for the data in Table 1 based on the initial schedule provided in Table 4.

Table 6. ATC-h schedule.

Position	1	2	3	4	5
Machine 1	1	6	5	2	4
Machine 2	10	9	3	7	8

shows the schedule produced using ATC-h.

Figure 2 shows the standardized values of $I_i\left(t\right)$ and $I_i^{DD}$ for the 10 jobs described in Table 1. In ATC-h, as $D{D}_i-P{T}_i$ value, the Due Date Tightness (DDT), increases, the $I_i\left(t\right)$ value decreases, and consequently the priority of the job decreases, while in DDT-h, as the DDT value increases, the $I_i^{DD}$ value increases but the priority of the job decreases.

The Figure shows that the two heuristics have the same basic behavior for jobs with small values of DDT like jobs 2, 3 and 7 but have fundamentally different behavior for jobs with large values like jobs 4 and 8. This difference in the behavior is because the ATC-h takes into account the cumulative processing time for the predecessor $C{T}_k$ in calculating $\mathrm{L}\mathrm{S}$ while DDT-h does not. The effect of the $C{T}_k$ on the $I_i\left(t\right)$ values in ATC-h is evident in jobs 2 and 8, where both jobs have very close $I_i\left(t\right)$ values even though they have a big difference in their DDT values.

2.3. Swap Heuristic (S-h)

The aim of the Swap Heuristic (S-h) is to fine-adjust the schedule by removing one job (with positive tardiness) at a time from a tardy machine and assigning it to the machine with the lowest total tardiness. This heuristic is a fine-adjusting heuristic, so it is meant to be applied after ATC-h, which is a coarse-adjusting heuristic. The aim of this heuristic is to level the load on the machines. S-h is similar to ATC-h in terms of the need for an initial schedule and in terms of using the cumulative times in their calculations.

The pseudo-code for this heuristic is as follows (Algorithm 1):

Algorithm 1: The pseudo-code of the Swap Heuristic (S-h)
1:	Input schedule from ATC-h
2:	Calculate the tardiness $T_j$ for each machine in machine set $M$
3:	Determine the machine $M_L$ with lowest $T_j$
4:	Determine the set that contains the rest of the other machines $M_o$ such that $M_{o_j}\in \left\{x \in M|x\notin M_L\right\}$
5:	Determine the set of jobs $J_L$ on $M_L$
6:	Calculate$C_{t_l}={\displaystyle \sum }_{i \in J_l}P{T}_i$
7:	Do WHILE the overall total tardiness $TT$ is improving or termination condition is reached
8:	FOR all machines indexed $j$ in $M_o$ do the following
9:	FOR all jobs indexed $i$ in $M_{o_j}$ do the following
10:	Calculate the cumulative processing time $C_{t_{j_i}}$ for job i on $M_{o_j}$
11:	IF $C_{t_l}+P{T}_i<C_{t_{j_i}}$ do the following
12:	Remove job $i$ from $M_{o_j}$ and assign it to the end of the schedule for $M_L$
13:	Update $T_j$, $M_L$, $J_L$,$M_o$, and $C_{t_l}$
14:	Go to DO WHILE loop
15:	END IF
16:	END FOR indexed $i$
17:	END FOR indexed $j$
18:	END DO WHILE
19:	Report the new Schedule

The heuristic chooses the job to be moved according to the Ineq. 7 (Equation (7)).

$$C_{t_l}+P{T}_i<C_{t_{j_i}}$$

(7)

Ineq. 7 states that moving a tardy job from any machine in $M_o$ to the end of the schedule for $M_L$ always results in an improvement in the overall tardiness of the schedule. The left-hand side of the inequality is a quasi-representation of the new tardiness value for the removed job $i$ in the new machine, while the right-hand side is a quasi-representation of the tardiness value for the removed job $i$ in its original machine. If the left-hand side is less than the right-hand side of the inequality, then removing job $i$ from the current machine $M_{o_j}$ and assigning it to $M_L$ guarantees enhancement of the overall total tardiness of the schedule by the difference between the left-hand side and the right-hand side values.

To illustrate the effect of this heuristic, consider the data in

Table 7. Process times and due dates for Table 8.

Job i	1	2	3	4	5	6	7	8	9	10
$P{T}_i$	100	1150	275	840	357	50	750	912	450	224
$D{D}_i$	165	1200	321	1528	378	69	692	1490	342	373

and the corresponding proposed schedule in

Table 8. The proposed schedule.

Position	1	2	3	4	5
Machine 1	2	7	9	1	10
Machine 2	5	3	6	8	4

.

The total tardiness for machine 1 is 7802 and for machine 2 is 1934; the overall total tardiness for the schedule is 9736. The cumulative processing time for machine 2, which is $M_L$ in this case, is 2434; hence, feeding the data of job 10 in Ineq. 7 gives a correct inequality, as shown below:

$$\left(2434+224-373\right)<\left(2674-373\right)\to 2285<2301$$

Thus, removing job 10 from machine 1 and assigning it at the end of the schedule for machine 2 should improve the overall total tardiness for the schedule by 2301 − 2285 = 16. In fact, removing job 10 from machine 1 and assigning it at the end of the schedule for machine 2 gives an overall total tardiness of 9720, which is 16 units less than the total tardiness of the original schedule, with total tardiness for machine 1 of 5501 and total tardiness for machine 2 of 4219. It should be noticed here how S-h levels the load on the machines and enhances the overall total tardiness of the schedule.

2.4. Genetic Algorithm (GA)

The GA has been used intensively in PMS with the aim of minimizing the overall total tardiness of the schedule [25,33,34,35]. GA has two kinds of operations: the genetic operation and the evolution operation. Crossover and mutation in GA belong to the genetic operation, while the selection mechanism belongs to the evolution operation [55]. The crossover operator in GA aims to roughly search the solution space while the mutation operator aims to finely search the solution space by exploiting the promising areas found by the crossover operator [56].

Chromosome representation, mutation, and selection strategies should be tailored to fit the problem at hand. These strategies are explained in the following sections.

2.4.1. Chromosome Representation

In this proposed GA, the chromosome consists of $m$ rows, one row for each machine, and $n-\left(m-1\right)$ columns (positions) for each row, to ensure that each machine has at least one job on it. In this representation, gene ${\xi }_{ij}=k$ means that the $i^{th}$ position on the $j^{th}$ machine is occupied by job $k$. In this representation, each gene carries three pieces of information: the value of the gene itself represents the job, while the position of the gene, determined by $i$ and $j$ indices, represents the machine and the position on that machine for the job. This representation ensures the feasibility of the chromosomes and offspring and thus avoids the need for any repair actions.

Consider the data used in Table 1.

Table 9. One possible chromosome for data in Table 1.

Position	1	2	3	4	5	6	7	8	9
Machine 1	2	7	6	3	1	9	0	0	0
Machine 2	10	5	8	4	0	0	0	0	0

shows one possible chromosome for this data. The phenotype can be easily retrieved from the genotype in this representation, as gene ${\xi }_{22}=5$ means that job 5 is the second job to be processed on machine 2, while ${\xi }_{17}=0$ means that there are no jobs processed in position 7 or beyond for machine 1.

2.4.2. Fitness Function

In this GA, the fitness function used is the overall total tardiness of the schedule, as expressed in Equation (8):

$$TT={\displaystyle \sum }_{j=1}^m{\displaystyle \sum }_{\begin{array}{c}{d}_{{\xi }_{ij}}<\left(S_{{\xi }_{ij}}+P{T}_{{\xi }_{ij}}\right)\\ i=1:n-\left(m-1\right)\end{array}}\left(S_{{\xi }_{ij}}+P{T}_{{\xi }_{ij}}-D{D}_{{\xi }_{ij}}\right),$$

(8)

where $S_{{\xi }_{ij}}$, $P{T}_{{\xi }_{ij}},$ and $D{D}_{{\xi }_{ij}}$ are the start time, processing time, and due date for gene ${\xi }_{ij}$.

The fitness function value for the chromosome in Table 9 is as follows:

$${\displaystyle \sum }_{j=1}^2{\displaystyle \sum }_{\begin{array}{c}{d}_{{\xi }_{ij}}<\left(S_{{\xi }_{ij}}+P{T}_{{\xi }_{ij}}\right)\\ i=1:5\end{array}}\left(S_{{\xi }_{ij}}+P{T}_{{\xi }_{ij}}-D{D}_{{\xi }_{ij}}\right)=\left(7618\right)+\left(1011\right)=8629.$$

2.4.3. Mutation

This GA is a crossover-free GA in which only mutation is used to produce the offspring from a single parent. Four different mutation types were used to mutate the selected chromosome. The Two Genes Exchange mutation (TGEm) affects only two jobs on the same machine, as it chooses two random jobs from a randomly selected machine and switches their positions. The Number of Jobs mutation (NoJm) changes the number of jobs on two randomly selected machines as it swaps randomly selected jobs from one randomly selected machine to another randomly selected one, provided that the minimum of one job per machine constraint is conserved. NoJm imitates the S-h, but it differs from S-h in two aspects. First, S-h swaps one job each time it is applied while NoJm may swap more than one job each time it is applied. Second, unlike S-h, NoJm does not guarantee that the change is beneficial. The Flip Ends mutation (FEm) flips the ends of the schedule for a randomly selected machine such that the first job becomes the last job and the last job becomes the first job on that machine. Flip Middle mutation (FMm), flips the sequence of the jobs between two randomly selected positions near the middle of the machine’s schedule.

TGEm plays the role of the traditional mutation in the GA, in which it generates a limited disturbance in the chromosome; hence, it performs fine search. The other three types of mutations play the role of crossover in the GA, as they introduce high disturbances in the chromosome; hence, they play the role of coarse search. The offspring produced by these four types of mutations are always feasible offspring thanks to the chromosome representation discussed earlier. Consequently, there is no need for any repair actions on the offspring. Moreover, in this GA, a 25% mutation rate is adopted. This means that the number of offspring generated by mutation is the same as the population size, as each chromosome selected for the mutation will produce 4 offspring.

2.4.4. Selection

An elitist selection strategy is adopted in this GA. Under this strategy, all the parents and the offspring form a pool in which they have to compete for their survival. Those who have better fitness values will be selected as the parents of the next generation.

2.5. Mathematical Model

Binary programming for $P_m, S1\left|S{T}_{si}\right|{{\displaystyle \sum }}_i{T}_i$ is formulated in studies such as refs. [57,58]. The objective function of this model is

$$TT={\displaystyle \sum }_{k=1}^m{\displaystyle \sum }_{j=1}^p{T}_{jk}$$

(9)

The constraints are

$${\displaystyle \sum }_{j=1}^p{\displaystyle \sum }_{k=1}^m{X}_{ijk}=1 ,\forall i=1,\dots , n$$

(10)

$${\displaystyle \sum }_{i=1}^{job}{X}_{ijk}\le 1 ,\forall j=1,\dots , p and k=1,\dots , m$$

(11)

$$C_{jk }= C_{\left[j-1\right]k }+{\displaystyle \sum }_{i=1}^{n}P{T}_i\ast X_{ijk} \forall j=1, \dots , p, k=1, \dots , m. C_{0k}=0$$

(12)

$$C_{jk }-{\displaystyle \sum }_{i=1}^{n}D{D}_i\ast X_{ijk}-T_{jk}\le 0 \forall j=1, \dots , p, \forall k=1, \dots , m$$

(13)

$$T_{jk}\ge 0$$

(14)

$$X_{ijk Binary}$$

(15)

In this mathematical model, indices $i$, $j,$ and $k$ are indices for job, position, and machine, respectively, and $p$ is the number of positions on the machine. Moreover, $X_{ijk}=1$ if job $i$ is processed in position $j$ at machine $k$ and is “0” otherwise, $C_{jk }$ is the completion time for position j at machine $k$, $T_{jk}$ is a positive value that represents the tardiness value for position $j$ at machine $k$.

Equation (9) calculates the overall total tardiness of the schedule by summing the individual tardiness values for the positions on the machines. Equation (10) guarantees that each job is assigned only once, while Equation (11) guarantees that each position on each machine, if occupied, will be occupied only once. Equation (12) calculates the cumulative processing time for the job, and Equations (13) and (14) together dictate that if the position on the machine is occupied by a tardy job, then the tardiness of the position equals the tardiness of that job; otherwise, the tardiness of the position and consequently the tardiness of the job is zero.

3. Performance Measures

The performance of DAS-h, DAS/GA, and GA was measured in this article using two performance measures suggested by ref. [17], (Relative Error ($RE$) and Average Relative Improvement ($ARI$)), and a third performance measure that is suggested in this article: the standardized overall total tardiness $StdrdTT$.

$RE$ is the difference between the tardiness of the method used ${TT}_h$ and the tardiness of the optimal schedule ${TT}_{op}$ found by the binary programming model discussed in Section 2.5 using CPLEX software relative to ${TT}_{op}$. Mathematically $RE$ is given by Equation (16). It should be noted that this measure can only be used when ${TT}_{op}>0$. If ${TT}_{op}$ could not be found due the memory limitations or if ${TT}_{op}=0$, ${TT}_{op}$ will be substituted by ${TT}_{Best},$ which is the best $TT$ found among the different methods used to solve the problem.

$$RE=\frac{T{T}_h-T{T}_{op}}{T{T}_{op}}$$

(16)

$ARI$ is used only with GA and DAS/GA to measure their tardiness ${TT}_{GA|DAS/GA}$ with respect to the tardiness of DAS-h, which is ${TT}_{DAS\text{-}h}$. Mathematically, ARI is given by Equation (17):

$$ARI=\frac{T{T}_{GA|DAS/GA}}{T{T}_{DAS\text{-}h}}$$

(17)

$StdrdTT$ is the relative deviation between the overall total tardiness of the method and the minimum overall total tardiness among the methods used, divided by the overall total tardiness among the methods used. Mathematically, $StdrdTT$ is given by Equation (18):

$$\begin{gathered} StdrdTT=\frac{T{T}_H-min\left(T{T}_{DAS\text{-}h},T{T}_{DAS/GA}, T{T}_{GA}\right)}{min\left(T{T}_{DAS\text{-}h},T{T}_{DAS/GA}, T{T}_{GA}\right)}, \forall H \\ \in \left\{DAS\text{-}h, DAS/GA, GA\right\} \end{gathered}$$

(18)

It should be noted that $RE$ and $StdrdTT$ is the same for cases where ${TT}_{op}=0$.

4. Data Generation for Experiments

In this section, 18 benchmark problems are considered for experimentation. The problems’ instances were generated such that they cover small, medium, and large problems to study the performance of the different methods, ATC-h, DAS, DAS/GA, and GA, under these cases. The average of 20 replicates was considered in calculating the performance of GA, DAS/GA, and ATC-h, as they demand a random start-up schedule. The running time for DAS/GA and GA is only 1 min per replicate. The instances for the experimentation problems were generated according to Fisher’s standard method as discussed in refs. [57,59]. The method starts by generating $n$ integer processing times $P{T}_{i}s$ from a uniform distribution such that $P{T}_i~U\left[1, 100\right]$. The corresponding due dates $D{D}_{i}s$ are generated from another uniform distribution such that $D{D}_i~\left[P\left(1-\tau -\frac{R}{2}\right)/m, P\left(1-\tau +\frac{R}{2}\right)/m \right]$, where $P={\displaystyle \sum }_{i=1}^{n}P{T}_i$, $\tau \in \left\{0.2,0.4,0.6,0.8,1\right\}$ and $R\in \left\{0.2,0.4,0.6,0.8,1\right\}$. The template used for the instances is $J\_M\_\tau \_R$. For example, 2000_10_04_04 means scheduling 2000 jobs on 10 identical machines such that due dates are generated using $\tau =0.4$ and $R=0.4$.

5. Results and Experiments

Table 10. Results for the 18 problems used in the experimentation.

#	Problem	Opt. $\mathit{T}\mathit{T}$	DAS		DAS/GA			GA
			$\mathit{T}\mathit{T}$	$\mathit{R}\mathit{E}$	$\mathit{T}\mathit{T}$	$\mathit{R}\mathit{E}$	$\mathit{A}\mathit{R}\mathit{I}$	$\mathit{T}\mathit{T}$	$\mathit{R}\mathit{E}$	$\mathit{A}\mathit{R}\mathit{I}$
1	20_02_02_02	147	162	0.1020	151.8	0.0327	0.9370	151.7	0.0320	0.9364
2	20_05_02_02	149	195	0.3087	161.7	0.0852	0.8292	160.1	0.0745	0.8210
3	20_10_10_10	195	246	0.2615	226.0	0.1590	0.9187	218.1	0.1185	0.8866
4	30_02_02_02	83	188	1.2651	83.0	0.0000	0.4415	83.0	0.0000	0.4415
5	30_10_02_02	101	787	6.7921	171.4	0.6970	0.2178	170.7	0.6901	0.2169
6	40_02_02_02	13	26	1.0000	13.0	0.0000	0.5000	13.0	0.0000	0.5000
7	40_05_02_02	68	166	1.4412	102.8	0.5118	0.6193	85.6	0.2588	0.5157
8	40_10_02_02	0	0	NA	0.0	NA	NA	0.0	NA	NA
9	50_05_02_02	49	188	2.8367	104	1.1224	0.5532	102.2	1.0857	0.5436
10	100_02_02_02	25	141	4.6400	25	0.0000	0.1773	25.0	0.0000	0.1773
11	100_5_02_02	86	240	1.7907	140.7	0.6360	0.5863	104.4	0.2140	0.4350
12	100_10_02_02	NA	195	0.0285	189.6	0.0000	0.9723	190.0	0.0021	0.9744
13	300_15_06_06	NA	28164	0.0084	27929	0.0000	0.9917	41182.0	0.4745	1.4622
14	500_10_05_05	NA	50428	0.0041	50220	0.0000	0.9959	74571.0	0.4849	1.4788
15	750_15_04_04	NA	47727	0.0004	47707	0.0000	0.9996	73344.0	0.5374	1.5367
16	1000_10_06_06	NA	355500	0.0003	355396	0.0000	0.9997	590010.1	0.6601	1.6597
17	1500_15_04_04	NA	168559	0.0011	168378.7	0.0000	0.9989	274604.3	0.6309	1.6291
18	2000_10_04_04	NA	399815	0.0004	399673	0.0000	0.9996	649413.5	0.6249	1.6243

shows the performance measures for 18 problems generated according to Fisher’s standard method as discussed earlier. It should be noted that CPLEX software did not find the optimal solution, Opt.$TT,$ for problems beyond problem 11 due to memory limitations. This shows the importance of this work and other related works in solving big NP-hard PMS problems where binary programming fails due to technical issues.

Figure 3a shows a comparison between the performances of the different methods using the $RE$ measure. Figure 3b shows that the performance of GA slightly outperformed the performance of DAS/GA for small problems and significantly for medium problems. On the other hand, for large problems, the performance of DAS/GA significantly outperformed the performance of GA. This means that DAS-h helped GA improve its performance significantly in large problems but deteriorated its performance for medium problems. Figure 3c shows that the trend between the performances of GA and DAS-h is the same as the trend captured in Figure 4b between GA and DAS/GA. The performance of GA slightly outperformed the performance of DAS-h for small problems and significantly for medium problems, while for large problems the performance of DAS-h significantly outperformed the performance of GA. From Figure 3b,c, one can see that the behavior of DAS-h masks the behavior of DAS/GA for large problems, as DAS/GA has the same behavior of DAS-h relative to GA in this range of problem sizes. The comparison between the performance of DAS-h and DAS/GA shown in Figure 3d supports this argument. The Figure shows that DAS/GA slightly outperformed DAS-h for small problems and significantly for medium problems; the methods had a negligible difference in their performance for large problems.

The negligible difference in performance between DAS-h and DAS/GA shown in Figure 3d for large problems suggests that when combining DAS-h with GA to form the DAS/GA meta-heuristic, DAS/GA will be trapped in a region of good local optima created by DAS-h; consequently, the effect of GA will be negligible as it is trapped in this region.

In Figure 4, the standardized total tardiness values $StdrdT{T}_H$ for the different methods were compared. Figure 4a shows the exact same trends as found in Figure 3a between the performances of the different methods but using the $StdrdTT$ performance measure. Figure 4b shows that GA slightly outperformed DAS/GA for small problems and significantly for medium problems. For large problems, DAS/GA significantly outperformed GA, which is the same as the trend in Figure 3b. Figure 4c shows the same trend found in Figure 3c between the performances of GA and DAS-h.

Figure 4d shows that DAS/GA outperformed DAS-h for small problems and significantly for medium problems; however, the methods had a negligible difference in their performance for large problems, which is the same trend as found in Figure 4d.

Figure 5 shows a comparison between DAS/GA and GA using $RAI$ measure. The figure reveals the same trend found earlier using $RE$ and $StdrdTT$ measures in Figure 3b and Figure 4b, respectively: GA slightly outperformed DAS/GA for small problems and especially for medium problems. For large problems, DAS/GA significantly outperformed GA. DAS-h helped GA to improve its performance significantly in large problems but deteriorated its performance for small and especially for medium problems, as the $ARI$ values for DAS/GA for large problems are almost constant and approximately 1, but for small problems and especially for medium problems, the values are less than 1.

Moreover, looking at the $ARI$ values for DAS/GA for large problems supports the argument made earlier: DAS-h creates a region of good local optima for large size problems that trap GA in it and renders the effect of GA negligible, and hence in this region DAS-h dictates the behavior of DAS/GA. The values of $ARI$ support this argument, as the $ARI$ values for large problems are almost 1, which indicates that the behavior of DAS/GA is very close to the behavior of DAS-h, and hence the effect of GA is almost negligible in DAS/GA compared to the effect of DAS-h.

Figure 6 compares the evolution line of DAS/GA and GA for problem 500_10_05_05. The Figure shows the same basic behavior for their evolution lines, except that DAS/GA’s evolution line, shown in Figure 6b, started from a better point and reached a better fitness value than GA. Moreover, the figure shows that GA had a higher number of enhancement points in its evolution line than DAS/GA. This observation agrees with what was noted earlier about the effect of the region of local optima that DAS-h introduces in DAS/GA.

To explore this observation more, Figure 7 shows a comparison between Average Number of Enhancements Per Replicate (ANEPR) for both meta-heuristics DAS/GA and GA. It is noted that as the problem size increased, the ANEPR for the GA method increased significantly, while for the DAS/GA method, the ANEPR was independent of the problem size, as the DAS/GA method showed a random relation between ANEPR and the problem size.

This shows that generating a strong initial solution for DAS/GA for large-size problems using DAS-h will cause DAS/GA to be trapped in a region of local optima and hence limit the number of enhancements made to the strong initial solution. This matter makes the difference between the performances of DAS-h and DAS/GA negligible, as revealed in Figure 3d and Figure 4d and the DAS/GA curve in Figure 5, and hence supports the argument made earlier that DAS-h dictates the behavior of DAS/GA in this region of large-size problems.

Figure 8 shows a comparison between the performance of ATC-h and DAS-h. The Figure shows that DAS-h outperformed ATC-h for most of the problems, whether they are small, medium, or large. Moreover, the Figure shows that the largest difference between the two heuristics is for the medium-size problems, where DAS-h significantly outperformed ATC-h.

This superior performance of DAS-h can be linked to the structure of this heuristic, where DDT-h first constructs a good initial feasible schedule; then, this schedule is coarse-tuned using ATC-h, after which the S-h fine-tunes the schedule.

This superior performance of DAS-h in medium-range problems explains the strong deterioration in the performance of DAS/GA relative to GA in medium-size problems. DAS-h generates a region of local optima that traps DAS/GA, and consequently the performance of DAS/GA is limited in this region to the performance of DAS-h. Unlike the case with large-size problems, in medium-size problems GA alone can reach better regions than the region provided by DAS-h in DAS/GA; therefore, GA alone outperforms the performance of DAS/GA in medium-size problems, as the region provided by DAS-h traps DAS/GA in it and limits the capabilities of GA in DAS/GA to reach better regions.

6. Conclusions

This article proposed a Heuristic-Based Genetic Algorithm (DAS/GA) to minimize the overall total tardiness in scheduling large-size identical parallel machines with a single server. The results showed that DAS-h significantly enhanced the performance of GA for large-size problems where MIP failed due to high execution time and/or memory limitations, and GA performed badly due to the large search space. The results also showed that the usage of the proposed meta-heuristic DAS/GA algorithm should be limited only to large-size problems because DAS-h limited the capabilities of GA in small-size problems and especially in medium-size problems and because MIP performed well in small-size problems, which rendered the usage of DAS/GA unnecessary in this range of problems.

Future works will investigate existing meta-heuristic algorithms for scheduling large identical parallel machines with a single server.