Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out

Job Shop Scheduling Using TOC - JOB SHOP SCHEDULING USING THEORY

VIEWS: 139 PAGES: 67

									JOB SHOP SCHEDULING
  USING THEORY OF
    CONSTRAINTS
   JOB SHOP SCHEDULING
The philosophy here is to apply the TOC principles
to a job shop environment. This involves
determining the bottleneck machine, exploiting the
bottleneck machine, and subordinating the other
machines to the needs of the bottleneck. In flow
shop environment the way we practiced the TOC
was using a Drum-Buffer-Rope (DBR) technique. In
that, the material is released to the first station
with enough frequency to keep the bottleneck
machine busy all the time with the least amount of
WIP. The bottleneck machine paced the speed
(drumbeat). The rope was the timing of the release
of material to the first machine, and the buffer
corresponds to safety stock in front of the
bottleneck machine.
 JOB SHOP SCHEDULING
The machines before the bottleneck(including the
bottleneck) were scheduled by a pull mechanism
and the machines following the bottleneck were
scheduled by using a push mechanism.

In job shop scheduling, a set of jobs with
processing times on each machine and due dates
are given. The purpose is to schedule the order of
jobs on each machine to optimize a suitable
objective (e.g., minimize the maximum
tardiness).
Let P be the matrix representing the processing
times of each job on each machine. Therefore, pij
represents the processing time of job i on
machine j. Similarly let Q represent the routing
matrix indicating the order in which the jobs
travel between the machines in their routing. The
entry, qij, represents the operation number of job
i on machine j. For example, qij = 4 indicates
that job i visits machine j on its fourth operation.
Also let Z be the matrix of machine indices where
zil represents the index of the machine for job i in
its lth operation. For example consider the
following data given for a scheduling problem
called Quick Closures.
 Following is the algorithmic procedure for job
 shop scheduling.
 m = number of machines
 n = number of jobs
 Step 1. Finding the Bottleneck Machine
 Use rough-cut capacity utilization calculations by
 using      n
     CUj =   pij
           i 1
                            j = 1, …, m

Choose machine b, with CUb = maxj {CUj} as the
  bottleneck machine. This is our first guess on
  the bottleneck machine.
    Step 2. Scheduling the bottleneck machine

    Let rij be the time job i arrives at machine j. It is
    calculated by adding the release time of job i into
    the shop floor, ri, to the sum of processing times
    of all machines prior to machine j. (includes
    processing as well as wait times on all previous
    operations).



,
Initially assume no wait time. Therefore
Similarly, define dij as the due date for job i
coming out of machine j. Obviously, this quantity
is simply the job i's due date (di) minus all wait
and processing times of job i on the downstream
machines. Assuming zero wait, we write:
All we need to do now is given rib and dib, i = 1,
2, .., n, to schedule the bottleneck machine.
Unfortunately this problem is NP-hard. Therefore,
the     following    heuristic   procedure      is
recommended.

ONE MACHINE SCHEDULING HEURISTIC
Let U be the set of unscheduled jobs and t be the
current time.

Step 0. Set U = {1,2,…,n} and find
               t = min iU rib 
Some priority rules that may be used at this step
are
– Choose most work remaining for minimizing Cmax
– Choose the job with least work remaining for minimizing
  Fmax
– Choose the job with the smallest bottleneck due date for
  minimizing Tmax.
Step3.Upstream     and    Downstream     Machine
Scheduling
Release times and due dates are determined for
jobs on a particular machine from the bottleneck
station’s schedule. Following this, each machine
is scheduled as a one-machine scheduling
problem with release dates and due dates.

