7.3 Production Sequencing, Dispatching Rules & Johnson's Algorithm

Production Sequencing, Dispatching Rules & Johnson's Algorithm

Operations scheduling transforms aggregate production plans and master production schedules into actionable, short-interval execution sequences on the factory floor. While aggregate planning operates across monthly buckets, production scheduling allocates specific jobs, tooling, and labor to discrete machines over shift, hourly, or minute-by-minute timeframes.

In manufacturing environments, sequencing determines the exact order in which waiting jobs are processed at a workstation. Because machine capacity is finite, queue dispatching decisions dictate manufacturing lead times, work-in-process (WIP) accumulation, machine utilization, and on-time customer delivery performance.

---

1. Single-Machine Scheduling Framework & Performance Measures

The fundamental building block of scheduling theory is the single-machine model ($1 || \gamma$). In this formulation, $n$ distinct jobs are available at time $t = 0$ awaiting processing on a single, continuously available processing unit. Preemption is prohibited (once processing begins on a job, it must run to completion without interruption).

Primary Job Attributes

For each job $i \in \{1, 2, \dots, n\}$:

• Processing Time ($p_i$): The required machine execution time (including setup, run time, and teardown).
• Due Date ($d_i$): The committed contractual completion deadline.
• Ready / Release Time ($r_i$): The earliest time job $i$ is physically available for processing ($r_i = 0$ for static scheduling).

Mathematical Performance Metrics

Let $C_i$ denote the completion time of job $i$ under a given schedule sequence. The primary operational evaluation metrics are formulated as follows:

1. Flow Time ($F_i$): The total elapsed span spent by job $i$ in the shop environment: $F_i = C_i - r_i = C_i \quad (\text{when } r_i = 0)$
2. Makespan ($C_{max}$): The total completion time of the entire job batch: $C_{max} = \max_{1 \le i \le n} C_i = \sum_{i=1}^n p_i$ Crucial Property: For any non-preemptive single-machine problem without inserted idle time, makespan is strictly constant, equal to the sum of all processing times regardless of the dispatch sequence.
3. Mean Flow Time ($\bar{F}$): The average system residence time across all $n$ jobs: $\bar{F} = \frac{1}{n} \sum_{i=1}^n F_i = \frac{1}{n} \sum_{i=1}^n C_i$
4. Average Work-in-Process ($\overline{WIP}$): By Little's Law ($L = \lambda W$), the average number of jobs residing in the shop is: $\overline{WIP} = \frac{\sum_{i=1}^n F_i}{C_{max}} = \frac{n \bar{F}}{C_{max}}$ Minimizing mean flow time $\bar{F}$ directly minimizes factory WIP inventory.
5. Lateness ($L_i$): The deviation of completion time from committed due date: $L_i = C_i - d_i$
   • $L_i > 0$: Job is late (completed after due date).
   • $L_i < 0$: Job is early (completed ahead of due date).
   • Mean Lateness ($\bar{L}$): $\bar{L} = \frac{1}{n} \sum_{i=1}^n L_i = \bar{F} - \bar{d}$.
6. Tardiness ($T_i$): The non-negative measure of lateness (penalizes tardy jobs while treating early completion as zero penalty): $T_i = \max(0, C_i - d_i) = \max(0, L_i)$
   • Mean Tardiness ($\bar{T}$): $\bar{T} = \frac{1}{n} \sum_{i=1}^n T_i$.
   • Maximum Tardiness ($T_{max}$): $T_{max} = \max_{1 \le i \le n} T_i$.
7. Number of Tardy Jobs ($N_T$): The count of jobs missing their committed due dates: $N_T = \sum_{i=1}^n U_i \quad \text{where } U_i = \begin{cases} 1 & \text{if } C_i > d_i \\ 0 & \text{if } C_i \le d_i \end{cases}$

2. Priority Dispatching Rules & Optimality Theorems

When multiple jobs queue before a machine, dispatching heuristics prioritize the sequence of execution.

Dispatching Rule Taxonomy:
├── Static Rules (Calculated once at t = 0)
│   ├── FCFS (First-Come, First-Served) -> Baseline fairness, poor inventory efficiency
│   ├── SPT (Shortest Processing Time)   -> Minimizes mean flow time, completion time & WIP
│   ├── WSPT (Weighted SPT / Smith)     -> Minimizes weighted flow time sum(w_i * F_i)
│   ├── EDD (Earliest Due Date)          -> Minimizes maximum lateness L_max & max tardiness T_max
│   └── Moore-Hodgson Algorithm          -> Minimizes total number of tardy jobs N_T
└── Dynamic Rules (Recalculated dynamically as current time t advances)
    ├── CR (Critical Ratio)              -> Sequence ascending CR = (d_i - t) / p_i
    └── STR (Slack Time Remaining)       -> Sequence ascending STR = (d_i - t) - p_i

