Discrete Optimization
Parallel machine scheduling with speed-up resources

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

Highlights

  • We study scheduling problems where processing times can be reduced via resources.

  • We provide a constant approximation algorithm for the general problem.

  • We provide polynomial time approximation schemes for special cases.

  • We establish a relationship between the two main parameters of the problem.

Abstract

We consider the problem of scheduling with renewable speed-up resources. Given m identical machines, n jobs and c different discrete resources, the task is to process each job non-preemptively on one of the machines so as to minimize the makespan. In our problem, a job has its original processing time, which could be reduced by utilizing one of the resources. As resources are different, the amount of the time reduced for each job is different depending on the resource it uses. Once a resource is being used by one job, it cannot be used simultaneously by any other job until this job is finished, hence the scheduler should take into account the job-to-machine assignment together with the resource-to-job assignment. We observe that, the classical unrelated machine scheduling problem is actually a special case of our problem when m=c, i.e., the number of resources equals the number of machines. Extending the techniques for the unrelated machine scheduling, we give a 2-approximation algorithm when both m and c are part of the input. We then consider two special cases for the problem, with either m or c being a constant, and derive PTASes (Polynomial Time Approximation Schemes) respectively. We also establish the relationship between the two parameters m and c, through which we are able to transform the PTAS for the case when m is constant to the case when c is a constant. The relationship between the two parameters reveals the structure within the problem, and may be of independent interest.

Introduction

We consider a natural generalization of the classical scheduling problem in which there are multiple different resources available. Each job has an original processing time which may be reduced by utilizing one of the resources. Since resources are different, the amount of the time reduced for each job is different depending on the resource it uses. It is a hard constraint that each resource is not used simultaneously by multiple jobs at the same time, that is, once a specific resource is being used by some job, it becomes unavailable to all the other jobs until this job is completed. Consequently, a good schedule not only needs to choose the right machine and resource for each job but also needs to sequence jobs on each machine in a proper way.

Our problem arises naturally in production logistics where job processing times are not constant but may be reduced by allocating resources, such as additional energy, catalysts and manpower, to the job operations. In general, this framework is called scheduling with controllable job processing times and has received much study in literature. We refer the reader to a nice survey on this topic (Shabtay & Steiner, 2007). It also finds applications in computer science where the discrete resources may represent additional cache or memory which can be utilized to reduce the processing time of tasks (Chen, Ye, & Zhang, 2014). Our problem also has its own right from a theoretical point of view. As we will provide details later, this problem is a special case of the general multiprocessor task scheduling problem (P|set|Cmax), which does not admit any constant ratio approximation algorithm (Chen & Miranda, 2001), and meanwhile a generalization of the unrelated machine scheduling problem (R||Cmax), for which a 2-approximation algorithm stands for more than two decades (Lenstra, Shmoys, & Tardos, 1990). As an intermediate model, the study of our problem may help in the understanding of the relationship between these two fundamental scheduling problems.

We give a formal description of our model. There are m parallel identical machines, n jobs and c discrete resources. Each job j has a processing time pj and has to be processed non-preemptively on one of the machines. This processing time might be reduced by utilizing a resource. Specifically, when resource k is allocated to job j then its processing time becomes pjk. At most one resource could be allocated to a job at a time, and the processing intervals of the jobs that use the same resource must not overlap. We refer to this requirement as the main resource constraint. Throughout this paper, we do not necessarily require pjk ≤ pj. We assume all parameters take integral values.

As we have described, in our model jobs could be processed with or without a resource. However, we always assume that each job is processed with a resource unless otherwise specified. Such an assumption causes no loss of generality since we could always introduce m dummy resources (that could not alter the processing time of any job), one for each machine, and jobs scheduled on a machine without a resource could then be viewed as processed with the dummy resource corresponding to this machine. This assumption works for the case that c, the number of resources, is part of the input. For the case that c is a constant, we return to the original assumption that the usage of resources is optional.

