Minimizing the makespan on a single machine with flexible maintenances and jobs’ release dates

Accepted Manuscript

Minimizing the makespan on a single machine with flexible maintenances and jobs’ release dates Wei-Wei Cui , Zhiqiang Lu PII: DOI: Reference:

S0305-0548(16)30274-X 10.1016/j.cor.2016.11.008 CAOR 4121

To appear in:

Computers and Operations Research

Received date: Revised date: Accepted date:

29 October 2014 10 November 2016 10 November 2016

Please cite this article as: Wei-Wei Cui , Zhiqiang Lu , Minimizing the makespan on a single machine with flexible maintenances and jobs’ release dates, Computers and Operations Research (2016), doi: 10.1016/j.cor.2016.11.008

This is a PDF file of an unedited manuscript that has been accepted for publication. As a service to our customers we are providing this early version of the manuscript. The manuscript will undergo copyediting, typesetting, and review of the resulting proof before it is published in its final form. Please note that during the production process errors may be discovered which could affect the content, and all legal disclaimers that apply to the journal pertain.

ACCEPTED MANUSCRIPT

A clear mathematical description of the integration between production scheduling and maintenance is presented. A high accurate heuristic ERD-LPT is proposed based on the analysis of optimal properties. A branch-and-bound algorithm is developed, which can be used to solve the

AC

CE

PT

ED

M

AN US

CR IP T

small-to-medium sized problems.

ACCEPTED MANUSCRIPT

Minimizing the makespan on a single machine with flexible maintenances and jobs’ release dates

CR IP T

Wei-Wei Cui a, Zhiqiang Lu b,* a

School of Mechanical Engineering, Shanghai Jiao Tong University, Shanghai 200240, PR China

b

School of Mechanical Engineering, Tongji University, Shanghai 201804, PR China

AN US

*Corresponding Author: Name: Zhiqiang Lu E-mail: [email protected]

AC

CE

PT

ED

Fax: (86) 021-34206539

M

Phone: (86) 021- 69589485

ACCEPTED MANUSCRIPT

Minimizing the makespan on a single machine with flexible maintenances and jobs’ release dates Abstract: This paper addresses the production scheduling problem on a single machine with flexible periodic preventive maintenances (PM), where jobs’ release dates are also considered. Both resumable and non-resumable cases are studied. For the resumable case, it is proved that the problem can be solved in polynomial time with Earliest Release Date

CR IP T

(ERD) rule. For the non-resumable case, it is proved to be NP-Hard in strong sense. And, a mixed integer programming (MIP) mathematical model is provided. Then, an effective

heuristic ERD-LPT based on the properties of optimal solution is proposed. Meanwhile, a branch-and-bound algorithm (B&B) that utilizes several dominance rules is developed to search the optimal schedule for small-to-medium sized problems. Computational results

AN US

indicate that the proposed heuristic is highly accurate and the two algorithms are

complementary in dealing with different sized problems. Furthermore, the improvement of the integration between production scheduling and PM is significant compared with the First-in-First-out (FIFO) rule which is adopted commonly in industry.

Keywords: scheduling; preventive maintenance; release date; makespan

M

1. Introduction

In the past decades, production scheduling problems have been interesting topics to

ED

many researchers and practitioners, such as single machine scheduling problem, parallel machine scheduling problem, flow shop scheduling problem, and job shop scheduling

PT

problem, etc. The objectives of minimizing makespan, total flow time, tardiness, and number of late jobs, etc., are widely studied. The exact algorithms, such as optimal dispatching rules, dynamic programming and branch & bound algorithm, and the approximation algorithms,

CE

such as constructive heuristic and meta-heuristic, are developed according to the features of problem. But, most of traditional literature assumes that machine is always available during

AC

the scheduling horizon, which is not the case in real industrial practice. Nowadays, maintenance planning becomes more and more important in manufacturing

processes. With the development of maintenance theory, corrective maintenance (CM) strategy is commonly replaced by preventive maintenance (PM) strategy in industries. PM is a scheduled downtime, usually periodical, in which a well-defined set of tasks (e.g., inspection, repair, replacement, cleaning, lubrication, adjustment and alignment) are performed [1]. PMs can keep machines in good condition and decrease the probability of machines’ failures. Meanwhile, PM occupies the running time of machine, which decreases

ACCEPTED MANUSCRIPT the capacity of machine. Even if there are many jobs waiting for the processing, no job can be processed on the machine when PM is performed. Thus, it’s necessary to consider the plan of production scheduling when we decide when to perform PMs. And, the impact of PM also needs to be considered in the decision of production scheduling. Production scheduling and PM planning should be taken into the integrated optimization model into consideration to balance the utilization and availability of the resource [2]. Since

CR IP T

the machine is unavailable when PMs are performed, the PMs as deterministic unavailability constraints are introduced into the production scheduling problems in most of related

studies. The scheduling problems with unavailable intervals have received considerable

attention since the beginning of the 1990s. Two cases of consideration about unavailability constraints can be found in literature: (i) unavailable intervals are known and fixed in

AN US

advance; (ii) the intervals are flexible, which can be scheduled by decision makers.

In the first case, the unavailable intervals are known and fixed at the beginning of scheduling horizon. Comprehensive reviews about this case are provided in [3-5]. The following is a review of the works dealing with single machine scheduling problems. As far as the makespan is considered, Lee [6] assumed that only one unavailable interval exists in the

M

scheduling horizon. He proved that the problem is NP-hard and showed that the worst case relative error bound of LPT rule is 1/3. Ji et al. [7] assumed that maintenances are periodical.

ED

They proved that the error bound of LPT rule is 1 and showed that no polynomial time algorithm with an error bound of less than 1 exists for this problem. No mathematical model

PT

is shown and no method is proposed to obtain the optimal solution in [6, 7]. When the objective is to minimize total completion time, Adiri et al. [8] proved that the problem is NP-hard and showed that the error bound of SPT rule is 1/4. Then, Lee & Liman [9]

CE

presented a much shorter NP-completeness proof than the one in [8]. Meanwhile, they proved that the tight error bound of SPT rule is 2/7. Then, Sadfi et al. [10] presented an

AC

approximation algorithm MSPT with a tight error bound of 3/17. Then, Breit [11] proposed a parametric O(nlogn)-algorithm H with which a better error bound can be obtained compared with [10]. No mathematical model is shown and no method is proposed to obtain the optimal solution in [8-11]. For the objective of total weighted completion time, Kacem & Chu [12] showed that both the absolute and asymptotical bounds of WSPT and MWSPT are equal to 3 under some conditions. Then, Kacem [13] proposed a 2-approximation algorithm with O(n2) time complexity and showed that this bound is tight. Then, Kacem & Chu [14] proposed a branch & bound algorithm based on a set of lower bounds and heuristics for this

ACCEPTED MANUSCRIPT problem. Meanwhile, Kacem et al. [15] compared the performances of three exact algorithms, including a Mixed-Integer linear programming, a dynamic programming and a branch & bound algorithm. They showed that dynamic programming and branch & bound are complementary and both of them are better than MIP method. [16-19] studied the similar problems for some other objectives with jobs’ due dates. Liao & Chen [16] proposed a heuristic and a branch & bound algorithm for minimizing maximum tardiness of the problem subject to periodic maintenances. Chen [17] proposed a heuristic and a branch &

CR IP T

bound algorithm for minimizing the number of tardy jobs. While, in [16] and [17], the time

complexity of heuristic is pseudo-polynomial and the computation time of branch & bound is rather long even for the problem with 30 jobs. Then, Lee & Kim [18] studied the same

problem with [17] and proposed a two-phase heuristic TPH. The performance of TPH is

better than the heuristic in [17], but the computation time of TPH is longer than that in [17].

AN US

Molaee et al. [19] proposed a branch & bound algorithm for minimizing the maximum earliness and number of tardy jobs for a problem with an unavailable interval in the

scheduling horizon. The Pareto frontier is found for the bi-objective in this paper, which makes it different from the above studies.

M

In the second case, the unavailability constraints are deterministic, and segmental flexibility is permitted at the same time. Some researchers assume that machine must be maintained after it continuously works for a maximum allowed continuous working time T.

ED

Graves & Lee [20] proposed a pseudo-polynomial time dynamic programming algorithm to minimize the total weighted completion time when there are at most two unavailable

PT

intervals in the scheduling horizon. Mosheiov & Sarig [21] proposed a pseudo-polynomial dynamic programming algorithm and a simple heuristic to minimize the total weighted

CE

completion time when there is only one unavailable interval. However, the worst case optimality gap of the heuristic is unbounded in [21]. When the periodical flexible

AC

maintenances are considered, Qi et al. [22] proposed three simple heuristics and a branch & bound algorithm to minimize the total completion time. The calculation of error bounds of these heuristics was not presented in this paper. Sbihi & Varnier [23] proposed a heuristic and a branch & bound algorithm to minimize the maximum tardiness. The time complexity and error bound of the heuristic were not presented in this paper. Some other researchers assume that maintenances must be executed in predefined intervals. When only one flexible maintenance activity needs to be performed in a predefined interval [u,v], Chen [24] developed four mixed binary integer programming models for minimizing the total tardiness. Since no algorithm was provided in this paper, only small sized problems can be

