Approximation ratio of LD algorithm for multi-processor scheduling and the Coffman–Sethi conjecture

https://doi.org/10.1016/j.ipl.2020.105959Get rights and content

Highlights

  • Coffman and Sethi's LD algorithm seeks to minimize makespan over flowtime-optimal schedules for identical parallel machines.

  • In 1976, they conjectured that, for m machines, this algorithm has the worst-case bound 5/4 – 3/(4(4m-1)).

  • In this paper, utilizing some recent work by the authors and Huang, we provide a proof of this four decades-old conjecture.

Abstract

Coffman and Sethi proposed a heuristic algorithm, called LD (Longest Decreasing), for multi-processor scheduling, to minimize makespan over flowtime-optimal schedules. The LD algorithm is an extension of a very well-known list scheduling algorithm, Longest Processing Time (LPT) list scheduling, to this bicriteria scheduling problem. Coffman and Sethi conjectured (in 1976) that the LD algorithm has the following precise worst-case performance bound: 5434(4m1), where m is the number of machines. In this paper, utilizing some recent work by the authors and Huang (2016), which exposed some very strong combinatorial properties of various presumed minimal counterexamples to the conjecture, we provide a proof of this conjecture. The problem and the LD algorithm have connections to some other fundamental problems (such as the assembly line-balancing problem) and algorithms.

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 1,2,,n with given processing times p1,p2,,pn. No pre-emption is allowed, and the machines are assumed to be completely reliable. For a scheduling problem environment described above, with data m,p1,p2,,pn, 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).

Given a feasible schedule, let Cj denote the completion time of job j in that schedule. By denoting Cmax:=maxj{1,2,,n}{Cj}, our two criteria are: minimize Cmax, minimize j=1nCj. A feasible schedule is called flowtime-optimal if it minimizes total flow time F:=j=1nCj. In this paper, we consider the bicriteria optimization problem of minimizing makespan among all flowtime-optimal schedules. In scheduling theory notation, let F denote the optimal objective function value of P//Cj. Then, our bicriteria optimization problem is: P//(Cmax;Cj=F), which we call Flowtime-Makespan (FM) problem.

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 (mn/mn) 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 k:=n/m, and the set of jobs belonging to rank r are the following: (r1)m+1,(r1)m+2,,(r1)m+m.

A feasible schedule in which all rank (r+1) jobs are started before all rank r jobs (where r{1,2,,(n/m)1}) 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 n/m 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 (m!)(n/m) 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 NP-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, Ci represents the total amount of processing time assigned to machine i. When the algorithm terminates, Ci is the completion time on machine i for the LD schedule. Ji 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 Ji 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 C1,C2,,Cm (the total processing time assigned to each machine so far) so thatCσ(1)Cσ(2)Cσ(m). The algorithm starts with all Ci equal to zero and σ being the identity permutation. However, after each run of the loop given by Steps 8–11, we update σ so that σ(i) 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.

Coffman–Sethi conjecture [2]: For every mZ+, the LD algorithm has a makespan ratio with a worst-case bound equal to5m24m1=5434(4m1).

The authors and Huang [5] constructed a family of instances, proving that the above conjectured ratio cannot be improved for any mZ+. 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 P//Cmax problem. In the P//Cmax problem setting, the simple lower bound on Cmax given by max{p1,j=1npj/m} (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 m4. 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 m4 with k{4m,5m}, it works for all m4 and k4.

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 λr and μr. Therefore, we haveλ1μ1λ2μ2λk1μk1λkμk0.

Given an instance of the FM problem, we denote by tLD the makespan of the LD schedule(s). We use t 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)

  • J. Bruno et al.

    Algorithms for minimizing mean flow time

  • E.G. Coffman et al.

    Algorithms minimizing mean flowtime: schedule-length properties

    Acta Inform.

    (1976)
There are more references available in the full text version of this article.

Cited by (0)

View full text