The scheduling logic is as follows: Since in a job
shop setting, for a given machine, some jobs
may be before the bottleneck and some may be
after the bottleneck, each case must be handled
separately.
If an operation of a job precedes the bottleneck,
it must be scheduled to be completed by its due
date so it will arrive at the bottleneck before its
start time there (just-in-time). Since this job may
have other operations preceding this one, the
goal is to schedule it to finish as late as possible
and still arrive on time at the bottleneck. Thus we
try to complete it at its due date. This is
backward scheduling (pull). On the other hand,
operations succeeding the bottleneck may have
other operations following, so we wish to start
them as soon as possible to give them time to
complete before its final due date. This is forward
scheduling (push).
To schedule a machine, choose the job with the
highest (best) priority according to the priority
used. If its operation on this machine comes
before the bottleneck, schedule it to complete as
late as possible. If its operation follows the
bottleneck, schedule it to start as soon as
possible. Keep choosing jobs by their priority
until they are all scheduled. Then, schedule the
other machines similarly.

When all jobs are scheduled a sequence of all
jobs on each machine will result.
EXAMPLE
Consider the scheduling problem called Quick
 Closures. Table 1, Table 2, and Table 3 provide
 the necessary data.
Solution:
 Sum of process times on each machine and for
 each job are given Table 1 above. According to
 these numbers job 4 takes 34 minutes of
 processing and machine 3 is used for 44 minutes.
 From the largest of the two we conclude that a
 first estimate on the makespan is 44 and a first
 guess on the bottleneck machine is #3.
Using machine 3 as the bottleneck, we must find
the due dates and release times for a single
machine problem. All processing times used now
belong to machine 3. Take a look at job 1. Its
sequence is 1-2-3-4, therefore, it is processed on
machines 1 and 2 before it gets processed on
machine 3. The earliest it can get processed on
machine 3 is p11 + p12 = 6 + 8 = 14, so the
release time for job 1 on machine 3 will be
r13 = 14. Similarly, if job 1 is to be completed by
time 44, its last operation (on machine 4) must
be completed by time 44.
Since p14 = 5 minutes, the previous operation
must be finished by time 44 - 5 = 39, so d13 =
39. Using the same logic, job 6 has route 3-1-2-4
so its first operation is on machine 3, i.e., it
release time is zero. Its due date is the estimate
for makespan minus the processing time of all
operations of job 6 that follow the operation on
machine 3;d63 = 44 - 2 – 4 - 5 =33. The
remaining due dates and release times are
calculated similarly and provided next.
Job 1: Machine sequence 1-2-3-4.

r1 = 0 (release of job 1 to the job shop),
d1 = 44 (final due date of job 1).
r13 = r1 + p11 + p12 = 0 + 6 + 8 = 14 (release of
 job 1 to machine 3)
d13 = d1 - p14 = 44 - 5 = 39 (due date of job 1
 from machine 3)
Job 2: Machine sequence 1-2-3-4.

r2 = 0 (release of job 1 to the job shop),
d2 = 44 (final due date of job 2).
r23 = r2 + p21 + p22 = 0 + 4 + 1 = 5 (release of
 job 2 to machine 3)
d23 = d2 - p24 = 44 - 3 = 41 (due date of job 2
 from machine 3)
Job 3: Machine sequence 4-2-1-3.

r3 = 0 (release of job 3 to the job shop),
d3 = 44 (final due date of job 3).
r33 = r3 + p34 + p32 + p31 = 0 + 3 + 8 + 6 =
 17 (release of job 3 to machine 3)
d33 = d3 - 0 = 44 - 0 = 44 (due date of job 3
 from machine 3)
Job 4: Machine sequence 2-1-3-4.

r4 = 0 (release of job 4 to the job shop),
d4 = 44 (final due date of job 4).
r43 = r4 + p42 + p41 = 0 + 5 + 10 = 15
(release of job 4 to machine 3)
d43 = d4 - p44 = 44 - 4 = 40 (due date of job 4
from machine 3)
Job 5: Machine sequence 1-2-4-3.

r5 = 0 (release of job 5 to the job shop),
d5 = 44 (final due date of job 5).
r53 = r5 + p51 + p52 + p54 = 0 + 3 + 4 + 6 =
 13 (release of job 5 to machine 3)