Shortest Processing Time (SPT) Rule

Under SPT, jobs are ordered in ascending order of their processing durations:

$p_{[1]} \le p_{[2]} \le \dots \le p_{[n]}$

Proof Intuition: Under sequence $[1, 2, \dots, n]$, completion times accumulate as $C_1 = p_1$, $C_2 = p_1 + p_2$, ..., $C_n = \sum p_i$. Summing completion times yields: $\sum_{i=1}^n C_i = n p_{[1]} + (n-1) p_{[2]} + (n-2) p_{[3]} + \dots + 1 p_{[n]}$ To minimize this dot product, the largest multiplier coefficients ($n, n-1, \dots$) must pair with the smallest processing times $p_i$, proving that sorting $p_i$ ascending minimizes total flow time.

Weighted Shortest Processing Time (WSPT): If jobs carry different holding or inventory carrying weights $w_i$, the WSPT rule (Smith's Rule) minimizes total weighted flow time $\sum_{i=1}^n w_i F_i$ by sequencing jobs in descending order of the ratio:

$\frac{w_{[1]}}{p_{[1]}} \ge \frac{w_{[2]}}{p_{[2]}} \ge \dots \ge \frac{w_{[n]}}{p_{[n]}}$

Earliest Due Date (EDD) Rule

Under EDD, jobs are ordered in ascending order of their committed delivery due dates:

$d_{[1]} \le d_{[2]} \le \dots \le d_{[n]}$

When an industrial facility faces steep contractual penalty clauses for any job delivered exceptionally late, EDD is the provably optimal dispatching policy.

Critical Ratio (CR) Rule

Critical Ratio ($CR$) is an operational dynamic dispatching heuristic that evaluates the ratio of available slack time to remaining work at the current scheduling decision epoch $t$:

$CR_i = \frac{d_i - t}{p_i}$

• $CR_i < 1.0$ (Behind Schedule): Available time until due date is less than remaining processing duration. The job will be late unless expedited. Priority increases as $CR$ decreases.
• $CR_i = 1.0$ (On Schedule): Job has zero slack; if initiated immediately, it completes precisely on its due date.
• $CR_i > 1.0$ (Ahead of Schedule): Job has positive slack time available.
• $CR_i \le 0$ (Already Past Due): Due date has already passed ($t \ge d_i$). These jobs require immediate emergency intervention.

Dispatch Logic: Sequence available jobs in ascending order of Critical Ratio (smallest $CR$ first).

Slack Time Remaining (STR)

Slack Time Remaining computes the absolute surplus margin before a job must commence to meet its deadline:

$STR_i = (d_i - t) - p_i$

Dispatching prioritizes jobs with the lowest $STR_i$. A variant for multi-operation routings is Slack Time Remaining per Operation ($STR/OP$):

$STR/OP_i = \frac{(d_i - t) - \sum p_{ij}}{\text{Number of Remaining Operations}}$

Moore-Hodgson Algorithm (Minimizing $N_T$)

To minimize the total number of late jobs ($N_T$), Moore and Hodgson developed an exact $O(n \log n)$ algorithm:

1. Sequence all $n$ jobs according to the EDD rule ($d_1 \le d_2 \le \dots \le d_n$).
2. Evaluate job completions sequentially. Find the first tardy job in the sequence ($C_k > d_k$). If no jobs are tardy, the current schedule is optimal.
3. Identify the job in the current set of scheduled jobs $\{1, 2, \dots, k\}$ that has the largest processing time ($p^* = \max_{1 \le j \le k} p_j$).
4. Remove that job from the active schedule and assign it to a rejected pool to be processed at the very end of the schedule (in any order).
5. Recalculate completion times for remaining jobs and repeat steps 2–4 until no scheduled jobs are tardy. The resulting schedule minimizes $N_T$.

3. Two-Machine Flow Shop Sequencing: Johnson's Rule

When production expands beyond a single workstation to multiple processing centers in series, scheduling complexity escalates rapidly. The classical Two-Machine Flow Shop Problem ($F_2 || C_{max}$) models $n$ jobs processed sequentially across two machines, $M_1$ and $M_2$.

Two-Machine Flow Shop Architecture:
   [Job Queue] ===> [ Machine 1 (A_i) ] ===> [ Machine 2 (B_i) ] ===> [ Completed ]
   (All n jobs)      First Operation          Second Operation         Shipment

Problem Formulation

• Every job $i \in \{1, \dots, n\}$ must be processed first on Machine 1, and subsequently on Machine 2.
• Operation time for job $i$ on Machine 1 is $A_i$.
• Operation time for job $i$ on Machine 2 is $B_i$.
• Machine 2 cannot begin working on job $i$ until Machine 1 completes job $i$ ($C_{2, i} \ge C_{1, i} + B_i$).
• Both machines process jobs in identical permutation sequence.

Johnson's Algorithm (1954)

S.M. Johnson proved that a simple sorting heuristic finds the globally optimal sequence that minimizes the total makespan ($C_{max}$) across both machines.

Step-by-Step Algorithmic Procedure:

1. Compile Processing Matrix: Tabulate processing times $A_i$ (Machine 1) and $B_i$ (Machine 2) for all unscheduled jobs.
2. Identify Global Minimum: Scan all remaining processing times across both machines to locate the smallest value: $p^* = \min_{i} \{A_i, B_i\}$
3. Conditional Assignment:
   • If the minimum processing time occurs on Machine 1 ($A_i$): Schedule job $i$ in the earliest available unassigned position (toward the beginning of the sequence).
   • If the minimum processing time occurs on Machine 2 ($B_i$): Schedule job $i$ in the latest available unassigned position (toward the end of the sequence).
4. Tie-Breaking Protocols:
   • If a tie occurs between Machine 1 and Machine 2 ($A_i = B_j$), place job $i$ at the beginning and job $j$ at the end.
   • If a tie occurs between two jobs on Machine 1 ($A_i = A_j$), arbitrarily place either job first.
   • If a tie occurs between two jobs on Machine 2 ($B_i = B_j$), arbitrarily place either job last.
5. Iterate: Remove the assigned job from the candidate list and repeat steps 2–4 until all $n$ jobs have been sequenced.

Gantt Chart Construction & Makespan Calculation

Let $[1], [2], \dots, [n]$ denote the sequence determined by Johnson's algorithm. Tracking completion times recursively:

• Machine 1 Completion Times: Machine 1 runs continuously with zero idle time: $C_{1, [1]} = A_{[1]}$ $C_{1, [k]} = C_{1, [k-1]} + A_{[k]} \quad \forall k = 2, \dots, n$
• Machine 2 Completion Times: Machine 2 cannot start job $[k]$ until Machine 2 finishes job $[k-1]$ AND Machine 1 finishes job $[k]$: $C_{2, [1]} = A_{[1]} + B_{[1]}$ $C_{2, [k]} = \max(C_{2, [k-1]}, C_{1, [k]}) + B_{[k]} \quad \forall k = 2, \dots, n$
• Machine 2 Idle Time: Idle time occurs on Machine 2 whenever $C_{1, [k]} > C_{2, [k-1]}$ (Machine 2 is waiting for Machine 1 to finish): $I_{2, [k]} = \max(0, C_{1, [k]} - C_{2, [k-1]})$
• Total Makespan ($C_{max}$): The completion time of the final job on Machine 2: $C_{max} = C_{2, [n]}$

4. Job Shop Scheduling Complexity and Advanced Heuristics

While flow shops enforce identical, unidirectional routings across all jobs, job shops ($J_m || \gamma$) feature complex, multi-directional routings. Each job follows an individualized technological route sheet (e.g., Job 1 routes Lathe $\to$ Mill $\to$ Grind; Job 2 routes Mill $\to$ Lathe $\to$ Assembly).

Combinatorial Complexity

A general job shop with $n$ jobs and $m$ machines exhibits extreme combinatorial complexity. The theoretical schedule space contains $(n!)^m$ active schedules. For a modest shop with 10 jobs and 5 machines:

$(10!)^5 = (3{,}628{,}800)^5 \approx 6.29 \times 10^{32} \text{ candidate schedules}$

General job shop scheduling is proven $NP$-hard. Finding guaranteed optimal schedules via exact mathematical programming (mixed-integer linear programming, branch-and-bound) is computationally intractable for industrial scales, forcing reliance on advanced heuristics.

The Shifting Bottleneck Heuristic (SBH)

Developed by Adams, Balas, and Zawack (1988), the Shifting Bottleneck Heuristic is one of the most powerful and widely cited algorithms for job shop scheduling:

1. Decomposition: The overall job shop problem is decomposed into $m$ single-machine subproblems.
2. Bottleneck Identification: For each unsequenced machine, release dates $r_i$ and due dates $d_i$ are derived from preceding and succeeding operations. Each machine is analyzed as a single-machine problem with release dates minimizing maximum lateness ($1 | r_i | L_{max}$, solved using Carlier's exact algorithm or Schrage's heuristic).
3. Bottleneck Selection: The machine exhibiting the largest maximum lateness $L_{max}$ is identified as the current critical bottleneck.
4. Fix Sequence: The sequence of operations on this bottleneck machine is permanently locked into the global schedule.
5. Shifting / Re-optimization Phase: Every time a new bottleneck machine is sequenced, previously scheduled machines are systematically re-optimized to capture newly created schedule constraints.
6. Termination: Repeat until all $m$ machines have been sequenced.

5. Worked Engineering Examples

Example 1: Comparing Dispatching Rules on a Single Machine

Problem Statement: Five jobs are waiting to be processed on a CNC vertical machining center at time $t = 0$. Job processing times and committed due dates are:

Evaluate the schedule under Shortest Processing Time (SPT) and compute: makespan ($C_{max}$), mean flow time ($\bar{F}$), average WIP ($\overline{WIP}$), maximum lateness ($L_{max}$), and maximum tardiness ($T_{max}$).

Solution:

Step 1: Order jobs by SPT ($p_i$ ascending): Sequence: J4 (2) $\to$ J2 (3) $\to$ J1 (5) $\to$ J5 (6) $\to$ J3 (8)

Step 2: Compute schedule timeline:

Step 3: Compute Performance Metrics:

• Makespan ($C_{max}$): $24\text{ hours}$
• Total Flow Time: $\sum C_i = 2 + 5 + 10 + 16 + 24 = 57\text{ hours}$
• Mean Flow Time ($\bar{F}$): $\frac{57}{5} = 11.40\text{ hours}$
• Average WIP ($\overline{WIP}$): $\frac{\sum F_i}{C_{max}} = \frac{57}{24} = 2.375\text{ jobs}$
• Maximum Lateness ($L_{max}$): $\max(-5, -1, 1, 4, 9) = +9\text{ hours}$
• Maximum Tardiness ($T_{max}$): $\max(0, 0, 1, 4, 9) = 9\text{ hours}$
• Number of Tardy Jobs ($N_T$): 3 jobs (J1, J5, J3)

(Note: Under EDD [J2 $\to$ J4 $\to$ J1 $\to$ J5 $\to$ J3] the completion times are 3, 5, 10, 16, and 24 hours, so total flow time rises to 58 hours and $\bar{F} = 11.6$ hours. $L_{max}$ is still +9 hours with the same three tardy jobs. That is the best possible here: some job must finish at $t = 24$, and the latest due date is 15, so no sequence can have $L_{max}$ below 9.)

---

Example 2: Two-Machine Flow Shop Optimization via Johnson's Rule

Problem Statement: Five structural weldments must be processed sequentially across two dedicated workstations: Fit-up/Tack Welding (Machine 1) and Final Robotic Seam Welding (Machine 2). Processing times (in hours) are:

Determine the optimal sequence using Johnson's algorithm and calculate total makespan and idle time on Machine 2.

Solution:

Step 1: Execute Johnson's Algorithm Iterations:

• Iteration 1: Smallest processing time overall is 2 hours (Job 3 on Machine 1). Because it is on Machine 1, place J3 in the first available slot. Current sequence: [ J3, __, __, __, __ ]
• Iteration 2: Smallest remaining processing time is 3 hours (Job 2 on Machine 2). Because it is on Machine 2, place J2 in the last available slot. Current sequence: [ J3, __, __, __, J2 ]
• Iteration 3: Smallest remaining processing times are 4 hours (Job 1 on Machine 1, and Job 5 on Machine 2):
  • Job 1 ($A_1 = 4$ on M1) $\implies$ place J1 in earliest available slot.
  • Job 5 ($B_5 = 4$ on M2) $\implies$ place J5 in latest available slot. Current sequence: [ J3, J1, __, J5, J2 ]
• Iteration 4: Only Job 4 remains. Place J4 in the final remaining middle slot. Optimal sequence: [ J3 $\to$ J1 $\to$ J4 $\to$ J5 $\to$ J2 ]

Step 2: Construct Schedule Timeline:

Step 3: Evaluate Results:

• Makespan ($C_{max}$): $30\text{ hours}$
• Machine 1 Total Runtime: $2 + 4 + 6 + 7 + 8 = 27\text{ hours}$ (finishes at $t = 27$)
• Machine 2 Idle Time: $2\text{ hours}$ (waiting for J3 to finish on M1) $+ 1\text{ hour}$ (waiting from $t=26$ to $t=27$ for J2 to finish on M1) = $3\text{ hours}$ total idle time.
• Machine 2 runtime is $7 + 5 + 8 + 4 + 3 = 27$ hours. Total makespan = $27\text{ runtime} + 3\text{ idle} = 30\text{ hours}$.