ACCEPTED MANUSCRIPT solved by Cplex software. Yang et al. [25] calculated error bound of the SPT algorithm and developed a dynamic programming and a branch-and-bound algorithm to minimize the total completion time. When multiple maintenances are considered, Chen [26] developed four mixed binary integer programming models to minimize the mean flow time. He proposed a heuristic based on SPT rule to solve the large sized problem. Chen [27] developed two mixed binary integer programming models to minimize the makespan and proposed a heuristic to solve the large sized problems. Then, Low et al. [28] compared the performances of six kinds

CR IP T

of heuristics for this problem and provided the calculation of error bounds.

All the above papers assume that jobs are arrived at time zero. However, it is very

common that jobs are arrived at different times in practical industrial environments. Some researchers study the scheduling problems considering the jobs’ release dates without the

maintenance consideration. The related studies in this field can be found in [29-31], etc. To

AN US

the best of our knowledge, only one paper simultaneously considers the maintenance

constraints and jobs’ release dates. Detienne [32] investigated scheduling problems with deterministic machine availability constraints in order to minimize the weighted number of late jobs. In Detienne’s work, the jobs’ release dates were considered. But, the author

M

assumed that the time durations of unavailable intervals are given in advance. It means that the number of unavailable intervals is fixed no matter with the size of jobs. However, we focus on another case, which is applied widely in industries. The period time of PM is given,

ED

while the number of PMs is not known. The number depends on the input of problem and

PT

the decision maker’s scheduling plan.

This paper aims to provide a mathematical description and two effective algorithms for the production scheduling problems on a single machine, where flexible periodical

CE

maintenances and jobs’ release dates are considered at the same time. The remainder of this paper is organized as follows. In Section 2, we describe the problem in detail and

AC

formulate it with a mathematic model. In Section 3, a heuristic based on the properties of optimal solution is proposed. Section 4 details the architecture of the proposed branch-and-bound algorithm. Computational experiments are then given in Section 5 to demonstrate the effectiveness of algorithms and the value of the integration between production scheduling and maintenances. Section 6 makes conclusion and discusses possible extensions of this study.

ACCEPTED MANUSCRIPT 2. Problem description 2.1 Problem formulation A set of jobs J  {J1 , J 2 ...J n } is to be scheduled on a single machine. pj is the deterministic processing time of Jj and rj is the job’s release date. It is necessary to perform PMs periodically in order to keep machine in a good condition. The machine’s continuous working time ignoring idle time cannot exceed a maximum allowed time T. The maintenance

CR IP T

time is tp. No pre-emption of operation is allowed, i.e., non-resumable case is focused here. If a job is started but not finished before an unavailable interval, it must be restarted after the interval. The objective is to minimize makespan Cmax subject to the given jobs’ release

dates and maintenance constraints. We need to decide the sequence of jobs and the start times of PMs. Besides, we assume that T≥pj for all jobs; otherwise, there is simply no

feasible schedule. According to the standard machine scheduling classification, the problem

AN US

P can be denoted as 1| rj , nr  a, fm | Cmax .

As shown in Fig.1, a schedule  contains a sequence of jobs and PMs inserted in the sequence. If a batch denotes a set of jobs in the same PM period, then  can be

M

represented as   {BH1 , PM1 ,..., BHl ,..., PM L1 , BH L } . BH l is the lth batch in  . Let

Ql be the total processing time of jobs in BH l . Then, Ql must be less than or equal to T.

ED

It can be represented easily by the definition of machine’s age. The initial machine’s age is 0. It increases with processing jobs and it doesn’t change when machine is idle. The machine’s idle time is only caused by jobs’ release dates. No idle time exists immediately before a PM;

PT

otherwise, we can just move the PM forward and get a better solution. After PM, the machine’s age becomes 0. It means that the preventive maintenance policy is run-based

CE

rather than time-based in this study. Then, the unavailability constraints can be represented by that the machine’s age must be less than or equal to T at any time during the scheduling

AC

horizon.

Q1   i 1 p[ i ]  T

J[1]

j

J[2] BH1

J[j]

Q2   i  j 1 p[i ]  T k

t PM1

J[j+1]

J[j+2] BH2

J[k]

t PM2

Q3   i  k 1 p[ i ]  T n

J[k+1]

J[n] BH3

Fig.1. The Gantt chart of a schedule with flexible periodic PMs

ACCEPTED MANUSCRIPT In the following part, we provide a mixed integer programming (MIP) model for this problem. This model is a clear mathematical description and can be used to search the optimal solution with a commercial mixed integer programming solver. The notations used in this paper are shown as follows:

x ji : the jobs’ sequence decision variable, if J j is performed in the ith position, x ji  1 ; otherwise, x ji  0 . J [ i ] : the job in the ith position. p[ i ] : the processing time of J [ i ] . r[ i ] :

y[ i ] : if a

CR IP T

the release date of J [ i ] . s[ i ] : the start time of J [ i ] . c[ i ] : the finish time of J [ i ] .

maintenance is performed immediately before J [ i ] , y[i ]  1 ; otherwise, y[i ]  0 . a[ i ] :

the machine’s age immediately after J [ i ] . b[ i ] : the machine’s age immediately before J [ i ] .

AN US

The mathematical model is finally set as follows:

s.t.

 

n i 1

n j 1

x ji  1

1  j  n

x ji  1

1  i  n

p[i ]   j 1 x ji p j 1  i  n r[i ]   j 1 x ji rj

1  i  n

(1)

(2)

(3)

(4)

c[i ]  s[i ]  p[i ]

1  i  n

(5)

CE

PT

n

ED

n

M

Min c[n]

1  i  n

(6)

AC

s[i ]  r[i ]

s[i ]  c[i 1]  y[i ]t p

1  i  n

(7)

b[1]  0, y[1]  0

(8)

b[i 1]  a[i ] (1  y[i 1] )1  i  n

(9)

ACCEPTED MANUSCRIPT

a[i ]  b[i ]  p[i ]

1  i  n

(10)

a[i ]  T

1  i  n

(11)

1  i  n, 1  j  n

(12)

y[ i ] is binary

1  i  n

(13)

p[i ] , r[i ] , c[i ] , s[i ] , b[i ] , a[i ]  0

CR IP T

x ji is binary

(14)

1  i  n

AN US

Constraint (1) and Constraint (2) ensure that each job can only be placed at one position and each position can only be occupied by one job. Constraint (3) specifies the processing time of J [ i ] . Constraint (4) specifies the arrive time of J [ i ] . Constraint (5) establishes the link between the start time and finish time of J [ i ] . Constraint (6) ensures that the job cannot start before its arrive time. Constraint (7) ensures that the job should start no earlier

M

than the sum of its immediate predecessor’s finish time and the possible maintenance time. Constraint (8) specifies the initial condition of the system. Constraint (9) and Constraint (10)

ED

specify the machine’s age immediately before J [ i ] and the machine’s age immediately after J [ i ] . Constraint (11) ensures that the machine’s continuous working time is not larger

PT

than T.

CE

2.2 Preliminary analyses We will show that the problem is NP-hard by reducing the well-known Bin-packing

AC

problem.

Theorem 1. The problem P: 1| rj , nr  a, fm | Cmax is NP-hard. Proof: When all jobs’ release dates are 0, which means all the jobs are ready to be

processed at time zero, a special problem P’: 1| nr  a, fm | Cmax is generated. No idle time exists in this problem. The makespan of P’ can be obtained by

Cmax  i 1 p[i ]  i 1 y[i ] * t p   j 1 p j  i 1 y[i ] * t p   j 1 p j   * t p , where  is n

n

n

n

n

ACCEPTED MANUSCRIPT the number of PMs. The minimization of Cmax is the optimization version. The recognition version of P’ can be stated as follows. Definition of recognition version of P’: Given a set of n jobs J with the maintenance constraint (T, t p ), does there exist a schedule whose makespan is not larger than a value



n j 1

p j   *tp ?

CR IP T

We provide the proof of NP-hardness for this special case by transforming the Bin-packing problem into the case.

Recognition version of Bin-packing problem: Given a bin B of size c and a set

K  {a1 , a2 ...ak } of positive numbers. The number of bins is L, does there exist an



a j  c 1  l  L ?

a j Bl

AN US

assignment f :{a1 , a2 ...ak }  {B1 , B2 ...BL } with

Given an instance  of Bin-packing problem, we construct the following instance  ' of P’:

M

Let n=k, T=c. Jobs’ processing times are: p j  a j for j  1, 2...k .   L  1. Next, we will show that the feasible assignment exists for  if and only if a feasible

ED

schedule exists for  ' .

PT

(1) If there is a schedule for  ' such that Cmax 



k j 1

a j  ( L  1)t p , it means that

we can find a feasible solution   {BH1 , PM1 , BH 2 ,..BHl ,..PM L1 , BH L } considering

