1. Introduction
In the industry field, machines are often supposed to be continuously available for processing assigned jobs. However, this assumption is not totally realistic in realworld cases. For instance, machines may be subject to unavailability periods due to many reasons, such as preventive maintenance [
1], corrective maintenance [
2], and toolchange activities [
3]. There are two main concerns related to the temporary unavailability of a machine. The first is related to the increased costs caused by stopping the machine’s activity, while the second is linked to the difficulty in taking decisions regarding the balance between resource unavailability and production. Therefore, a proper planning strategy in a manufacturing system is necessary for it to operate in the most costeffective way.
Scheduling under machineunavailability constraints has attracted the attention of many researchers, and many real applications can be found. In [
4], the authors listed two applications in the aerospace industry where the machine must be stopped to change microdrilling tools after a fixed number of use times. Another application was mentioned by [
5] related to electricbattery vehicles that require refuelling operations.
In this paper, we study a scheduling problem on
m uniform parallel machines with multiple unavailability constraints with the objective to minimize the makespan, which is the completion time of the last assigned job. The reason behind the choice of such an objective is that minimizing the makespan can ensure a good load balance among the machines. We followed threefield
$\alpha \left\beta \right\gamma $ classification, developed by [
6], to represent the problem as
$Qm,{h}_{ik}\lefta\right\gamma $. In the first field,
Q denotes uniform parallel machine setting,
m represents the number of considered machines, and
${h}_{ik}$ states that each machine is unavailable during
k periods in the planning horizon. In the second field,
$\beta $,
a indicates that the machines are subject to availability constraints. Lastly, the third field,
$\gamma $, describes the objective to be minimized, that is, the completion time of the last processed job, denoted by
${C}_{max}$.
Many papers in the literature studied parallel machinescheduling problems with availability constraints, but very few considered a uniform parallel machine setting. To the best of our knowledge, only two related papers exist so far, [
7,
8]. In [
7], the authors studied the uniform parallel machinescheduling problem where each machine could be unavailable during one period of time. The considered performance measures were total completion times and makespan. Two types of jobs were treated, namely, identical and nonidentical jobs. Linear programming models and optimal algorithms were developed to solve the problem where jobs are identical. For the case of nonidentical jobs, the authors proved that the problem is NPhard, and proposed a quadratic program and a heuristic that were tested on largesized problem instances. The online version of the problem was studied in [
8]. The authors considered the case of two machines under the constraint of one periodically unavailable machine. The identical and uniformmachine cases were investigated. The objective was to minimize the makespan. The solution approach consisted of optimal algorithms with competitive ratios.
Furthermore, most research papers studied the case of identical parallel machines. For example, [
9,
10,
11,
12,
13] studied various identical parallel machine problems allowing various types of unavailable intervals for machines.
The shortage in research in this area, and the important applications of the investigated problem in reality motivated the author of this paper to explore this area more and contribute to the scientific research on it. Uniform parallel machine scheduling can be found in the manufacturing field where the same type of job can be processed on new and old machines that have different speeds. As an example, a printing task can take much more time on an old machine than on a new one.
In this paper, the main contributions are a quadratic programmingmodel (QM) formulation of a uniform parallel machine with multiple availability constraints and an algorithm that provides optimal solutions. To the best of our knowledge, the proposed QM is the first such formulation for scheduling on uniform parallel machine with availability constraints.
The content of this paper is organized as follows. Problem notations are laid in
Section 2. In
Section 3.1, a quadratic model for the problem with makespan as an objective is developed.
Section 3.2 details an algorithm proposed for makespanperformance measurement. The proposed algorithm was tested on different problem instances, and results are displayed in
Section 4. Finally, a general conclusion is formulated in
Section 5.
2. Notations
For accuracy of description, by ‘unavailability interval’ we denote the time interval in which the machine is not available for processing any job, whereas the time interval between two consecutive unavailability intervals is called the ‘availability interval’ of the machine.
In this paper, we consider m uniform parallel machines that can process n jobs. Each job j, $j=1,\dots ,n$ is characterized by processing time ${p}_{j}$ and completion time ${C}_{j}$. We assumed that the jobs were ready at time 0 and could be processed once at any time, but could not be interrupted once started. Since we consider uniform parallel machines, each machine i, $i=1,\dots ,m$, can process at most one job at a time at speed ${s}_{i}$. So, the processing time of any job j depends on the machine on which it is processed and is equal to ${p}_{ij}={p}_{j}/{s}_{i}$, $i=1,\dots ,m$; $j=1,\dots ,n$. Without loss of generality, we assumed that jobs were indexed in $LPT$ order, that is, ${p}_{i1}\ge {p}_{i2}\ge \dots \ge {p}_{in}$. We assumed that the machine could process the next job once the previous one was finished. Thus, no setup time was considered. Let ${s}_{ik}$ and ${e}_{ik}$ be the starting and ending time of the ${k}^{th}$ unavailability period on machine i, respectively. Without loss of generality, we assumed that all machines were available at the beginning of the planning horizon. By ${L}_{ik}$, we denote the length of the ${k}^{th}$ availability interval on machine i.
The problem was to find a job assignment on machines that minimizes the makespan. As stated earlier, the problem of scheduling jobs on uniform parallel machines subject to unavailability constraints has not been studied before. Therefore, a mathematical formulation of the problem can be of great interest. Thus, in
Section 3.1, we detail a mathematical model to describe the problem under consideration.
3. Proposed Solution Approach for $Qm,{h}_{i{n}_{i}}\lefta\right{C}_{max}$
In this section, we studied the scheduling problem on uniform parallel machine, where each machine i can be unavailable during ${n}_{i}$ unavailability periods in its planning horizon. Thus, there are ${n}_{i}+1$ availability intervals. The objective was to minimize the makespan.
It is easy to see that
$Qm,{h}_{i{n}_{i}}\lefta\right{C}_{max}$ is NPhard. To see this, let
${s}_{i}=1$ for every machine
$i.$ Then the problem reduces to the identical parallel machinescheduling problem under availability constraints that was proved to be NPhard by [
14].
3.1. Mathematical Model
Using the abovelisted decision variables, the problem can be modeled as a quadratic program as follows:
Subject to
where
d is a large positive number.
Equation (
1) minimizes the makespan. Equation (
2) guarantees that, when all jobs are completed before the start of the 1st unavailability period, the unavailability duration is not considered in the evaluation of the completion time of the last job assigned to machine
i. There are
m of these constraints. Equation (
3) states that the completion time of the last job assigned to machine
i is at most equal to the makespan. There are
m of these constraints. Equation (
4) guarantees that no more than one
${y}_{ik}$ is equal one for a given machine
i. There are
m of these constraints. The total processing time of the jobs assigned to a given availability interval cannot exceed the length of that interval. This is shown by Equation (
5). There are
$m\sum {n}_{i}$ of these constraints. Equation (
6) assures that, if a job is assigned to a machine, it can be processed on only one availability interval of that machine. There are
n constraints of this type. Equations (
7) and (
8) define the nonnegativity constraints about the decision variables used to develop the mathematical model.
The above quadratic model ($QM$) can be optimally solved by CPLEX for problem instances with up to 73 machines. Therefore, a good polynomial algorithm that can solve large and more complicated problems, and provide promising results is of great interest.
The Largest Processing Time algorithm (
$LPT$) is a famous rule used to build heuristics for scheduling problems with a makespan criterion. For example, in [
15] the authors proposed
$LPT$based heuristics to solve
$Q2\left\rightCmax$ and
$Qm,ai\left\rightCmax$ problems, respectively. The
$LPT$ rule sorts jobs into a nonincreasing order of their processing times and then assigns a job to the machine on which it can finish as early as possible.
3.2. ProposedSolution Approach
The approach proposed to solve the problem of scheduling on parallel machines under unavailability constraints consists of two steps. The first step focuses on assigning jobs to different available machines using a newly proposed LPTBased Heuristic, named $LPTBH$. The second step, named $LSHIP$, tries to improve solutions obtained by $LPTBH$. The Main Algorithm, named $MA$, is a combination of $LPTBH$ and $LSHIP$.
3.2.1. $LPTBH$ Heuristic Procedure
The main idea of
$LPTBH$ is to divide the set of jobs
N into two subsets. The first set includes jobs that can be assigned to one of the machines’ availability intervals. The second set contains the remaining jobs. The
$LPTBH$ consists of two phases. The first is the main phase, as it schedules the maximum of jobs. First, for every machine, a list of job candidates is formed on the basis of whether they could fit the machine’s availability intervals except the last ones. This step is achieved by using the
$Candidate\_Search$ procedure shown in Algorithm 1. Second, jobs in every constructed list are sorted in decreasing order of their processing times. Then, for every machine, starting from machine 1, select the first job in the candidate list of machine 1. If the selected job is only in that machine’s list, assign it to the availability interval that can fit it. Otherwise, assign it to the machine on which it can finish as early as possible. The first phase ends when all the machines’ jobcandidate lists are empty. The remaining unscheduled jobs are input for the second phase. The pseudocode of the
$LPTBH$ heuristic is shown in Algorithm 2.
Table 1 lists notations used to develop Algorithms 1 and 2.
Algorithm 1$Candidate\_Search$. 
 1:
procedure (Input $N=\{1,\dots ,n\}$, m, ${p}_{ij},\phantom{\rule{4pt}{0ex}}i=1,\dots ,m;j=1,\dots ,n$, $maxA{v}_{i},\phantom{\rule{4pt}{0ex}}i=1,\dots ,m$)  2:
 3:
for $i=1$ to m do  4:
 5:
for $j=1$ to n do  6:
 7:
if (${p}_{ij}\le maxA{v}_{i}$) then  8:
 9:
$L{c}_{i}=L{c}_{i}\cup \left\{j\right\}$  10:
 11:
end if  12:
 13:
end for  14:
 15:
end for  16:
 17:
Sort the jobs in every $L{c}_{i},\phantom{\rule{4pt}{0ex}}i=1,\dots ,m$ in a nonincreasing order of their processing times.  18:
 19:
end procedure  20:

Algorithm 2$LPTBH$. 
 1:
procedure (Input $N=\{1,\dots ,n\}$, m, ${p}_{ij},\phantom{\rule{4pt}{0ex}}i=1,\dots ,m;j=1,\dots ,n$, ${N}_{i},\phantom{\rule{4pt}{0ex}}i=1,\dots ,m$, ${S}_{ik},{E}_{ik},\phantom{\rule{4pt}{0ex}}i=1,\dots ,m;k=1,\dots ,{N}_{i}$. Output $S={C}_{max}$)  2:
 3:
for $i=1$ to m do  4:
 5:
for $k=1$ to ${N}_{i}$ do  6:
 7:
$a{v}_{ik}={E}_{ik}{S}_{ik1}$  8:
 9:
end for  10:
 11:
$maxA{v}_{i}={max}_{k}a{v}_{ik}$  12:
 13:
${C}_{i}=0$  14:
 15:
end for  16:
 17:
Call $Candidate\_Search$  18:
 19:
while ($S\ne \varnothing $) do  20:
 21:
Among the jobs of $L{c}_{i},\phantom{\rule{4pt}{0ex}}i=1,\dots ,m$, select the job with the highest processing time. Let l be that job and ${i}_{l}\left(s\right)$ the machine(s) to which it can be assigned.  22:
 23:
if (l exists in more than one $L{c}_{i}$) then  24:
 25:
Assign l to the machine on which it can finish as early as possible.  26:
 27:
else Assign l to machine ${i}_{l}$  28:
 29:
Update ${C}_{{i}_{l}}$  30:
 31:
end if  32:
 33:
$S=S\setminus \left\{l\right\}$  34:
 35:
Update $a{v}_{ik}$ of the machine to which job l was assigned.  36:
 37:
Call $Candidate\_Search$  38:
 39:
if ($L{c}_{i}=\varnothing ,\forall \phantom{\rule{4pt}{0ex}}i=1,\dots ,m$) then  40:
 41:
if ($\leftS\right\ne n$) then  42:
 43:
$LR\leftarrow N\setminus S$  44:
 45:
Schedule the jobs of $LR$ according to $LPT$ rule.  46:
 47:
Calculate ${C}_{i},\forall \phantom{\rule{4pt}{0ex}}i=1,\dots ,m$  48:
 49:
end if  50:
 51:
$S\leftarrow S\setminus LR$  52:
 53:
end if  54:
 55:
end while  56:
 57:
$S={max}_{i}{C}_{i}$  58:
 59:
return S.  60:
 61:
end procedure

