Parallel machine scheduling with nested job assignment restrictions

https://doi.org/10.1016/j.orl.2009.09.010Get rights and content

Abstract

We derive a polynomial time approximation scheme for a special case of makespan minimization on unrelated machines.

Introduction

Scheduling with job assignment restrictions. Consider n independent jobs J1,,Jn that are to be scheduled on m parallel (but not necessarily identical) machines M1,,Mm. Every job Jj can only be processed on a certain subset M(Jj) of the machines, and on those machines it takes pj time units of uninterrupted processing to complete. All jobs are available for processing at time 0. The goal is to schedule the jobs on the machines such that the maximum job completion time Cmax is minimized. This problem is called scheduling with job assignment restrictions, and we will denote it by Rpij{pj,}Cmax; see Lawler, Lenstra, Rinnooy Kan and Shmoys [1] for more information on the standard three-field scheduling notation.

The approximability behavior of problem Rpij{pj,}Cmax is not fully understood: The results of Lenstra, Shmoys and Tardos [2] yield a polynomial time approximation algorithm with worst case ratio 2 for the more general scheduling problem RCmax; this is also the strongest known positive approximability result for problem Rpij{pj,}Cmax. On the negative side, [2] prove that (unless P=NP) one cannot reach any worst case ratio better than 3/2 for Rpij{pj,}Cmax in polynomial time. Ebenlendr, Krcal and Sgall [3] extend this negative result even to the highly restricted special case where |M(Jj)|=2 holds for all jobs. The exact location of the approximability threshold between 3/2 and 2 is totally unclear, and forms an outstanding open problem in the area of machine scheduling (see for instance Schuurman and Woeginger [4]).

Special cases with ordered and nested machine sets. Hwang, Chang and Lee [5] and Glass and Kellerer [6] discuss special cases of Rpij{pj,}Cmax where the family of sets M(Jj) carries certain nice combinatorial structures. In one of these special cases, the machine sets M(Jj) are totally ordered by inclusion:

For any two jobs Jj and Jk, either M(Jj)M(Jk) or M(Jj)M(Jk).

This special case arises for instance in the assignment of computer programs to processors, where each program has a memory requirement and where each processor has a memory capacity. A program can only be assigned to processors with sufficiently large memories. Clearly, if the processing requirement of Jj is larger than the processing requirement of Jj, then M(Jj)M(Jk). Hwang, Chang and Lee [5] derived a polynomial time approximation algorithm with worst case ratio 21/(m1) for this totally ordered special case. Glass and Kellerer [6] improved the worst case ratio to 3/2, and finally Ou, Leung and Li [7] came up with a polynomial time approximation scheme.

Glass and Kellerer [6] also discuss another special case of Rpij{pj,}Cmax where the machine sets M(Jj) are nested. (Note that the totally ordered special case as discussed above forms a subproblem of the nested special case.)

For any two jobs Jj and Jk, either M(Jj)M(Jk)=, or M(Jj)M(Jk), or M(Jj)M(Jk).

This special case arises for instance in the drying stage of flour mills in the United Kingdom; see Glass and Mills [8]. Glass and Kellerer [6] derive a polynomial time approximation algorithm with worst case ratio 21/m for this nested special case. The existence of a polynomial time approximation scheme for the nested special case is posed as an open research problem in the conclusions section of [6].

Our result. We derive a polynomial time approximation scheme for the special case of Rpij{pj,}Cmax where the machine sets M(Jj) are nested. Our result generalizes the approximation scheme of [7] and answers the open problem of [6]. Our approach is heavily built on the ideas of Hochbaum and Shmoys [9] and Alon, Azar, Woeginger and Yadid [10].

The note is structured as follows. Section 2 summarizes several easy observations on an auxiliary packing problem in trees. Section 3 shows how to simplify a scheduling instance into a so-called rounded instance, and Section 4 shows how to solve this rounded instance in polynomial time. Section 5 wraps things up and presents the approximation scheme.

Section snippets

Trees and packings

Tree structures will play a central role in our investigations. As usual, a rooted tree T=(V,E) is a connected acyclic graph, where the edges in E correspond to father–son relations between the vertices in V. With the exception of one distinguished vertex (that is called the root), every vertex in V has a unique father; the root has no father. The vertices without sons are called leaves. The descendants of a vertex v are vertex v itself, the sons of v, the sons of its sons, and so on.

Every

Definition of the rounded instance

We now return to the scheduling problem, and we consider an arbitrary instance I of the nested special case of Rpij{pj,}Cmax. We enumerate all machine sets M(Jj) occurring in this instance, and we add every missing one-element machine set and also the set {M1,,Mm} to this enumeration. We organize these machine sets in a tree T=(V,E):

  • Every vertex v corresponds to a set of machines M(v) in the enumeration. The leaves correspond to the one-element machine sets, and the root corresponds to {M1,

Solution of the rounded instance

Throughout this section we will assume that the integer α is a fixed constant that does not depend on the input. Our goal is to design a fast algorithm for the rounded instance I#(α). Recall from the preceding section that in such a rounded instance I#(α), all job processing times are integer multiples of A/α2 lying in the range from A/α to A.

We represent subsets of the jobs in instance I#(α) as vectors λ=(λα,,λα2) where the non-negative integer λk denotes the number of jobs in the subset

The approximation scheme

Finally, let us put things together and derive the desired PTAS. Consider some fixed real number ε with 0<ε<1. For a given instance I of Rpij{pj,}Cmax with nested machine sets, we perform the following three steps (S1 through S3) to get an approximation algorithm with worst case ratio 1+ε.

  • (S1)

    Define a positive integer α9/ε. Compute the instance I#(α) from I.

  • (S2)

    Use Theorem 4.2 to solve instance I#(α) to optimality, and call the resulting optimal schedule Σ#.

  • (S3)

    Transform schedule Σ# into a

Acknowledgements

This research was supported by the Netherlands Organisation for Scientific Research (NWO), grant 639.033.403, by the EU Research Project 015964 (AEOLUS: Algorithmic Principles for Building Efficient Overlay Computers) and by BSIK grant 03018 (BRICKS: Basic Research in Informatics for Creating the Knowledge Society).

References (10)

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

Cited by (37)

View all citing articles on Scopus
View full text