Skip to content
Business Management

Production planning: MRP and sequencing rules

Hierarchical planning and MRP, optimality of SPT and EDD proved by exchange, Johnson's rule for two machines with an example and optimality proved.

A factory must decide every day what to produce, in what quantities and in what order on the machines. Production planning translates orders and forecasts into plans, and scheduling establishes the sequence of jobs. In this lesson we look at hierarchical planning and MRP logic, sequencing rules on one machine with the proofs of the optimality of SPT and EDD, and Johnson’s rule for two machines with an example whose optimality is proved.

From planning to sequencing

Planning proceeds by levels, with shorter and shorter horizons:

  1. the aggregate plan (months): capacity, shifts, inventory levels by product family;
  2. the master production schedule (MPS, weeks): which finished products, how many and when;
  3. material requirements planning (MRP): starting from the MPS and the bill of materials (the list of components of each product, level by level), the net quantities to produce or buy are computed for each component, subtracting available stock, together with the order release dates, brought forward by the lead time;
  4. scheduling (days, hours): the sequence of jobs on each resource.

A car has thousands of components; an electronic board hundreds. Computing requirements by hand would be impossible: MRP was one of the first great applications of computers in business, and it is the heart of ERP systems.

One machine: SPT and EDD

n jobs must be processed on one machine, with durations p_j and due dates d_j. Different rules optimise different objectives.

Theorem (SPT). Processing jobs in order of increasing duration (shortest processing time) minimises the mean completion time.

Proof. It is the same exchange argument as CPU scheduling (Operating Systems lesson on scheduling): if two consecutive jobs are in “long before short” order, swapping them brings the short one’s completion forward by the long one’s duration and delays the long one by the short one’s duration, so the sum decreases; the other jobs do not change. The optimum has no inversions. ∎

Theorem (EDD). Processing jobs in order of increasing due date (earliest due date) minimises the maximum lateness L_{max} = \max_j(C_j - d_j).

Proof. Consider two consecutive jobs i and j with d_i \gt  d_j and i before j, starting at time t and both finishing by T = t + p_i + p_j. Before the swap j finishes at T, with lateness T - d_j, the larger of the two (because i finishes before T and has a later due date). After the swap j finishes before T, and i finishes at T with lateness T - d_i \lt  T - d_j. The maximum of the two does not increase, and the other jobs do not change. Removing the inversions one by one leads to the EDD order without getting worse. ∎

Neither rule is good for everything: SPT may make long jobs wait for a long time; EDD ignores durations. To minimise the number of late jobs there is a dedicated algorithm (Moore-Hodgson); for more complex objectives the problems quickly become intractable and heuristics are used.

Two machines: Johnson’s rule

Each job goes first on machine M_1 (duration a_j) and then on M_2 (duration b_j), in the same order. The goal is to minimise the total time (makespan). Johnson (1954) gave the optimal rule:

  1. jobs with a_j \le b_j go first, in order of increasing a_j;
  2. the others go last, in order of decreasing b_j.

The idea is to keep M_2 busy as soon as possible (short jobs on M_1 at the start) and not to leave it with a lot of work at the end (short jobs on M_2 at the end).

Example. Five jobs (a_j, b_j): J1 (3, 6), J2 (5, 2), J3 (1, 2), J4 (6, 6), J5 (7, 5). First group, by increasing a: J3, J1, J4. Second group, by decreasing b: J5, J2. Sequence J3, J1, J4, J5, J2.

Johnson sequence on two machines
On machine M 1 jobs J3, J1, J4, J5, J2 follow each other without idle time until time 22. On machine M 2 each job starts when it has finished on M 1 and M 2 is free; the last, J2, finishes at time 24.

On M_1 the jobs finish at times 1, 4, 10, 17, 22; on M_2 at 3, 10, 16, 22, 24. The makespan is 24.

Optimality in the example. Any sequence must occupy M_1 for \sum a_j = 22, and after the last job on M_1 at least its duration on M_2 is still needed, which is at least \min_jb_j = 2. So no sequence finishes before 24, and Johnson’s sequence reaches the bound. (The general proof again uses an exchange between adjacent jobs.)

With three or more machines the problem becomes NP-hard and heuristics are used; Johnson’s rule remains useful when two machines dominate, for example an assembly station followed by testing.

Subscribe
Notify of
guest
0 Comments
Oldest
Newest Most Voted
0
Would love your thoughts, please comment.x
()
x