J Intell Manuf (2011) 22:767–777DOI 10.1007/s108450090272z
AGRASPapproachformakespanminimizationonparallelbatchprocessingmachines
PurushothamanDamodaran
·
MarioC.VélezGallego
·
JairoMaya
Received: 6 November 2008 / Accepted: 13 May 2009 / Published online: 2 June 2009© Springer Science+Business Media, LLC 2009
Abstract
Inthispaperweconsidertheproblemofscheduling a set of identical batch processing machines arranged inparallel. A Greedy Randomized Adaptive Search Procedure(GRASP) approach is proposed to minimize the makespanunder the assumption of nonzero job ready times, arbitrary job sizes and arbitrary processing times. Each machine canprocess simultaneously several jobs as a batch as long as themachine capacity is not violated. The batch processing timeisequaltothelargestprocessingtimeamongthosejobsinthebatch. Similarly, the batch ready time is equal to the largestready time among those jobs in the batch. The performanceof the proposed GRASP approach was evaluated by comparing its results to a lower bound and heuristics published inthe literature. Experimental study suggests that the solutionobtained from the GRASP approach is superior compared toother heuristics.
Keywords
Scheduling
·
GRASP
·
Batch processingmachines
·
Parallel machines
P. Damodaran (
B
)Department of Industrial and Systems Engineering, NorthernIllinois University, DeKalb, IL 60115, USAemail: purushd@gmail.comM. C. VélezGallego
·
J. MayaDepartamento de Ingeniería de Producción, Universidad EAFIT,Medellín, Colombiaemail: marvelez@eaﬁt.edu.coJ. Mayaemail: jmaya@eaﬁt.edu.co
Introduction
In electronics manufacturing, printed circuit boards (PCB’s)go over a series of processes at the end of which they aretested on environmental stress screening (ESS) chambers.ESS chambers can process several PCB’s simultaneouslyas a batch as long as the total size of the PCB’s in thebatch does not violate the chamber capacity. In the process that motivated this work, PCB’s from different production lines arrive dynamically to a queue in front of a setof ESS chambers, where they are grouped into batches forfurther testing. Each line delivers PCB’s that vary in sizeand require different processing time at the chamber. Oncea batch is formed, its processing time is the longest processing time among the PCB’s in the batch, and its ready timeis given by the PCB arriving last to the batch. ESS chambers are expensive and a bottleneck, thus manufacturers areinterested in maximizing their utilization (i.e., minimize themakespan). For the remainder of this paper PCB’s will bereferred to as jobs and ESS chambers as batch processingmachines.Formally, we are given a set
J
of
n
jobs to be processedby
m
identical batch processing machines with capacity
S
.Each job
j
∈
J
has processing time
p
j
, ready time
r
j
andsize
s
j
. The objectives are (1) to group the jobs into batches,and (2) schedule the batches so that the makespan is minimized. While grouping the jobs into batches, the sum of all job sizes should not exceed the machine capacity. Using the
α

β

γ
notationintroducedbyGrahametal.(1979),theprob
lem can be represented as
P
m

batch
,
r
j

C
max. The problem is NPhard since the particular case where
r
j
=
0 and
s
j
=
S
for all
j
∈
J
is the classical
P
m

