12.4 Job Sequencing, Dispatching Rules, and Flow Shop Scheduling

12.4 Job Sequencing, Dispatching Rules, and Flow Shop Scheduling

Aggregate planning sets the workforce, the master production schedule sets the end items, and MRP releases the orders. Sequencing answers the last and most immediate question on the shop floor: of the jobs now queued in front of this machine, which one runs next? The NCEES FE Industrial and Systems specification lists sequencing alongside inventory, aggregate planning, MRP, and the theory of constraints under Planning and Scheduling, and it is tested with short, fully computable single-machine and two-machine problems.

---

1. Scheduling Terminology and Performance Measures

Consider $n$ jobs, all available at time zero, queued at a single work center. For job $i$ let:

• $p_i$ = processing time (including setup)
• $r_i$ = release (ready) time; here $r_i = 0$ for all jobs
• $d_i$ = due date
• $C_i$ = completion time under the chosen sequence

The standard measures follow directly:

Exam Watchout — Lateness versus Tardiness: Lateness can be negative; tardiness cannot. A job finishing 6 days early has lateness $-6$ and tardiness $0$. Averaging lateness across a job set therefore understates customer impact, which is why service targets are written on tardiness, not lateness.

Two Derived Quantities

On a single machine with no idle time, the makespan is fixed at $\sum p_i$ no matter what sequence is chosen. Two other quantities do change with sequence:

$\bar{F} = \frac{1}{n}\sum_{i=1}^n F_i \qquad \text{Average number of jobs in the system} = \frac{\sum_{i=1}^n F_i}{\sum_{i=1}^n p_i}$

The second expression is Little's Law applied to the shop: average WIP equals total flow time divided by the makespan. Minimizing mean flow time is therefore mathematically identical to minimizing average WIP.

A third identity is worth memorizing because it explains why one rule can win two objectives at once:

$\bar{L} = \bar{F} - \bar{d}$

Because the mean due date $\bar{d}$ is a property of the job set and not of the sequence, any sequence that minimizes mean flow time simultaneously minimizes mean lateness.

2. Priority (Dispatching) Rules

A dispatching rule is a formula the operator or MES applies to pick the next job from the queue. Rules are classed as static (priority fixed when the job arrives) or dynamic (priority recomputed at every dispatch decision).

Critical Ratio and Slack