CE

that the total processing time



k j 1

a j is a constant. It satisfies that the total processing

time of jobs in each batch is not larger than c. It means that we also find a feasible

AC

assignment for  and the elements in each bin correspond to the processing time of jobs in each batch. (2) Conversely, if there is a feasible assignment for  , it means that we find an

assignment f '' :{a1 , a2 ...ak }  {B1 , B2 ...BL } , which satisfies that the sum of elements in each bin is not larger than c. It means that we also find a schedule, the jobs in each batch correspond to the elements in each bin, whose makespan is



k j 1

a j  ( L  1)t p . The

ACCEPTED MANUSCRIPT contrapositive of this implication is that the answer NO for  ' yields the answer NO for

. Then, we can conclude that   p  ' . Since Bin-packing problem is NP-Complete, P’:

1| nr  a, fm | Cmax is NP-Hard. In addition, when jobs’ release dates are considered, the original problem P is more

CR IP T

complicate than P’. The optimal schedule of problem P may have more number of maintenances than the schedule which contains the minimum number of maintenances. The following is a simple example.

Example1: Let n=4, p1=p2=2, p3=p4=8, r1=r2=0, r3=r4=10, T=10, t=5. The schedule  1 with the minimum number of batches is (J1, J3, t, J2, J4) and the makespan f (1 )  33 .

better, which is shown in Fig.2 clearly. 2

10

J1

AN US

Considering another schedule  2  (J1, J2, t, J3, t, J4), its makespan f ( 2 )  31 .  2 is

18

4

10

18

J3

25

J2

J4

23

PM

31

J4

33

1

2

ED

PM

M

2

J1 J2

23

PM

J3

Fig.2. Gantt chart of the two schedules

PT

When the maintenance constraint is not considered, the problem 1| rj | Cmax can be solved in polynomial time with the Earliest Release Date (ERD) rule, i.e., the job with earlier

CE

release date has higher priority. It is well known and can be proved easily by pair wise interchange procedure.

AC

Next, we introduce some properties of optimal schedule of problem P. Property 1. There is at least one optimal schedule satisfying that jobs in each batch are

sequenced according to the ERD rule. Proof: There are maybe more than one optimal schedules. We assume that there is at least one batch satisfying that jobs in this batch are not sequenced according to the ERD rule in any optimal solution. Then, we can easily get another optimal schedule by reordering the jobs’ sequence in that batch according to the ERD rule. It is a contradiction.

ACCEPTED MANUSCRIPT Some notations are presented here to make the next two properties clear. PS is a partial schedule. C(PS) is the completion time of the last job in PS. S(PS) is the start time of the first job in PS. r(PS) is the release date of the first job in PS. b(PS) is the machine’s age before the first job in PS. a(PS) is the machine’s age after the last job in PS. C(BHi) is the completion time of the last job in BHi. a(BHi) is the machine’s age after the last job in BHi. Property 2. Consider a schedule  ={PS1, PMi-1, BHi, PMi, PS2, Jj, PS3}, where PSs are

CR IP T

partial schedules. If rj  C ( BH i ) and a( BHi )  p j  T , then a Cmax , which is not larger than the original one, can be obtained by moving Jj to the batch BHi.

Proof: For schedule  , S(PS3)=max{r(PS3), C(PS2)+pj}, b(PS3)=a(PS2)+pj. Another

schedule  ' can be obtained by moving Jj to the batch BHi. For the schedule  ' ,

S’(PS3)=max{r(PS3), C’(PS2)}, b’(PS3)=a’(PS2). Since a’(PS2)=a(PS2), we can get b’(PS3)
AN US

There are idle times in PS2 for  , and some of them can be absorbed in  ' . It results in C’(PS2) ≤ C(PS2)+pj. We can get S’(PS3) ≤ S(PS3). Considering the machine’s age at the beginning of PS3 and the start time of PS3, we can get Cmax ( ')  Cmax ( ) . Property 3. Consider a schedule  ={PS1, PMi-1, BHi, PMi, PS2, Jj, PS3}, where PSs are

M

partial schedules. If there is a job Jk in BHi, which satisfies p j  pk , rj  S ( J k ) and

ED

a( BHi )  p j  pk  T , then a Cmax, which is not larger than the original one, can be obtained by interchanging Jk with Jj.

Proof: For schedule  , S(PS3)=max{r(PS3), C(PS2)+pj}, b(PS3)=a(PS2)+pj. Another schedule

PT

 ' can be obtained by interchanging Jk with Jj. For the schedule  ' , S’(PS3)=max{r(PS3), C’(PS2)+pk}, b’(PS3)=a’(PS2)+pk. Since a’(PS2)=a(PS2) and pk < pj, we can get b’(PS3)
CE

There are idle times in PS2 for  , and some of them can be absorbed in  ' because of pj > pk . It results in an formula C’(PS2)≤C(PS2)+(pj－pk). Then, we have C’(PS2)+pk ≤ C(PS2)+pj. We

AC