Related work One special case of our problem with c=1 and m=2 is considered by Xu et al. (Xu, Chen, Ye, & Zhang, 2011), who provide an FPTAS (Fully Polynomial Time Approximation Scheme). Another related problem is considered by Kellerer and Strusevich (2008), in which c=1 again, but the machines are dedicated, i.e., for each job the processing machine is known in advance. For the case when the number of machines is a constant, they prove that the problem is NP-hard and admits a PTAS. For the case when the number of machines is part of the input, they give a 3/2-approximation algorithm.

Another closely related model is that a job can be given several resources and yet all resources are identical, so the processing time of each job does not depend on which resource but rather depends on the number of resources it uses. For this problem on unrelated machines, Grigoriev, Sviridenko, and Uetz (2007) give a (3.75+ɛ)-approximation algorithm. On identical machines, Kellerer (2008) gives a (3.5+ɛ)-approximation algorithm, which is improved very recently by Jansen, Maack, and Rau (2016) to an asymptotic PTAS.

Our problem is a generalization of the classical unrelated machine scheduling problem, denoted by R||Cmax, in which each job j has a (machine dependent) processing time pij if it is processed on machine i. Indeed, if the number of machines is equal to the number of resources, i.e. m=c, and pj=, then our problem is equivalent to the unrelated machine scheduling problem. To see why, notice that given any feasible solution of our problem, we can rearrange jobs so that all jobs that use the same resource, say, k, are scheduled on machine k. By doing so the makespan is not increased, and meanwhile the new solution is a feasible solution of the unrelated machine scheduling problem in which machine k is one of the unrelated machines which processes job j with time pjk. It is also not difficult to observe that pj= could be replaced by pj>i,jpij, as in this case a schedule that does not process job j with any resource is never optimal. For the unrelated machine scheduling problem, Lenstra, Shmoys and Tardos provided a 2-approximation algorithm if m is part of the input, and showed that no approximation algorithm could achieve a ratio strictly better than 1.5, assuming P ≠ NP (Lenstra et al., 1990). In 2005, a slightly better algorithm with the approximation ratio of (21/m) was derived by Shchepin and Vakhania (2005). It remains as a major open problem whether an approximation algorithm with a ratio strictly smaller than 2 exists for R||Cmax. If m is a constant, an FPTAS exists and its current best running time is O(n)+(logm/ɛ)O(mlogm) (Jansen, & Mastrolilli, Jansen, Porkolab, 2001).

Meanwhile, our problem is also a special case of the general multiprocessor task scheduling problem, denoted by P|set|Cmax, in which each task (job), say, j, could be processed simultaneously on multiple machines, and its processing time is pj, S where S is the set of machines we choose to process it. To see why our problem is a special case, we view each resource as a special machine which we call a resource machine, and each job could either be processed on a normal machine with processing time pj, or processed simultaneously on a normal machine i and some resource machine k, with pj,{i,k}=pjk. Thus, our problem could be transformed to a multiprocessor task scheduling problem with m+c machines. There is a PTAS for the general multiprocessor task scheduling problem if the number of machines is a constant, and no constant ratio approximation algorithm exists if the number of machines is part of the input (Chen, Miranda, 2001, Jansen, Porkolab, 1999). This result implies that for our problem, if both the number of resources and the number of machines are constants, then there is a PTAS.

Our problem also falls into the general category of scheduling with controllable job processing times, where job processing times are not constant but may vary due to different conditions. Depending on how job processing times can be changed, various different models are studied in literature. Reducing of the processing times due to the allocation of resources, including our problem, is one of them. Jansen, Mastrolilli, and Solis-Oba (2005) studied the scheduling problem where reducing the processing time of a job incurs some cost that is a function of the processing time. Nip, Wang, and Wang (2016) studied the problem where the job processing times may vary due to a set of linear constraints. The reader is referred to a survey (Shabtay & Steiner, 2007) for more different models.

