A Parallel Branch & Bound Algorithm for Makespan Optimal Sequencing in Flow Shops with Parallel Machines Klaus Brockmann Wilhelm Dangelmaier Heinz Nixdorf Institute, University of Paderborn Furstenallee 11, 33102 Paderborn, Germany email: fbrockm,
[email protected] ABSTRACT
to the machines at each stage and, for each machine, sequencing the allocated jobs. Possible objectives of job sequencing can be minimzing the makespan, the mean ow time, or any other regular measure of performance. The branch & bound algorithm presented in this paper minimizes the makespan, i. e. the maximum completion time required to process all jobs.
In this paper we address the problem of makespan optimal sequencing in a ow shop with parallel machines (FSPM). This kind of production facility is a generalization of the standard ow shop where at least one stage consists of two or more identical machines. We present a branch & bound algorithm and its parallel implementation which minimizes the makespan, i. e. the maximum completion time required to process all operations for a given set of jobs. Compared to other algorithms our method makes use of a quite simple branching scheme and is to our knowledge the rst exact algorithm which can deal with machine available times. Although the minimum makespan scheduling problem in the FSPM environment is NP -hard, this paper shows that instances of small to moderate scale can be solved in a reasonable amount of time. In particular, this is true if the computing performance of massively parallel systems is used to solve such problems.
Q1
> A A A AU
m
1
A
A 2 ZAAU ~ Z . . . 1
m
Q2
> A A A AU
m
1
2 . . .
m
j
A A ZAAU ~ Z
Q
s
> A A A AU
m
1
A
2 . . .
m
s
A ZAAU ~ Z
m
Figure 1: Schematic representation of the FSPM. In order to limit the class of problems under consideration, the following assumptions are made: (1) The number of jobs, their release times, and their processing times are known and xed. (2) All jobs follow the same stage sequence. (3) No job may be cancelled, split, or preempted. (4) No two operations of the same job may be processed simultaneously. (5) Setup time is independent of the job sequence and is therefore considered as part of the processing time. (6) All machines of the same stage are identical. (7) No machine may process more than one job at a time. (8) Machines may remain idle. Note, that we do not assume that the machines are available at the beginning, i. e. our algorithm can be applied without any modi cation if problem instances with a rolling horizon are to be solved.
1. INTRODUCTION The problem
The term ow shop with parallel machines (FSPM) | in the literature synomyms like ow shop with multiple processors, hybrid ow shop, or exible ow line are likewise common | characterizes a generalization of the standard
ow shop. The FSPM consists of s > 1 stages where a stage j (1 j s) embraces mj 1 identical parallel machines. A given set of jobs, denoted as N (jN j = n > 1), have to be processed on the machines of the ow shop. Each job i 2 N consists of s operations with processing times pij (1 i n, 1 j s). All jobs follow the same unidirectional ow pattern through the shop, where an operation has to be processed on one of the parallel machines of the corresponding stage. Between the processing of two subsequent operations a job can be bu ered in a queue in front of the corresponding stage. At the beginning all jobs are queued in front of stage 1 or arrive there at their release times. The FSPM can be presented graphically as in Figure 1. A sequencing algorithm for this kind of production facility consists of allocating the jobs
Contribution of this paper and its organization
The sequencing problem in the FSPM environment frequently arises in practice. Since it belongs to the class of NP -hard combinatorial optimization problems [7] many heuristic methods have been proposed for the approximative solution of di erent variants of it, e. g. see [1, 5, 8, 9, 11, 13, 14]. The rst exact algorithm for solving the mimimum makespan problem was developed by Brah and Hunsucker [2]. Based upon this branch & bound algorithm and a generalization of the global lower bounds presented in [10] a signi cantly improved method was developed by Brockmann, Dangelmaier, and Holthofer [3, 4]. Besides
This work is supported by the DFG Sonderforschungsbereich 376: \Massive Parallelitat: Algorithmen, Entwurfsmethoden, Anwendungen".
1
completion time at the previous stage, its processing time at the current stage, and the machine available times of the current stage. Let cij and ajk denote the completion time of job i at stage j and the available time of the kth machine of stage j , respectively (1 i n, 1 j s, 1 k mj ). Since job i0 is allocated to the rst free machine its start time at stage j 0 , si j , results from:
the improvement of the lower bounds, they have implemented the rst parallel branch & bound algorithm which to our knowledge is the up to the present fastest method for the stated problem. However, concerning the combinatorial complexity of the solution area the branching scheme they have used is not optimal. Besides, their algorithm cannot handle with available times of the machines which is very important in practical applications. In section 2 the simpli ed branching operation of our algorithm is presented. This branching scheme leads not only to a lower combinatorial complexity of the solution area but also allows the consideration of machine available times. In principle, our algorithm makes use of the same lower bounds as those presented in [3, 4]. However, we have adapted them to the simpli ed branching scheme and the inclusion of machine available times. The lower bounds are presented in section 3.
0 0
: si j := max 1min fa g ; c kmj j k i j ?1 Note, that the completion time of each job i at the virtual stage 0, ci0 , can be de ned as its release time. If pij denotes the processing time of job i at stage j (1 i n, 1 j s), the completion time of job i0 at stage j 0 can 0 0
0
0 0
0
easily be computed as:
ci j := si j + pi j : 0 0
Parallel branch & bound algorithms have been developed for a large class of application problems. Gendron and Crainic have presented a detailed survey of the extensive literature until 1994 [6]. We don't want to give an extensive description of all the technical details of our algorithm. However, together with a short survey of its components and the implemtation platform we used, some speci c details of it are described a little more comprehensive in section 4. Section 5 covers some experimental results which demonstrate the eciency of our algorithm. Finally, we close with the conclusions in section 6.
0 0
0 0
Incremental Computation of Machine Data
Besides the computation of start and completion times of job i0 at the current stage it is necessary to determine the modi ed available times of the machines of stage j 0 . These times are required when the branching operation is applied to the new generated node of the branching tree as well as for the computation of the lower bound of the current node. Let be the machine which rst became available before i0 has been allocated to it. Then the available time of the kth machine of stage j 0 must be modi ed in the following manner (1 k mj ):
2. BRANCHING OPERATION Feasible solutions and branching scheme
aj k := 0
In contrast to the algorithms presented in [2] and [3, 4] our method makes use of a quite simple branching scheme for the construction of the branching tree and the enumeration of feasible solutions. In each node of the branching tree one job, which has not been scheduled at the current stage so far, is added to the partial solution given by the node to which the branching operation is applied. In this way a sequence (permutation) of the job numbers is constructed subsequently for each stage, beginning with the rst one. Thus, a complete solution consists of s job sequences, one for each stage, each xing a non decreasing order of start times of all jobs at the corresponding stage. Obviously, there exist n!s feasible solutions which is equal to the number of possible end nodes in the branching tree. Note, that a sequence of job numbers does not x an allocation of the operations to the machines of the corresponding stage. This is not necessary because all machines of the same stage are identical. Thus, when a job number is added to a sequence simply the machine which rst becomes available can be selected to process the corresponding operation of this job.
0
if k = ; ci j max (si j ; aj k ) else: 0 0
0 0
0
The second part of this assignment is due to the fact that each sequence xes a non decreasing order of start times of the jobs at the corresponding stage. Thus, if job i0 is scheduled at time si j by the given modi cation of the machine available times no subsequent job can be scheduled earlier than i0 at the same stage. Note, that the available times of the machines initially can be de ned by input data. Because of this fact, which has also been taken into account for the development of the lower bounds, for the application of our algorithm it is not presupposed that all machines are available at the beginning. Hence, there is no need for any modi cation to the algorithm if problem instances with a rolling horizon are to be solved. 0 0
Objective
The branch & bound algorithm presented in this paper minimizes the makespan, Cmax, which for a complete solution in an end node of the branching tree is de ned as:
Cmax = max fc g : i2N is
Incremental Computation of Job Data
3. LOWER BOUNDS
When a speci c job, say i0 , is added to a sequence for the current stage, denoted as j 0 , its start and completion times at this stage can be computed very easily from its
In order to get a good estimation of the makespan for a given partial solution it is necessary to develop strong
2
vector of the machine available times of stage j , which are the ajk -values, in non decreasing order of its entries. Assuming that all operations can be scheduled without intermediate machine idle times, which is of course the optimal case, obviously each job should be scheduled as soon as possible. On the other hand, no job can be scheduled before one of the machines becomes available. Regarding these facts we de ne the vector of earliest possible machine start times, STNj , in non decreasing order of its entries as follows (1 k min(mj ; jN j)): STNj [k] := min(stjNj [k]; stmj [k]) : Similar, let the remaining work of all jobs i 2 N behind stage j be given as an array, RWNj , in non decreasing order of its entries | Pthe remaining work of a job i behind stage j is given as sl=j+1 pil .
lower bounds. Our algorithm makes use of three di erent lower bounds: the job based lower bound, the stage based lower bound, and the machine based lower bound, the last two of which are generalizations of the global stage based lower bound presented in [10] while the job based lower bound is well known from the standard ow shop problem. However, we have adapted these bounds in order to be able to regard initial machine available times. This makes our algorithm applicable without any modi cation when problem instances with a rolling horizon are to be solved. In the following the lower bounds are described in detail.
Job Based Lower Bound
The job based lower bound, LBJ, serves as an optimistic estimation of the makespan for a given partial solution in consideration of the job completion times as far as they are known, the remaining work of the jobs respectively the processing times of their unscheduled operations, and the machine available times of the current stage as well as all subsequent stages. The job based lower bound comprises the earliest possible completion times at stage s of all jobs. We can compute the earliest possible completion times not only for stage s but also for any arbitrary stage not considered so far. Since we use these values for the computation of the stage based lower bound presented below it seems to be useful to give a general de nition. For a given partial solution the earliest possible completion time of job i at stage j , lbjij , can be de ned recursively as follows:
Since we do not know how many machines of stage j have to be utilized in order to get an optimal schedule we have to estimate Cmax by the optimal case. Thus, Cmax is always greater than or equal to the stage based lower bound of stage j which we now can de ne as follows: lbsj = min 1kmin(m ;jN j)
(
j
k k 1 X STN [l] + X p + X RWN [l] ij j j k i2N
l=1
l=1
!)
:
Since this is true for all stages not considered so far, we can choose the maximum over all stages j with j 0 < j s as the stage based lower bound: LBS = j max flbs g :