can get S’(PS3) ≤ S(PS3). Considering the machine’s age at the beginning of PS3 and the start time of PS3, we can get Cmax ( ')  Cmax ( ) .

3. Heuristic: ERD-LPT Firstly, two principles are proposed in order to show the heuristic clearly. (i) If a batch is envisaged as a bin, then the bin should be filled as full as possible, i.e., the total processing time of jobs in a batch should be close to T. The main idea of this principle comes from the Property 2 and Property 3. (ii) It is common that there may exist idle times between two consecutive jobs since the jobs cannot be started before release dates. Then, it’s easy to

ACCEPTED MANUSCRIPT know that PMs should be inserted in such idle times when the maintenance constraint is considered, since performing the PMs in these idle times will not affect the successive job’s start time. According to the principles, jobs are scheduled dynamically. At each decision epoch e, we need to determine which task (job or PM) is performed according to the decision rule. And then, the finish time of that task is the new decision epoch. The main idea of decision rule is

CR IP T

described as follows. If there are one or more than one jobs which can be finished without violating the maintenance constraint, then the job with the longest processing time is processed instantly. Otherwise, the unprocessed job with the earliest release date is

selected to be the next processed job if it can be finished without violating the maintenance constraint.

AN US

Let S1 be the set of scheduled jobs. Let S2 be the set of unscheduled jobs. Let C(S1) be the completion time of the last job in S1. Let V(S2) be the total processing time of unscheduled jobs. Let t(e) be the time of epoch e. Let age be the machine’s age. At any decision epoch e, 1 (e) is the set of jobs { J j | ( J j  S 2, rj  t (e)) } and 2 (e) is the set of jobs { J j | ( J j  S 2, rj  t (e), p j  age  T ) }. Obviously, 2 (e)  1 (e) . Let J Lg (e) be

M

the job with the longest processing time in 2 (e) . The detailed procedure of heuristic is

ED

described in Algorithm I. At the beginning of algorithm, S1   . Algorithm I: ERD-LPT heuristic

PT

Step 1. Reorder the jobs according to ERD rule, i.e., r1  r2  ...  rn . Ties are broken by

CE

the LPT rule. Then, the jobs’ list S2={J1, J2,.. Jn}. Step 2. Process J1 at time r1 , set age  p1 . S1  {J1}, S 2  S 2 \ J1 . The finish time of

AC

J1, t  r1  p1 , is the next decision epoch. Step 3. For each decision epoch e, do Step3.1. Find 2 (e) . If 2 (e) is empty, goto Step3.2; else, goto 3.2.4. Step3.2. Find 1 (e) . If 1 (e) is not empty, goto 3.2.1; else, goto 3.2.2.

ACCEPTED MANUSCRIPT 3.2.1 Perform PM at t(e), set age=0. If V (S 2)  T , then the jobs in S2 are scheduled according to ERD rule and algorithm stops; else, the finish time of PM, t=t(e)+tp, is the next decision epoch and goto Step 3. 3.2.2 If V (S 2)  T , perform PM at t(e), and the jobs in S2 are scheduled according to ERD rule and algorithm stops; else, goto 3.2.3.

1 : If r 2 3 ○ S 2i  t (e)  t p , goto ○; else, goto ○.

CR IP T

3.2.3 S 2i means the ith job in the list S 2 . Set i=1.

2 : Perform PM at t(e), set age=0. If V ( S 2)  T , then the jobs in S2 are ○

scheduled according to ERD rule and algorithm stops; else, the finish time of PM, t=t(e)+tp , is

AN US

the next decision epoch and goto Step 3.

3 : If age  p ○ S 2i  T , then perform S 2i at time t  max{rS 2i , C ( S1)} ,

age  age  pS 2i , and the finish time of that job, t  max{rS 2i , C (S1)}  pS 2i , is the next

M

4 . epoch, set S1  S1  S 2i , S 2  S 2 \ S 2i and goto Step 3; else, goto ○

4 : If S 2 is the last job in S2, perform PM at t(e), set age=0, the finish time of ○ i

ED

1 . PM, t=t(e)+tp , is the next epoch and goto Step 3; else, i=i+1, goto ○

3.2.4. Process J Lg (e) at t(e), age  age  pJ Lg ( e ) .

PT

S1  S1  J Lg (e), S 2  S 2 \ J Lg (e) . The finish time of J Lg (e) , t  t (e)  pJ Lg ( e) , is the

CE

next decision epoch and goto Step 3. Let TC be the time complexity of Algorithm I. Let TC1 be the complexity of Step 1. Let TC2

AC

be the complexity of Step 2. Let TC3 be the complexity of Step 3. Then, we have TC=TC1+TC2+TC3. Sorting procedure in Step 1 leads to TC1= O(n log n) . The constant procedure in Step 2 leads to TC2= O(1) . Step 3 is an iteration procedure. Considering that the PM may be selected to be performed instead of the jobs in an iteration step, one job will be selected in two iteration steps in the worst case. A job has been scheduled in Step2. Then, at the beginning of Step3, there are n-1 jobs in the unscheduled set S2. Let n2 be the number of jobs in S2. For each iteration, in the worst case, it goes through 3.13.23.2.23.2.3, which results in (3n2+1) sub-steps. Then, we have

ACCEPTED MANUSCRIPT TC3  2 n 1 (3n2  1)  3n2  n  2 . n 1 2

Then, we can get that TC3= O(n2 ) . Then, the total time complexity can be stated as TC= O(n2 ) . A simple example is presented below to show the procedure of the proposed heuristic clearly. Example2: n=8, Ji=(pi, ri), T=10, tp=5. Applying Step 1, we have the jobs set

steps executed according to ERD-LPT.

CR IP T

J={(3,1);(2,2);(4,3);(2,9);(5,18);(4,20);(3,20);(5,30)}. The following shows the results of the

(1). Applying Step 2, J1 is processed firstly, which results in S2={ J2, J3, J4, J5, J6, J7, J8}. The finish time of J1 is 4. Time 4 is the next epoch.

AN US

(2). Applying Step3.1, and it will go to 3.2.4. J2 and J3 can be processed here, and J3 is

selected since its processing time is longer. It results in S2={ J2, J4, J5, J6, J7, J8}. The finish time of J3 is 8. Time 8 is the next epoch.

(3). Applying Step3.1, and it will go to 3.2.4. Only J2 can be processed here. It results in

M

S2={J4, J5, J6, J7, J8}. The finish time of J2 is 10. 10 is the next epoch.

(4). Applying Step3.1, and it will go to Step3.2 and go to 3.2.1. No jobs can be processed

ED

here since the machine’s age is 9 now. Then, a PM is performed instantly. The finish time of PM is 15. Time 15 is the next epoch.

PT

(5). Applying Step3.1, and it will go to 3.2.4. Only J4 can be processed here. It results in

CE

S2={J5, J6, J7, J8}. The finish time of J4 is 17. Time 17 is the next epoch. (6). Applying Step3.1, and it will go to Step3.2 and go to 3.2.2 and go to 3.2.3. J5 is selected to be processed at time 18. It results in S2={J6, J7, J8}. The finish time of J5 is 23. Time

AC

23 is the next epoch. (7). Applying Step3.1, and it will go to 3.2.4. Only J7 can be processed here. It results in

S2={J6, J8}. The finish time of J7 is 26. Time 26 is the next epoch. (8). Applying Step3.1, and it will go to Step3.2 and go to 3.2.1. No jobs can be processed here. Then, a PM is performed instantly. Since the total processing time of unscheduled jobs is less than 10, no more PM is needed. J6 and J8 are processed orderly. The algorithm stops.

ACCEPTED MANUSCRIPT

Fig.3. Example of different steps according to ERD-LPT

4. Branch and Bound algorithm A heuristic is proposed in Section 3. It is necessary to test the gap between the heuristic

CR IP T

and exact solution. Then, a branch-and-bound (B&B) algorithm is devised in this section to provide the optimal schedule.

4.1 Branching rule Since each feasible schedule can be represented as a permutation of n jobs and PM

AN US

decision before each job, we adopt a branching rule in which a node at the lth level of the

search tree corresponds to a partial schedule. In the partial schedule, the first l positions are filled. Let S1 be the set of scheduled jobs in node Nl and S2 be the set of unscheduled jobs. Let V(S2) be the total processing time of jobs in S2. And, there are 2*(n-l) child nodes emanating from each node. Each child node represents the addition of an unscheduled job

M

with the possible maintenance decision (1 or 0) in relation to the current partial schedule. Two possible branching nodes from the same added job for the partial schedule can be

ED

denoted by Nl 1 ([l  1],0) and Nl 1 ([l  1],1) , representing no PM and PM before job J[l+1] , respectively. [l  1] represents the (l+1)th job added to the partial schedule. Let C(Nl) be the completion time of the last job in node Nl. Let age(Nl) be the machine’s age

PT

immediately after the last job in node Nl. Some nodes will be discarded immediately if the

CE

machine’s age is larger than T. For a node Nl, if V(S2)+age(Nl) ≤ T, then it’s unnecessary to branch this node, we can get the exact objective of this node applying the ERD rule to the unscheduled jobs. For a node

AC

Nl, if V(S2)+age(Nl) >T and V(S2) ≤ T, then it’s unnecessary to branch this node, we can get the exact objective of this node as follows. Perform the PM instantly and schedule the jobs in S2 according to the ERD rule. 4.2 Dominance rules Firstly, in order to facilitate the searching process, we propose several dominance rules.

ACCEPTED MANUSCRIPT Rule 1. For a node Nl (a partial schedule), Ji is the last scheduled job and Jj is the second to the last scheduled job. Suppose Ji and Jj are in the same batch. If rj>ri, this node is dominated. Proof: The result follows immediately from the Property 1. Rule 2. For a node Nl, Ji is the last scheduled job and there is a PM immediately before Ji, Jj is the second to the last job. If there exists a job J k {S 2  J i } which satisfies

CR IP T

pk  a( J j )  T and rk  C ( J j ) , then this node is dominated.

Proof: a(Jj) is the machine’s age immediately after Jj and C(Jj) is the completion time of Jj. The result follows immediately from the Property 2.

Rule 3. For a node Nl, Ji is the last scheduled job and there is a PM immediately before Ji,

AN US

Jj is the second to the last job and BH is the batch of Jj. If there exists jobs J q {BH } and

J k {S 2  J i } , which satisfies pk  pq , a( J j )  pk  pq  T and rk  S ( J q ) , then this node is dominated.

M

Proof: S(Jq) is the start time of Jq. The result follows immediately from the Property 3. Rule 4. For a node Nl, if there exists another node Nl’ whose scheduled jobs are the same

ED

with those of Nl, and C ( Nl )  C ( Nl ') , age( Nl )  age( Nl ') , then Nl is dominated. Proof: The earliest allowed start time of the unscheduled jobs in Nl’ is earlier than that of

PT

Nl, and the machine’s age of Nl’ is smaller than Nl at this moment. Then, it’s obvious that node Nl is dominated by Nl’. In addition, if C ( Nl )=C ( Nl ') and age( Nl )=age( Nl ') , only

CE

one of them is dominated.

AC

Rule 5. Since the initial machine’s age is 0, it is unnecessary to perform a PM before the first job. Then, all the nodes N1 ([1],1) are eliminated in the first level. Rule 6. For a node Nl, the child nodes Nl 1 ([l  1],0) are dominated by Nl 1 ([l  1],1)

if Nl satisfies any condition below. (i) The release date of the earliest job in S2 is later than

C ( Nl )  t p . (ii) The unscheduled jobs whose release dates are earlier than C ( Nl )  t p cannot be processed instantly since their processing times (e.g., p j ) are too large, i.e.,

age( Nl )  p j  T .

ACCEPTED MANUSCRIPT Rule 7. For a node Nl, if there exists jobs in S2 which can be processed at time C(Nl), i.e., the release date of one job is earlier than C(Nl) and processing it will not violate the maintenance constraint, two kinds of child nodes can be eliminated. (i) The child nodes

Nl 1 ([l  1],1) can be eliminated, since they satisfy the Rule 2. (ii) The child nodes

Nl 1 ([l  1],0) satisfying r ( J[l 1] )  C ( Nl )  t p can be eliminated, since Nl 1 ([l  1],0) is dominated by Nl 1 ([l  1],1) , and Nl 1 ([l  1],1) can be eliminated as mentioned

CR IP T

above. 4.3 Lower bound

Firstly, we will show the optimal solution for the problem 1| rj , r  a, fm | Cmax in

Lemma 1, which can be used to derive the lower bound of the original problem. r-a means that jobs are resumable, i.e., the job interrupted by PM can be processed continually

AN US

without time penalty.  x  is the smallest integer which satisfies  x   x , e.g.,  2.5  3 .

Lemma 1. For 1| rj , r  a, fm | Cmax , the construction of optimal solution is as follows. The optimal jobs’ sequence is obtained by ERD rule. The optimal number of PMs is



p  ( j 1 p j ) / T  1 T . Then, PM is performed successively whenever j 1 j  

n

n

ED

reaches

M

n m*  ( j 1 p j ) / T  1 . The first PM is performed at the epoch when the machine’s age  

PT

the machine’s age reaches T.

Proof: The optimal jobs’ sequence is still the ERD order when maintenance constraint

CE

exists, which can be proved easily by the pair wise interchange procedure. When the PM constraint is ignored, the start times of jobs can be obtained according to

AC

the optimal sequence and there are some idle times which are caused by the jobs’ release dates. The objective is f 



n i 1

p[i ]  i 1 I[i ] , where I[i ] is the idle time between J[i 1] n

and J [ i ] . For example, the Gantt chart in Fig.4(a). When the PM constraint is considered, it’s obvious that the minimum number of PMs is

m  ( j 1 p j ) / T  1 .   n

ACCEPTED MANUSCRIPT We assume that the optimal number of PMs is m*  m , i.e., the set of PMs

PM  {PM1 , PM 2 ,...PM m } needs to be performed during the scheduling horizon. One PM can be viewed as a special job. Thus, we get a job set J '  {J }U{PM} . The number of jobs in J ' is n  m . The release dates of jobs in {J } are the same with those in the original problem and release dates of jobs in {PM } are 0. The total processing time between any

CR IP T

consecutive PM cannot be larger than T. If we ignore the constraint of T and want to finish all the jobs in J ' as quickly as

possible, the jobs in {PM } should be processed firstly based on the ERD rule since their

release dates are earlier than those of jobs in {J } . For example, the Gantt chart in Fig.4(b). When the maintenance constraint T is considered, the schedule in last paragraph is

AN US

infeasible for the original problem. Now, we prove that the earliest allowed start time of

PM m should satisfy that the total processing time after this epoch e equals to T. (1) The total processing time after this epoch cannot be larger than T; otherwise, it is infeasible. (2) Suppose there is an optimal schedule  in which the total processing time after epoch e is

M

less than T. It means PM m is started at a time after epoch e. We reset the epoch e to be time 0 and just consider the jobs after epoch e in schedule  . We get the corresponding

ED

sub-schedule  sub from  . Since  is optimal,  sub is also optimal for the new sub-problem. For the new sub-problem, we can get another schedule  sub ' by moving

PT

PM m forward to the time 0. It is feasible since the total processing time of jobs in the new sub-schedule equals to T, which does not violate the maintenance constraint. According to

CE

the ERD rule, Cmax ( sub ')  Cmax ( sub ) , it is a contradiction.

AC

Likewise, PM m1 should be inserted in the epoch e’ that the total processing time of jobs between e’ and e equals to T. By such analogy, we can get all the positions of PMs. Note that the analogy stops when the total time is not larger than T. It means that PM 1 is performed at the epoch when the machine’s age reaches For example, the Gantt chart in Fig.4(c). Next, we will prove that m*  m by contradiction.



p  ( j 1 p j ) / T  1 T . j 1 j  

n

n

ACCEPTED MANUSCRIPT Assume m  m in the optimal solution. According to the description above, the additional PMs will be inserted before the machine’s age reaches



p  ( j 1 p j ) / T  1 T . We can delete the additional PMs to get a better solution j 1 j  

n

n

directly. It’s a contradiction. For example, the Gantt chart in Fig.4(d).

[1]

PM1

[2]

PM2

[3]

[1]

PM3

[4]

[2]

[3]

[5]

[6]

[4]

[5]

T T [2]

PM1

[3]

[4] PM2

T [1]

PM0

[1]

PM1

[2]

[3]

[4]

[6]

[7]

[8]

(a)

[7]

[8]

(b)

T

[5]

[6] PM3

[6]

[7]

AN US

[1]

CR IP T

Thus, this lemma holds.

T

[4] PM2

[4]

[5]

[6] PM3

[6]

[8]

(c)

T [7]

[8]

(d)

M

Fig.4 Example of the proof when n=8, m*=3

For a partial schedule (node), the lower bound of Cmax can be calculated based on a completion of the partial schedule. The most important part of the algorithm for computing

ED

lower bound is based on the Lemma 1.

PT

Algorithm II: Computation of lower bound

CE

Step1. Set age  age( Nl ) . Step2. For the jobs J k {S 2} , count the number of jobs which satisfy age  pk  T

AC

and rk  C ( Nl )  t p . If the number is 0, goto Step3; else, goto Step4. Step3. Perform PM immediately after the last job in S1. Set age=0. Step4. The number of maintenance is m  (age  V (S 2)) / T  1 . Step5. Assume the jobs are resumable. The unscheduled jobs are sequenced according to the ERD rule. Step6. If V ( S 2) / T  1  m , goto step6.1; otherwise, goto step6.2.

ACCEPTED MANUSCRIPT Step6.1 Perform the PMs according to the Lemma1, i.e., the first PM is performed when machine’s age reaches age  V (S 2)  mT , and the other PMs are performed successively whenever machine’s age reaches T. Step6.2 Perform the first PM immediately after the last job in S1, set age=0. Perform the second PM when machine’s age reaches V ( S 2)  V (S 2) / T  1 T , and the

CR IP T

other PMs are performed whenever machine’s age reaches T. It is easy to show that the time complexity of Algorithm II, dictated by Step5, is bounded by O(nlogn).

4.4 Complete procedure A detailed procedure of the B&B developed before is given below, and the depth first

AN US

search strategy is employed because of its relatively low memory requirements. When we

search one node Nl in level l, 2*(n-l) child nodes are generated in level l+1. Then, we choose one of them to search and generate 2*(n-l-1) child nodes in level l+2. Accordingly, we will go deeply to the lowest level of the search tree. Then, go back to upper level one by one.

M

Algorithm III: Procedure of B&B

Step1. Initialization Rule. Use the ERD-LPT to obtain an upper bound of the problem,

ED

which is denoted UB.

Step2. Branching Rule. For a node Nl in level l, create new partial schedules and the PM

PT

positions according to the method in subsection 4.1. Then we get some child nodes in level l+1 of the tree. Calculate the completion time of the new added job and update the

CE

machine’s age as equations (9 and 10) for each node. Step3. Bounding Rule. For each newly created node, if the machine’s age is larger than T,

AC

delete it immediately; otherwise, calculate the lower bound by using the Algorithm II. Step4. Searching Rule. Use the dominance rules given in Rules 1–7 to eliminate any

possible newly created partial schedules. Eliminate those newly created partial schedules whose lower bound is not strictly smaller than UB. Select a node with the smallest lower bound among these newly created nodes to search. Update the UB if a whole schedule is obtained and its objective is smaller than that of incumbent best schedule. Step5: Stop Rule. If there are nodes remaining unsearched, go to Step2; otherwise, stop.

ACCEPTED MANUSCRIPT 5. Numerical experiments With particular interests in examining the computational behavior of the heuristic ERD-LPT and B&B algorithm, the solution approaches were coded in C# and tested on a large set of randomly generated instances using a personal computer with an Intel Core i3 3.30GHz CPU and 4 GB RAM. 5.1 Data generation A complete instance is composed of jobs’ parameters and maintenances’ parameters.

CR IP T

The jobs’ parameters consist of n, {pj} and {rj}. The maintenances’ parameters consist of T and t.

In order to make the validation more convictive, the parameters are randomly generated from wide intervals, which can cover different kinds of circumstances. Meanwhile, the

AN US

reality of factory is also considered. Generally, the job’s processing time is small compared with the maintenance period time in practice, which means the condition that only one or

two jobs can be placed in one period is very sparse. Finally, the jobs’ parameters are set as follows. {pj} are integers uniformly generated from the intervals [9, 29], [29, 49] and [9, 49]. {rj} are integers uniformly generated from an interval [0, 



n

j 1

p j ], where  is a control

M

variable that represents the characteristic of jobs’ release dates.  is set to {0.5, 1.0, 1.5}, and larger value means larger difference among jobs’ release dates. The job size n is set to

ED

{35, 100, 200, 300, 400, 500, 600, 700, 800, 900}. The number of jobs that can be placed in one period is mostly decided by the jobs’ processing times and the period time T. Since the

PT

job’s processing time is changeable, T is only set to 200. That means 6~20 jobs can be placed in one period when the processing time interval is [9, 29] and 4~6 jobs can be placed in one

CE

period when the interval is [29, 49]. The maintenance time t is uniformly generated from an interval [ 1 T,  2 T]. [ 1 ,  2 ] is set to [1/5, 1/3], [1/3, 2/3] and [2/3, 4/5].

AC

Different combinations of pj, rj , n and  lead to 270 sets of instances. And, for each

combination, fifteen instances are generated randomly. Thus, there are 270x15=4050 instances totally. 5.2 Performance of the proposed algorithms 5.2.1 Computational results In the mathematical model proposed in Section 2, constraint (9) is nonlinear. We use the big-M method to linearize the constraint. The next three constraints are adopted in the model instead of constraint (9). M1 is an infinity.

ACCEPTED MANUSCRIPT b[i 1]  a[i ]1  i  n

(15)

b[i 1]  M1 (1  y[i 1] )1  i  n

(16)

b[i 1]  a[i ]  M1 y[i 1]1  i  n

(17)

Since the mathematical model is a mixed integer programming model, it can be solved in ILOG CPLEX Optimizer v12.5. Since it’s proved that jobs are sequenced according to ERD rule

CR IP T

in each period in Property 1, we add constraint (18) in the Cplex model to narrow the search space.

r[i 1]  r[i ]  M 2 y[i 1]i  n

(18) ; where M2 is an infinity.

AN US

Note that it’s unnecessary to set M an infinite value since M can be bounded to increase the performance of the solver when we code the Cplex in C#. Then, M1 is set to T and M2 is set to the maximum value of rj.

By comparing the computation results of the same instances in Cplex, B&B and ERD-LPT,

M

the efficiency and effectiveness of the proposed algorithms can be judged. For the Cplex, we provide two items. Obj means the average objective value of instances,

ED

Tavg is the average computation time of the corresponding instances. For the B&B, another four items are used. Tmax is the maximal computation time, Navg is the average number of nodes that are explored by B&B, Nmax is the maximal number of nodes that are explored by

PT

B&B, Num is the number of instances which are not solved within 3600 seconds. The limit on the CPU time for each instance is set to 3600 seconds (for B&B) to avoid excessive

CE

computation time for the tests. And, the value Obj is the average objective value of instances whose optimal solution is found within the time limit. For the heuristic, another

AC

two items are used to judge the effectiveness. Gavg is the average Gap between the near-optimal solution obtained by ERD-LPT and the optimal value obtained by B&B, which can be calculated as Gap  [Obj (Heu ) Obj (B & B )] / Obj (B & B )*100% . Gmax is the maximal Gap. Tables 1~3 show the computation times in seconds and objective values of three algorithms under different parameters’ settings. “-” means that the problem cannot be solved by Cplex within acceptable time. “b” means the computation time is less than 0.1 second. Since the computation times of heuristic are less than 0.1 second in all instances, we

ACCEPTED MANUSCRIPT do not include this item in the table. Note that the following three tables are derived from the same data. If all the detailed results are put into a single table, 270 sets of instances correspond to 270 rows. The table will be too large to be inserted in this article. Meanwhile, we want to know the effect of different parameters. Thus, we summarized the original data according to the parameters’ category, which means that 135 instances are included in each row of the following tables. For example, {pj} is [9, 29] and n is 100 in the second row of

selected from {[1/5, 1/3], [1/3, 2/3], [2/3, 4/5]}.

CR IP T

Table 1. It contains 9 combinations, where  is selected from {0.5, 1.0, 1.5} and [ 1 ,  2 ] is

Table 1. Results of the algorithms under different processing time settings Cplex

Heuristic

n Tavg

999.23

710

999.23

b

100

-

-

2822.2

0.9

200

-

-

5661.3

0.3

300

-

-

8500.9

10.7

400

-

-

11369

500

-

-

600

-

-

35

-

CE

700

2.8

Navg

Nmax

Num

Obj

Gavg

Gmax

b

233

5439

0

1019.8

1.94

18.8

110

8636

758355

0

2850.5

0.98

6.38

2.7

13764

115317

2

5686.1

0.42

2.40

1249

69249

3988396

2

8546.2

0.51

2.07

22.4

77856

366593

3

11427

0.49

1.84

14186

6.0

27.4

141991

671575

3

14247

0.41

1.49

17059

22.8

1196

267702

3813373

1

17142

0.46

1.51

-

19903

16.4

98.1

261964

1071430

5

19980

0.37

1.37

800

-

-

22614

27.3

193

376966

1837922

6

22704

0.37

1.14

900

-

-

25545

51.9

269

600089

3011298

5

25635

0.34

1.03

2071.9

1066

2071.9

b

b

2395

42324

0

2144.2

3.39

6.89

100

-

-

5929.2

42.3

2598

185394

13986795

3

6045.9

1.91

5.91

200

-

-

11816

4.3

128

254252

4142760

5

12050

1.91

3.68

300

-

-

17696

34.1

2249

932810

33007647

5

18076

2.05

3.72

400

-

-

23708

102

3581

1503999

7891225

7

24201

2.00

3.61

AC [29,49]

Tmax

AN US

Obj

M

Tavg

ED

[9,29]

Obj

PT

pj

B&B

35

-

29440

86.1

437

2785140

14376381

11

30041

1.96

3.81

600

-

-

35422

241

3595

5391847

40393003

17

36132

1.92

3.48

700

-

-

41492

559

2112

7996084

43995115

15

42318

1.92

3.58

800

-

-

47159

645

3179

10669398

54332068

16

48098

1.91

3.43

900

-

-

53059

1158

3474

13428390

49870029

22

54135

1.94

3.34

1521.0

1379

1521.0

b

b

892

46474

0

1552.7

1.97

11.3

100

-

-

4343.9

0.2

9.9

8172

351152

2

4372.9

0.64

3.25

200

-

-

8720.3

0.3

4.3

14599

136307

3

8750.1

0.33

2.29

300

-

-

13151

1.6

30.6

49969

639500

2

13194

0.31

1.67

400

-

-

17531

5.6

500

-

-

21902

9.9

600

-

-

26252

47.2

700

-

-

30576

62.9

800

-

-

34933

900

-

-

39376

AN US 86.1

137558

1017458

4

17604

0.40

1.15

74.0

234207

1420830

4

21977

0.33

1.04

1979

529604

22187815

5

26341

0.32

1.02

1460

567676

3132119

5

30667

0.28

1.16

M

35

CR IP T

-

905

820906

4012477

7

35023

0.24

0.77

1242

1221330

7573982

6

39470

0.23

0.80

64.9

131

PT

[9,49]

500

ED

ACCEPTED MANUSCRIPT

Table 2. Results of the algorithms under different release date settings

CE

Cplex

0.5

B&B

Heuristic

n

Obj

Time

Obj

Tavg

Tmax

Navg

Nmax

Num

Obj

Gavg

Gmax

1468.5

19.7

1468.5

b

b

750

11204

0

1498.0

1.49

9.61

100

-

-

4231.1

0.1

1.1

16006

143091

0

4280.0

0.95

4.82

200

-

-

8480.1

0.9

6.6

66417

501944

2

8560.8

0.69

3.39

300

-

-

12835

6.6

189

219537

2047047

0

12979

0.85

3.09

400

-

-

17118

13.4

102

552449

4241122

2

17331

0.99

3.31

AC



35

ACCEPTED MANUSCRIPT

21406

33.4

437

1130875

14376381

0

21665

0.94

3.18

600

-

-

25582

57.6

373

1606049

10407304

2

25884

0.93

3.09

700

-

-

29988

141

1580

3163978

35700691

0

30336

0.90

3.03

800

-

-

34130

235

1979

4267756

34372852

1

34525

0.91

3.13

900

-

-

37455

392

2656

3780808

25518118

6

37827

0.76

3.08

1494.0

93.9

1494.0

b

b

922

12738

0

1533.9

2.27

9.67

100

-

-

4259.2

37.7

2598

52957

2801375

0

4321.6

1.26

5.91

200

-

-

8495.1

1.2

7.9

84001

585260

2

8607.5

1.07

3.68

300

-

-

12776

5.8

45.5

302917

2431125

2

12946

1.07

3.72

400

-

-

17047

17.7

500

-

-

21361

35.7

600

-

-

25497

99.9

700

-

-

29679

221

800

-

-

34271

900

-

-

1629.2

3041

35

AN US 532

543870

5110472

3

17279

1.09

3.61

213

1129030

7517700

1

21636

1.02

3.81

3595

1994797

24688263

4

25820

1.02

3.48

1975

3178658

43675556

5

30038

0.95

3.58

M

35

CR IP T

-

245

3103

3705789

41650321

3

34695

0.97

3.43

ED

1.5

-

38543

456

3474

5845847

41045500

4

39019

0.97

3.35

1629.2

b

b

1847

46474

0

1683.7

3.56

18.8

200

PT

1.0

500

-

-

8997.8

2.8

128

124806

4142760

6

9082.4

0.83

3.39

300

-

-

13430

34.6

2249

501380

33007647

7

13564

0.87

3.66

400

-

-

18147

78.7

3581

587960

7891225

9

18316

0.77

3.32

500

-

-

22374

29.3

326

769688

11230712

17

22548

0.65

2.81

600

-

-

26576

144

1979

2254539

40393003

17

26778

0.63

3.07

700

-

-

31606

259

2112

1974093

43995115

20

31842

0.62

2.82

800

-

-

35486

225

3178

3293813

54332068

25

35720

0.53

2.97

-

-

4578.4

4.7

445

133969

13986795

5

4640.1

1.32

6.38

AC

CE

100

ACCEPTED MANUSCRIPT

900

-

-

40296

393

3421

4422420

49870029

23

40606

0.61

3.10

Table 3. Results of the algorithms under different maintenance time settings

[1/3,2/3]

Heuristic

Time

Obj

Tavg

Tmax

Navg

Nmax

Num

Obj

Gavg

Gmax

1351.9

1710

1351.9

b

b

836

46474

0

1367.7

1.09

5.71

100

-

-

3817.6

3.4

445

113512

13986795

1

3841.9

0.61

2.70

200

-

-

7623.0

0.6

4.9

40124

392077

3

7661.6

0.43

2.12

300

-

-

11446

3.2

39.5

160543

2047047

2

11507

0.47

2.03

400

-

-

15265

8.9

500

-

-

19049

20.9

600

-

-

22776

64.7

700

-

-

26583

131

800

-

-

30531

900

-

35

1530.5

AN US 78.8

333308

3258133

3

15345

0.46

1.88

229

631299

7847772

2

19145

0.44

1.78

3595

1038004

10302620

5

22883

0.42

1.70

1821

1491790

11038956

5

26709

0.41

1.82

1751

2170783

34372852

3

30676

0.42

1.76

M

35

119

CR IP T

Obj

100

-

33952

243

2656

2596033

22259644

6

34108

0.39

1.71

1123

1530.5

b

b

1305

42324

0

1576.3

2.78

18.8

-

-

4361.9

20.7

2598

49359

2801375

2

4420.1

1.20

4.38

-

-

8505.1

1.1

11.9

74907

911877

3

8597.8

0.91

3.21

300

-

-

12720

34.7

2249

531961

33007647

2

12861

0.93

3.39

400

-

-

17302

42.7

2469

585693

5110472

6

17506

0.99

3.09

500

-

-

21750

39.1

311

1208285

8291520

7

22004

0.96

3.11

600

-

-

25427

106

1979

1918362

22187815

13

25696

0.88

3.13

700

-

-

30021

186

1901

3150386

43995115

15

30337

0.86

3.46

800

-

-

34058

232

3072

3652744

28224851

13

34407

0.83

2.76

CE

200

AC

B&B

ED

[1/5,1/3]

Cplex n

PT

1 ,  2

ACCEPTED MANUSCRIPT

-

38342

447

3474

4891989

49870029

13

38728

0.80

2.91

1709.2

322

1709.2

b

b

1378

34357

0

1771.6

3.43

16.9

100

-

-

4884.8

18.8

1300

37212

1422245

2

4975.7

1.72

6.38

200

-

-

9811.0

3.1

128

156136

4142760

4

9960.5

1.26

3.68

300

-

-

14834

8.3

189

326764

4394573

5

15082

1.40

3.72

400

-

-

19692

56.1

3581

763093

7891225

5

20020

1.40

3.61

500

-

-

24403

39.5

438

1239350

14376381

9

24776

1.27

3.81

600

-

-

29350

125

1693

2861368

40393003

5

29809

1.30

3.48

700

-

-

34485

293

2112

3810802

43675556

5

34997

1.22

3.58

800

-

-

39472

366

900

-

-

43805

560

35

CR IP T

[2/3,4/5]

-

AN US

900

3179

5665448

54332068

13

40069

1.24

3.43

3462

6683628

40764969

14

44436

1.17

3.34

M

5.2.2 The efficiency of B&B From the three tables above, we can obtain that CPLEX can only be used to solve small

ED

sized problems, and B&B can be used to solve small-to-medium sized problems. And, the heuristic can be used to solve large sized problems. We can draw a conclusion that B&B and ERD-LPT are complementary to each other. Since the Gap between B&B and heuristic is

PT

larger when n is smaller, we can use B&B to solve small sized problems for a better accuracy. When the computation time of B&B is very large and more and more instances cannot be

CE

solved with the increscent job size, the heuristic is very effective, since the gap is very small in this circumstance.

AC

Generally, a tendency is found that the size of nodes explored by B&B algorithm is

consistent with the computation time. Then, the computation time and the number of unsolved instances are the judgment measures of the efficiency of B&B. Table 1 shows that the computation time of [29, 49] is much longer than that of [9,29], while the time will be much shorter if there are some jobs with smaller processing time, e.g., [9, 49]. It can be explained as follows. The calculation of lower bound in B&B is mostly based on the resumable assumption. Thus, longer processing time results in a worse lower bound, which is harmful to the cutting of branches. Table 2 shows that the difference among computation

ACCEPTED MANUSCRIPT times of the instances solved by B&B is inconspicuous for different  . But the number of unsolved instances is larger with larger  . In Table 3, the computation time and the number of unsolved instances are irregular, which means the efficiency of B&B is not related to the settings of maintenance time. 5.2.3 The effectiveness of ERD-LPT As it is emphasized in another part of this paper, a large part of the objective value is the jobs’ processing times. Let Q be the total processing time of jobs, i.e., Q   j 1 p j . We

CR IP T

n

remove this part from the objective value and calculate a new gap value since Q is constant for one instance.

Gap '  {[Obj ( Heu)  Q]  [Obj ( B & B)  Q]} / [Obj ( B & B)  Q]*100%  [Obj ( Heu)  Obj ( B & B)] / [Obj ( B & B)  Q]*100%

.

AN US

It’s obvious that Gap '  Gap . The tables with Gap’ values are not provided. In order to

observe the detailed information, we make the statistic boxplot of the Gap’ values according to the parameters’ combination. Boxplot is a convenient way of graphically depicting the distribution of numerical data through their quartiles. The bottom and top of the box are

M

always the first and third quartiles, and the band inside the box is always the second quartile (the median). But, the ends of the whiskers can represent several possible alternative values.

ED

In our study, the upper whisker is the 95th percentile and the lower whisker is 5th percentile. Meanwhile, the maximum and minimum value are represented by the asterisk, the average

PT

value is represented by the rectangular. From Fig.5, we can find that the performances of the heuristic for [9, 29] and [9, 49] are

CE

much better than [29, 49]. The gap value for [29, 49] is basically stable when n is large. For the interval [9, 29] and [9, 49], the maximum value decreases gradually with the increment

AC

of n and the average value is basically stable when n>200. From Fig.6, we can find that the performance of the heuristic for 1.5 is much better than

0.5 and 1.0 when n is large. For the cases of 0.5 and 1.0, all the indicators are basically stable when n is large. For the case of 1.5, the 75th percent line decreases gradually with the increment of n, while the other indicators are basically stable when n is large. Besides, the 50th percent line is lower than the average value for all the cases. Fig.7 indicates clearly that the gap is smaller with smaller t. For the case [1/5,1/3], the 75th percent line decreases gradually with the increment of n, while the other indicators are

ACCEPTED MANUSCRIPT basically stable when n is large. For [1/3, 2/3], the maximum value, the average value, the 50th percent line are basically stable when n is larger than 200. For [2/3, 4/5], all the

100

200

300

400

AN US

CR IP T

indicators are basically stable when n is larger than 200.

500

600

700

800

900

M

Fig.5 The boxplot of the Gap’ under different processing times settings

AC

CE

PT

ED

0.5 1.0 1.5

100

200

300

400

500

600

700

800

900

Fig.6 The boxplot of the Gap’ under different release dates settings

100

200

300

400

500

600

700

CR IP T

ACCEPTED MANUSCRIPT

800

900

AN US

Fig.7 The boxplot of the Gap’ under different maintenance times settings

5.3 Value of scheduling production and maintenances simultaneously The First-In-First-Out (FIFO) rule is very common in practical industry, i.e., the job with smaller release date is processed earlier and the ties are broken by choosing one job arbitrarily. Obviously, this rule does not consider the effects of maintenances on the

M

production scheduling. The heuristic FIFO is set as follows. Jobs are reordered according to the release date and the ties are broken by LPT rule, i.e., the job with longer processing time

ED

has smaller index if the release dates of two jobs are the same. The jobs’ sequence is exactly the same with the index of jobs. And, PMs are inserted into the sequence as late as possible

PT

without violating the maintenance constraint. In order to show the value of the integrated optimization of production scheduling and

CE

maintenances, the comparison between the rules ERD-LPT and FIFO are investigated in this subsection. Actually, the only difference between ERD-LPT and FIFO is that the jobs are scheduled dynamically in ERD-LPT rule, which considers the interaction between the jobs’

AC

arrive time and maintenance constraint. It makes the algorithm ERD-LPT more flexible than FIFO.

Firstly, the instances’ parameters are the same with those in Section 5.1. The objectives

of ERD-LPT have been recorded in Section 5.2. We only need to apply the FIFO rule to the corresponding instances, and we can get the improvement of the ERD-LPT compared with FIFO in percent, which is calculated as (ObjFIFO  ObjERD LPT ) / ObjFIFO *100% . Then, we get the figures (a), (b) and (c), which are shown in Fig.8 clearly. In Fig.8, horizontal axis represents the size of job, e.g., “5” means job size n equals to 500. Generally, the ERD-LPT

ACCEPTED MANUSCRIPT rule is better than FIFO. And the improvement is no matter with the job size n when it is larger than 200. From Fig.8(a), we can get that the improvement is higher with larger range of the generator interval of processing time. The larger range of the generator interval means that the difference among jobs’ processing times is larger. Then, the difference between the job selected dynamically by ERD-LPT and the job arranged statically by FIFO will be larger, which makes our heuristic better. From Fig.8(b), we can get that the improvement is higher with smaller  . It can be explained by the fact that if  is large enough, i.e.,

CR IP T

many jobs arrive very late, the selection space of ERD-LPT at the decision epoch is very small, which will result in the same choice as FIFO. From Fig.8 (c), we can get that the

improvement is higher with larger t. Since the impact of maintenance constraint, i.e., the unavailable interval, is the basic reason we develop this new heuristic, it’s obvious that ERD-LPT is better with larger t.

AN US

In order to validate our explanation, we added a lot of instances. The jobs’ processing

time interval is set to [1, 100]. The coefficient of release date is set to 0.2. The maintenance time is set to [4/5, 9/10]T. That means we have 4x4x4x10=640 combinations in total, which leads to 9600 random instances. From the figures Fig.8(d, e, f), we can find that the

M

numerical results match our explanation very well. Besides, we find that the processing time setting has a big effect on the value, while the effect of release date setting is very small

ED

when the coefficient is smaller than 0.5.

2.5

[9,29]

[29,49]

2

[9,49]

2

1.5

1.8

1.0

1.6

0.5

2.5

[1/5,1/3] [1/3,2/3]

2

[2/3,4/5]

1.4

1.5

1

0.5

0 2

3

4

5

6

7

8

1.5

1 1

0.8

0.6 0.5

0.4 0.2

0

0

9

CE

1

PT

1.2

1

2

3

a): Processing time

7

6

AC

5

[9,29]

[29,49]

8

1

9

2

[1,100]

3

4

5

6

7

8

9

c): Maintenance time 1.5