Our contribution We study the scheduling problem with speed-up resources. As we have mentioned, it is an intermediate model between the general model P|set|Cmax and the classical unrelated machine scheduling R||Cmax. We hope our research could bridge the study of these two well-known models and leads to a better understanding of them.

In this paper, we give the first 2-approximation algorithm when the number of machines m and resources c are both part of the input. We then consider two special cases with either m or c being a constant, and provide PTASes, respectively.

For the general case, we observe that the natural LP (Linear Programming) formulation of the problem has too many constraints, whereas its extreme point solution may split too many jobs which causes the classical rounding technique of Lenstra et al. (1990) inapplicable. To handle this, the key idea is to iteratively remove constraints from the LP program. We will iteratively modify the fractional solution such that either we get a new solution with fewer split jobs (which is the same as the traditional rounding technique), or we get a new solution for which we need fewer constraints to characterize it.

Given the lower bound of 1.5ϵ on the approximation ratio for the unrelated machine scheduling problem R||Cmax, and hence also for our problem, PTASes are only possible for special cases. We first consider the case when m is a constant and present a PTAS. To achieve this, we first determine (through enumeration) the scheduling of a constant number of jobs, and then handle the scheduling of remaining jobs by formulating it as an LP program. We prove that, the LP program we construct has a special structure which enforces that only a constant number of constraints, among its huge number (non-constant) of constraints, could become tight and correspond to an extreme point solution. Using this fact, we are able to make use of the classical rounding technique by Lenstra et al. (1990) to derive a PTAS.

We then consider the case when c is a constant. We establish an interesting relationship between this special case and the case when m is a constant. Indeed, we show that it suffices to consider solutions where all jobs that use resources are scheduled only on O(c) machines. Thus, this special case is a combination of scheduling with resources on O(c) machines, together with the classical scheduling without resources on the remaining mO(c) machines.

Section snippets

General case

In this section, we consider the problem when the number of machines and resources, i.e., m and c, are both part of the input and give a 2-approximation algorithm. Recall that we can assume every job is processed with one resource.

We start with a natural LP formulation of this problem. Let xijk=1 denote that job j is processed on machine i with resource k, and xijk=0 otherwise. We first ignore the main resource constraint and establish the following LPr, i.e., in LPr different jobs may use the

The special case with a constant number of machines

In this section, we show that the problem admits a PTAS if the number of machines, m, is a given constant. Again, we assume that every job uses exactly one resource.

Let p¯j=min{pj1,,pjc} be the shortest possible processing time of job j and we call it the critical processing time. The resource with which the processing time of job j achieves p¯j is then called the critical resource of j (ties are broken arbitrarily). We sort jobs so that p¯1p¯2p¯n. Let q ≤ n be some fixed number, which

The special case with a constant number of resources

In this section we assume that each job could be processed with or without a resource. We show that the problem when c is a constant admits a PTAS. The following lemma, which characterizes the relationship between the two parameters m and c, is the key to the algorithm.

Lemma 8

Given any positive integer λ=1/ϵ, if there is a feasible solution with makespan T and m > 2cλ, then there exists a feasible solution with makespan T(ϵ+1) and all the jobs that use resources are distributed on at most 2

Conclusion

We study the scheduling problem in which job processing times could be reduced by utilizing speed-up resources. We provide a 2-approximation algorithm for the general problem and PTASes for the special cases when either the number of machines or the number of resources is a constant. It is interesting to consider even more general models. Specifically, in our problem, the underlying scheduling problem is P||Cmax and there are speed-up resources. It is an interesting open problem whether an O

Acknowledgments

We thank Janer Chen for pointing out the relationship between the problem we consider and Pm|set|Cmax and other useful communications.

References (19)

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

Cited by (6)

An extended abstract appeared in APPROX-RANDOM 2016.

View full text