Coffman–Sethi conjecture [2]: For every , the LD algorithm has a makespan ratio with a worst-case bound equal to
Approximation ratio of LD algorithm for multi-processor scheduling and the Coffman–Sethi conjecture
Introduction
The most fundamental machine environment in multiprocessor scheduling problems is a parallel identical machine model. In this basic set-up, we have m parallel identical machines and n independent jobs, all simultaneously available at time zero, indexed by with given processing times . No pre-emption is allowed, and the machines are assumed to be completely reliable. For a scheduling problem environment described above, with data , there are two performance criteria that immediately come to mind:
- •
minimize the completion time of the last job (i.e., makespan),
- •
minimize the total (or equivalently the average) time that the jobs spend in the system (i.e., total or average flowtime).
Conway, Maxwell and Miller [3], in their seminal book, develop the notion of rank for the FM problem. Without loss of generality, we may assume that m divides n (if m does not divide n, we can add dummy jobs with zero processing times). We may further assume that the jobs are indexed in nonincreasing order of processing times.
Definition 1 The number of ranks for an FM instance is defined by , and the set of jobs belonging to rank r are the following: .
A feasible schedule in which all rank jobs are started before all rank r jobs (where ) is said to satisfy the rank restriction or rank constraint. A feasible schedule without idle time and satisfying the rank constraint, and in which all rank jobs start at time zero, is a flowtime-optimal schedule. Since within each rank the assignment of jobs to machines can be arbitrary, it immediately follows that there are at least flowtime-optimal schedules. It makes sense to consider a secondary criterion to choose a “best” flowtime-optimal schedule among these (a huge number of) schedules each of which minimizes total flowtime.
The FM problem is -hard [1]. In 1976, Coffman and Sethi [2] proposed some approximation algorithms for the FM problem. One of these algorithms, the LD algorithm, is an implementation of the LPT (Longest Processing Time) idea which respects the rank constraint. Detailed description follows:
In the above, represents the total amount of processing time assigned to machine i. When the algorithm terminates, is the completion time on machine i for the LD schedule. is an ordered string of integers, it represents the jobs assigned to machine i. Until Steps 14–16 of the algorithm are executed, jobs listed in are in the LPT order. To generate a flowtime optimal schedule, in the Steps 14–16, the order of assigned jobs in each machine is reversed. σ denotes the permutation that sorts the integers (the total processing time assigned to each machine so far) so that The algorithm starts with all equal to zero and σ being the identity permutation. However, after each run of the loop given by Steps 8–11, we update σ so that denotes the number of the machine which has the ith smallest total processing time at that point. Note that the LD Algorithm also has very close ties to List Scheduling. For each ℓ from Step 7, the inside loop just implements List Scheduling. Coffman and Sethi conjectured the following worst-case bound for the LD algorithm.
The authors and Huang [5] constructed a family of instances, proving that the above conjectured ratio cannot be improved for any . The Coffman–Sethi conjecture has remained open for four decades. Some of the difficulties in dealing with this conjecture and similar ones are due to the lack of efficiently computable tight lower bounds on the makespan of flowtime-optimal schedules. This is in contrast to the situation in the problem. In the problem setting, the simple lower bound on given by (maximum of the length of the longest job and the average work to be done per machine), when used with a fundamental notion of minimality (smallest n) in hypothesized counterexamples leads to a very elegant and short proof of the exact worst-case performance ratio of the LPT algorithm. However, in the FM problem, the above lower bound and its variants and the above used basic notion of minimality seem to be too weak to lead to an exact worst-case analysis for the LD algorithm. The first major advances on the Coffman–Sethi conjecture were reported by the authors and Huang in [5]. These efforts reduced the task of verifying the correctness of this long-standing conjecture to checking the cases when the number of ranks are either 4 or 5, but number of machines in the unsolved cases remained unbounded. At that time, to verify the remaining cases, the only viable tool seemed to be setting up and solving to optimality finitely many LP problems for each . In the next section, utilizing our recent work with Huang [5], we provide a proof for all the remaining cases of this conjecture which does not rely on extensive computations or extensive case analysis. Moreover, our proof here not only covers the remaining cases with , it works for all and .
Section snippets
A proof of the Coffman–Sethi conjecture
In every rank r, we identify the largest and smallest processing times and denote them by and . Therefore, we have
Given an instance of the FM problem, we denote by the makespan of the LD schedule(s). We use to denote the makespan of the optimal schedule(s). We will restrict our attention to problem instances with integer data in this paper (as established in [4] this is without loss of generality). It follows that the smallest nonzero processing time
Declaration of Competing Interest
The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.
Acknowledgement
The work was supported in part by Discovery Grants from NSERC (Natural Sciences and Engineering Research Council of Canada), NSERC Discovery Grant RGPIN-2015-05546. The second author's research was also supported in part by U.S. Office of Naval Research under award number: N00014-15-1-2171.
References (5)
- et al.
Algorithms for minimizing mean flow time
- et al.
Algorithms minimizing mean flowtime: schedule-length properties
Acta Inform.
(1976)