3

1.0

4

[1/3,2/3]

0.5

3.5

[2/3,4/5]

2.5

1.5

2

1

1

0.5

0.2

4.5

[1/5,1/3]

[4/5,9,10]

3 2.5 2 1.5 1

0

4

7

3.5

3

3

6

[9,49]

2

2

5

b): Release date

4

1

4

0.5

0

0 5

6

7

8

9

1

d): Processing time

2

3

4

5

6

e): Release date

7

8

9

1

2

3

4

5

6

7

8

9

f): Maintenance time

Fig.8. The improvement of ERD-LPT in percent compared with FIFO

6. Conclusion and remarks This paper addresses the integration between production scheduling and PMs on a single machine, where jobs’ release dates are considered. Two complementary algorithms,

ACCEPTED MANUSCRIPT ERD-LPT and B&B, are developed to solve different sized problems for the non-resumable case. Computational results indicate that B&B can be used to solve small-to-medium sized problems. ERD-LPT is highly accurate and efficient compared with the accurate algorithms in almost all instances. Besides, the improvement of the integration between scheduling and PMs is significant compared with FIFO rule. As a future work, the current integration can be extended to multiple machine

CR IP T

scheduling problems, such as parallel machine, flow shop, job shop, etc. And the impact of unexpected breakdowns is also one interesting research area, since machines may break

