The Preemptive Resource Allocation Problem

11/18/2018 ∙ by Kanthi Sarpatwar, et al. ∙ Technion New Jersey Institute of Technology ibm 0

We revisit a classical scheduling model to incorporate modern trends in data center networks and cloud services. Addressing some key challenges in the allocation of shared resources to user requests (jobs) in such settings, we consider the following variants of the classic resource allocation problem (RAP). The input to our problems is a set J of jobs and a set M of homogeneous hosts, each has an available amount of some resource. A job is associated with a release time, a due date, a weight, and a given length, as well as its resource requirement. A feasible schedule is an allocation of the resource to a subset of the jobs, satisfying the job release times/due dates as well as the resource constraints. A crucial distinction between classic RAP and our problems is that we allow preemption and migration of jobs, motivated by virtualization techniques. We consider two natural objectives: throughput maximization (MaxT), which seeks a maximum weight subset of the jobs that can be feasibly scheduled on the hosts in M, and resource minimization (MinR), that is finding the minimum number of (homogeneous) hosts needed to feasibly schedule all jobs. Both problems are known to be NP-hard. We first present a Ω(1)-approximation algorithm for MaxT instances where time-windows form a laminar family of intervals. We then extend the algorithm to handle instances with arbitrary time-windows, assuming there is sufficient slack for each job to be completed. For MinR we study a more general setting with d resources and derive an O( d)-approximation for any fixed d ≥ 1, under the assumption that time-windows are not too small. This assumption can be removed leading to a slightly worse ratio of O( d^* T), where T is the maximum due date of any job.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

We revisit a classical scheduling model to incorporate modern trends in data center networks and cloud services. The proliferation of virtualization and containerization technologies, along with the advent of increasingly powerful multi-core processors, has made it possible to execute multiple virtual machines (or jobs) simultaneously on the same host, as well as to preempt and migrate jobs with relative ease. We address some fundamental problems in the efficient allocation of shared resources such as CPU cores, RAM, or network bandwidth to several competing jobs. These problems are modeled to exploit multi-job execution, facilitate preemption and migration while respecting resource and timing constraints. Typically, the infrastructure service providers are oversubscribed and therefore, the common goals here include admission control of jobs to maximize throughput, or minimizing the additional resource required to process all jobs.

The broad setting considered in this paper is the following. Suppose we are given a set of jobs that need to be scheduled on a set of identical hosts , where each host has a limited amount of one or more resources. Each job has release time , due date , and length , along with a required amount of the resource ( for multiple resources). A job can be preempted and migrated across hosts but cannot be processed simultaneously on multiple hosts, i.e., at any given instant of time a job can be processed by at most one host. However, multiple jobs can be processed by any given host, at any given time, as long as their combined resource requirement does not exceed the available resource. As mentioned above, we consider two commonly occurring objectives, namely, throughput maximization and resource minimization.