3.2.2. Improvement Procedure $LSHIP$
The idea of the improvement procedure was inspired from a localsearch heuristic proposed in [
16], developed to solve the scheduling problem of parallel identicalbatch processing machines. The aim of the improvement procedure was to try to balance the load of different machines so that the completion times of the last jobs in every machine are almost the same. This improvement can be achieved by interchanging pairs of jobs between the most loaded machine and other machines. The flowchart of the aforementioned heuristic is shown in
Figure 1.
In order to illustrate the proposed heuristic, let us consider a problem instance with 2 machines and 10 jobs.
Table 2 summarizes the input data, and
Figure 2 and
Figure 3 show the Gantt charts of solutions obtained by
$LPTBH$ and
$LSHIP$, respectively.
Note that after interchanging a pair of jobs between two machines, the $LSHIP$ procedure looks to shift jobs to the left whenever the idle time interval on the machine can fit them. In the above example, after interchanging jobs $J3$ and $J8$, $LSHIP$ shifted job $J2$ to the left since it could fit in the idle time interval.
4. Experiment Results
For the purpose of evaluating the performance of the proposed algorithm, many problem instances were tested. These were generated after examining the important factors that significantly impacted the performance of the proposed algorithm. The first factor was the number of jobs n to be processed that directly affects the machines’ load. The second important factor is the number of machines m that has an impact on the assignment of jobs to machines. Job processing times may play a role in the efficiency of the proposed algorithm. Thus, we generated problem instances with different job processing times. The algorithm was coded in IntelliJ IDEA. In addition, the quadratic model was modelled in IBM ILOG CPLEX Optimization Studio 12.7. The proposed heuristic was implemented using programming language Java. We ran all test problems on an Intel Core i5 2.5 Gigahertz, 4 Gigabyte RAM Macintosh HD.
In order to avoid useless computational time, the program was stopped for two possible reasons. The first was when the CPLEX became unable to generate a solution within the time limit of 3600 s (1 h). The second reason was due to memory overflow. At this point, the best feasible solution found within the time limit was recorded.
4.1. Data Generation
A deep empirical study was conducted with the aim to generate datasets that would help to correctly analyze the efficiency of the proposed algorithm. By the end, two dataset series were considered, namely,
$DS1$ and
$DS2$. In fact, the way to generate dataset series
$DS2$ was inspired from Graham’s datageneration process [
17] addressing
$P\left\rightCmax$ problems. The parameters used to generate
$DS1$ and
$DS2$ are summarized in
Table 3 and
Table 4, respectively.
The starting and ending times
${S}_{ik}$ and
${E}_{ik}$ of the unavailability periods were generated according to Equations (
9) and (
10), respectively.
4.2. Experiments
In this section, we outline different experiments that were conducted to evaluate the performance of the
$QM$ and the proposed algorithm. In all experiments, Central Processing Unit time (
$CPUt$) represents the time in seconds required to find the optimal or best feasible solution.
Table 5 and
Table 6 show the results obtained by
$QP$ and
$MA$ for small and large job processing times, respectively.
Table 5 clearly shows that the proposed algorithm was generating optimal solutions with a
$CPU$ time of less than 1 second for all problem instances. Quadratic model
$QM$ was also able to provide optimal schedules in a reasonable time. By considering much longer processing times than in the previous data series, we still obtained optimal solutions in reasonable
$CPU$ time even though the quadratic model became slower than in the first batch of problem instances. The proposed algorithm outperformed the quadratic model in terms of computational time that was still less than 1 second.
Table 6 confirms these observations.
In order to investigate the limitations of the proposed quadratic model, a second dataset series, namely,
$DS2$ was considered.
Table 7 reports the computational results for both
$QM$ and
$MA.$The computational results displayed in
Table 7 show that quadratic model
$QM$ was able to generate an optimal solution within a time limit for problems with up to 73 machines.
On the basis of the computational results shown in
Table 7, the quadratic model was not able to generate optimal solutions in a reasonable time and for bigger problems. Therefore, proposed procedure
$MA$ was tested for largesized problems and compared to an adapted form of
$MLPT$, proposed earlier by the author of this paper in [
7].
Table 8 reports the obtained results for problem instances with
$m\in \{100,200,300,400,500,600,700,800,1000\}$ and
$n=2m+1.$Table 8 shows that
$MA$ outperformed
$MLPT$ for all problem instances with slightly higher
$CPU$ time than the time of
$MLPT$$CPU$ for most instances. In addition, run time increased with problem size.