C
max, provento be NPhard (Garey and Johnson 1979). Consequently, aGreedy Randomized Adaptive Search Procedure (GRASP)isproposedinthisresearch.Theeffectiveness oftheGRASP
1 3
768 J Intell Manuf (2011) 22:767–777
is evaluated by comparing its solution to a lower bound andheuristics published in the literature.The remainder of this paper is organized as follows. Section“Previousrelatedwork”presentsthepertinentliterature.Section “A Lower bound on the optimal makespan” presentsa procedure to compute the lower bound for the problemunder study. Section “GRASP solution approach” presentsour GRASP solution approach. Section “Experimentationand computational results” presents the experimental work carriedouttoevaluate theperformance oftheproposed solution approach. Section “Conclusions” presents our conclusions and future research directions.
Previousrelatedwork
Scheduling batch processing machines in parallelLiterature pertinent to the problem under study with different objectives are total completion time (Chandru et al.1993), total weighted completion times (Koh et al. 2004; Li
et al. 2006a,b), total weighted tardiness (Balasubramanian
etal.2004;Mönchetal.2005,2006;MathirajanandSivaku
mar 2006; Habenicht and Mönch 2005), maximum lateness
(Li et al. 2004; Malve and Uzsoy 2007), earliness–tardiness
(MönchandUnbehaun2007),andmultiobjectives(Reichelt
and Mönch 2006). Many of the above research work considered jobs with incompatible job families (i.e., jobs fromdifferent families cannot be batched together). Jobs from thesame families require identical processing times, and hencethe batch processing time is equal to the processing time of the job family. Many of them did not consider the job sizes(i.e., all the jobs are of equal size or the number of jobs in abatch is restricted).Makespan minimization has also been addressed by several researchers under the assumption of zero ready timesfor all the jobs. Chang et al. (2004) proposed a simulated
annealing approach, Koh et al. (2004) assumed incompati
ble job families with a common family processing time andproposed several heuristics and a genetic algorithm, Kashanetal.(2008)developedageneticalgorithm,andXuandBean
(2007)proposedageneticalgorithmtotheextendedproblemof non identical machines (i.e. the capacity of the machineswere assumed to be different). Li et al. (2005) proposed a
PTAS assuming nonzero ready times but equal job sizes.To the best of our knowledge only two research efforts havebeenconductedthatconsiderbotharbitraryjobsizesandnonzero ready times: (1) Chung et al. (2008) proposed a Mod
iﬁed Delay (MD) heuristic, and (2) VélezGallego (2009)
proposed ﬁve heuristics and compared their results to thosepublished in Chung et al. (2008). The aim of this work is to
proposeaGRASPapproachandcompareitssolutionqualitywith the heuristics published in Chung et al. and VélezGallego.Greedy randomized adaptive search procedure (GRASP)The metaheuristic known as GRASP is a multistart methodintroduced by Feo and Resende (1989) that combines three
classical approaches used in combinatorial optimization: (1)greedy heuristic, (2) randomization and (3) local search. Atypical GRASP implementation starts from a solution constructed by means of a randomized greedy algorithm andtries to improve it through a local search. The procedure isrepeatedseveraltimesandthebestsolutionfoundisreturned.References (Feo and Resende 1989, 1995; Pitsoulis and
Resende 2002; Resende and Ribeiro 2003) present exten
sive reviews on GRASP, and some recent implementationsto scheduling problems can be found in references (Aiexet al. 2003; Rojanasoonthon and Bard 2005; Armentano and
Araujo 2006; Armentano and França Filho 2007).
ALowerboundontheoptimalmakespan
In this section we present a procedure to calculate a lowerbound for the problem under study. For
P
m

prmp

C
max(i.e.,identicalparallelmachineschedulingproblemwithpreemptions allowed) the optimal makespan is given by(McNaughton 1959):
C
max
=
max
p
1
,
j
∈
J
p
j
m
,
(1)where
p
1
is the largest processing time job. Kashan et al.(2008) developed a lower bound for the
Pm

batch

C
maxscheduling problem. They assumed that all the jobs wereready at time zero. However, in our problem we need to consider the ready times of the jobs.The procedure to calculate the lower bound for the problem under study is as follows:1. Let
J
be the srcinal set of jobs, and let
J
1
be the set of jobs in
J
that satisfy the following relation:
J
1
=
j
∈
J

S
−
s
j
<
min
i
∈
J
{
s
i
}
(2)If
j
∈
J
1
is assigned to a batch, the residual capacity of the batch
(
S
−
s
j
)
is smaller than the smallest sized job.Consequently,allthejobsinset
J
1
arelargejobsandwillnot accommodate any other job in the same batch. Each job from
J
1
is separately assigned to a unique batch. Theready time and processing time of these batches will beequal to the ready and processing time of the job in thatbatch.
1 3
J Intell Manuf (2011) 22:767–777 769
2. Let
J
2
includeallthejobsfrom
J
whichdonotbelongto
J
1
(i.e.,
J
2
=
J
\
J
1
).Replaceeachjob
j
in
J
2
with
s
j
jobsofunitsize,eachwithprocessingtime
p
j
andreadytime
r
j
. List these jobs in decreasing order of their processing times and successively group the ﬁrst
S
unassigned jobsintothesamebatch.Thisprocedurewillresultintheformation of a set of
L
batches, with

L
 =
