Hemisfic Methods for Flexible Flow Ime Scheduling
Sandeep Koehher, Harvard University, Cambridge, Massachusetts
Robert J.T. Morris, AT&T Bell Laboratories, Holmdel, New Jersey
Abstract
Heuristic methods are presented for
scheduling a flexible flow line. Two problems are
considered: entry point sequencing, that is,
deciding the order in which to present the jobs to
the system, and dispatching, that is, deciding at
each machine which job to start next. The
results of these methods on test and realistic
problems are described. The approach takes into
account various line phenomena, such as set-
ups, finite buffers, blocking and starvation,
machine downtimes, and the current and sub-
sequent states (at rescheduling intervals) of the
line. Various optimization techniques are in-
vestigated including myopic and local search
methods. The most successful technique
developed uses local perturbation to obtain
successively improved schedules. In test cases
where the optimal schedule is obtainable, we
are able to produce solutions within a few
percent of the optimal. Our experience with
these methods is sufficiently encouraging to
lead us to conjecture that they are capable of
producing entry point sequences that are, for all
practical purposes, optimal. Various methods of
dispatching are considered which tryto minimize
the effects of setup times and blocking. While
dispatching is found to be useful in setup-
intensive lines, one of our conclusions is that
care must be taken, as plausibly helpful rules
can lead to unexpected d e t e r i o r a t i o n of
performance.
Keywords: Scheduling, Entry Point
Sequencing, Dispatching, Local Search.
299
Introduction
We consider the scheduling of a class of
manufacturing facilities called flexible flow lines
(FFLs). In our terminology a FFL, which is shown
schematically in Figure 1, has several key character-
istics. The line consists of several workstations, each
having a n u m b e r of identical machines. The line is
flexible in that it can produce several types of items
which we refer to as 'codes'. P r o d u c t flows through
the line, from left to right on Figure 1, although
more complex routings (e.g., certain machines are
skipped, machines are revisited, etc.) are not ruled
out. There are finite buffers to hold jobs between
different workstations (besides the position each
machine has to work on its current job). A machine
on finishing its job can only release it if the input
buffer for the next workstation has a position
available to hold it; otherwise the machine has to
wait, a p h e n o m e n o n referred to as blocking. A
machine has to remain idle if the input buffer
b e l o n g i n g to its w o r k s t a t i o n is e m p t y , this
p h e n o m e n o n is called starvation. There is a certain
a m o u n t of setup time involved when a machine has
to switch from one code type to another. Machines
are also subject to breakdowns and maintenance
downtimes.
The production of the FFL is driven from daily
lists which are derived from dates when the products
of the line are to be shipped or assembled into
systems. (We use one day as a typical figure,
 Journal of Manufacturing Systems
Volume 6/No. 4
Maehina_~_~~
~O--q/ut
Workstation
In
~-~-~ ~ "''-]~FinitiBuffer
Figure 1
A Flexible Flow Line
however it could be replaced by one week, one shift,
etc.) The FFL we consider is then required to
produce these items as efficiently as possible by
scheduling its operations. This scheduling problem
consists of three subproblems: (I) determining the
sequence in which to begin work on each item (the
entry point sequencing problem defined below), (2)
management of the material in-process - - in the
FFL approach, this can be done by using strictly
limited intermediate buffering (a version of the 'pull'
or just-in-time (JIT) concept with the finite buffer
positions corresponding to kanbans), and (3) decid-
ing which of the available jobs to run next whenever
a machine becomes available and there is work in its
buffer (the dispatching problem defined below).
Problem Definition. The aim of scheduling
jobs is to optimize some 'cost' associated with the
manufacturing process. For example, we might
wish to maximize throughput (the number of jobs
produced in a given time), minimize the makespan
(the time between the first job of a given production
order entering the system and the last job of that
order leaving the system), minimize the work in
process (number of unfinished jobs in the system) or
minimize the average interval (the interval of a job,
also referred to as its sojourn time, being the time it
spends in the system, from entering the first work-
station to leaving the last one), or some combination
of these.
The actual cost criterion chosen would depend
on the system, the types of codes produced and
300
business objectives (relative cost of material, plant
etc.). Although the methodology we describe applies
equally well to any of these objectives, we chose the
average interval or the sojourn time as our cost
criterion for the purposes of this study. The reason
for this is that a lower interval implies lower
inventory carrying costs. Experience has also shown
that when intervals are small, quality tends to be
much higher and more controllable. For example,
the manufactured product quickly reaches a test or
inspection area and process defects can be quickly
corrected.
If we wished to be completely general, we
would regard the scheduling problem as deciding
exactly when to present each job to each machine.
This problem appears too difficult to solve com-
pletely. As already stated, we consider a simplified
form of the scheduling problem consisting of two
subproblems:
1. Entry Point Sequencing. Once a new (e.g.,
daily) requirement has come in, a decision has
to be made as to when to initiate the production
of each item on the line. This in turn affects the
order in which these items reach downstream
machines. Thus, entry point sequencing, or
EPS, is the simplest way in which to exert some
control over the operation of the line.
2. Dispatching. Once a machine is ready to start
a new job and more than one job is waiting in
the input buffer, one of those jobs has to be
chosen. This decision could be based on a
combination of the setup costs involved, the
amount of blocking and starvation in the
system and the up/down states of the machines.
The attraction in dispatching stems from the
fact that EPS can only exercise limited control
over the machines far down the line by varying
the input to the first machine, whereas it
appears that at any time a machine has signi-
ficant knowledge (e.g., tool status) which could
be of value in choosing its next job.
Previous Work. Previous work in this area has
generally been concerned with scheduling in special
cases of the FFL. Wittrock ~ considers a restricted
{,ersion of the FFL described above by assuming
that no setup is incurred when a machine switches
between codes, that blocking is not present due to
large (infinite) buffers between machines, and the
only dispatching rule is first come, first served. This

method, as well as several other recent approaches, :-3
uses heuristics to minimize dynamic imbalance in
the system and thereby reduce queueing, blocking
and starvation effects. These methods work well for
certain classes of FFL, but as Wittrock points out,
these techniques need to be enhanced to take into
account many of the effects that we consider, such as
setups, finite buffers, downtimes, etc.
Bruno et al.' describe a rule-based system that
uses heuristic rules to introduce jobs into the system,
but they do not make any attempt to optimize entry
point sequences. Optimization techniques similar to
the ones we describe are explored by Baker ~ in the
simpler one-machine case. The paper by Krone'
considers application of local search methods to the
scheduling of flow shops without setup, buffer or
downtime effects and finds results which compare
favorably with 'empirical optima'. There is a con-
siderable existing literature on the dispatching
problem (for a recent survey see Reference 7), much
of it dealing with special cases of the general flow
line problem described above. To our knowledge,
no attention has been directed to the interaction of
dispatching rules and entry point sequencing.
Our Approach. We considered two basic
approaches to entry point sequencing. The first
approach is myopic in nature and tries to build a
complete 'good' input sequence by successively
adding jobs to initial subsequences. The second
approach works with complete sequences and tries
to optimize them through local perturbations.
Other researchers have used myopic strategies
(e.g., References 1 and 3) similar to the first
approach mentioned above for job scheduling. We
found, however, that the myopic approach did not
perform as well as the more global second approach
which we found to lead to near optimal solutions.
Our second approach, based on local search, ~ is
similar to those approaches used for other difficult
combinatorial optimization problems--see, for
example, Lin and Kernighan's approach to solving
the "Traveling Salesman Problem"' (this is reputed"
still to be the best method for this problem) and the
"Graph Partitioning Problem"."
We experimented with dispatching rules con-
sidering both setup optimization and blocking/
starvation minimization. We found that minimizing
setup was useful as a dispatching rule, while mini-
mizing blocking was less effective.
301
Journal of Manufacturing Systems
Volume 6/No. 4
Entry Point Sequencing
The entry point sequencing problem can be
stated as follows:
Given a FFL and a production requirement
(A, n~), (B, ne) .... (that is, no number of code
A, n a of B, etc. have to be produced), find
the permutation (e.g., ABCAA) of these
jobs such that this permutation as the input
sequence to the first workstation optimizes
some cost criterion.
The above production requirements may be
viewed as unit items or lots. The lot sizing decision is
often made independently based on issues of effici-
ency or material handling, although it could be
incorporated as a decision variable in our approach.
Note also that the EPS problem is defined inde-
pendently of the dispatching rules used.
Evaluating Solutions. At the heart of our
method lies a deterministic simulator, or Gantt
chart generator, for the FFL. This simulator is an
efficient method of evaluating the cost associated
with a given solution (an entry point sequence).
Most previous approaches to the scheduling prob-
lem p r o d u c e d solutions having some heuristic
appeal, but made no attempt to evaluate the solution
or to produce multiple solutions and choose the best
among them. The strategies that we use, however,
rely heavily on getting an accurate measure of the
cost and we use the simulator for this purpose.
The simulator is written in the'C'language and
uses only fixed point calculations for speed and
efficiency. It has been used on both a VAX TM 11 / 785
and an AT&T-3 B2/300 computer running under the
UNIX® Operating System. One evaluation takes
about 30-35 milliseconds on the VAX for a problem
with seven workstations having 16 machines, and an
input sequence of 45 jobs.
The simulator creates a deterministic model of
the FFL by reading its description from a file. The
following parameters are required inputs:
• Number of workstations,
• Number of machines at each workstation,
• Number of jobs of each code to be produced,
• Service times for each code at each workstation,
• Setup matrix at each workstation,
• Number of buffers at each workstation,
• Current state of the FFL.
Journal of Manufacturing Systems
Volume 6 / N o . 4
The last item above, namely the ability to take
into account the current state of the FFL (queue
lengths and u p / d o w n status of machines), while
natural in simulation, is novel and important in
scheduling since it permits our approach to respond
to dynamic fluctuations and contingencies in the
line (e.g., breakdowns, inaccuracy of measurements,
etc.). Previous approaches (to our knowledge) at
best accounted for these effects using static correc-
tions. In this sense, we are developing a 'closed loop'
solution (as opposed to the previous 'open loop'
solutions) to the scheduling problem (Figure 2).
Product Database
(resource requirements
Production I service times, downtimes, machine status and con-
Entry Point Scheduler
I '
Optimizer
I I
L__~_
Current State
of FFL
I • Respond to machine breakdowns,
I-" FFL -1
I I
1_ .J
Figure 2
E P S and F F L Interaction
Another important characteristic of the simu-
lator (and hence of the approach) is that it can be
used in two modes: short-term (corresponding to a
daily production schedule), and long-term (or steady
state, for example, corresponding to 10 days). This
is useful for ensuring that short-term scheduling
does not leave the line (at the end of the day) in a
state that is not good for the coming days. Another
useful characteristic of the approach is that addi-
tional guiding heuristics and line information can be
easily added, for example, maintenance downtime
schedules, operator unavailability during lunch
breaks, etc.
The deterministic nature of the simulation
might at first seem a drawback when we consider the
fact that a real FFL would have 'noise' in the service
and setup times, unpredictable machine break-
downs, etc. (Queueing theory and other approaches
often use approximate probabilistic models to try to
account for the stochastic nature of the line.)
However, inherent efficiencies more than compen-
sate for this potential disadvantage since the sched-
ule is fast enough to be run quite often. The
scheduler can and should be run whenever the state
of the line changes significantly (for example, a
machine breaks down, or a new production re-
quirement comes in), or periodically to take into
account an up-to-date state (queue lengths, etc.) of
the line. Note that software tools are now being
developed that automatically construct models of
systems based on operational measurements of
figuration, etc. '2 We discuss practical and imple-
7
mentation issues in a forthcoming section.
To summarize, the major advantages of our
I_.1 "~.~Optimized approach over previous approaches to the FFL
I / Sequence
scheduling problem are the ability to:
/ • Optimize to improve setup efficiency,
• Optimize to reduce blocking and starvation,
• Consider finite buffer space,
• Take into account the current state of the line,
• Incorporate additional guiding heuristics or
characteristics particular to the line.
Search Techniques. We now turn to the
methods for constructing the entry point sequence.
Given a FFL and the requirement to produce
quantity n i of a code i (i = l, 2 ..... M), there are
N!
different entry point sequences, where N =
1-I(ni!)
E nl. This is usually a very large number. For
example, even with M= 5 and n/s all 5, we have over
1014 sequences possible. Testing every one of these
sequences is computationally intractable. One or
more of these sequences will attain the optimal cost,
denoted E. We would like to come up with an entry
point sequence that has cost E or nearly E. The
results are sufficiently encouraging that we are led to
conjecture that, for all practical purposes, these
methods can be used to find essentially optimal (i.e.,
close to E in cost) entry point sequences. Before
describing these, we briefly discuss our experience
302

with some myopic strategies that do not perform as
well. The next section discusses best first, A*, and
beam search techniques applied to our problem.
(Readers not familiar with these techniques are
referred to texts such as Reference 13.)
Best First, A * and Beam Search. One of the
approaches to scheduling put forward by many
researchers (References 1,3, etc.),tries to find a good
solution sequence by constructing it from smaller
sequences. The basic strategy is as follows:
start with the null sequence
while (there are jobs remaining to be scheduled) {
pick job that optimizes the cost over partial
sequence produced so far.
} associated with the sequence x. Our notation is as
We tried out similar techniques of building up
the solution from smaller sequences using average
interval as the cost. Best first search, which always
expands the best as yet unevaluated partial sequence,
was used in an attempt to direct the search and find
better sequences earlier in the process. We found the
performance of best first search to be disappointing.
Apparently, it is too myopic--it tries to estimate the
quality of a sequence by considering only initial
subsequences. We found that short jobs were often
chosen early in the sequence and the longer jobs,
with their attendant ill effects, were not considered
until much later. The program ended up searching
the solution space in a breadth-first manner causing
the program to exhaust memory before finding
solutions, even for quite small problems.
To alleviate this problem, we tried a method
based on the idea of A* search. Thus, to the cost of
the partial sequence we added a lower bound of the
cost of the remaining sequence. The hope was that
this would better direct the search by avoiding
expanding initial sequences that would have expen-
sive remaining subsequences. However, since getting
a tight lower bound turned out to be quite difficult
(we used the average total processing time of a given
sequence as a lower bound on the average interval
for that sequence), the program again wound up
searching too large a part of the search tree and
consequently ran out of memory.
We next tried a variation on the beam search
technique combined with the A* method. Basically,
at each step, only W (where W is the beam width)
partial sequences were kept--those having the least
303
Journal of Manufacturing Systems
Volume 6/No. 4
sum of the cost so far and the estimated remaining
cost. This did help cut down the search tree, but the
myopic nature of the scheme still prevented us from
getting 'good' solutions.
Our conclusion from these attempts was that
strategies that do not accurately take complete
sequences into account are not likely to produce
good solutions.
LocalSearch. The basic elements in a local
search are as follows. (For an introduction to the
principles of local search see Reference 8.) We have
some method of systematically generating from a
given feasible solution sequence x a set of related
sequences--we refer to this as the sequences gen-
erated by perturbing x - - a n d a cost function C(x)
follows. Sequences are written within parentheses,
for example (aabbcdef). The application of an
operator H to a sequence x is denoted by Hx. We
define a perturbation operator H, which when
applied to sequence x produces another sequence y
as follows:
Let J be the set of sequences created by per-
turbing x
Let y be the minimum cost sequence in J (ties
broken arbitrarily)
if C(x) > C(y) return y
else return x
Given a starting feasible solution sequence x, we
produce from x a locally optimal solution as
follows:
loop
Let y = Hx
if y is the same as x, exit with x as a local
optimum else replace x by y
continue
The solution obtained by this procedure is
locally optimum in the sense that it can not be
improved using the perturbation operator H. Since
this search may terminate prematurely at local
minima, we repeat the entire procedure for as many
starting points as computational resources permit.
In our case, we would start with a complete entry
point sequence and locally optimize it using some
perturbation operator. We would then repeat this
for as many initial sequences as computationally
feasible, and pick the best solution obtained as the
entry point sequence.
Journal of Manufacturing Systems
Volume 6/No. 4
The success of a local search approach generally
depends on (1) choosing good initial starting points,
and (2) good perturbation operators. These are
discussed next.
Starting Points. We experimented with various
kinds of initial solutions: the solution obtained by
an algorithm similar to that of Johri 3 (which is
based on enhancements to the 'dynamic balancing'
heuristic proposed in Reference 1), the solution
obtained by an algorithm similar to that of Rege ~
(which is based on a scheme of clustering like
products based on resource requirements and then
sequencing those products through the line in an
order that attempts to maintain a short-term balance
at each workstation), and a few random sequences.
It turned out that random sequences were as good
starting points as the other sequences. Moreover,
the solutions obtained from all the starting se-
quences were about as good, leading us to conclude
that this approach would work quite well with just
one starting point, and that more starting points
could be used to improve the solution only mar-
ginally. Detailed results are presented in the next
section.
Operators. The perturbation operators that
we used are basically interchange operators, that is,
they swap two subsequences of a given sequence.
Specifically, two operators that we call P (for
pairwise) and B (for blockwise) are defined as:
1. P: Px is the sequence with the lowest cost from
the set containing x and the sequences that can
be produced from x by pairwise exchanging
any two elements ofx. For example, to apply P
to the sequence (aabc), we would pick the
lowest cost sequence from the set {(aabc),
(aacb), (acba), (cabal (abac), (baac)}.
2. B: Similar to P, except that the unit of
exchange is a block or a subsequence of like
codes. For example, the sequence (aabba)
contains three blocks (aa), (bb) and (a). Thus,
Bx would be the lowest cost sequence from the
set {(aabba), (bbaaa), (aaabb), (abbaa)}.
(These operators would be classified, in the
terminology of Reference 8, as 'steepest descent'
methods, as opposed to 'first improvement' methods
which take the first sequence generated that shows a
lower cost.)
From these, the operators P ~ and B~ are
defined as follows:
304
1. Poo "- P" such that P " ' ~ x = P"x, that is, we
apply P to x repeatedly until no improvement
(decrease in cost) takes place.
2. B~ = B" such that B"" x - B"x, that is, we apply
B to x repeatedly until no improvement
(decrease in cost) takes place.
Finally, the operators that we found lead to
'good' (near-optimal) entry point sequences are
(P~Boo)o~ and (B~Po~)oo. (PooB~)~ is defined as
(Po~B~)" such that (P~B~)"+'x = (P~B~)"x.
Informally, we apply P ~ , B ~ , P ~ , B ~ ..... to x, until
no further improvement takes place. (B~P~):~ is
defined similarly with P a n d B interchanged. Both
operators seem to perform about as well (see
results next section), though ( P ~ B ~ ) ~ seems
slightly better.
Briefly, the motivation behind using these
operators is as follows. P is useful for causing small
perturbations and for breaking up long sequences of
similar codes, thereby helping reduce blocking and
starvation. B, on the other hand, is useful for
coalescing short subsequences of similar codes into
longer subsequences, and for keeping subsequences
of similar codes together while interchanging,
thereby helping reduce setup costs. Our scheme,
therefore, optimizes a sequence both by breaking up
blocks of similar codes and by coalescing elements
into blocks.
The results of experiments using these oper-
ators are described in the next section.
Results. The testing of these methods was
divided into three phases. In the first, we constructed
small sample problems for which it was possible to
do exhaustive search over all possible entry point
sequences and find the true optimum (even though it
took over 100 hours of CPU time!), and compared
the solutions obtained using our methods to the true
optimum. In the second phase, we ran our methods
on the same test problems, but for a 10 day period
with a new EPS constructed at the beginning of each
day, to see how well these methods were able to
respond to the current state of the line. Finally, in
the third phase, we constructed a realistic problem
with data taken from a real FFL, and applied our
methods. These phases are discussed in more detail
below. It should be noted that at this point in our
research, the simulator only had the default first
come, first served dispatching.
Sample Problems and Exhaustive Search. We
constructed three FFLs each having two work-
 Journal of Manufacturing Systems
Volume 6/No. 4

stations with three machines. Ten types of codes obtain the true optimal entry point sequence for the
were allowed. The first FFL was setup-intensive first day and its cost (Table 1). We then created the
(setups were high, and blocking was prevented by following types of starting points for each case:
having large buffers). The second was blocking-
intensive (setups were all zero and there was only I a : Block oriented sequence (useful for re-
one buffer space between the two workstations), ducing setups) e.g., (aaaabbbcccdcO
and the third was mixed (setups were present and Ix : Obtained by a variation of the method of
there was only one buffer between the two work- Reference 2.
stations). Four data sets of daily production lists I,, : Obtained by a variation of the method of
were constructed, having between 10 and 12 jobs to Reference 3.
be produced. (The details of the test FFL parameters I R : Random sequence (actually five random
and data sets can be found in the Appendix.) sequences were tried out for each case,
We then did an exhaustive search over all though in Table 1 we only show the
possible permutations for each of the 12 cases to results of one for each case.

Table Z
Test P r o b l e m s - - R e s u l t s for One D a y

FFL I: Setup Intensive FFL 2: Blocking Intensive

Initial Initial Cost using Co~t using Initial Initial Cost using Cost using
Seq . . . . . Cost (P.Boo). (B.P.). Seq . . . . . Cost (PooBoo)oo {B~oPoo)oo
D a t a set 1 ( E = 167) Data set 1 ( E = 104)
IB 201 176 176 IB 119 106 106
~K
P
231
249
180
176
180
176
~K 125
132
107
106
107
106
IR 25l 167 167 1'2.9 104 104
D a t a set 2 ( E ffi 151) Data set 2 ( E = 99}
IB 204 153 175 18 125 100 106
I 246 163 168 116 103 103
266 172 172 p 130 99 99
lR 282 153 153 [1~ 134 103 103
Data set 3 ( E = 132) Data set 3 ( E = 100)
IB 226 132 139 Is 135 103 105
K
IP
~ 262
287
144
165
144
159
119
117
101
102
101
102
R 214 139 132 1-'20 105 105
Data set 4 (E = 111} Data set 4 ( E = 94}
IB 160 Ill Ill IB 120 95 94
iK 168 111 Ill 105 97 97
p 146 I11 111 105 94 97
IR 181 Ill Ill 113 94 94
FFL 3: Mixed
Initial Initial Cost using Cost using Notes:
Seq . . . . . . Cost (P.Boo). ( B . P . ) .
1. Cost is measured as the average
Data set 1 ( E = 167) interval.
IB 194 168 168
I 215 168 168 2. E is the minimum cost obtained by
pK °0"~
- . 173 173 exhaustive search over all possible
la 203 173 173 permutations.
D a t a set 2 ( E = 150}
[B 173 155 152 3. Initial Sequences(Starting Points]:
211 155 162 le: Block oriented sequence (useful
oo
..1 162 162 for reducing setups) e.g.
IRP 229 155 155 (aaaabbbcecdd)
Data set 3 (E ffi 132} IK: Variation of method of [2].
IB 165 132 135
Ip: Variation of method of [3].
~K
p
206
~°4
--
138
139
138
153 Is: Random sequence
Ia 182 132 135
Data set 4 ( E = 105)
lB 1-19 105 105
~K
ip
149
136
105
105
105
105
a 159 105 I05

305
Journal of Manufacturing Systems
Volume 6/No. 4

We then computed the cost of each of the
starting sequences for each case (using the simulator)
and the costs of the sequences obtained by applying
the operators (BooPoo)oo and (P~Boo)oo to the
starting sequences, for one day. The results are
summarized in Table 1, which is self-explanatory.
For example, for FFL #3 (which had both blocking
and setups) and data set #2, the true optimum entry
point sequence had a cost (average interval) of 150;
the random sequence had a cost of 229 and applying
either (B~Poo)~o or (PooBoo)oo to it produced a
sequence of cost 155, which is within 4% of the true
optimum.
Periodic Rescheduling. We used the same
FFLs, data sets and starting sequences as in the
previous section, but allowed the optimization to be
done at the beginning of each day for 10 consecutive
days, assuming the same job requirement each day.
(The cost used was the average interval over all
jobs.) Thus, the optimization for day i + 1 had to
take into account the state of the line (unfinished
jobs in the system, etc.) at the end of day i.
The costs of loading the optimized sequences
(different sequences were produced for each day)
were compared with the cost of loading the first
day's sequence 'as is' every day. Table 2 summarizes
the results at the end of 10 days. Thus, for example,
in the case of FFL #3 and data set #2, loading the
block starting point IB every day led to a cost of 190,
while using (BooPoo)oo and (PooB~)~ led to sched-
ules with costs 165 and 158, respectively. In some
cases, dramatic improvements of factors of four or
five in interval resulted from periodic rescheduling.
Realistic Example. Finally, we constructed a
realistic problem from data taken from a real FFL.
It had seven workstations, 16 machines, seven code
types and a requirement to produce 45 items.
(Details can be found in the Appendix.) Except for

Table 2
Test P r o b l e m s - - R e s u l t s for 10 D a y s

FFL 1: Setup Intensive FFL 2: Blocking Intensive

Initial Rep.* Cost using Cost using Initial Rep. Cost using Cost using
Sequence Cost (PooB~)oo (B~Po.)~ Sequence Cost (PooBc~}oo (BooPoo)oo
Data set 1 Data set 1
Is 848 775 775 IB 143 139 139
I 876 683 683 I 144 138 138
~g 874 758 758 146 137 137
Data set 2 Data set 2
IS 292 168 173 IB 138 132 128
I011 206 242 I 138 131 131
980 195 290 140 129 130
Data set 3 Data set 3
[B 403 250 364 18 135 129 124
1098 284 335 I 133 128 128
852 476 478 128 129 130
Data set 4 Data set 4
Is 163 114 118 I8 110 105 105
560 IIO II0 [ 114 105 105
322 122 120 114 108 108
FFL 3: M i x e d
Initial Rep. Cost using Cost using
Sequence Cost (PmBoo)oo (B~P~)~
Data set I
Is 248 227 227 Notes:
253 221 221
251 224 224 1. Cost is measured as the average interval
over all jobs produced over 10 days.
Data set 2
IB 190 158 165
* "Repetitive cost" i.e. cost
I. 258 178 195
of loading the same sequence every day
266 181 178
Data set 3
[s 174 152 161
! 241 154 158
[~p 214 166 168
Data set 4
IB 142 125 126
I 190 129 128
185 127 127

306

the exhaustive search (which was computationally
infeasible), we followed the same steps as for the
sample problems. The results are summarized in
Table 3.
Table 3
Realistic Problem--Results for One Day
Initial Initial Cost using Cost using
Sequence Cost (P ooBoo)oo ( BooP oo)oo
9806 6914 7069
9396 6929 6998
P
IR 9027 7202 7278
These experiments led to observations that we
discuss next.
Observations. From the results of these ex-
periments (summarized in Tables 1, 2 and 3), we
were able to draw the following observations:
1. For the sample problems;
a. The method converged rapidly to within
close range of the true optimum. In all the 12
cases, we were able to obtain solutions
within 0.5% of the true o p t i m u m on the
average and 2% in the worst case.
b. The p e r t u r b a t i o n o p e r a t o r s , P and B,
described above are good operators--they
work well and are not too expensive com-
putationally.
c. The resulting local optima are about equally
good, regardless of the starting sequence
chosen. However, there is some marginal
value in repeating the optimization with
different starting sequences.
d. Usually, significant (25% or more) im-
provement is possible over the cost of the
starting sequence.
2. The method is able to respond well to the
current state of the line and produces good
solutions with dynamic rescheduling.
3. For the realistic example, all the observations
for the sample problems appear to hold, al-
though we were unable to compare the results
with the true o p t i m u m (it was computationally
intractable to do an exhaustive search).
4. On the prototype implementation on a VAX
11/785, the sample problems require a few
CPU seconds to come to a solution, while the
realistic problems take on the order of 30
307
Journal of Manufacturing Systems
Volume 6/No. 4
minutes. However, we feel that with more
efficient programming improvement on the
order of two or three ispossible. Examples of
techniques which we did not exploit but would
add to efficiency, include the use of more
efficient m e m o r y allocation and event list
management techniques, and the keeping of a
dictionary of previously evaluated sequences
to prevent multiple evaluations of a sequence.
Since the computational resources required
are essentially integer arithmetic with little I/O
or floating point, an inexpensive machine such
as a personal computer should be able to
effectively perform this scheduling algorithm
in a comparable a m o u n t of time.
Dispatching
The dispatching problem can be defined as
follows:
When a machine is ready to start a new job,
and (one or m o r e ) j o b s are waiting in the
input buffer of the workstation that this
machine is part of, should it start a new job
immediately (or wait for some specific job to
come along), and if so, which job (if more
than one job is available) should it begin
working on?
Dispatching is part of the FFL; in our approach,
therefore, it would be incorporated in the simulator.
As mentioned earlier, the EPS problem is defined
independently of dispatching; the effects of dis-
patching influence the scheduling through the cost
function--the same entry point sequence might
have a different average interval under different
dispatching schemes. In fact, the simulator used in
the previously described experiments does have the
implicit dispatching rule: first come, first served,
i.e., a machine when ready to start a job would pick
the job that had come into the input buffer first, and
if there was none, the first that came along.
Why do we need dispatching? As discussed in
the prior section, EPS considers the entire FFL at
once and tries to p r o d u c e an optimal global
sequence. (We should distinguish the usage of the
terms 'local' and 'global' from their usage in the
previous section. Here a locally optimal sequence
refers to a sequence optimal for a part of the FFL,
and a globally optimal sequence refers to one
obtained by considering the entire FFL. In the prior
Journal of Manufacturing Systems
Volume 6/No. 4
section, a local optimization scheme optimized a
sequence only by examining its neighbors obtained
by minor perturbations, while global optimization
considered all sequences possible.) In other words,
we use it to give the system a 'good' input.
However, while it may be possible to control
the events or the order in which jobs arrive at the
first few workstations through control over the
input sequence, it may not be possible to exercise
enough control on the sequence of events at work-
stations far down the line. When multiple machines
are present at a workstation, the possibility arises
that job overtaking occurs and jobs are reordered in
a complex manner down the line. Thus, for example,
it may be very important to minimize setups at a
particular workstation far down the line, but it may
not be possible to produce an appropriate job
arrival sequence at that workstation by varying only
the input to the FFL, or it may only be possible at the
expense of not being able to produce good job
arrival sequences at other workstations. This sug-
gests that we might be able to improve the per-
formance of the line (i.e., reduce the average interval,
etc.) using local optimization at each workstation--
each machine when ready would pick its nest job
considering a few workstations both up and down
the line (this is called the dispatching window).
Finding a good dispatching algorithm is diffi-
cult since it should take into account both dynamic
phenomena, such as buffers filling, and static data
such as machine characteristics. Dispatching rules
for job shops with infinite buffers are surveyed in
detail in the paper by Blackstone, Phillips and
Hogg. 7 Much of the previous work on dispatching
has been concerned with meeting due dates and less
attention has been paid to maximizing efficiency
through minimization of blocking or setup effects.
Also, most of the prior literature on scheduling has
considered either sequencing or dispatching. Here
we are particularly interested in the interaction
between the two. Many empirical rules for dispatch-
ing seem appropriate, for example:
1. Choose the job that minimizes setups.
2. If the machine might be blocked because the
output buffer is nearly full, pick a long job; if
that buffer is nearly empty, pick a short job to
prevent the next machine from starving.
3. If the input buffer is nearly full, pick a short job
so as to prevent the previous machines from
308
blocking; if that buffer is nearly empty, the
machine should pick a long job to prevent itself
from the possibility of starvation.
These rules can be extended to cover buffers
other than the immediate input and output buffers.
Many other rules could also be added, for example
those pertaining to breakdowns and due dates.
Some combinations of them may conflict--hence,
we need to assign priorities to jobs based on some
weighted combination of priorities derived from
each of the rules. Also, it should be pointed out that
since a machine when dispatching just looks at the
part of the FFL within the dispatching window, the
performance of the system may not always improve
over just using the default first come, first served
dispatching. In fact, we did find just that in our
experiments--dispatching alone in quite a few cases
increased the average interval for a given sequence.
To see how this can happen, consider a simple
example. Suppose we have just one machine at each
workstation and there is a bottleneck machine in the
middle of the line. The sequencing at this machine is
crucial to the performance of the line. With first
come, first served dispatching, the input sequence to
this machine is completely controllable from the
entry point, and so we can optimize the entry point
sequence to give the best sequence at this machine.
However, with dispatching using setups or other
criteria, the number of arrival sequences at this
machine may be greatly reduced and we may not be
able to get the best arrival sequence at this machine.
For similar reasons, dispatching also tends to
prevent some of the benefits of EPS. However, we
found that EPS with dispatching (of the kind
described below) incorporated in the simulator
produced better input sequences, i.e., those have a
lower average interval, in most of the cases.
We experimented with dispatching using a
combination of the first two of the above dispatching
rules mentioned earlier. Priorities (lower numbers
corresponding to higher priorities) were assigned to
a waiting job using the following formula:
S
+3Q-- R
S°~ R.v
where S is the setup time required for the particular
job, Soy is the average setup time over all the waiting
jobs, R is the service time for the job, R°~ is the
average service time over all the waiting jobs, and Q
 Journal of Manufacturing Systems
Volume 6/No. 4

is -1 if the input buffer of the next workstation is Results. The results of EPS using setup-based
more than -r% full and + 1 otherwise. The parameters dispatching are shown in Tables 4, 5 and 6. To see
a, B, and ~/are to be tuned dynamically or statically. the effects of dispatching, both with and without
The first term in this formula gives higher EPS, Tables 4, 5 and 6 should be compared with
priority to jobs with lower setups, while the second Tables 1,2 and 3 respectively. Dispatching was used
term tries to give higher priority to short jobs if the at all workstations but the first (since the arrival
output buffer is nearly empty, and to long jobs if the sequence at the first workstation is completely
output buffer is nearly full. The first term, therefore, determined by the EPS). For this reason, it had
tries to optimize for setups and the second term for effect in only the case of FFL #1 (FFLs #2 and#3 had
blocking and starvation. Note that in the case of only one buffer between the workstations, so there
infinite buffers, this formula can be viewed (some- was never more than one job to choose from at the
what approximately) as a generalization of the second workstation). Therefore, Tables 4 and 5
shortest imminent rule that has been shown to be a show only the case of FFL #1.
promising rule in job shop studies and is known to
be optimal for mean interval in the case of a single
Table 4
machine. 7 Test Problems--Results for One Day, with Dispatching
After doing various experiments with the same
problems as those previously described using differ- F F L 1: S e t u p I n t e n s i v e
ent a, 8, and 7, we came to the following conclusion: Initial Initial Cost using Cost using
Dispatching using the blocking/starva-
Sequence Cost (P~B~)~ (B~P~),~
tion-based rule (rule #2) does not work well Data set 1
(almost as often as not raises the interval), IB 201 180 180
while the setup-based rule (rule #1), does I 215 167 167
help. 224 174 174
The reason for this seems to be the fact that Data set 2
blocking and starvation are more global phenom- IB 204 153 175
ena, i.e., they generally affect a large part of the FFL, I 221 159 169
and are therefore harder to control by local dis- 219 159 159
patching rules, while setups are a more local Data set 3
phenomenon and performance can generally (but IB 221 148 132
not always) be improved by picking the lowest setup I 214 139 139
job. (It is well known that the case of an FFL with 217 145 145
just one machine is the traveling salesman problem Data set 4
where the cities represent codes and the cost between IB 146 110 111
cities A and B is the setup incurred in switching from I 157 110 110
code A to code B.) Detailed results are described in 132 110 111
the next section, but we state our conclusion:
Incorporating dispatching using the setup-
based rule (that is, picking the job having the Observations. We found that setup-based
lowest setup involved) in the simulator, in dispatching did help in most of the test problems,
almost all cases, improves the results ob- especially in the periodic loading cases. However,
tained by EPS, i.e., produces lower cost for the realistic problem, it did not improve the
(average interval) solutions. performance in the two of three cases we tried. This
To conclude this section, we should mention is probably because in that problem, blocking and
that in real systems we should incorporate rules starvation as well as setups are important factors.
taking the age (length of time a job has been in the The principal use of dispatching seems to lie in
line) of a job into account in the dispatching, to dealing with setup-intensive operations, line disrup-
prevent certain codes from remaining in the line for tions (e.g., machine breakdowns) and possibly to
excessive periods of time. smooth out the effects of noise in the measurements

309
Journal of Manufacturing Systems
Volume 6/No. 4

Table 5 realistic problems. For each case, we produced

Test Problems--Results for 10 Days, with Dispatching
optimized schedules using the operators and data
F F L 1: Setup Intensive described earlier. We then ran these schedules
Initial Initial Costusing Costusing through the simulator after changing the service and
Sequence Cost (PooBoo)oo (BooPoo)oo setup times for the different codes and machines by
r a n d o m a m o u n t s between -5% and +5%, and
Data set 1
366 273 273
obtained the average interval. The purpose of the
~p 368 292 292 experiment was to investigate the effect of noise in
381 290 290 the service and setup times on the average interval
predicted, without taking the random deviations
Data set 2 into account. We found that in no case was there a
IB 285 171 169
difference of more than 5%, suggesting that the
~p 298 189 189
256 171 171 methods we propose are quite robust in nature.
Different Operators. The most computation-
D a t a set 3
ally expensive part of our approach is the cost
IB 294 235 216
evaluation for a sequence. The operator P requires
~e 323 215 215
O(n 2) cost evaluations to be done when applied to a
293 231 228
sequence of length n, since we allow any pairwise
D a t a set 4 exchange. We tried out a simpler operator, which
148 127 111 we call Q, which allows only adjacent pairwise
170 129 129
exchanges. Each application of Q requires only O(n)
174 137 139
cost evaluations. We compared the results obtained
using (QooBoo)oo(defined analogously to (PooBoo)oo)
Table fi with (Po~Boo)~ on all the test cases and found that it
Realistic Problem--Results for One Day, with Dispatching did not perform as well. While it reached local
minima more quickly, these were rather poor solu-
Initial Initial Cost using Cost using
tions and even with additional starting sequences to
Sequence Cost (S=P=)=
compensate, the operator was considerably less
9896 6939 7179 efficient. We concluded the Q was an inferior
9422 7279 7082 operator to P.
P
Ia 9027 7202 7079
We also tested other operators which would be
classified as 'weaker' a n d / o r 'first improvement' (in
(since slight variations in the service/setup times the terminology of Reference 8) and found generally
may not exactly produce the sequences predicted by inferior performance. However, it is possible that
the simulator at different workstations). these approaches may need to be reconsidered for
much larger problems. It should also be noted that
FFLs with larger numbers of codes or production
Other Results volumes do not necessarily constitute larger EPS
In this section we touch u p o n some other problems. It should be possible to devise simple
results we obtained and the resulting observations. 'divide and conquer' heuristics which group codes
However, definite conclusions on these can only be and schedule more frequently.
made through more investigation. Different Cost Criterion. We stated in the
Robustness. It might seem that our approach beginning of this paper that although we were using
has the disadvantage of being excessively dependent the average interval as the cost criterion in this
on the accuracy of the line data, that is, the quality study, our methods were equally applicable using
of the schedule produced may require ideal condi- different objectives. We tried our optimization
tions in order to reap the benefits that we have techniques using makespan (defined under "Prob-
shown. To find out whether this was so, we did the lem Definition" in the first section) as the cost
following simple experiment on both the test and criterion for the realistic problem and obtained

310

degrees of improvement similar to those obtained
using the average interval. This does seem to lend
support to our claim that these methods would
perform well when optimizing different objectives.
Practical and Implementation Issues
There are several issues of importance relating
to a practical implementation of the techniques
described in this paper. It should be noted that at the
heart of our methods is the idea that loading
sequences should be evaluated for their effect on a
shop. Even if no optimization of the type described
in this paper were to be carried out, operating
management would find extremely useful a tool
which projects, as does our deterministic simulation,
the behavior of the shop given current conditions
and the proposed work for the shop in that schedul-
ing interval. Of course, once a tool like this is
provided, then it is natural for operating manage-
ment to begin experimenting with different oper-
a t i n g policies. In o u r a p p r o a c h we do this
automatically.
It is clear that in order for this projection to
have any validity, it is important to have reliable and
accurate data both on the products (processing and
setup times, etc.), the process (routings, equipment
reliability, etc.), and the current state of the line.
Regardless of the method used to operate a shop,
the collection and maintenance of this sort of data is
crucial in attaining efficiency of operation. As
automation becomes more c o m m o n , it is important
that measurements be incorporated at strategic
points so that the manufacturing process, costs, etc.,
can be properly understood. It is well known that
when there are humans 'in the loop', mere existence
of the measurement process can play an important
role in stimulating efficiency.
The optimization approach taken in this paper
also assumes that there is available an appropriate
definition of a cost objective to be minimized. The
question arises as to whether this should address the
minimization of WlP, interval, machine hours,
makespan or perhaps maximize throughput, capac-
ity, etc. The methodology of this paper is equally
applicable with a variety of choices for the objective.
The appropriate choice (perhaps some weighted
sum of the previous examples, or one with additional
constraints incorporated through the use of penalty
311
Journal of Manufacturing Systems
Volume 6/No. 4
functions) depends on the business objectives of the
manufacturing operation. We would assert that if a
manager knows and understands the business he is
in, he should be able to come up with such a function
which, if optimized, results in desirable operation.
Finally, several issues remain as to the detailed
operation of the local search technique described
above. One issue is that of the computer time
required to do the optimization that we propose.
Our experience has been that while the computa-
tional demands of the approach are substantial, for
the size of problem we considered they are easily
handled by a desktop or personal computer. Much
larger problems (many more jobs to be sequenced)
should probably be addressed using some additional
preliminary lot sizing heuristic (the parameters for
which can also be optimized using the search
strategy).
Some other implementation issues are worth
discussion. Although we noted above that the
choice of initial points did have some marginal
effect, it appeared to us that for practical applica-
tions it may not be necessary to start the local search
procedure more than once, and if it was desired to
have multiple starts, then random choices appeared
sufficient. Some further investigation of starting
strategies has been performed by the authors and is
reported in the literature. '~ Other approaches to
reducing the dependence of the result on the initial
sequence are also applicable, for example, the use of
simulated annealing. 15
Another question that may arise concerns
whether the mechanics of the production line being
considered are sufficiently predictable that the de-
terministic simulation described above will suffice.
There has already been some discussion on this issue
in previous sections. One way of dealing with unpre-
dictable events, provided they are not too frequent, is
to reschedule wherever they occur. Additionally,
there has already been some evidence in the last
section that a degree of robustness may be present in
the approach. This suggests that the embedded
deterministic simulation model can be viewed more
as an evaluation function that has the ability to
differentiate between good and bad sequences, than
an exact predictor of the line behavior. Many
stochastic effects can be approximated in the simu-
lation model by appropriate adjustment of param-
eters. However, if it is felt that it is mandatory to use
 Journal of Manufacturing Systems
Volume 6 No. 4

a Monte Carlo simulation as part of the sequence were constructed, each having two workstations
evaluation technique, then this can be done, al- with two machines at the first workstation and one
though it may be necessary to make multiple runs of at the second. The service time matrix for each code
the model and take ensemble averages. The authors at each workstation was kept the same for all three
feel that, if possible, this option should be avoided FFLs. The three FFLs differed in only the following:
since it has the potential of greatly reducing the 1. Setup matrices at the workstations,
number of sequences that can be explored, and so 2. Number of buffer positions between work-
result in a reduced effectiveness of the technique. stations #1 and #2.
Only practical experience will provide guidance on The first FFL had setups involved at both
some of these issues. workstations and a large buffer between the work-
stations--this prevented blocking and created a
Concluding Remarks setup intensive problem. The second FFL had zero
setups at each workstation and only one buffer
Local optimization with the operators P a n d B position between the two workstations--this created
is a promising and practical approach toward a blocking intensive problem. Finally, the third FFL
obtaining near-optimal schedules, given an efficient had the setup matrices from FFL #I and only one
simulator to accurately evaluate solutions. The buffer between the two workstations as in FFL #2--
strength of this approach as compared to other it thus had both setups and blocking involved.
scheduling strategies lies in its ability to respond to Only the parameters for the first FFL are given
various line phenomena--finite buffers, setups, below (the others can be constructed as described
blocking/starvation, machine breakdowns and above). All times are in seconds. In the setup matrix,
downtime, and the current state of the line. The the entry for row i and columnj represents the setup
deterministic nature of the simulation is offset by incurred in switching from C o d e / t o Codej. Note
the fact that the method would be run frequently, that the output buffer of a workstation is the same as
for example, whenever the state of the FFL changes, the input buffer of the workstation following it.
say, due to machine breakdowns, or even once a day
FFL #1: System Data
just to take slight changes in the system parameters
Number of Codes = 10
into account.
Number of Workstations -- 2
We found that certain myopic methods of job
scheduling did not perform as well. Also, dispatch- Workstation #1:
ing using setups was found to be useful in many Number of machines = 2
cases, whereas attempts to minimize blocking/ Input buffer size - 200
starvation were not so effective. Service times for different codes:
A number of practical and implementation 20 80 80 40 20 60 90 60 20 20
issues remain that need to be addressed in the Setup matrix:
context of a specific application. 0 3 3 3 3 30 30 30 30 30
3 0 3 3 3 30 30 30 30 30
3 3 0 3 3 30 30 30 30 30
Acknowledgements 3 3 3 0 3 30 30 30 30 30
The authors with to thank P. Johri, K. Rege, B. 3 3 3 3 0 30 30 30 30 30
Samadi and W.S. Wong for the useful suggestions 33333 030303030
given during these investigations. 3333330 0303030
333333030 03030
33333303030 030
Appendix 3333330303030 0
Test and Realistic FFL D a t a Workstation #2:
In this appendix we describe the data the we Number of machines = 1
used for the experiments described in the paper. Input buffer size = 20
Test Problems. Ten codes, which we refer to a s Service times for different lot types:
Code0 through Code9, were allowed. Three FFLs 50 30 30 50 20 50 20 40 30 50

312
 Journal of Manufacturing Systems
Volume 6/No. 4

Setup matrix: Service times for different lot types:

0 5 5 5 5 50 50 50 50 50 252 1106 658 210 210 854 588
5 0 5 5 5 50 50 50 50 50 Setup matrix:
5 5 0 5 5 50 50 50 50 50 0 1200 1200 1200 1200 1200 1200
5 5 5 0 5 50 50 50 50 50 1200 0 1200 1200 1200 1200 1200
5 5 5 5 0 50 50 50 50 50 1200 1200 0 1200 1200 1200 1200
55555 050505050 1200 1200 1200 0 1200 1200 1200
5555550 0505050 1200 1200 1200 1200 0 1200 1200
555555050 05050 1200 1200 1200 1200 1200 0 1200
55555505050 050 1200 1200 1200 1200 1200 1200 0
5555550505050 0 Workstation #2:
The four data sets used had the following production Number of machines -- 2
requirements: Input buffer size = 12
Data set 1. 10 items, one each of Code0 Service times for different lot types:
through Code9. 1036 546 588 224 224 1008 560
Setup matrix:
Data set 2. 10 items, two each of Code3,
0 600 600 600 600 600 600
Code4, Code5, Code6 and Code7.
600 0 600 600 600 600 600
Data set 3. 12 items, three each of Code3, 600 600 0 600 600 600 600
Code4, Code5 and Code6. 600 600 600 0 600 600 600
Data set 4. 12 items, three of Codel, four of 600 600 600 600 0 600 600
Code2 and five of Code8. 600 600 600 600 600 0 600
Realistic Problem. The realistic data was 600 600 600 600 600 600 0
derived from data taken from a real FFL. The FFL Workstation #3:
had seven workstations, 16 machines, seven codes Number of machines = !
and a requirement to produce 45 items--10 of Input buffer size = 9
Code0, five of Codel, 15 of Code2, five of Code3, Service times for different lot types:
five of Code4, three of Code5 and two of Code6. The 224 308 574 224 252 224 252
FFL parameters are listed below, in the same format Setup matrix:
as those for the test problems above. 0 600 600 600 600 600 600
Realistic FFL: System Data 600 0 600 600 600 600 600
Number of codes - 7 600 600 0 600 600 600 600
Number of workstations = 7 600 600 600 0 600 600 600
Workstation #0 600 600 600 600 0 600 600
Number of machines = 1 600 600 600 600 600 0 600
Input buffer size -" 400 600 600 600 600 600 600 0
Service times for different lot types: Workstation #4:
210 210 210 210 210 210 210 Number of machines = 2
Setup matrix: Input buffer size " 9
0 1800 1800 1800 1800 1800 1800 Service times for different lot types:
1800 0 1800 1800 1800 1800 1800 672 664 686 252 504 252 588
1800 1800 0 1800 1800 1800 1800 Setup matrix:
! 800 1800 1800 0 1800 1800 1800 0 300 300 300 300 300 300
1800 1800 1800 1800 0 1800 1800 300 0 300 300 300 300 300
1800 ! 800 1800 1800 1800 0 1800 300 300 0 300 300 300 300
1800 1800 1800 1800 1800 1800 0 300 300 300 0 300 300 300
Workstation # 1: 300 300 300 300 0 300 300
Number of machines = 2 300 300 300 300 300 0 300
Input buffer size - 9 300 300 300 300 300 300 0

313
Journal of Manufacturing Systems
Volume 6/No. 4

Workstation #5:
Number of machines = 7 References
Input buffer size = 17 !. R.J. Wittrock. "Scheduling Algorithms for Flexible Flow Lines",
Service times for different lot types: IBM J. Res. Develop., Volume 29. No. 4, 1985. pp. 401-412.
2. K. Rege. "A Loading Algorithm for Job Shops Run as Pull
2688 434 476 812 728 266 1344 Systems", O R S A / T I M S Conference. October 27-29, 1986, Miami
Beach. Florida.
Setup matrix: 3. P. Johri, unpublished work.
0 1800 1800 1800 1800 1800 1800 4. G. Bruno, A. Elia, P. Laface. "A Rule-Based System to Schedule
Production", IEEE Computer, Volume 19, No.7, July 1986, pp. 32-40.
1800 0 1800 1800 1800 1800 1800 5. K.R. Baker. "General Purpose Methodologies for the Single-
Machine Problem." In Introduction to Sequencing and Scheduling,
1800 1800 0 1800 1800 1800 1800 New York: John Wiley, 1974, pp. 42-75.
1800 1800 1800 0 1800 1800 1800 6. M.J. Krone, K. Steiglitz. "Heuristic-Programming Solution of
Flowshop-Scheduling Problem", Operations Research, Volume 22,
1800 1800 1800 1800 0 1800 1800 No. 3, 1974, pp. 629-638.
1800 1800 1800 1800 1800 0 1800 7. J.H. Blackston¢, D.T. Phillips, G.L. Hogg. "A State-of-the-Art
Survey of Dispatching Rules for Manufacturing Job Shop Operations",
1800 1800 1800 1800 1800 1800 0 Int. J. Prod. Res., Volume 20, No. I, 1982, pp. 27-45.
8. C.H. Papadimitriou, K. Steiglitz. Combinatorial Optimization:
Workstation #6 Algorithms and Complexity. Prentice-Hall, Englewood Cliffs, New
Jersey, 1982.
Number of machines = 1 9. S. Lin, B. Kernighan. "An Efficient Heuristic for the Traveling
Salesman Problem", Operations Res.. Volume 21, 1973, pp. 498-516.
Input buffer size " 17 10. D.S. Johnson, C.H. Papadimitriou, M. Yannakakis. "How Easy is
Service times for different lot types: Local Search?", Proc. 26th Annual Symposium on the Foundations of
Computer Science, Portland, Oregon, October 1985, pp. 39-42.
403 403 403 403 403 403 403 11. B. Kernighan, S. Lin. "An Efficient Heuristic Procedure for
Partitioning Graphs", Bell Syst. Tech. J., Volume 49, 1972. pp. 291-307.
Setup matrix: 12. B.L. Farrell, G. Ramamurthy, "A Prototype Performance Engi-
0000000 neering/Management Tool for UNIX-based Systems", Computer
Measurement Group 86 Conference, Las Vegas, Nevada, December
0000000 9-12, 1986.
0000000 13. N.J. N ilsson. Principles ofA rtificial Intelligence. M organ Kauffma n
Publishers, Los Altos, California, 1980.
0000000 14. S. Kochhar, R.J.T. Morris, W.S. Wong. "The Local Search
Approach to Flexible Flow Line Scheduling". Second International
0000000 Conference on Production Systems, Paris. April 6-10, 1987,
0000000 pp. 175-189.
15. S. Kirkpatrick, D.C. Gelatt, M.P. Vecchi. "Optimization by
0000000 Simulated Annealing", Science, 220, 1983, pp. 621-680.

Author(s) Biography
Sandeep Kochhar received the B. Tech. (Electrical Engineering) degree from the Indian Institute of
Technology, Delhi, in 1984, and the MS (Computer Science) degree from Harvard University in 1985. He is
currently pursuing his Doctoral degree in Computer Science at Harvard University. He is working in the area
of knowledge-based computer graphics; his thesis research is concerned with developing automated CAD
techniques using domain-specific knowledge. He is also interested in machine learning, and in various
applications of AI techniques. The research detailed in this paper was conducted when he was a summer
student intern at AT&T Bell Laboratories, Holmdel, New Jersey.
Robert J.T. Morris received the BSc BE (Computer Science, Electrical Engineering) degrees from the
University of New South Wales, Sydney, Australia in 1974, and the MS (System Science) and P h D
(Computer Science) degrees from the University of California, Los Angeles in 1976 and 1978.
Since 1978 he has been with AT&T Bell Laboratories and has held the position of Supervisor,
Performance Analysis Department since 1981. His work has involved the application of modeling and
analysis techniques to a wide variety of computer, communication and manufacturing systems. Dr. Morris
was in charge of development of AT&T's Performance Analysis Workstation. He is also an Editor of the
I E E E Transactions on Computers.

314