Discrete Optimization
Fast approximation algorithms for uniform machine scheduling with processing set restrictions

https://doi.org/10.1016/j.ejor.2017.01.013Get rights and content

Highlights

  • We consider the problem of scheduling n jobs on m uniform machines.

  • The jobs are subject to inclusive or tree-hierarchical processing set restrictions.

  • We propose fast approximation algorithms to solve the problem.

  • It is shown that the algorithms have a worst-case ratio no more than 4/3.

  • The 4/3 bound is achievable in both cases.

Abstract

We consider the problem of nonpreemptively scheduling a set of independent jobs on a set of uniform machines, where each job has a set of machines to which it can be assigned. This kind of restriction is called the processing set restriction. In the literature there are many kinds of processing set restrictions that have been studied. In this paper we consider two kinds: the “inclusive processing set” and the “tree-hierarchical processing set”. Epstein and Levin (2011) have given Polynomial Time Approximation Schemes (PTAS) to solve both classes. However, the running times of their PTAS are rather high. In this paper, we give fast approximation algorithms for both cases and show that they both have a worst-case performance bound of 4/3. Moreover, we show that the bounds are achievable.

Introduction

We consider the problem of nonpreemptively scheduling n independent jobs J={J1,J2,,Jn} on m uniform machines M={M1,M2,,Mm}, where the machines differ in their speeds but not in their functionality. Each job Jj has a processing requirement pj and each machine Mi has a speed si. If job Jj is processed by machine Mi, then it takes pj/si units of real time to complete. Each job Jj has a set of machines MjM to which it can be assigned. Our goal is to find a schedule so that each job Jj is assigned to one of the machines in Mj and that the makespan Cmax  is minimized.

The problem we study belongs to a class of machine scheduling problems with processing set restrictions. As stated in the survey paper by Leung and Li (2016), there are several special forms of processing set restrictions studied by researchers, including “inclusive processing sets”, “nested processing sets”, “interval processing sets”, “tree-hierarchical processing sets”, and “arbitrary processing sets”. In this paper we study the classes of “inclusive processing set” and “tree-hierarchical processing set” restrictions.

The “inclusive processing set” restriction has the property that for each pair of jobs Ji and Jj, either MiMj or MjMi. The “tree-hierarchical processing set” has the property that each machine Mk is associated with a vertex of a tree, and that the processing set of a job Jj is the set of machines composed of its associated vertex as well as all the vertices on the unique path from its associated vertex to the root of the tree. Clearly, the “inclusive processing set” restriction is a special case of “tree-hierarchical processing set” restriction since we can view the machines in “inclusive processing set” restriction as forming a chain. The 3-field notation for “inclusive processing set” with uniform machines is QMj(inclusive)Cmax, while that of “tree-hierarchical processing set” is QMj(tree)Cmax. The problem QMj(inclusive)Cmax is strongly NP-hard, since a special case of the problem, Q∣∣Cmax , is strongly NP-hard.

The problem QMj(inclusive)Cmax has several interesting real-life applications. As noted in the paper by Epstein and Levin (2011), consider the situation where a job must be completed within a certain amount of time once it starts the processing. In this case, each job Jj has a minimum speed level lj, and the job can only be processed by a machine Mk if sklj. That is, the job must be processed by a machine fast enough to complete it within the required time interval. Another application is when we have a set of workers with different skill levels, and a job requires a worker with a minimum skill level to process. A worker with a higher level of expertise can handle a larger set of jobs and is also faster in completing the jobs.

The problem QMj(tree)Cmax also has real-life applications. Consider a company with the following management structure. There is a director who supervises several managers. Each manager supervises several staff members. Most of the jobs can be handled by the staff members, but there are certain jobs that can only be handled by the managers or the director. Moreover, there are other jobs that can only be handled by the director. Thus, we can view the director as the root of the tree, the managers are the descendants of the director, and the staff members are the descendants of the managers. Here we assume that the director is more experienced and efficient than the managers, and the managers are more experienced and efficient than the staff members. Given a set of jobs, we would like to finish the jobs as soon as possible.