accidentally during processing jobs in practice. Then, the robustness of schedule should be

considered, and it’s also necessary to find out how such uncertainties affect the operational

AN US

decisions.

Acknowledgements. The authors really appreciate the editor and anonymous reviewers for valuable comments and suggestions which helped considerably in improving this article. This work was supported by the National Natural Science Foundation of China under Grant

M

[number 71171130 and number 61473211].

ED

Reference:

[1]. Ebeling CE. An introduction to reliability and maintainability engineering. 2th ed. Illinois:

PT

Waveland Press Inc.; 2009.

[2]. Wang S, Liu M. Two-stage hybrid flow shop scheduling with preventive maintenance using multi-objective tabu search method. International Journal of Production Research 2014; 52:

CE

1495-1508.

[3]. Sanlaville E, Schmidt G. Machine scheduling with availability constraints. Acta Informatica

AC

1998; 35: 795-811.

[4]. Schmidt G. Scheduling with limited machine availability. European Journal of Operational Research 2000; 121: 1-15.

[5]. Ma Y, Chu C, Zuo C. A survey of scheduling with deterministic machine availability constraints. Computers & Industrial Engineering 2010; 58: 199-211. [6]. Lee CY. Machine scheduling with an availability constraint. Journal of Global Optimization 1996; 9: 395-416. [7]. Ji M, He Y, Cheng TCE. Single machine scheduling with periodic maintenance to minimize makespan. Computers & Operations Research 2007; 34: 1764-70.