In the maximum throughput (MaxT) variant, we are given a set of homogeneous hosts and a set of jobs , such that each job has a profit and attributes . The goal is to find a subset of jobs of maximum profit that can be feasibly scheduled on . This problem can be viewed as a preemptive variant of the classic resource allocation problem (RAP[28, 11, 8, 5].

In the resource minimization (MinR) variant, we assume that each job

has a resource requirement vector

as one of the attributes, where is the number of available resources. W.l.o.g., we assume that each host has a unit amount of each of the resources. A schedule that assigns a set of jobs to a host at time is feasible if . Given a set of jobs with attributes , we seek a set of (homogeneous) hosts of minimum cardinality such that all of the jobs can be scheduled feasibly on . This problem is a generalization of the classic vector packing (VP) problem, in which a set of -dimensional items needs to be feasibly packed into a minimum number of -dimensional bins of unit size in each dimension, i.e., the vector sum of all the items packed into each bin has to be less than or equal to . Any instance of VP can be viewed as an instance of MinR with , and for job .

Another application of this general scheduling setting relates to the allocation of space and time to advertisements by online advertisement platforms (such as Google or Facebook). In the ad placement problem [14, 18] we are given a schedule length of time slots and a collection of ads that need to be scheduled within this time frame. The ads must be placed in a rectangular display area whose contents can change in different time slots. All ads share the same height, which is the height of the display area, but may have different widths. Several ads may be displayed simultaneously (side by side), as long as their combined width does not exceed the width of the display area. In addition, each advertisement specifies a display count (in the range ), which is the number of time slots during which the ad must be displayed. The actual time slots in which the advertisement will be displayed may be chosen arbitrarily by the scheduler, and, in particular, need not be consecutive. Suppose that each advertisement is associated with some positive profit, and the scheduler may accept or reject any given ad. A common objective is to schedule a maximum-profit subset of ads within a display area of given width. Indeed, this problem can be cast as a special case of MaxT with a single host, where all jobs have the same release time and due date.

1.1 Prior Work

The classical problem of preemptively scheduling a set of jobs with attributes on a single machine so as to maximize throughput can be cast as a special case of MaxT with a single host, where each job requires all of the available resource. Lawler [25] showed that in this special case MaxT admits a PTAS, and the problem is polynomially solvable for uniform job weights. For multiple hosts (i.e., ), this special case of MaxT ( for all ) admits a -approximation, for any fixed . This follows from a result of Kalyanasundaram and Pruhs [22].

As mentioned earlier, another special case of MaxT was studied in the context of advertisement placement. The ad placement problem was introduced by Adler et al. [1] and later studied in numerous papers (see, e.g., [14, 18, 15, 24, 23] and the comprehensive survey in [27]). Freund and Naor [18] presented a -approximation for the maximum profit version, namely, for MaxT with a single host and the same release time and due date for all jobs.

Fox and Korupula [17] recently studied our preemptive scheduling model, with job attributes , under another popular objective, namely, minimizing weighted flow-time. Their work differs from ours in two ways: while they focus on the online versions, we consider our problems in an offline setting. Further, as they note, while the throughput and resource minimization objectives are also commonly considered metrics, their techniques only deal with flow-time. In fact, these objectives are fundamentally different and we need novel algorithms to tackle them.

The non-preemptive variant of MaxT, known as the resource allocation problem (RAP), was introduced by Phillips et al. [28], and later studied by many authors (see, e.g., [7, 6, 8, 9, 20, 11] and the references therein).***RAP is also known as the bandwidth allocation problem. Chakaravarthy et al. [9] consider a generalization of RAP and obtain a constant approximation based on a primal-dual algorithm. We note that the preemptive versus non-preemptive problems differ quite a bit in their structural properties.

As mentioned above, MinR generalizes the classic vector packing (VP) problem. The first non-trivial -approximation algorithm for VP was presented by Chekuri and Khanna [10], for any fixed . This ratio was improved by Bansal, Caprara and Sviridenko [3] to a randomized algorithm with asymptotic approximation ratio arbitrarily close to . Bansal, Eliás and Khan [4] recently improved this ratio further to . A “fractional variant” of MinR problem was considered by Jansen and Porkolab [21]

, where time was assumed to be continuous. For this problem, in the case of a single host, they obtain a polynomial time approximation scheme (PTAS), by solving a configuration linear program (rounding the LP solution is not necessary because time is continuous in their case).

Resource minimization was considered also in the context of the ad placement problem. In this variant, all ads must be scheduled, and the objective is to minimize the width of the display area required to make this possible. Freund and Naor [18] gave a -approximation algorithm for the problem, which was later improved by Dawande et al. [15] to . This implies a -approximation for MinR instances with , where all jobs have the same release time and due date. We note that this ratio can be slightly improved, using the property that for all . Indeed, we can schedule the jobs to use the resource, such that the total resource requirements at any two time slots differ at most by one. Thus, the total amount of resource required at any time exceeds the optimum, , at most by one unit, implying the jobs can be feasibly scheduled on hosts.

Another line of work relates to the non-preemptive version of MinR, where and the requirement of each job is equal to (see, e.g. [13, 12]); thus, at most one job can be scheduled on each host at any time.

1.2 Contributions and Techniques

Before summarizing our results, we define the notion of slackness. Denote the time window for processing job by , and let denote the length of the interval. Throughout the discussion, we assume that the time windows are large enough, namely, there is a constant , such that for any job . Such an assumption is quite reasonable in scenarios arising in our applications. We call the slackness parameter of the instance.

For the MaxT problem, we present (in Section 3) an approximation algorithm. As mentioned earlier, the non-preemptive version of this problem is the classic resource allocation problem (RAP). To see the structural differences between the non-preemptive and preemptive versions, we consider their natural linear programming relaxations. In the case of RAP, it is sufficient to have a single indicator variable for each job and time slot to represent its start time. This allows the application of a natural randomized rounding algorithm, where job is scheduled to start at time

with probability

. On the other hand, in MaxT, a job can be preempted several times; therefore, each job requires multiple indicator variables. Further, these variables must be rounded in an all-or-nothing fashion, i.e., either we schedule all parts of a job or none of them. Our approach to handle this situation is to, somewhat counter-intuitively, “dumb down” the linear program by not committing the jobs to a particular schedule; instead, we choose a subset of jobs that satisfy certain knapsack constraints and construct the actual schedule in a subsequent phase.

We first consider a laminar variant of the problem, where the time windows for the jobs are chosen from a laminar family of intervals.See the formal definition in Section 2. This setting includes several important special cases, such as all jobs are released at but have different due dates, or jobs are released at different times, but all must be completed by a given due date. Recall that is the number of hosts. Our result for the laminar case is a -approximation algorithm, assuming that the slackness parameter satisfies . Using a simple transformation of an arbitrary instance to laminar, we obtain a -approximation algorithm for general instances, assuming that . Our results imply that as decreases, the approximation ratio approaches and for the laminar and the general case, respectively.

Subsequently, we tighten the slackness assumption further to obtain an approximation algorithm for any constant slackness for the laminar case and any constant for the general case. In the special case where the weight of the job is equal to its area, we extend an algorithm due to Chen, Hassin and Tzur [11] to obtain an approximation guarantee for the general case with no assumption on slackness.

Our algorithm for the laminar case relies on a non-trivial combination of a packing phase and a scheduling phase. While the first phase ensures that the output solution has high profit, the second phase guarantees its feasibility. To facilitate a successful completion of the selected jobs, we formulate a set of conditions that must be satisfied in the packing phase. Both phases make use of the structural properties of a laminar family of intervals. In the packing phase, we apply our rounding procedure (for the LP solution) to the tree representation of the intervals.This procedure bears some similarity to the pipage rounding technique of [2]. We further use this tree in the scheduling phase, to feasibly assign the resource to the selected jobs in a bottom-up fashion. Our framework for solving MaxT is general, and may therefore find use in other settings of non-consecutive resource allocation.

For the MinR problem, we obtain (in Section 4) an -approximation algorithm for any constant , under a mild assumption that any job has a window of size , where . We show that this assumption can be removed, leading to a slight degradation in the approximation factor to , where is the smallest integer such that . Our approach builds on a formulation of the problem as a configuration LP, inspired by the works of [3, 16]. However, we quickly deviate from these prior approaches, in order to handle the time-windows and the extra constraints. Our algorithm involves two main phases: a maximization phase and residual phase. Roughly speaking, a configuration is a subset of jobs that can be feasibly assigned to a host at a given time slot . For each , we choose configurations with probabilities proportional to their LP-values. In this phase, jobs may be allocated the resource only for part of their processing length. In the second phase, we construct a residual instance based on the amount of time each job has been processed. A key challenge is to show that, for any time window , the total “area” of jobs left to be scheduled is at most of the original total area. We use this property to solve the residual instance.

2 Preliminaries

We start with some definitions and notation. For our preemptive variants of RAP, we assume w.l.o.g. that each host has a unit amount of each resource. We further assume that time is slotted. We allow non-consecutive allocation of a resource to each job, as well as job migration. Multiple jobs can be assigned to the same machine at a given time but no job can be processed by multiple machines at the same time. Formally, we denote the set of jobs assigned to host at time by . We say that job is completed if there are time slots in which is allocated its required amount of the resource on some host. A job is completed if . Let be the latest due date of any job.

In MaxT, each job has a resource requirement . An assignment of a subset of jobs to the hosts in is feasible if each job is completed, and for any time slot and host , , i.e., the sum of requirements of all jobs assigned to host is at most the available resource.

For the MinR variant, we assume multiple resources. Thus, each job has a resource requirement vector , for some constant . Further, each host has a unit amount of each of the resources. An assignment of a set of jobs to a host at time is feasible if .

Let denote the total resource requirement (or, area) of job and refer to the quantity as the density of job . Finally, a set of intervals is laminar if for any two intervals and , exactly one of the following holds: , or .

3 Throughput Maximization

We first consider the case where forms a laminar family of intervals. In Section 3.1, we present an -approximation algorithm for the laminar case when . Following this, we describe (in Section 3.2) our constant approximation for the general case for . We then show, in Section 3.3, how to tighten the results to any constant slackness parameter (i) in the laminar case (ii) in the general case. As an interesting corollary, we obtain an -approximation algorithm for the general MaxT problem with no slackness assumption. Further, we show that in the special case of maximum utilization (i.e., the profit of each job equals its “area”), we obtain an guarantee with no assumption on the slackness.

3.1 The Laminar Case

Our algorithm proceeds in two phases. While the first phase ensures that the output solution has high profit, the second phase guarantees its feasibility. Specifically, let be a parameter (to be determined).

In Phase 1, we find a subset of jobs satisfying a knapsack constraint for each . Indeed, any feasible solution guarantees that the total area of jobs within any time-window is at most . Our knapsack constraints further restrict the total area of jobs in to some fraction of . We adopt an LP-rounding based approach to compute a subset that is optimal subject to the further restricted knapsack constraints. (We remark that a dynamic programming approach would work as well. However, such an approach would not provide us with any intuition as to how an optimal solution for the further restricted instance compares with the optimal solution of the original instance.)

In Phase 2 we allocate the resource to the jobs in , by considering separately each host at a given time slot as a unit-sized bin and iteratively assigning each job to a subset of such available bins, until has the resource allocated for distinct time slots. An outline of the two phases is given in Algorithm 1.

1:Set of jobs , hosts and a parameter
2:Subset of jobs and a feasible assignment of to the hosts in
3:Phase 1: Select a subset , such that for each :
4:
5:Phase 2: Find a feasible allocation of the resource to the jobs in
Algorithm 1 Throughput maximization outline

Phase 1:  The algorithm starts by finding a subset of jobs such that for any : . We solve the following LP relaxation, in which we impose stricter constraint on the total area of the jobs assigned in each time window .

Rounding the Fractional Solution: Suppose is an optimal fractional solution for the LP. Our goal is to construct an integral solution . We refer to a job with as a fractional job, and to the quantity as its fractional area. W.l.o.g., we may assume that for any interval , there is at most one job with such that , i.e., it is fractional. Indeed, if two such jobs exist, then the fractional value of the higher density job (breaking ties arbitrarily) can be increased to obtain a solution no worse than the optimal. Note, however, that there could be fractional jobs with .

We start by setting for all . Consider the tree representation of , which contains a node (also denoted by ) for each , and an edge between nodes corresponding to and , where , if there is no interval such that .§§§Throughout the discussion we use interchangeably the terms node and interval when referring to a time-window . Our rounding procedure works in a bottom-up fashion. As part of this procedure, we label the nodes with one of two possible colors: gray and black. Initially, all leaf nodes are colored black, and all internal nodes are colored gray. The procedure terminates when all nodes are colored black. A node is colored as black if the following property holds:

Property 1.

For any path from to a leaf there is at most one fractional job such that lies on .

We note that the property trivially holds for the leaf nodes. Now, consider a gray interval with children , each colored black. Note that is well defined because leaf intervals are all colored black. If there is no fractional job that has as its time-window, Property 1 follows by induction, and we color black. Assume now that is a fractional job that has as its time-window (i.e., ). If there is no other fractional job that has its time-window (strictly) contained in , Property 1 is trivially satisfied. Therefore, assume that there are other fractional jobs that have their time-windows (strictly) contained in . Now, we decrease the fractional area (i.e., the quantity ) of by and increase the fractional area of jobs in the set by for job , such that . Formally, we set and . We choose these increments such that either becomes , or for each , becomes . Clearly, in both scenarios, Property 1 is satisfied, and we color black.

When all nodes are colored black, we round up the remaining fractional jobs. Namely, for all jobs such that , we set . It is important to note that by doing so we may violate the knapsack constraints. However, in Theorem 1, we bound the violation.

Theorem 1.

Suppose is a laminar instance of MaxT with optimal profit and : . For any , the subset , obtained as above, satisfies , and for any , .

Proof.

We first observe that any optimal solution for the LP satisfies: . Indeed, consider an optimal solution for the instance . We can construct a fractional feasible solution for the LP by setting if ; otherwise, . Clearly, is a feasible solution for the LP with profit .

Consider an integral solution , obtained by applying the rounding procedure on . We first show that . To this end, we prove that . Suppose we decrease the fractional area of a job by an amount , i.e., we set . By the virtue of our procedure, we must simultaneously increase the fractional area of some subset of jobs , where for each we have . Further, the combined increase in the fractional area of the jobs in is the same . Now, we observe that the density of job (i.e., ) cannot be higher than any of the jobs in . Indeed, if has density strictly lower than , then the optimal solution can be improved by decreasing the fractional area of by some while increasing that of by the same amount (it is easy to see that no constraint is violated in this process) – a contradiction. Therefore, our rounding procedure will never result in a loss, and .

We now show that, for each , . First, observe that for any gray interval the total fractional area is conserved. This is true because there is no transfer of fractional area from the subtree rooted at to a node outside this subtree until is colored black. Now, consider an interval that is colored black. We note that for any job with , our algorithm ensures that , i.e., it creates no new fractional jobs. Consider the vector when the interval is converted from gray to black. At this stage, we have that the total (fractional) area packed in the subtree rooted at is . Let denote the set of all fractional jobs that have their time-windows contained in (i.e., ). We claim that the maximum increase in by the end of the rounding procedure is at most . This holds since our procedure does not change the variables . Thus, the maximum increase in the total area occurs due to rounding all fractional jobs into complete ones, after all nodes are colored black.

To complete the proof, we now show that the total area of the fractional jobs in the subtree rooted at satisfies . We prove this by induction on the level of node . Clearly, if is a leaf then the claim holds, since there can exist at most one fractional job in , and . Suppose that are the children of . If there is a fractional job with then, by Property 1, there are no other fractional jobs with time-windows contained in . Hence, . Suppose there is no fractional job with ; then, by the induction hypothesis: for all . Further, and . ∎

Let be an optimal solution for satisfying

for some . Then it is easy to verify that any optimal solution for the LP satisfies: . Hence, we have

Corollary 1.

Suppose is a laminar instance of MaxT, such that . Let be a subset of jobs of total profit satisfying : , for some . Then, for any , there exists a subset satisfying , such that , .

Phase 2:  We refer to host at time as a bin . In the course of the allocation phase, we label a bin with one of three possible colors: white, gray or black. Initially, all bins are colored white. We color a bin gray when some job is assigned to host at time , and color it black when we decide to assign no more jobs to this bin. Our algorithm works in a bottom-up fashion and marks an interval as done when it has successfully completed all the jobs with . Consider an interval such that any has already been marked done.

Let be a job with time-window , that has not been processed yet. To complete job , we must pick distinct time slots in and assign it to a bin in each slot. Suppose that we have already assigned the job to slots so far. Denote by avail the subset of time slots where has not been assigned yet. We pick the next slot and bin as shown in Algorithm 2.

1:if there exists a gray bin in avail then
2:     let be the set of jobs assigned to this bin
3:     if  then
4:         assign to host at time
5:     else if there exists a white bin in avail then
6:         assign to host at time .
7:         color and black
8:         pair up
9:     else
10:         report fail
11:     end if
12:else if there exists a white bin in avail then
13:     assign to host at time
14:     color the bin gray
15:else
16:     report fail
17:end if
Algorithm 2 Resource allocation to job in a single time slot
Theorem 2.

For any , there exists a -approximation algorithm for the laminar MaxT problem, assuming that for all .

Proof.

Given an instance and a parameter , let denote the optimal profit. We apply Theorem 1 to find a subset of jobs of profit , such that for any : . We now show that there is a feasible resource assignment to the jobs in for . Clearly, this would imply the theorem.

We show that for the above value of Algorithm 2 never reports fail, i.e., the resource is feasibly allocated to all jobs in . Assume towards contradiction that Algorithm 2 reports fail while assigning job . Suppose that was assigned to bins before this fail. For , we say that bin is bad if either is colored gray, or has been assigned to some bin in the same time slot. We first show that the following invariant holds, as long as no job such that has been allocated the resource: the number of bad bins while processing job is at most . Assuming that the claim is true in each of the child intervals of , , before any job with time window is allocated the resource, we have the number of bad bins = number of gray bins is at most . Now, consider the iteration in which we assign to host at time . If is a gray bin, then the number of bad bins cannot increase. On the other hand, suppose was white before we assign . If there are no gray bins in , then the number of bad bins is at most . Suppose there exist some gray bins, and consider those bins of the form such that job has not been assigned to any host at time . If there are no such bins, then again the number of bad bins is at most . Otherwise, we must have considered one such gray bin and failed to assign to host at time . By the virtue of the algorithm, we must have colored both and black. Thus, the number of bad bins does not increase, and our claim holds. Now, since we pair the black bins only if + , the total number of black bins . Hence, the total number of bins that are black or bad is . Now, setting , there should be at least one bin that is neither black nor bad. But in this case, we could have assigned to host at time , which is a contradiction to the assumption that the algorithm reports a fail. ∎

For convenience, we restate the claim shown in the proof of Theorem 2.

Corollary 2.

Let be a laminar instance where , for . Let be a subset of jobs, such that for any : , where . Then, there exists a feasible resource assignment to the jobs in .

3.2 The General Case

We use a simple transformation of general instances of MaxT into laminar instances and prove an -approximation guarantee. Let denote the set of all time-windows for jobs in , i.e., . We now construct a laminar set of intervals and a mapping . Recall that . The construction is done via a binary tree whose nodes correspond to intervals . The construction is described in Algorithm 3.

1:Job set and
2:Laminar set of intervals and a mapping
3:let be the root node of tree
4:while  a leaf node in such that  do
5:     add to two nodes and as the children of
6:end while
7:let be the set of intervals corresponding to the nodes of
8:For each , let , where is the largest interval in contained in , breaking ties by picking the rightmost interval.
Algorithm 3 Transformation into a laminar set
Lemma 1.

In Algorithm 3, the following properties hold:

  1. For any , .

  2. For , let , i.e., the union of all time-windows in that are mapped to . Then, .

Proof.

To prove the first property, it suffices to show that cannot completely contain consecutive intervals in that are at the same level as . Indeed, this would imply that cannot intersect more than consecutive intervals, and therefore . Now, suppose contains at least such consecutive intervals. Then, by the virtue of our algorithm, is the rightmost interval. Let be the parent of . Two cases arise:

Case 1: is a left child of . Consider the two other consecutive intervals at the same level as that are contained in . Observe that these two intervals are siblings; therefore, their parent (which is also in ) is also contained in . This is a contradiction to the assumption that is the largest interval in contained in .

Case 2: is a right child of . We observe that the sibling of must also be contained in , implying that is contained in , a contradiction.

We now prove the second property. For any , let (resp. ) be the leftmost (resp. rightmost) interval in such that (resp. ); then, . Consider the intervals and . As argued above, cannot contain 3 consecutive intervals in at the same level as Thus, . Also, ; otherwise, there is an interval to the right of of the same size that can be mapped to . Thus, . Now, the claim follows by observing that . ∎

Theorem 3.

For any , there exists a -approximation algorithm for MaxT , assuming that for all .

Proof.

Given an instance of MaxT with slackness parameter , we first use Algorithm 3 to obtain a laminar set of intervals and the corresponding mapping . Consider a new laminar instance , constructed by setting . Note that if is a feasible solution for this new instance, the corresponding set is a feasible solution for the original instance. Let denote the slackness parameter for the new instance. We claim that . Assume this is not true, i.e., there exists a job , such that ; however, by Lemma 1, we have . A contradiction. Now, suppose is an optimal solution of total profit for the original (non-laminar) instance. Consider the corresponding subset of jobs . By Lemma 1, for any , . It follows that, for any , .

Now, we use Corollary 1 for the laminar instance, taking , and . Then, for any , there exists of total profit , such that , . By Corollary 2, there is a feasible assignment of the resource to the jobs in for . Taking

we have the approximation ratio , for any .

We now return to the original instance and take for the solution the set . ∎

3.3 Eliminating the Slackness Requirements

In this section we show that the slackness requirements in Theorems 2 and 3 can be eliminated, while maintaining a constant approximation ratio for MaxT . In particular, for laminar instances, we show below that Algorithm 1 can be used to obtain a polynomial time -approximation for any constant slackness parameter . For general MaxT instances, this leads to an -approximation for any constant . We also show a polynomial time -approximation algorithm for general MaxT using no assumption on slackness. We use below the next result, for instances with ‘large’ resource requirement.

Lemma 2.

For any there is an -approximation for any instance of MaxT satisfying .

Proof.

Given an instance , we first round down the resource requirement (or, height) of each job to the nearest value of the form , for some fixed and integer . We now partition the jobs into classes, such that the jobs in each class have the same rounded height. For a class with job height , let . We define for this class the instance of MaxT  in which and for all .

Recall that Lawler [25] gave a PTAS for MaxT on a single host, where for all . Consider an algorithm for MaxT on , which proceeds as follows. We schedule iteratively the jobs in on hosts . Let be the set of jobs scheduled on hosts , and . In iteration , we use the PTAS of [25] for the set of jobs . We note that the resulting schedule uses no migrations. By a result of [22], this iterative algorithm yields a ratio of to the profit of an optimal schedule for MaxT (which may use migrations).

Let be the profit of the solution obtained for . Then we choose the solution set for the instance which maximizes the profit. That is, . We note that since the job heights are rounded down, transforming back to the original job heights may require to reduce the number of hosts, at most by factor . W.l.o.g., assume that (otherwise, the rounded height of the scheduled jobs is larger than , implying they can be scheduled feasibly with their original heights on hosts). Thus, among the hosts, we select hosts on which the total weight of scheduled jobs is maximized. It follows that the approximation ratio is . ∎

3.3.1 Laminar Instances

Recall that is the number of hosts. Given a fixed , let

(1)

In Phase 1 of Algorithm 1, we round the LP solution to obtain a subset of jobs . We first prove the following.

Lemma 3.

Let be a slackness parameter, and

(2)

where is defined in (1). Then, given a laminar instance satisfying and , there is a feasible allocation of the resource to the jobs in S.

Proof.

We generate a feasible schedule of the jobs in proceeding bottom-up in each laminar tree. That is, we start handling job only once all the jobs with time windows have been scheduled. Jobs having the same time window are scheduled in an arbitrary order. Let be the next job, whose time window is . We can view the interval as a set of time slots, each consisting of unit size bins. We say that a time slot is ‘bad’ for job if there is no space for one processing unit of (i.e., an ‘item’ of size ) in any of the bins in ; else, time slot is ‘good’. We note that immediately before we start scheduling job the number of bad time slots for is at most . Indeed, by Theorem 1, choosing for the value in (2), after rounding the LP solution the total area of jobs , such that , is at most

(3)

In addition, for a time slot to be ‘bad’ for job , each bin in has to be at least -full. Hence, the number of good time slots for is at least

The first inequality follows from the fact that , and the second inequality holds since . Hence, job can be feasibly scheduled, for any . ∎

Using Lemmas 2 and 3, we prove our main result.

Theorem 4.

For any and constant , MaxT admits a polynomial time -approximation on any laminar instance with slackness parameter .

Proof.

Given a laminar instance satisfying the slackness condition, we handle separately two subsets of jobs.

Subset 1:  Jobs satisfying , where is defined in (1). We solve MaxT for these jobs using Algorithm 1, taking the value of as in (2). By Theorem 1, the approximation ratio is , i.e., we have a constant factor.

Subset 2:  For jobs satisfying , use Lemma 2 to obtain an -approximation.

Taking the best among the solutions for the two subsets of jobs, we obtain an -approximation. ∎

3.3.2 The General Case

Recall that, given a general MaxT instance, , with a slackness parameter , our transformation yields a new laminar instance with a slackness parameter (see the proof of Theorem 3). Now, define

(4)

and set

(5)

Then, by Lemma 3, we have that any job selected for the solution set can be assigned the resource (using Algorithm 1).

Theorem 5.

For any and constant , MaxT admits a polynomial time -approximation on any instance with slackness parameter