d53 = d5 - 0 = 44 - 0 = 44 (due date of job 5
 from machine 3)
Job 6: Machine sequence 3-1-2-4.

r6 = 0 (release of job 6 to the job shop),
d6 = 44 (final due date of job 6).
r63 = r6 + 0 = 0 + 0 = 0 (release of job 6 to
machine 3)
d63 = d6 - p61 - p62 - p64 = 44-2 - 4 - 5 = 33
(due date of job 5 from machine 3)
Therefore, the sequence of jobs on machine 3 is
6-2-5-1-4-3 with Cmax = 49.The estimate of the
makespan is now at 49.

In Step 2 of the algorithm, we must subordinate
the other machines to the schedule obtained for
the bottleneck machine. Take any machine not
scheduled yet, say machine 1. On this machine
some jobs’ sequence come before the bottleneck
and some come after the bottleneck. Jobs 1, 2, 3,
4, and 5 have operations on machine 1 that come
before the bottleneck, whereas job 6 is processed
on machine 1 after it gets processed on machine
3.
Jobs with operations before machine 3 will have
release times determined by the earliest time
they could get to machine 1; these are calculated
in the same manner as the bottleneck. For
example, r11 = 0 for job 1, since it is its first
operation, while machine 1 is the third operation
for job 3, following operations on machines 4 and
2, so r31 = p34 + p32 = 3 + 8 = 11.

Due dates for an operation preceding the
bottleneck are determined by that job's start time
on the bottleneck. Job 1 is scheduled to start on
machine 3 at time 17.
To do so, it must be finished on machine 1 and
complete processing on the intervening machine
2 at time 17. Its due date must be d11 = 17 - p12
=17 - 8 = 9.

An operation which is processed on machine 1
after the bottleneck, has its release time on
machine 1 determined by its completion time on
the bottleneck plus any intervening processing
times. Job 6 has its first operation on the
bottleneck, which completes at time 4.
Its second operation is on machine 1, so it can
arrive   at   machine     1    immediately  upon
completion, so r61=4. Its due date is the
makespan estimate minus processing time after
machine 1, or d61 = 49 - p62 - p64 = 49 - 4 - 5 =
40. The remaining release times and due dates
are displayed in the table below.
Job 1: Machine sequence 1-2-3-4. The operation
of job 1 on machine 1 comes before the
bottleneck, therefore we will schedule it to arrive
at the bottleneck machine (machine 3) just-in-
time. Note that for job 1 to reach to machine 3 it
must be processed on machines 1 and 2,
respectively. It is needed on machine 3 at s13 =
17 (scheduled start time on machine 3).
Therefore, the due date of job 1 from machine 1
must be the scheduled start time on machine 3
minus the intervening operations on machine 2,
i.e., d11 =s13 - p12 = 17 - 8 = 9. Since machine
1 is the first operation of job 1 its release time
will be r11 = 0.
Job 2. Machine sequence 1-2-3-4. Using the
same logic as in job 1 we get s23 = 5, thus d21
= s23 - p22 = 5 - 1 = 4. r21 = 0 (since machine
1 is first operation).

Job 3. Machine sequence 4-2-1-3. Since machine
1 is just prior to bottleneck d31 = s33 = 45. To
find the release time it will go through machines
4 and 2, thus r31 = 0 + p34 + p32 = 0 + 3 + 8
=11.
Job 4. Machine sequence 2-1-3-4. d41 = s43 = 30.
  r41 = 0 + p42 = 0 + 5 = 5
Job 5. Machine sequence 1-2-4-3. d51 = s53 - p52
  - p54 = 13 - 4 - 6 = 3. r51 = 0.