k
∈
J
2
s
k
S
.3. A lower bound on the optimal makespan
C
LBmax
can becalculated as follows:
C
LBmax
=
max
j
∈
J
1
p
j
+
l
∈
L
P
l
m
+
min
j
∈
J
{
r
j
}
,
max
j
∈
J
{
r
j
+
p
j
}
.
(3)All the jobs in set
J
2
can be grouped to form batches. In ourproblem, a job cannot be split between batches. By allowing the jobs to split, a lower bound can be determined. Theminimum number of batches required to group all the jobsin
J
2
is equal to the ratio of the total size of all jobs and thebatch capacity. We round the ratio up to the nearest integeras fractional solution is not feasible. Equation(3) is similar
to Eq.(1), except we have now to consider the ready times
of the jobs (or batches). The ﬁrst term in (3) implies that thetotal processing time of all the jobs in the set
J
1
and the totalprocessing time of all the batches in the set
L
are equallydivided among all the
m
machines (i.e., the machines areperfectly balanced). Since processing cannot begin until theﬁrst job becomes available, the least ready time of all the jobs is added to the ﬁrst term. The second term in (3) impliesthat the makespan has to be at least the earliest completiontime of all the jobs. The earliest completion time of job
j
is
r
j
+
p
j
.We use the data of the 10job problem instance, shownin Table1, to illustrate how the lower bound is calculated.
Assume that
S
=
7 and
m
=
2.1.
J
1
= {3} and
J
2
= {1,2,4,5,6,7,8,9,10}2.

L
 =
29
/
7
=
5, so 5 new batches are to be formed:Job 1 is replaced by 3 jobs (since
s
1
=
3), each witha processing time of 9, job 2 by 3 jobs of processingtime 4 and so on. The newly created jobs are arranged innonincreasing order of their processing times. The ﬁrst
S
=
7 jobs form the ﬁrst batch; the next
S
jobs form thesecond batch, etc. At the end the processing times of the
Table1
Data for a 10job problem instance
j
1 2 3 4 5 6 7 8 9 10
p
j
9 4 3 8 8 4 4 7 7 9
r
j
3 1 3 1 1 3 2 3 3 2
s
j
3 3 6 5 4 2 2 4 2 4
B
a
tch Processin
g
Time
R
e
ady
Time B
a
tch 1
1 1 1 10 10 10 10 9 3
B
a
tch 2
4 4 4 4 4 5 5 8 1
B
a
tch 3
5 5 8 8 8 8 9 8 3
B
a
tch 4
9 2 2 2 6 6 7 7 3
B
a
tch 5
7 4 2
Fig.1
Lower bound calculations example
batches formed are:
P
1
=
9
,
P
2
=
8
,
P
3
=
8
,
P
4
=
7and
P
5
=
4.3.
C
LBmax
=
max
3
+
362
+
1
,
12
=
21
.
Figure1summarizesallthecalculationswithrespecttoforming batches (i.e., jobs in set
J
2
)
. The composition of eachbatch along with the batch processing and ready times isgiven in the ﬁgure. Chung et al. (2008) proposed a mixed
integer program for the problem under study. By solving thismodel using a commercial solver for the parameters shownin Table1, the optimum was found to be 21.
GRASPsolutionapproach
Each iteration of the algorithm starts with a feasible solution found by means of a randomized greedy heuristic. Thissolution is later taken as the initial solution of a local searchprocedure and the procedure is repeated until some stoppingcriterion is met. While a greedy heuristic is a constructionheuristic that ﬁxes one variable at a time using some deterministic rule, in a randomized greedy heuristic randomnessis introduced to such rule in order to prevent the generationof same solution every time the greedy heuristic is called.The randomized greedy heuristic proposed to ﬁnd a startingsolutionisbasedonthe
ModiﬁedFirstFit
(MFF)heuristicpresented in VélezGallego (2009). The pseudo code for the
MFF heuristic is:
1 3
770 J Intell Manuf (2011) 22:767–777
Let
J
be the set of jobs, and let
s
j
be the size of job
j
∈
J
Let
B
={
B
a
tc
h
1
,
B
a
tc
h
2
, …,
B
a
tc
h
J
} be a set of
J
batches, initially empty.
while