ACCEPTED MANUSCRIPT

[8]. Adiri I, Bruno J, Frostig E, Rinnooy Kan AHG. Single machine flow-time scheduling with a single breakdown. Acta Informatica 1989; 26: 679-96. [9]. Lee CY, Liman SD. Single machine flow-time scheduling with scheduled maintenance. Acta Informatica 1992; 29: 375-82. [10]. Sadfi C, Penz B, Rapine C, Błazewicz J, Formanowicz P. An improved approximation algorithm for the single machine total completion time scheduling problem with availability constraints. European Journal of Operational Research 2005; 161: 3-10. [11]. Breit J. Improved approximation for non-preemptive single machine flow-time scheduling

CR IP T

with an availability constraint. European Journal of Operational Research 2007; 183: 516-24. [12]. Kacem I, Chu C. Worst-case analysis of the WSPT and MWSPT rules for single machine scheduling with one planned setup period. European Journal of Operational Research 2008a; 187: 1080-9.

[13]. Kacem I. Approximation algorithm for the weighted flow-time minimization on a single

AN US

machine with a fixed non-availability interval. Computers & Industrial Engineering 2008; 54: 401-10.

[14]. Kacem I, Chu C. Efficient branch-and-bound algorithm for minimizing the weighted sum of completion times on a single machine with one availability constraint. Int. J. Production Economics 2008b; 112: 138-50.