Job 6. Machine sequence 3-1-2-4. d61 = 49 - p62
  - p64 = 49 - 4 - 5 = 40, r61 = c63 = 4.
  To schedule machine 1, we use a procedure
  similar to scheduling the bottleneck. From the
  candidate jobs choose the one with the smallest
  due date. Backward schedule any job with an
  operation on machine 1 that comes before its
  operation on machine 3 and forward schedule the
  others.
To backward schedule a job, schedule it to
complete as late as possible and be on time,
since there may be other operations of the same
job to be done before it. Ideally, it should
complete at its due date, but if there is no idle
period as long as the processing time of the
operation ending at the due date, the job must
be scheduled elsewhere.
First, try to create enough idle time by starting
previously     scheduled   jobs    earlier  without
violating their release times, or by delaying the
start of a previously scheduled job earlier without
violating its due date.
If successful, an idle period is created in which the
current job can be scheduled. If this is not possible,
schedule the job so that its tardiness is as small as
possible.
A forward scheduled job should start as soon as
possible, since it may have operations that must
follow it. If possible, start it at release time. If not,
it must be delayed.
t = 0, U = {1,2,3,4,5,6}, S = {1,2,5}. Since d51 <
{d11, d21} choose job 5 to go first. It should be
backward scheduled, denoted by the superscript b
in table above, so schedule it to complete at its due
date (t=3) so it will start at time 0. [s51, c51] =
[0,3]. t = 3, U = {1,2,3,4,6}, S = {1,2}.
Since d41 is the smallest, choose job 4 to
schedule next. Schedule job 4 on machine 1 to
arrive to machine 3 just-in-time, that is, c41 =
s43 (backward schedule). [s41, c41] = [20,30].
Since d61 is the smallest, choose job 6 to
schedule next. Job 6 needs to be forward
scheduled. Therefore, s61 = c63 = 4. Since
machine 1 is not available until t = 13 we
schedule job 6 there immediately. [s61, c61] =
[13,15].
Job 1: Machine sequence 1-2-3-4. The operation
 of job 1 on machine 2 comes before the
 bottleneck, therefore we will schedule it to arrive
 at the bottleneck machine (machine 3) just-in-
 time. Note that for job 1 to reach to machine 3 it
 must be processed on machines 1 and 2,
 respectively. It is needed on machine 3 at s13 =
 17 (scheduled start time on machine 3).
 Therefore, the due date of job 1 from machine 2
 must be the scheduled start time on machine 3,
 i.e., d12 = s13 = 17. To find the release time it
 will go through machine 1, thus r12 = 0 + p11 =
 6.
Job 2. Machine sequence 1-2-3-4. Using the
same logic as in job 1 we get s23 = 5, thus d22
= s23 = 5. r22 = 0 + p21 = 4.
Job 3. Machine sequence 4-2-1-3. d32 = s33 -
p31 = 45 – 6 = 39. To find the release time it will
go through machine 4 thus r32 = 0 + p34 = 0 +
3 = 3.
Job 4. Machine sequence 2-1-3-4. d42 = s43 -
p41 = 30 – 10 = 20, r42 = 0 .
Job   5. Machine sequence 1-2-4-3. d52 = s53 -
p54   = 13 - 6 = 7, r52 = p51 = 3.
Job   6. Machine sequence 3-1-2-4. d62 = 49 -
p64   = 49 - 5 = 44,r62 = c63 + p61 = 4 + 2 = 6.

