See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/270285891

Makespan Minimization for Parallel Machines Scheduling with Availability

Constraints

Conference Paper · April 2010

CITATIONS READS

5 33

3 authors:

Navid Hashemian Claver Diallo

Dalhousie University Dalhousie University
4 PUBLICATIONS   37 CITATIONS    80 PUBLICATIONS   685 CITATIONS   

SEE PROFILE SEE PROFILE

Béla Vizvári
Eastern Mediterranean University
157 PUBLICATIONS   1,113 CITATIONS   

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Chaotic models in economics View project

Has the European Union a Technology for Handling the Migration Crisis? View project

All content following this page was uploaded by Claver Diallo on 10 November 2016.

The user has requested enhancement of the downloaded file.

 1

Makespan Minimization for Parallel Machines

Scheduling with Availability Constraints

Navid Hashemian1 , Claver Diallo1 and Béla Vizvári2

1
Dalhousie University, Canada
n.hashemian@dal.ca, claver.diallo@dal.ca
2
Eastern Mediterranean University, Cyprus
bela.vizvari@emu.edu.tr

Keywords: scheduling, parallel machines, availability, makespan.

1 Introduction

In this paper, we consider the problem of production scheduling on m parallel machines,

where all or some machines are not available for a certain time period. The performance
measure is to minimize makespan. The non-availability period is assumed deterministic
and known in advance. There is no accidental breakdown. Jobs are resumable, i.e. if a
job is interrupted for machine maintenance it can continue its processing on the same
machine after maintenance without any time penalty. The setup time of a job is sequence
independent and is included in the processing time.
Although there are many papers in the literature dealing with parallel machine schedul-
ing, only few papers address machine scheduling with an availability constraint (Ma et.
al. 2010). Lee (1996) shows that the relative error of the classical longest processing time
(LPT) can be relatively large, even for two machines. He applies a new algorithm (LPT2)
which is similar to the LPT with the exception that a job is assigned to the machine that
minimizes its completion time. He proves that under the condition that one machine is
always available the algorithm has tight worst-case error of 1/2(1-1/m). In the current
state of literature the only optimal algorithm for this type of problem is developed by Liao
et. al. (2005). However, their method only applies to two machines with one being always
available.

2 Mathematical Formulation of the Problem

Let si and ei denote the start and end of the non-availability period on machine i, pj
the integer processing time of job j, M an appropriately large number, N the number of
jobs, and m the number of machines. The problem can be formulated using the following
three decision variables:

1 if job j is assigned to machine i
xij =
0 otherwise

1 if jobs on machine i are completed before the si
yi =
0 otherwise
h = the value of the makespan(h > 0).

min h
s.t:
N
X
pj xij ≤ si yi + M (1 − yi ) i = 1, . . . , m (1)
j=1
 2

N
X
pj xij + (ei − si )(1 − yi ) ≤ h i = 1, . . . , m (2)
j=1 m
X
xij = 1 j = 1, . . . , N (3)
i=1
xij ∈ { 0, 1 } i = 1, . . . , m; j = 1, . . . , N (4)

yi ∈ { 0, 1 } i = 1, . . . , m (5)
3 Preliminary Discussion of the Algorithm

The objective function value (Cmax ) of any feasible solution is the load, i.e. the sum
of the processing times, of at least one machine. Assume that the makespan of the best
known feasible solution is C best . If the optimal solution has not been explored yet then its
value is not greater than C best − 1 in the case of jobs with integer processing times. Thus
U B = C best − 1 is an upper bound for the load of all machines in the feasible solutions
still to be investigated. Hence
 
 X N 
LB = max 0, pj − (m − 1)U B (6)
 
j=1

is a lower bound for all of the loads in the same feasible solutions. After finding a new and
better feasible solution both bounds tighten up. However this upper bound may change on
a given machine i, because of the non-availability period and yield

UB U B ≤ si
U Bi =
U B − min{U B, ei } + si U B ≥ si
The duration of non-availability on any machine can be calculated by

U B − si if si ≤ U B ≤ ei
Di =
ei − si if U B > ei

4 Lexicographic Order of the Loads of a Machine

The main algorithm is an implicit enumeration. It is very important to ensure that

the enumeration does not skip any potential feasible solution. The loads of the machines
are determined one after another. Thus the potential loads of machine i (1 < i ≤ m) are
depending on the loads of the previous machines.
Any load on a machine must satisfy two constraints:
(i) it cannot contain more jobs than the number of remaining jobs,
(ii) its value must be between the lower and upper bounds.
These conditions can be described by the following system of inequalities, where zj is
the number of jobs with processing time pj in the load of the current machine and n is the
number of different processing times:

0 ≤ zj ≤ vj j = 1, . . . , n (7)
X n
LB ≤ pj zj ≤ U B (8)
j=1
zj is integer j = 1, . . . , n, (9)
 3

where vj is the number of tasks, which have processing time pj and are still not loaded on
any machine.
There are many feasible solutions to the system (6)-(8). For an implicit enumeration
procedure they must be ordered somehow and enumerated in that order. Using the greedy
method:
  
UB
z1 = min , v1 (10)
p1
($ Pj−1 % )
U B − β=1 pβ zβ
zj = min , vj j = 2, . . . , n. (11)
pj

Whenever a branch is explored the next load is needed in the enumeration. It can be
determined by the greedy method according to the following equations, where the current
load is z, and the lexicographic next is z̄

γ = max { j | zj > 0 } (12)

z̄j = zj j = 1, . . . , γ − 1 (13)
z̄γ = zγ − 1 (14)
($ Pj−1 % )
U B − β=1 pβ zβ
z̄j = min , vj j = γ + 1, . . . , n. (15)
pj

5 The Main Algorithm

The main algorithm is an enumeration, which consists of two types of steps: construction
and backtrack. In the construction step the algorithm determines the load of the machines
one by one. This is done by (10)-(11) if the machine has no load, or by (12)-(15) if it
already has a load. It is necessary that the total processing time represented by the load be
at least as high as the lower bound. If this constraint cannot be satisfied then again the next
possible load is determined by (12)-(15). If the construction is successful, i.e. all machines
have been loaded and all conditions are satisfied, then the lower and upper bounds of
machines are updated. The enumeration is continued at the machine with maximum load
and smallest index among such machines. Its lexicographically maximal load is determined
for the new upper bound with formulae (10)-(11). If the machine has no further feasible
load then a backtrack must be made at machine i − 1.

6 Methods to Accelerate the Program

For the effectiveness of the method, it is crucial to quickly find feasible solutions. When
the load of a machine is strictly less than the current upper bound then there is a loss in
the total capacity. These losses can accumulate and result in an infeasibility as shown by
the next lemma.

Lemma 1. Assume that the loads of the first α machines (1 ≤ α < m) are determined
and the loads are Li (i = 1, ..., α). If
PN Pα Pm
j=1 pj − i=1 Li + i=α+1 Di
> UB
m−α
then at least one of the unloaded machines must have an infeasible load and backtrack step
should be implemented on machine α.
 4

If lemma 1 is satisfied, proceed to lemma 2.

Lemma 2. If
PN Pα Pm
j=1 pj − i=1 U Bi +
i=α+1 Di
> UB
m−α
∗
then there is no feasible solution for the given U B, and Cmax is equal to U B + 1.
If lemma 2, is not satisfied proceed to lemma 3.
Lemma 3. If
PN Pα−1 Pm
j=1 pj − i=1 Li + U Bα + i=α+1 Di
> UB
m−α
then there is no feasible load for machine α and backtrack step should be applied on machine
α − 1.
If lemma 3 is not satisfied proceed to lemma 4.
Lemma 4. Equation 12 is changed to
γ = max { j | zj > 0 and j 6= n } (16)

7 Results

Two series of computational experiments are carried out with an availability constraint
on all machines. The non-availability length is 15 time units. The non-availability for the
k th machine starts at instant 15(k − 1). In the first and second series of experiments the pj
are random positive integer numbers drawn from the uniform distributions U (1, 99) and
U (5, 15) respectively. Our algorithm is coded in C and the program runs on a 3.0 GHz
PC. Although many experiences have been carried out in both series only the results of the
largest problems are reported here. For each problem size, 10 problems have been generated.
The minimal, maximal and average CPU times of these 10 instances are displayed in the
table below.

Table 1: Computational results for random problems.

number number CPU time (sec)

of of 1st Series 2nd Series
jobs machines min max avg min max avg
1,000,000 3 2.625 2.656 2.634 0.000 0.000 0.000
1,000,000 500 496.656 497.844 497.414 121.578 726.516 213.016
90,000 300 30.656 31.703 30.897 9.578 11.484 10.241

References
Lee. C. Y, 1996, “Machine scheduling with an availability constraint", Journal of Global Optimiza-
tion, Vol. 09, pp. 395-416.
Liao. C.J., Shyur . D.L., Lin. C.H, 2005, “Makespan minimization for two parallel machines with
an availability constraint", European Journal of Operational Research, Vol. 160, pp. 445-456.
Ma. Y., Chengbin. C., Chunrong. Z, 2010, “A survey of scheduling with deterministic machine
availability constraints", Computers & Industrial Engineering, Vol. 50, pp. 199-211.

View publication stats