Approximation Algorithms for Precedence-Constrained Scheduling Problems on Parallel Machines That Run at Different Speeds: A min{K + 2√K + 1, 1.89 log m + O(√log m)}-Approximation for Q|prec|CmaxResearch Paper
Scheduling precedence-constrained jobs on machines of different speeds
Graham (1966) showed that list scheduling finds a schedule within a factor of optimal for precedence-constrained jobs on identical parallel machines, the first performance guarantee for an approximation algorithm. When the machines run at different speeds (uniformly related machines), the same analysis breaks down, and for two decades the problem resisted a guarantee independent of the speeds better than .
Timeline:
- 1974, Liu and Liu: list scheduling on machines of different speeds, with a guarantee that depends on the speeds and can be arbitrarily large even for a fixed number of machines.
- 1980, Jaffe: list scheduling on the machines whose speed is within a factor of the fastest gives an -approximation.
- 1978, Lenstra and Rinnooy Kan: with precedence constraints, no -approximation with exists unless P = NP. This bound already holds for identical machines.
- 1997–1999, Chudak and Shmoys: an LP-guided variant of list scheduling achieves , and when there are only distinct speeds (J. Algorithms 30 (1999) 323–343; conference version SODA 1997).
The mission formalizes the makespan half of that paper, up to its Theorem 3.7.
Setting
An instance has jobs and machines. Job requires units of processing, and machine runs at speed , so job takes time units on machine . A strict partial order on the jobs gives precedence constraints: means that job may not start until job has completed.
A schedule runs each job without interruption on one machine , from a start time to its completion time . A machine processes at most one job at a time, and forces . Its length is . is the length of an optimal schedule.
Let be the distinct speeds and the number of machines of speed . An assignment names the speed class at which job is to run. Its loads are , and its chain bound is the largest value of over chains of . Speed-based list scheduling is Graham's rule restricted by the assignment: whenever a machine of speed is idle, it starts the first available job on the list with .
The linear program LP has variables , and . It minimizes subject to the following constraints:
- ;
- ;
- , and whenever ;
- .
From a solution, with , the assignment algorithm gives each job the speed class of largest capacity .
Formalization targets
Goal: Theorem 3.7 (p. 10)
There is an absolute constant such that for every instance with machines and distinct speeds, the better of the two schedules below has length at most
- (A) An optimal LP solution, the assignment algorithm with , and speed-based list scheduling.
- (B) The same algorithm run on speeds rounded down to powers of , with machines slower than dropped, and read back on the original machines.
Milestones, in proof order
- Existence of speed-based list schedules (p. 4).
- Theorem 2.1: .
- The LP lower bound (p. 6).
- Lemmas 3.1–3.4: chain bounds and , and load bounds and .
- Theorem 3.5 and Corollary 3.6: the factor against and against .
- Rounded schedules serve the original instance (p. 9).
- The speed rounding: at most speeds, and the LP value grows by a factor of at most (p. 10).
- The "In fact" form of the guarantee, relative to any feasible LP solution (p. 10).
Significance
The result gives the first guarantee for , independent of the speeds, and a guarantee depending only on the number of distinct speeds. Through the batching technique of Shmoys, Wein and Williamson it extends to release dates (Corollary 3.8). Since LP also relaxes the preemptive problem, it gives an bound on the ratio between the nonpreemptive and preemptive optima (Corollaries 3.9, 3.10). The "In fact" form, relative to an arbitrary feasible LP solution, drives the paper's algorithm in §4.
The result is proved in the literature but, as far as is known, not formalized. A formal proof requires machine-checking the following:
- the continuous-time list-scheduling argument for different speeds;
- the filtering argument of Lin and Vitter;
- the reduction to logarithmically many speeds, including the off-by-one count of rounded speeds that the page leaves implicit.
Later work gave a combinatorial -approximation (Chekuri and Bender, 2001) and an -approximation (Li, 2017). These are not part of this mission.
Difficulty
Graham's argument has two lower bounds:
- the total processing along a chain;
- the time during which every machine is busy.
With different speeds, the first bound fails: a chain may have been run on slow machines, and its length then says nothing about . Forcing every job onto a fast machine repairs chains but can leave most machines idle, so the second bound fails. The paper only guarantees that all machines of one speed are busy at each moment of an idle period. Making this pay off requires an assignment that controls chain lengths and per-class loads simultaneously. That assignment is the delicate part: Theorem 2.1 is the bookkeeping, while Lemmas 3.2 and 3.4 rely on the LP. Two of the formal steps are routine on paper but fiddly in Lean: time-interval accounting over a continuous-time schedule, and the counting of rounded speed classes.
Formalization scope
- Representation. Jobs are
Fin nand machinesFin mwith . and . is a strict partial order, and a chain is a finite set of pairwise comparable jobs. is the maximum completion time, or with no jobs. - Speed classes. The classes are computed from the speeds, so and by construction. The Lean index is the paper's fastest class .
- The algorithm as predicates. Speed-based list scheduling is the predicate the proof of Theorem 2.1 uses: jobs run at their assigned speed, and no machine of a job's speed idles while that job is available and unstarted. Every list order and every order of idle machines satisfies it. The assignment algorithm is a predicate allowing every maximizer, since the page does not break ties. Theorems 3.5 and 3.7 quantify over all optimal LP solutions, all such assignments and all such schedules. Existence is supplied by the milestones.
- Comparator. The bound is stated against every feasible schedule of the same instance, never against the LP value or a best schedule of the rounded instance. A statement asserting only that some good schedule exists would be trivially true (the optimum witnesses it); the goal bounds the schedule the algorithm returns.
- Constants and logarithms. is , as the paper specifies. is assumed in Theorem 3.7 and in the "In fact" remark, which are asymptotic in . The term is one absolute constant , quantified before the instance, and is the page's number.
- Generalizations and corrections. Lemmas 3.1–3.4 are stated for every feasible LP solution, since their proofs use only feasibility. The speed rounding is relative to , with no normalization. The count of rounded speeds is ; the page writes .
- Not formalized. Polynomial running time is not formalized.
- Out of scope. Corollaries 3.8–3.10, Theorem 3.11 and §4 are excluded.
Proofs of any milestone are welcome. Reusable beyond this mission are the following: the model of nonpreemptive schedules on uniformly related machines with precedence, the speed-based list-scheduling predicate with Theorem 2.1, and the LP.
Selected references
- F. A. Chudak and D. B. Shmoys, Approximation algorithms for precedence-constrained scheduling problems on parallel machines that run at different speeds, J. Algorithms 30 (1999) 323–343 (authors' manuscript used here). https://doi.org/10.1006/jagm.1998.0987
- R. L. Graham, Bounds for certain multiprocessing anomalies, Bell System Technical Journal 45 (1966) 1563–1581. https://doi.org/10.1002/j.1538-7305.1966.tb01709.x
- J. M. Jaffe, Efficient scheduling of tasks without full use of processor resources, Theoretical Computer Science 12 (1980) 1–17. https://doi.org/10.1016/0304-3975(80)90002-4
- J.-H. Lin and J. S. Vitter, ε-approximations with minimum packing constraint violation, STOC 1992, 771–782. https://doi.org/10.1145/129712.129787
- D. B. Shmoys, J. Wein and D. P. Williamson, Scheduling parallel machines on-line, SIAM J. Computing 24 (1995) 1313–1331. https://doi.org/10.1137/S0097539793248317
- C. Chekuri and M. A. Bender, An efficient approximation algorithm for minimizing makespan on uniformly related machines, J. Algorithms 41 (2001) 212–224. https://doi.org/10.1006/jagm.2001.1184
- S. Li, Scheduling to minimize total weighted completion time via time-indexed linear programming relaxations, SIAM J. Computing 46 (2017) 409–440. https://doi.org/10.1137/15M1053163