t = 0, U = {1,2,3,4,5,6}, S = {4}. Since 4 is the
only available job schedule that. It should be
backward scheduled, denoted by the superscript
b in table above, so schedule it to complete at its
due date (d42 = 20) so it will start at time 15.
[s42, c42] = [15,20].
t = 8, U = {1,3,6}, S = {1,3,6}. Since d12 is the
smallest, choose job 1 to schedule next. Schedule
job 1 on machine 2 to arrive to machine 3 just-
in-time, that is, c12 = s13 (backward schedule).
[s12, c12] = [9,17]. However, machine 2 is busy
between [15,20]. So we move job 4 to [8,13] to
reduce the tardiness of job 1 and schedule job 1
between [13,21].
Note that although according to forward schedule
we want to schedule job 6 to start at t = r62 = 6
we cannot. Since the machine is busy until t = 21
this is the earliest time we can schedule it.
Accordingly, the sequence on machine 2 is 5-2-4-
1-6-3. Note here that machine 2 requires a move
of previously scheduled jobs. Job 1 should be
scheduled to complete at time 17, but job 4 is in
process from [15,20]. There are not p12 = 8 idle
time units available to insert 1 before 4. Thus, we
moved job 4 back to make job 1 complete close
to its due date.
Job 1: Machine sequence 1-2-3-4. The operation
of job 1 on machine 4 comes after the
bottleneck, therefore we will forward schedule it.
d14 = 49. r14 = c13 = 30.
Job 2. Machine sequence 1-2-3-4. Using the
same logic as in job 1 we get c23 = 9, thus r24 =
c23 = 9. d24 = 49.
Job 3. Machine sequence 4-2-1-3. d34 = s33 -
p32 - p31 = 45 - 8 - 6 = 31. Since machine 4 is
the first operation r34 = 0. (backward schedule)
Job 4. Machine sequence 2-1-3-4. d44 = 49,
r44= c43 = 45. (forward schedule)
Job 5. Machine sequence 1-2-4-3. d54 = s53 =
13, r54 = p51 + p52 = 3 + 4 = 7. (backward
schedule)
Job 6. Machine sequence 3-1-2-4. d64 = 49, r64
= c63 + p61 + p62 =4+2+4 = 10. (forward
schedule)
t = 0, U = {1,2,3,4,5,6}, S = {3}. Since 3 is the
only available job schedule that. It should be
backward scheduled, denoted by the superscript
b in table above, so schedule it to complete at its
due date (d34 = 31) so it will start at time 28.
[s34, c34] = [28,31].
• t = 17, U = {1,4,6}, S = {6}.
  Schedule job 6 [s64,c64] = [17,22].
   (forward schedule)
    Job 5    Job 2   Job 6   Job 3

 0 7        13 17       22   28 31
Now we have a sequence of jobs for each
machine (5-2-1-6-4-3 for machine 1, 5-2-4-1-6-3
for machine 2, 6-2-5-1-4-3 for machine 3, and 5-
2-6-3-1-4 for machine 4). We also know the
sequence of machines each job has to follow
(1-2-3-4 for job 1, 1-2-3-4 for job 2, 4-2-1-3 for
job 3, 2-1-3-4 for job 4, 1-2- 4-3 for job 5, and
3-1-2-4 for job 6). To get the job shop schedule,
use dispatch procedure that maintains the
sequence of each job on each machine. No
priority is needed since an operation will not be
ready to schedule until its previous operation has
completed on another machine, and the
operation of the job immediately preceding it on
this machine has completed.
In other words, schedule the jobs on each
machine without violating the sequence of jobs
on each machine and the sequence of machines a
job has to follow. The Gantt Chart for the job-
shop is given below. Note that this may not be a
straight forward job. You may need to use your
ingenuity to maintain the job sequences and the
machine sequences simultaneously. You may use
trial and error method.
According to this schedule, the makespan is 53
minutes. At this point the machine that
determines the makespan could be designated as
the bottleneck and the procedure repeated (from
the Gantt chart we see that machines 3 and
4 determine the makespan). We may repeat the
process this time assuming that machine 4 is our
bottleneck. If this yields a better makespan and
the bottleneck doesn’t change, we may stop and
accept the solution. Else we may repeat this
process as many times as either:
i) the bottleneck changes,
ii) the makespan changes or
iii) all machines are treated as bottleneck once.

We will not go another cycle here. This may be a
nice exercise for you to try to treat machine 4 as
the bottleneck and come out with a new
schedule.

								
To top