$CR = \frac{\text{Due date} - \text{Today's date}}{\text{Remaining processing time}} = \frac{\text{Time remaining}}{\text{Work remaining}}$

• $CR > 1.0$: The job has slack and is ahead of schedule.
• $CR = 1.0$: The job is exactly on schedule and must run without delay.
• $CR < 1.0$: The job is already behind; it will be late unless expedited. A negative $CR$ means the due date has already passed.

The job with the smallest critical ratio is dispatched first. The related slack rules are:

$\text{Slack} = d_i - t_{\text{now}} - p_{\text{remaining}} \qquad S/RO = \frac{\text{Slack}}{\text{Number of remaining operations}}$

Optimality Results to Memorize

For $n$ jobs on one machine, all available at time zero:

1. SPT minimizes mean flow time. Proof sketch: swapping any adjacent pair so the shorter job runs first reduces the sum of completion times, so no sequence with a longer job ahead of a shorter one can be optimal. Because $\bar{L} = \bar{F} - \bar{d}$ and average WIP $= \sum F_i / \sum p_i$, SPT simultaneously minimizes mean lateness, mean waiting time, and average WIP.
2. EDD minimizes maximum lateness $L_{\max}$ (and therefore maximum tardiness). This is Jackson's rule.
3. Moore's algorithm minimizes the number of tardy jobs $N_T$: sequence by EDD; scan forward until the first job becomes tardy; from the sequence up to and including that job, remove the one with the largest processing time and set it aside to run last; repeat on the shortened list.
4. WSPT (largest $w_i/p_i$ first) minimizes weighted mean flow time, the correct rule when jobs carry unequal holding cost or customer value.

Critical Limitation: These theorems hold for a single machine with all jobs available at time zero. Once jobs arrive dynamically, machines run in parallel, or routings differ, general job-shop scheduling becomes NP-hard and dispatching rules become heuristics evaluated by simulation, not proofs.

3. Flow Shop Scheduling and Johnson's Rule

In a flow shop, every job visits the same work centers in the same technological order. The classical two-machine case has an exact polynomial-time solution.

Johnson's Rule (Two Machines, n Jobs)

Given $n$ jobs each requiring time $a_i$ on Machine 1 followed by $b_i$ on Machine 2, the sequence that minimizes makespan (equivalently, minimizes total idle time on Machine 2) is constructed as follows:

             Johnson's Rule Algorithm (2 machines, n jobs)

  1. List every processing time a_i (Machine 1) and b_i (Machine 2).
  2. Find the SMALLEST unassigned time in the whole list.
        |
        +-- If it is on MACHINE 1  -> place that job in the EARLIEST
        |                              open position (front of sequence)
        +-- If it is on MACHINE 2  -> place that job in the LATEST
                                       open position (back of sequence)
  3. Remove that job from further consideration.
  4. Repeat until every position is filled.
     (Break ties arbitrarily; alternate optimal sequences exist.)

The logic is intuitive: jobs with short Machine-1 times should go first so Machine 2 starts as early as possible, and jobs with short Machine-2 times should go last so Machine 2 is not left idle at the end waiting for a long finishing operation.

Johnson's rule extends exactly to three machines only when a special condition holds — either $\min a_i \ge \max$ of the middle-machine times, or $\min c_i \ge \max$ of the middle-machine times — in which case the middle machine is collapsed by forming $a_i' = a_i + b_i$ and $b_i' = b_i + c_i$ and applying the two-machine rule. Beyond that, flow shop scheduling is NP-hard.

Reading a Gantt Chart

A Gantt chart plots each machine on a horizontal time axis with a bar for every job. It is the standard way to expose two distinct losses:

• Idle time: a machine has no job available (starvation, typically on Machine 2 at the start of the schedule).
• Blocking: a machine has finished but cannot discharge because the downstream buffer is full.

Total idle time on Machine 2 equals the makespan minus the sum of the Machine 2 processing times; minimizing makespan in a two-machine flow shop is therefore precisely equivalent to minimizing Machine 2 idle time.

---

4. Step-by-Step Worked Engineering Calculations

Worked Example 12.4.1: Single-Machine Sequencing under FCFS, SPT, and EDD

Problem: Five jobs wait at a CNC machining center at time zero. Processing times and due dates (in days from now) are:

Jobs arrived in the order A, B, C, D, E. For each of FCFS, SPT, and EDD, determine the sequence, mean flow time, mean tardiness, maximum lateness, number of tardy jobs, and average number of jobs in the system.

Solution:

Total processing time $\sum p_i = 6 + 2 + 8 + 3 + 9 = 28$ days, so the makespan is 28 days under every sequence (single machine, no idle time).

Sequence 1 — FCFS (A, B, C, D, E)

$\bar{F} = \frac{77}{5} = 15.4\text{ days} \qquad \bar{T} = \frac{8}{5} = 1.6\text{ days} \qquad L_{\max} = +7 \qquad N_T = 2$ $\text{Average jobs in system} = \frac{77}{28} = 2.75$

Sequence 2 — SPT (B, D, A, C, E), ordering by $p_i$ = 2, 3, 6, 8, 9

$\bar{F} = \frac{65}{5} = 13.0\text{ days} \qquad \bar{T} = \frac{6}{5} = 1.2\text{ days} \qquad L_{\max} = +4 \qquad N_T = 2$ $\text{Average jobs in system} = \frac{65}{28} = 2.32$

Sequence 3 — EDD (A, D, C, B, E), ordering by $d_i$ = 9, 12, 15, 25, 28

$\bar{F} = \frac{79}{5} = 15.8\text{ days} \qquad \bar{T} = \frac{2}{5} = 0.4\text{ days} \qquad L_{\max} = +2 \qquad N_T = 1$ $\text{Average jobs in system} = \frac{79}{28} = 2.82$

Comparison

Engineering interpretation: SPT delivers the lowest mean flow time (13.0 versus 15.4 and 15.8 days) and therefore the lowest average WIP — 2.32 jobs on the floor instead of 2.75 or 2.82. EDD delivers the best customer-facing result: maximum lateness falls from 7 days to 2 days and only one job is tardy. The two rules optimize different objectives, and the choice is a business decision, not a mathematical one. Note also the identity check: mean due date $= (9 + 25 + 15 + 12 + 28)/5 = 17.8$ days, and for SPT $\bar{L} = 13.0 - 17.8 = -4.8$, exactly as $\bar{L} = \bar{F} - \bar{d}$ predicts.

---

Worked Example 12.4.2: Johnson's Rule in a Two-Machine Flow Shop

Problem: Five jobs must each be milled on Machine 1 and then deburred on Machine 2, in that order. Processing times in hours:

1. Apply Johnson's rule to find the makespan-minimizing sequence.
2. Compute the makespan and the idle time on each machine.
3. Compare against processing the jobs in numerical order (J1 through J5).

Solution:

Step 1: Apply Johnson's Rule Positions to fill: $[_,, _,, _,, _,, _,]$.

• Smallest time in the whole table is 1 (J2 on Machine 1) $\to$ Machine 1, so J2 takes the earliest open position: $[J2, _, _, _, _]$.
• Next smallest among remaining jobs is 2 (J1 on Machine 2) $\to$ Machine 2, so J1 takes the latest open position: $[J2, _, _, _, J1]$.
• Next is 3 (J4 on Machine 1) $\to$ earliest open: $[J2, J4, _, _, J1]$.
• Next is 4 (J5 on Machine 2) $\to$ latest open: $[J2, J4, _, J5, J1]$.
• Only J3 remains: $[J2, J4, J3, J5, J1]$.

Optimal sequence: J2 $\to$ J4 $\to$ J3 $\to$ J5 $\to$ J1

Step 2: Build the Gantt schedule Machine 2 can start a job only when both (a) Machine 1 has released it and (b) Machine 2 is free.

$\text{Makespan} = 30\text{ hours}$

Idle time:

• Machine 1 total work $= 5 + 1 + 9 + 3 + 10 = 28$ hours, so Machine 1 idles $30 - 28 = 2$ hours (all at the end, waiting for the schedule to close out).
• Machine 2 total work $= 2 + 6 + 7 + 8 + 4 = 27$ hours, so Machine 2 idles $30 - 27 = 3$ hours: 1 hour of initial starvation (0 to 1), 1 hour waiting for J5 (22 to 23), and 1 hour waiting for J1 (27 to 28).

Step 3: Compare against numerical order (J1, J2, J3, J4, J5)

Makespan $= 34$ hours, with Machine 2 idle for $34 - 27 = 7$ hours.

Engineering conclusion: Johnson's rule reduces the makespan from 34 hours to 30 hours, an 11.8% reduction, and cuts Machine 2 idle time from 7 hours to 3 hours — with zero capital investment and no change to any processing time. The gain comes entirely from starting with the job that clears Machine 1 fastest (J2, 1 hour) and finishing with the job that occupies Machine 2 for the shortest time (J1, 2 hours), so the downstream machine is fed early and drained late.

---

5. NCEES Reference Handbook Tips and Realistic Exam Traps

• Makespan Does Not Change on One Machine: With a single machine, no idle time, and all jobs available at time zero, every sequence finishes at $\sum p_i$. If a question asks which rule minimizes makespan in that setting, the answer is that all rules tie. Makespan only becomes sequence-dependent with two or more machines.
• Tardiness Is Truncated at Zero: When totaling tardiness, replace every negative lateness with 0 before summing. Averaging raw lateness values (including the negatives) understates customer impact and is the most common numerical error on these problems.
• Match the Rule to the Objective: SPT for mean flow time, mean lateness, or average WIP; EDD for maximum lateness or maximum tardiness; Moore's algorithm for the number of tardy jobs; WSPT when jobs carry unequal weights. Selecting SPT for a maximum-lateness question is the standard distractor.
• Critical Ratio Direction: The job with the smallest critical ratio has the highest priority. $CR < 1.0$ signals a job already behind schedule. Choosing the largest CR inverts the rule.
• Johnson's Rule Placement Direction: A smallest time on Machine 1 goes to the front; a smallest time on Machine 2 goes to the back. Reversing the two directions produces a valid-looking but non-optimal sequence, and it is the built-in distractor on nearly every Johnson's rule item.
• Check Johnson's Applicability: Johnson's rule requires a true flow shop — every job passes through Machine 1 and then Machine 2 in the same order, with no passing and no missed operations. It does not apply to a job shop with mixed routings.