J
>0
d
o
// while there are jobs to sched
u
le, do:
q
←
a
r
gm
i
n
j J
{
r
j
} // find the
u
nsched
u
led job with earliest ready time (job
q
)
for
t
= 1
to
J
d
oif
S
ss
q B
a
tc
h
i i
t
≤+
∑
∈
then
// if job
q
can be allocated in batch
t
, then
B
a
tc
h
t
←
B
a
tc
h
t
∪
{
q
} // assi
g
n job
q
to batch
t J
←
J
\ {
q
} // delete job
q
from the job set
J
exit for loo
p
en
d
if en
d
foren
d
while
Discard (delete) any remainin
g
empty batch
Table2
Evolution of the randomized MFF heuristicStep List Random Job Batch size Batch Batch Jobs
P
b
R
b
1 {4,5,2,10,7,1,8,9,6,3} 2 5 4 1 1 5, 2 8 12 {4,2,10,7,1,8,9,6,3} 2 2 7 1 2 7, 1, 9 9 33 {4,10,7,1,8,9,6,3} 3 7 2 2 3 4, 6 8 34 {4,10,1,8,9,6,3} 3 1 5 2 4 10 9 25 {4,10,8,9,6,3} 1 4 5 3 5 8 7 36 {10,8,9,6,3} 3 9 7 2 6 3 3 37 {10,8,6,3} 1 10 4 48 {8,6,3} 1 8 4 59 {6,3} 2 3 6 610 {6} 1 6 7 3
If each job is assigned to a unique batch, then the maximumnumberofbatchesformedisequaltothenumberofjobsconsideredinaninstance.Initially

J

batchesareopenedandany remaining unused batches are closed at the completionof the algorithm. The earliest ready job is assigned to theﬁrst available batch (i.e., adding a job should not violate thebatch capacity). This procedure is repeated until all the jobsare assigned to a batch. After the batches are formed, thebatch ready and processing times can be determined. Thebatch ready (processing) time is equal to the largest ready(processing) time of all the jobs in the batch. Randomizationis introduced to the MFF heuristic by means of the so calledRestricted Candidate List (RCL) which works as follows:while assigning jobs to the batches, instead of selecting theunscheduled job with the earliest ready time ﬁrst, the job israndomly chosen among the ﬁrst
k
earliest ready jobs. Here
k
is the size of the RCL.WeusetheexampleofSection“ALowerboundontheoptimalmakespan”toillustratehowtherandomizedMFFheuristicworks,assumingtheRCLsizeisthree
(
k
=
3
)
.Thejobsareﬁrstarrangedinnondecreasingorderoftheirreadytimes(i.e.,
List
= {
4
,
5
,
2
,
10
,
7
,
1
,
8
,
9
,
6
,
3
}
)
, ties are broken usingtheLPTrule.Table2showstheevolutionoftheheuristic.Thealgorithm starts in step 1 with the srcinal list and chooses atrandomajobfromtheﬁrstthreeelementsinthelist
(
k
=
3
)
.The selected job is then assigned to the ﬁrst feasible batch. If noneoftheexistingbatchescanaccommodatetheselectedjobthenanewbatchiscreatedandthejobisassignedtothisbatch.Finallythejobisdeletedfromthelistandtheprocedurestartsagain until all the jobs have been assigned to a batch. For theexampleproblem,applyingtherandomizedMFFheuristicledtotheformationofsixbatches.Thecompositionofeachbatchanditscharacteristics(i.e.,batchprocessingandreadytimes)arealsopresentedinTable2.We adopt a batch ﬁrst, schedule second strategy—groupthe jobs into batches and later schedule these batches to themachines—to minimize the makespan. Once the jobs aregrouped into batches using the randomized MFF heuristic,each batch is assigned to a machine which becomes ﬁrstavailable. This can also be called as a nondelay schedule.The nondelay schedule for the example problem is shownin Fig.2. The makespan is 25. The lower bound and the opti
mum for the same instance is 21.The following two types of movements deﬁne the neighborhood in the local search procedure: (1) job interchange,where two jobs scheduled in different batches are selected atrandom and interchanged; and (2) job insertion, where one jobisselectedrandomlyfromonebatchandtheninsertedintosomeotherrandomlyselectedbatchoranewlycreatedbatch.Both job interchanges and insertions are performed while
1 3
J Intell Manuf (2011) 22:767–777 771
Fig.2
Nondelay schedule forthe randomized MFF solution
maintaining the srcinal machine assignments and shouldensure that the machine capacity is not exceeded. After jobinsertions and exchanges, a 1

r
j