[15]. Kacem I, Chu C, Souissi A. Single-machine scheduling with an availability constraint to

M

minimize the weighted sum of the completion times. Computers & Operations Research 2008; 35: 827-44.

ED

[16]. Liao CJ, Chen WJ. Single machine scheduling with periodic maintenance and nonresumable jobs. Computers & Operations Research 2003; 30: 1335-47. [17]. Chen WJ. Minimizing number of tardy jobs on a single machine subject to periodic

PT

maintenance. Omega 2009; 37: 591-9. [18]. Molaee E, Moslehi G, Reisi M. Minimizing maximum earliness and number of tardy jobs in

CE

the single machine scheduling problem with availability constraint. Computers and Mathematics with Applications 2011; 62: 3622-41.

[19]. Lee JY, Kim YD. Minimizing the number of tardy jobs in a single-machine scheduling problem

AC

with periodic maintenance. Computers & Operations Research 2012; 39: 2196-205.

[20]. Graves GH, Lee CY. Scheduling maintenance and semiresumable jobs on a single machine. Naval Research Logistics 1999; 46: 845-63.

[21]. Mosheiov G, Sarig A. Scheduling a maintenance activity to minimize total weighted completion-time. Computers and Mathematics with Applications 2009; 57: 619-23. [22]. Qi X, Chen T, Tu F. Scheduling the maintenance on a single machine. Journal of the Operational Research Society 1999; 50: 1071-8. [23]. Sbihi M, Varnier C. Single-machine scheduling with periodic and flexible periodic maintenance to minimize maximum tardiness. Computers & Industrial Engineering 2008; 55: 830-40.

ACCEPTED MANUSCRIPT

[24]. Chen JS. Optimization models for the machine scheduling problem with a single flexible maintenance activity. Engineering Optimization 2006a; 38: 53-71. [25]. Yang SL, Ma Y, Xu DL, Yang JB. Minimizing total completion time on a single machine with a flexible maintenance activity. Computers & Operations Research 2011; 38: 755-70. [26]. Chen JS. Single machine scheduling with flexible and periodic maintenance. Journal of the Operational Research Society 2006b; 57: 703-10. [27]. Chen JS. Scheduling of nonresumable jobs and flexible maintenance activities on a single 90–102.

CR IP T

machine to minimize makespan. European Journal of Operational Research 2008; 190: [28]. Low C, Ji M, Hsu CJ, Su CT. Minimizing the makespan in a single machine scheduling

problems with flexible and periodic maintenance. Applied Mathematical Modeling 2010; 34: 334-42.

[29]. Lee WC, Wu CC, Chung YH. Scheduling deteriorating jobs on a single machine with release

AN US

times. Computers & Industrial Engineering 2008; 54: 441-52.

[30]. Pan Y, Shi L. New hybrid optimization algorithms for machine scheduling problems. IEEE Transactions on Automation Science and Engineering 2008; 5: 337-48. [31]. Nessah R, Kacem I. Branch-and-bound method for minimizing the weighted completion time scheduling problem on a single machine with release dates. Computers & Operations Research 2012; 39: 471-8.

M

[32]. Detienne B. A mixed integer linear programming approach to minimize the number of late jobs with and without machine availability constraints. European Journal of Operational

AC

CE

PT

ED

Research 2014; 235: 540-52.