Epstein and Levin (2011) give a Polynomial Time Approximation Scheme (PTAS) to solve QMj(inclusive)Cmax. However, the running time of their PTAS is very high. Li and Lee (2016) present an O(mn2log m) time algorithm for the problem QMj(inclusive),rj,pj=pCmax; i.e., a set of equal-processing-time jobs with release times. To the best of our knowledge, there is no fast approximation algorithm to solve the general problem. This paper is a first step towards this direction.

Epstein and Levin (2011) also give a PTAS to solve QMj(tree)Cmax. Again, the running time of their PTAS is very high. Li and Lee (2016) present an O(mn2log m) time algorithm for the problem QMj(tree),rj,pj=pCmax; i.e., a set of equal-processing-time jobs with release times. To the best of our knowledge, there is no fast approximation algorithm to solve the general problem.

We will set up some conventions and notations used throughout this paper. There are m uniform machines M={M1,M2,,Mm}, where machine Mi has speed si > 0. We assume that s1s2sm. (Note that our algorithm may not work if this assumption is not valid.) Furthermore, we assume that s1=1 and si ≥ 1 for all 2 ≤ im. In the case of “tree-hierarchical processing set”, Mm is the root while M1 is a leaf of the tree.

The organization of this paper is as follows. In the next section, we will review the literature of this and related problems. In Section 3, we give the algorithm for “inclusive processing set” and prove that it has a worst-case performance bound of 4/3. In Section 4, we give the algorithm for “tree-hierarchical processing set” and prove that it has a worst-case performance bound of 4/3. Finally, we give some concluding remarks in the last section.

Section snippets

Literature review

The problems studied in this paper are special cases of the unrelated machine scheduling problem (i.e., R∣∣Cmax ). For the problem R∣∣Cmax , Lenstra, Shmoys, and Tardos (1990) give a polynomial-time algorithm with a worst-case bound of 2. Moreover, they show that there is no polynomial-time algorithm with a worst-case bound better than 3/2, unless P = NP. Shchepin and Vakhania (2005) improve the bound to 21/m.

The problem QMj(inclusive)Cmax is a natural generalization of the problem PMj(inclu

Inclusive processing sets

In this section we give a fast approximation algorithm for QMj(inclusive)Cmax. First, we need to set up notations just for this section. There are m uniform machines M={M1,M2,,Mm}, where machine Mi has speed si > 0. We assume that s1s2sm. Let there be z classes of speeds S1<S2<<Sz, and for each class i there are mi machines with speed Si. Without loss of generality, we may assume that S1=1 and Si > 1 for all 2 ≤ iz. Thus, M can be partitioned into z subsets MS1,MS2,,MSz, where the

Tree-hierarchical processing sets

In this section we will give a fast approximation algorithm for QMj(tree)Cmax. We first define some notations that will be used throughout this section. Let M={M1,M2,,Mm} be such that s1s2sm. Without loss of generality, we may assume that s1=1 and sk ≥ 1 for each 2 ≤ km. The root of the tree is Mm and M1 is a leaf of the tree. For each 1 ≤ km, let Jk denote the set of jobs associated with the machine Mk. Note that some of the Jk may be the empty set. For each machine Mk, we define

Conclusion

In this paper we have given fast approximation algorithms for the “inclusive processing sets” and “tree-hierarchical processing sets” cases. Both algorithms have running time O(log P*m*n) and a worst-case bound of 4/3. Moreover, both bounds are achievable.

Our algorithm is not qualified to be called strongly polynomial since the running time is a function of log P. However, we can use the technique developed by Ou et al. (2008) to get a strongly polynomial algorithm. The worst-case bound then

Acknowledgment

The authors would thank the two anonymous referees whose suggestions have greatly improved the readability of the paper. The work of the second author is supported in part by the University Grants Council under grant number PolyU 152148/15E.

References (22)

View full text