C
max
problem is solved foreach machine to obtain the schedule.A job interchange between jobs ﬁve and ten is shown inFig.3;andjobinsertionisshowninFig.4wherejobonefrom
Batch 2 is inserted into Batch 4. The job exchange increasedthe makespan by two units and the insertion decreased themakespan by two units. It is important to note that job insertionsandjobinterchangesmaybeperformedbetweenbatchesassigned to the same machine.The pseudocode for the proposed GRASP approach isthe following:
is the instance of the problem to solve and
is the set of feasible schedules.
σ
is an arbitrary feasible schedule in
.
RandMFF
(,
k
)
is the randomized version of the MFFheuristic that returns a feasible solution for
, where
k
isthe size of the RCL.
Lo
w
erbound
()
returns a lower bound on the optimalmakespan for
as calculated in Eq.(3).
Makespan
(σ)
returns the makespan of
σ
.
JobInterchange
(σ)
and
JobInsertion
(σ)
returnasolutioninthe neighborhood of
σ
by means of a job interchange and a job insertion, respectively.
σ
best
←
φ
S
t
a
rt
←
1
re
p
e
a
t
σ
c
u
rre
n
t
←
R
an
dMFF
(
Π
,
k
)
i
←
1
re
p
e
a
t
U
←
Random
if
U
<
θ
σ
n
e
w
←
JobI
n
terc
hang
e
(
σ
c
u
rre
n
t
)
else
σ
n
e
w
←
JobI
n
sertio
n
(
σ
c
u
rre
n
t
)
en
d
if if
M
ak
esp
an
(
σ
n
e
w
) <
M
ak
esp
an
(
σ
c
u
rre
n
t
)
σ
c
u
rre
n
t
←
σ
n
e
w
if
M
ak
esp
an
(
σ
c
u
rre
n
t
) <
M
ak
esp
an
(
σ
best
)
σ
best
←
σ
c
u
rre
n
t
if
M
ak
esp
an
(
σ
best
) =
Lo
w
erbo
un
d
(
Π
)
exit o
u
ter loo
p
en
d
if en
d
if en
d
if
i
←
i
+ 1
u
ntil
i
>
M
a
x
S
topCo
un
t
S
t
a
rt
←
S
t
a
rt
+1
u
ntil
S
t
a
rt >
S
t
a
rt
P
oi
n
ts
p
rint
σ
best
The parameters for the GRASP approach are: (1) the sizeof RCL
(
k
)
, (2) probability used to choose an interchangeor an insertion when generating neighborhood solution
(θ)
,and(3)counterssuchas
MaxStopCount
and
StartPoints
.Preliminary experiments were conducted to choose appropriatevalues for these parameters. The process adopted to choosethe parameter values is discussed in the next section.The performance of the GRASP was evaluated bycomparing its solution to the Modiﬁed Delay (MD) heuristic proposed in Chung et al. (2008), and the ﬁve heuristics
proposed in VélezGallego (2009): MFF, Modiﬁed Best Fit
(MBF), Marginal Cost (MC), Job Similarity 1 (JS1) and JobSimilarity 2 (JS2). All these heuristics follow what we cancall a “batch ﬁrst, schedule second” approach in which thesecond phase (i.e., the batch scheduling phase) is shared byall of them, so the difference between them relies on howthey perform the ﬁrst phase (i.e., the batch formation phase).To schedule the batches the heuristics arrange the batches intwo different ways: (1) in nondecreasing order of the batchreadytimes
(
R
b
)
,and(2)innonincreasingorderof
R
b
+
P
b
.Two nondelay schedules are formed with each list and theminimum makespan schedule is kept. A brief description of the heuristics proposed by Chung et al. and VélezGallego toform the batches is presented below.
•
MD
: The jobs are arranged in nonincreasing order of their ready times. At the earliest time a machine becomesavailable; all the available jobs are assigned to a batch. If therearemorejobsthan capacity inthemachine, thejobswith the longest processing time are preferred. If thereis remaining capacity after the available jobs have beenassigned to the batch, the heuristic evaluates if there is a job with a longer processing time that becomes availablein the near future. If such a job exists, the job is assignedto the batch. The batch is closed if the machine utilization reaches a minimum speciﬁed value or if there are nocandidate jobs to be assigned to it.
•
MFF
:ThismodiﬁedversionoftheclassicalFirstFit(FF)heuristicencompassesthefollowingsteps:(1)sortjobsinnondecreasing order of their ready times, breaking tiesusingLargestProcessingTimeﬁrst(LPT)rule;(2)assignthe ﬁrst unassigned job in the list to the ﬁrst availablebatch in which there is sufﬁcient capacity, and eliminatethisjobfromthelist;and(3)repeatstep2untilalljobsareassigned to a batch. The pseudo code for the MFF heuristic is presented at the beginning of Section “GRASPsolution approach”.
1 3