Discrete OptimizationFast approximation algorithms for uniform machine scheduling with processing set restrictions
Introduction
We consider the problem of nonpreemptively scheduling n independent jobs on m uniform machines 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 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 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 or . 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 while that of “tree-hierarchical processing set” is . The problem is strongly NP-hard, since a special case of the problem, Q∣∣Cmax , is strongly NP-hard.
The problem 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 sk ≥ lj. 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 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 . However, the running time of their PTAS is very high. Li and Lee (2016) present an O(mn2log m) time algorithm for the problem ; 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 . Again, the running time of their PTAS is very high. Li and Lee (2016) present an O(mn2log m) time algorithm for the problem ; 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 where machine Mi has speed si > 0. We assume that . (Note that our algorithm may not work if this assumption is not valid.) Furthermore, we assume that and si ≥ 1 for all 2 ≤ i ≤ m. 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 .
The problem is a natural generalization of the problem
Inclusive processing sets
In this section we give a fast approximation algorithm for . First, we need to set up notations just for this section. There are m uniform machines where machine Mi has speed si > 0. We assume that . Let there be z classes of speeds and for each class i there are mi machines with speed Si. Without loss of generality, we may assume that and Si > 1 for all 2 ≤ i ≤ z. Thus, can be partitioned into z subsets where the
Tree-hierarchical processing sets
In this section we will give a fast approximation algorithm for . We first define some notations that will be used throughout this section. Let be such that . Without loss of generality, we may assume that and sk ≥ 1 for each 2 ≤ k ≤ m. The root of the tree is Mm and M1 is a leaf of the tree. For each 1 ≤ k ≤ m, let denote the set of jobs associated with the machine Mk. Note that some of the 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)
- et al.
Scheduling with processing set restrictions: PTAS results for several variants
International Journal of Production Economics
(2011) - et al.
A fast preemptive scheduling algorithm with release times and inclusive processing set restrictions
Discrete Optimization
(2009) - et al.
Fast approximation algorithms for job scheduling with processing set restrictions
Theoretical Computer Science
(2010) - et al.
Online scheduling on two uniform machines subject to eligibility constraints
Theoretical Computer Science
(2009) - et al.
Scheduling with processing set restrictions: A survey
International Journal of Production Economics
(2008) - et al.
Scheduling with processing set restrictions: A literature update
International Journal of Production Economics
(2016) - et al.
Scheduling parallel machines with inclusive processing set restrictions and job release times
Europen Journal of Operational Research
(2010) - et al.
Improved bounds for online scheduling with eligibility constraints
Theoretical Computer Science
(2011) - et al.
Online scheduling on two uniform machines to minimize the makespan
Theoretical Computer Science
(2009) - et al.
An optimal rounding gives a better approximation for scheduling unrelated machines
Operations Research Letters
(2005)
Online hierarchical scheduling: An approach using mathematical programming
Theoretical Computer Science
Cited by (6)
Approximation algorithms for batch scheduling with processing set restrictions
2023, Journal of SchedulingHeuristics for parallel machine scheduling with GoS eligibility constraints
2023, International Journal of Applied Science and EngineeringScheduling High Multiplicity Jobs on Parallel Multi-Purpose Machines with Setup Times and Machine Available Times
2022, Asia-Pacific Journal of Operational ResearchScheduling uniform machines with restricted assignment
2022, Mathematical Biosciences and EngineeringPARALLEL-MACHINE SCHEDULING IN SHARED MANUFACTURING
2022, Journal of Industrial and Management OptimizationOptimal bi-criterion planning of rescue and evacuation operations for marine accidents using an iterative scheduling algorithm
2021, Annals of Operations Research