Minimizing General Delay Costs on Unrelated Machines

Transcription

1 Minimizing General Delay Costs on Unrelated Machines Nikhil R. Devanur Janardhan Kulkarni Abstract We consider the problem of minimizing general delay costs on unrelated machines. In this problem, we are given a set of m machines and a set of n jobs. Each job j has a machine dependent processing time of p ij on machine i, and a release time r ij. Further, we are also given a non-decreasing function f j (t) which gives the cost of completing the job j at time t. Our goal is to assign each job to exactly one machine and specify a scheduling policy on each machine such that j f j(c j ) is minimized, where C j is the completion time of job j. This objective function captures several widely studied objective functions such as makespan, average completion time/flow-time, tardiness, and deadline scheduling. We design the first polynomial time bicriteria approximation algorithm for the problem that achieves a constant approximation when given a small constant factor speed augmentation. The speed augmentation is necessary as the objective function value can be zero, and hence no algorithm can achieve a bounded approximation factor without speed augmentation. As a corollary of our result, we also get the first polynomial time approximation algorithm for the tardiness objective for unrelated machines (or even for identical machines). Microsoft Research, Redmond, nikdev@microsoft.com Microsoft Research, Redmond, jakul@microsoft.com

2 1 Introduction With the explosive growth of data centers, scheduling and resource allocation problems have become an important topic of research in recent years. Reasons for this renewed interest are twofold: in data center contexts it has become quite evident to practitioners that even a modest increase in efficiency can save million of dollars. Second and the technical reason for this renewed interest is that the heterogeneity of machines in large data centers presents new algorithmic challenges. A scheduling model that incorporates heterogeneity in machines is the classical unrelated machine model arguably the most general scheduling model. Besides the practical relevance the study of scheduling problems in the unrelated machine model has led to the development of several beautiful techniques that have had a huge impact on the theory of approximation algorithms [3, 9, 10, 18, 29, 36]. In the unrelated machine model the processing length (or execution time) of a job depends on the machine on which it is scheduled. Formally, input to the problem consists of a set of m machines and a set n jobs. Each job j has a machine dependent processing length p ij on machine i and a release time r ij. The release time of a job denotes the first time instant when the job is available for processing. We assume that preemption is allowed but not migration. The algorithm has to assign each job to a single machine and specify a feasible schedule for processing jobs on each machine. A job can be paused in the middle of its execution and resumed later without any cost. Much of the literature on unrelated machine scheduling has focused on a few natural measures of efficiency, e.g., makespan, flow-time, completion time, throughput, etc. However, none of them completely capture the scheduling problems that arise in large data centers. Typically in an industrial setup there are two kinds of jobs: 1) high priority jobs that need to be scheduled within a certain deadline and 2) low priority jobs for which one is interested in minimizing flow-times. In an influential work, Bansal and Pruhs [8] introduced the general delay costs as a way to model this problem. Here, for each job j we are given a non-decreasing cost function f j, and the cost of completing the job at time t is equal to f j (t). The goal is to schedule jobs such that j f j(c j ) is minimized, where C j is the completion time of job j. Clearly, the general delay costs problem generalizes most scheduling objectives considered in the literature including makespan, (weighted) completion time, (weighted) flow-time, (weighted) tardiness, and deadline scheduling. In the same paper [8], the authors showed an O(log log np ) approximation to the problem for single machine setting, where n is the number of jobs and P is the ratio of largest to smallest processing lengths of jobs. In this paper we initiate the study of offline problem of general delay costs on unrelated machines. However, there is a subtle technical difficulty in this: the objective function value can be zero. While in a single machine setting [8] showed how to get around this issue, on multiple machines no algorithm can achieve a bounded approximation factor. To elaborate, consider for example the NP hard problem of minimizing makespan on two identical machines. An instance of this problem can be encoded in the general delay costs problem, by making the cost of completing each job equal to after the optimal makespan and zero otherwise. Hence the objective function value is zero in the optimal solution. Any algorithm with a non-trivial approximation factor has to necessarily solve the instance optimally. We move beyond this drawback by adopting the speed augmentation approach. We assume that the machines in our algorithm have extra speed compared to the optimal solution; an alternate way to interpret speed augmentation is as a bi-criteria analysis. The speed augmentation analysis, introduced in the seminal work of Kalyanasundaram and Pruhs [26], is a well accepted model in scheduling theory. The analysis technique has been widely successful both in the design of algorithms for problems for which no meaningful worst case bounds are possible, and also in explaining the effectiveness of certain heuristics that work well in practice [4, 5, 7, 11, 12, 20, 22, 23, 25]. The main contribution of the paper is the first constant factor approximation algorithm to the problem on unrelated machines in speed augmentation setting. 1

3 Theorem 1.1. For any 0 < ɛ 16, there exists a polynomial time (16 + ɛ)-speed, 64/ɛ-approximation algorithm for the general delay costs problem on unrelated machines. As a corollary of the above theorem, we also get the first constant factor polynomial time approximation algorithm in the speed augmentation setting to the classical problem of minimizing the total weighted tardiness of jobs. The tardiness of a job with deadline d j is defined as max{c j d j, 0}. To our knowledge, there has been a limited progress in designing approximation algorithms for tardiness. For a single machine, [28] gave a PTAS for the unweighted case, and the result in [8] implies an O(log log(np )) approximation for the weighted case. Both these results need no speed augmentation. For identical machines, [22] obtain a non-preemptive 8-speed 2-approximation quasi-polynomial time algorithm, based on dynamic programming. Note that even for tardiness speed augmentation is necessary to get non-trivial approximation factors on multiple machines. Corollary 1.2. For any 0 < ɛ 16, there exists a polynomial time (16 + ɛ)-speed, 64/ɛ-approximation algorithm for minimizing the total weighted tardiness on unrelated machines. Towards proving Theorem 1.1, we also design the first algorithm for the deadline scheduling problem on unrelated machines. The deadline scheduling problem we consider is a substantial generalization of the generalized assignment problem introduced in the seminal work of Shmoys and Tardos [34]. In our problem, each job j has a machine dependent deadline d ij and a release time r ij. The cost of assigning a job j to machine i is equal to h ij. The goal is to assign each job j to a machine i and specify a scheduling order on each machine such that each job is completely executed in the interval [r ij, d ij ]. Moreover, we want to minimize the assignment cost of jobs. Our algorithm guarantees that if an instance of the deadline scheduling problem is feasible, it returns a schedule with assignment cost at most the optimal cost and the completion time of every job is at most its deadline, when each machine is given 16 extra speed. Otherwise, the algorithm declares that the instance is infeasible. Prior to our work, such a result was known for the special case of related machines [1]. Theorem 1.3. There exists a polynomial time 16-speed 1-approximation algorithm for the deadline scheduling problem on unrelated machines. When release times of all jobs are zero, speed augmentation is equivalent to approximation factor in the following sense. Given that there exists a schedule that completes all jobs by their deadlines, the algorithm outputs a schedule that finishes job j by time 16d ij. This generalizes the celebrated result of [29] on minimizing makespan on unrelated machines which corresponds to the case where all d ij s are the same, but with a worse constant. Note that getting the speed augmentation below 2 implies improving the approximation factor for makespan on unrelated machines, which is a major open problem in approximation algorithms [37]. Our results are in the offline setting, and it is natural to ask what is the status of the problem in the online setting. Unfortunately, in the online setting no algorithm can achieve a bounded competitive ratio on unrelated machines, even if we allow migration of jobs and constant speed augmentation. This follows from the result of [1], who show such a lower bound for minimizing the maximum weighted flow-time objective on unrelated machines, which is a special case of the deadline scheduling problem. As the general delay costs problem captures almost all the objective functions, we give a more detailed survey of known results in Section Our Techniques Our proof of Theorem 1.1 consists of two main steps. In the first step, we give a time indexed linear programming relaxation (LP) for the problem, which is a 2 approximation. Using the LP solution, we reduce our general delay costs problem to an instance of the deadline scheduling problem. In particular, we reduce 2

4 the processing lengths, say by a factor of 1/2, and define a deadline for each job, and an assignment cost for each job, machine pair. We also give a feasible solution to an LP relaxation of the deadline scheduling problem, and show that rounding this solution will give a solution to the general delay costs instance of cost at most twice the LP cost with some additional speed augmentation. The bulk of the work is then in solving the deadline scheduling problem, which is via rounding another time indexed LP. An algorithm for the deadline scheduling problem has to make two decisions: 1) which set of jobs goes on a machine, and 2) what is the scheduling policy on each machine. For many scheduling problems such as makespan, completion time, and flow-time, the second question is usually easy; for makespan any ordering of jobs suffices, and for flow-time, shortest remaining processing time (SRPT) is the optimal policy. However, when jobs have release times and deadlines, the scheduling policy on each machine has a complex structure; in fact, it is given by a network flow (or as a solution of yet another LP). 1 Given lack of a simple structure for scheduling on a single machine, rounding poses two main challenges: 1) keep the total volume of jobs assigned to a machine in any time interval as close to the LP solution as possible, and 2) ensure that the jobs that are assigned to a machine do not have conflicting deadlines. Maintaining both the invariants simultaneously turns out to be tricky and makes the rounding significantly more complex than the rounding for makespan problem. It is also the reason why some approaches such as randomized rounding [32], iterated rounding [6], and unsplittable flow-rounding [16] do not work for our problem. A rounding based on these methods may assign too many jobs with conflicting deadlines onto a single machine, hence requiring a large speed augmentation. In fact, we can show that a straight forward application of these techniques need a speed augmentation of O(log n). We address these challenges by generalizing the rounding of Shmoys and Tardos [34]. Similar to their rounding, we rely on converting a fractional matching into an integral one, but our construction is more complex as jobs have releases times and deadlines, and we need to ensure the load balancing property for each time interval. This requires us to group jobs based on processing lengths, and interleave Shmoys and Tardos rounding across various job groups and time intervals. At the end of our rounding we get a tentative schedule where each job is assigned to a single machine with the property that for any interval of time, the total size of jobs is roughly the same as what LP assigned. This property alone, however, is not enough to guarantee that each job completes by its deadline. For the deadline scheduling we also need to ensure that the deadlines of the jobs assigned in each interval are feasible. In fact, the tentative schedule produced by our rounding can be infeasible in the sense that if we start processing the job from that point onwards we may not be able to complete the job even if given large extra speed. In the final part of the proof we show how to convert the tentative schedule into a feasible schedule by appropriately shifting jobs and using some extra speed. 2 Minimizing General Delay Costs In this section, we prove Theorem 1.1 using Theorem 1.3, which we prove in the next section. Recall that in this problem there is an arbitrary non decreasing function f j (t) that specifies the cost of completing the job at time t. Each job has a processing length p ij and a release time r ij on machine i. Without loss of generality, we assume that r ij and p ij are all positive integers. Throughout the paper, we use index j denote jobs and index i to denote machines. Our goal is assign each job to a single machine, and specify the order in which jobs are executed such that j f j(c j ) is minimized, where C j is the completion time of job j. 2.1 LP Relaxation Our algorithm is based on the following LP relaxation (1-4) for the problem. We assume that time is discrete. In our LP, there is a variable x ijt for each machine i [m], each job j [n] and time slot t r j. 1 Note that Earliest Deadline First (EDF) is optimal only when release times are zero. 3

5 The x ijt variables indicate the amount of job j that is processed on machine i in the time slot t. The first set of constraints (service constraints) says that every job must be completely processed. The second set of constraints (capacity constraints) enforces that a machine cannot process more than one unit of job during any time slot. Note that this LP allows a job to be processed on multiple machines, even at the same time. The non-trivial part of this LP is the objective function. Minimize ( j i t:t r ij x ijt fj(t) p ij ) + ( j i f j(r ij + p ij )( ) x ijt t:t r ij p ij ) s.t. j, x ijt i t r ij p ij 1 (2) i, t, j : t r ij x ijt 1 (3) (1) i, j, t, x ijt 0 (4) Now, consider the objective function. The first term lowerbounds the cost of completing a job at time C j by the fractional cost. The second term in the objective function accounts for the minimum cost of scheduling a job j on machine i by f j (r ij + d ij ). We show in Appendix A.1 that both terms are valid lowerbounds on OPT, and hence LP is 2 approximation to the optimal cost. 2.2 The Algorithm Our algorithm for general delay costs is based on reducing the problem to an instance of the deadline scheduling problem with assignment costs, and then appealing to Theorem 1.3. Let x = {x ijt } i,j,t denote the optimal solution to LP (1-4). Let 0 < ɛ 1/2 be any constant. For a job j, define d j as the first time instant when (1 ɛ) fraction of the job is processed in x. Formally, d j is equal to the smallest t such that t x ijt i t=r ij p ij (1 ɛ). We create an instance J of the deadline scheduling problem as follows. For every job j [n], we scale down the processing length of the job by (1 ɛ) and set p ij = (1 ɛ) p ij. We define the assignment cost of a job j on machine i as the minimum cost of scheduling job j on machine i; that is, h ij = f j (r ij + p ij ). Finally, we use d j to define a deadline for each job j on machine i as { d d ij := j if (d j r ij) p ij r ij + p ij if (d j r ij) < p ij Let us first verify that there is a fractional solution to the instance J for the deadline scheduling problem 1 with cost at most 1 ɛ j i f j(r j + p ij )( t:t r ij x ijt /p ij). In a fractional solution, we allow a job to be processed on multiple machines. In particular, our argument shows that there is a feasible solution to the deadline LP (8-12). Lemma 3.1 shows how to round such a fractional solution to an intergral solution where each job is assigned to a single machine. From the definition of d j and the fact that p ij = (1 ɛ)p ij for all jobs j, we claim that the LP solution {x ijt } i,j,t restricted to variables up to t d j for all i, j defines a feasible fractional solution for the instance J. First observe that from our definition of deadlines d ij, a job j can be assigned to any machine i. d j d j Therefore, i t:t r ij x ijt /p ij = 1/(1 ɛ) i t:t r ij x ijt /p ij 1, which implies that every job is completely processed by its deadline d j. The cost of this restricted solution is j i f j(r j + p ij )( d j t:t r ij x ijt /p ij ) 1/(1 ɛ) j i f j(r j + p ij )( t:t r ij x ijt /p ij), (5) which is at most 1/(1 ɛ) times the second term in LP objective (1). We now use Lemma 3.1 to schedule jobs in J. Let y := {y ijt } i,j,t denote the schedule returned by Lemma 3.1. Our final schedule, for the general delay costs problem, z = {z ijt } i,j,t is obtained by setting zijt = (1 + 2ɛ)y ijt for all i, j, t. 4

6 2.3 Bounding The Cost We now argue that the schedule z proves Theorem 1.1. Proof. We need to show two things, that z is a feasible schedule with a speed augmentation of (16 + ɛ ) for some ɛ, and that it is a 64/ɛ approximation to OPT. It is easy to verify that every job j is completely processed in z since we set zijt = (1 + 2ɛ)y ijt for all i, j, t. Further, the speed augmentation required is at most (1 + 2ɛ) times the speed augmentation used in the schedule y, which is at most 16 from Theorem 1.3. By taking ɛ = 32ɛ, we get the bound on speed augmentation. Now we argue about the the cost of our schedule. Let i(j) denote the machine to which job j is assigned in our final schedule. Let J 1 be the set of jobs for which d i(j)j = d j, and consider a job j J 1. The cost incurred by our solution is at most f j (d j ) which is at most 1/ɛ times the LP cost for job j since LP pays at least (considering only the first term in the objective) i t:t r ij x ijt f j(t)/p ij i t:t d x j ijt f j(d j )/p ij ɛ f j (d j ), (6) where the inequalities follow from 1) f j is a non-decreasing function, and 2) from the definition of d j. Let J 2 be the set of jobs for which d i(j)j = r ij + (1 ɛ)p i(j)j. A job j J 2 pays a cost of at most f j (r ij + (1 ɛ)p i(j)j ) f j (r ij + p i(j)j ). However, from the guarantee of Lemma 3.1 and Equation (5) we know that the assignment cost of our solution is at most 1/(1 ɛ) times the second term in the LP objective (1). Formally, j J 2 f j (r ij + p i(j)j ) j f j(r ij + p i(j)j ) 1/(1 ɛ) j i w j f j (r ij + p ij )( t:t r j x ijt /p ij). (7) Combining the two cases (Equations 6 and 7), we conclude that for 0 < ɛ 1/2 the total cost of our schedule is a 1/ɛ factor approximation to the LP objective (1). Since, ɛ = 32ɛ and LP is a 2-approximation to the optimal cost, we conclude that z is a (16 + ɛ )-speed 64/ɛ -approximation to the general delay costs problem. 3 The Deadline Scheduling Problem In this section we prove Theorem 1.3. Recall that the input to the problem consists of a set of n jobs, and a set of m machines. Each job j [n] needs p ij units of processing time on machine i. Each job j also has a release time r ij and a deadline d ij on machine i. Further, we are also given assignment costs for jobs; the cost of assigning a job j to a machine i is h ij. The goal is to assign each job j to a single machine i and specify a schedule on each machine such that every job is processed in the interval [r ij, d ij ], and the total assignment cost of jobs is minimized. For the rest of this section, we scale down the processing lengths of jobs to their nearest power of two. That is, for each job j, let p ij = 2k if p ij [2 k, 2 k+1 ). 3.1 LP Relaxation We write a time indexed LP for the problem. In our LP formulation (8-12), we have a variable x ijt that is intended to be 1 if job j is scheduled on machine i at time t. We briefly describe the LP constraints: The first set of constraints (9) say that every job is completely processed within the interval [r ij, d ij ]. The second set of constraints (10) make sure that only one unit of job is scheduled at each time instant. The constraints (11) ensure that we do not schedule job j on machine i if d ij r ij < p ij. The objective function of the LP (8) lower bounds the total assignment cost of jobs. Observe that the term ( d ij t:t r ij x ijt /p ij ) equals to the fraction of job j that is scheduled on machine i. Hence, in an optimal solution if job j is assigned to machine i then it pays h ij towards the objective. 5

7 Minimize j i h ij ( d ij t:t r ij x ijt /p ij ) (8) j, i d ij i, t, j x ijt p t r ij ij 1 (9) x ijt 1 (10) i, j, t : r ij t d ij, x ijt = 0 if d ij r ij < p ij (11) i, j, t : r ij t d ij, x ijt 0 (12) Clearly, if the instance is feasible then there is a solution to the linear program. The converse, however, is not true: the LP can schedule a job on multiple machines, hence a solution of the LP is not a feasible schedule. In this section we prove the following lemma. Lemma 3.1. If there is a feasible solution to the linear program (8-12), then there is a polynomial time algorithm that when given a speed augmentation of 16 (i) assigns each job j = 1,... n to exactly to one machine (ii) schedules a job j that is assigned to machine i in the interval [r ij, d ij ] (iii) incurs an assignment cost at most the LP cost. Note that proof of Lemma 3.1 implies Theorem Rounding Let x = {x ijt } i,j,t be an optimal solution to LP (8-12). For rest of this section, we use x ijt to refer to the LP variables and x ijt for their values in x. We give an algorithm to round x such that each job is assigned to a single machine. In this step, we also tentatively assign each job to an interval of time on a machine, which is intended to be the interval where the job gets processed. The main goal of this subsection is to prove Lemma 3.3, which states that in the tentative schedule for any time period [t 1, t 2 ], any machine i and class k, the total size of jobs belonging to class at most k is less than SIZE-LP(t 1, t 2 ) k. Given the lemma, we show in Section 3.3, how to convert this tentative schedule into a valid schedule by speed augmentation. The tentative assignment of jobs to intervals is given by generalizing the rounding of Shmoys and Tardos for the generalized assignment problem [34]. We say that a job j belongs to class k on machine i if p ij = 2k. For each class k and each machine i, we define intervals I(i, k, ) that correspond to a contiguous set of time slots on machine i with the property that the total size of class k jobs processed in the interval in the LP solution x is equal to 2 k. Since this may not always be possible, in our formal definition, I(i, k, ) intervals correspond to a consecutive set of x ijt variables such that their total value is equal to 2 k, which we achieve by appropriately modifying the x ijt variables. In spite of this, it is instructive to think of I(i, k, ) simply as intervals of time that corresponds to 1 slot for a class k job in the LP solution. Definition of I(i, k, ) intervals Fix a machine i and a class k. Formally, we define I(i, k, ) intervals inductively as follows. Sort the x ijt variables in the increasing order of t breaking ties in the lexicographic order of job indices. Let t 0 be the first time instant when t 0 t=0 j:p ij =2k x ijt 2k. If the sum t0 t=0 j:p ij =2k x ijt = 2k, then we define I(i, k, 0) := { } x ijt p ij = 2k and t [0, t 0 ]. 6

8 Let us look at the case when the sum is greater than 2 k. Consider the set of {x ijt0 } j variables, and let j n be the index of the first class k job such that t 0 1 t=0 j:p ij =2k x ijt + j:j j,p ij =2k x ijt 0 2 k. We split the variable x ij t 0 into two variables x ij t 0 (1) and x ij t 0 (2) and set ( x t0 1 ij t 0 (2) := t=0 j:p ij =2k x ijt + ) j:j j,p ij =2k x ijt 0 2 k and x ij t 0 (1) := x ij t 0 x ij t 0 (2). This would imply that t0 1 t=0 j:p ij =2k x ijt + j:j j 1,p ij =2k x ijt 0 + x ij t 0 (1) = 2 k. We define I(i, k, 0) as the set of all x ijt variables in the interval [0, t 0 ] up to x ij t 0 (1). That is, I(i, k, 0) := { } } {xij x ijt p ij = 2k and t [0, t 0 1] {x ijt0 p ij = 2k and j < j t 0 (1) } We call the job j as a boundary job, and we define the operation of breaking a variable x ijt into x ijt (1) and x ijt (2) as splitting. Note that each interval can have at most 2 split variables, one at each end of the interval. Further, we also associate the interval [0, t 0 ] to I(i, k, 0), and call t 0 as the right end point and 0 as its left end point. By splitting a boundary job if necessary, we inductively define I(i, k, l) for l > 0 as the contiguous set of x ijt variables not belonging to the previous intervals such that the sum of their LP values is exactly equal to 2 k. For an interval I(i, k, l), we define the left end point t L (l) of the interval as smallest value of t for which some x ijt I(i, k, l). Similarly, we define the right end point t R (l) of the interval as largest value of t for which some x ijt I(i, k, l) (including the split variables). To simplify notation, let t l 1 (instead of t R (l 1)) denote the right end point of the interval (l 1) and j be the index of the boundary job at the right end point of the interval (l 1). Let t l > t l 1 be the first time instant and j n be the index of first class k job such that x ij t l 1 (2) + j:j>j,p ij =2k x ijt l 1 + j:p ij =2k tl 1 t>t l 1 x ijt + j:j j,p ij =2k x ijt l 2 k. We split the variable x ij t l into x ij t l (1) and x ij t l (2) (if necessary), and define I(i, k, l) as the contiguous set of variables from x ij t l 1 (2) to x ij t l (1). The last I(i, k, l) interval on each machine i and class k contains the remaining x ijt variables even if their value do not sum up to 2 k. We define the right end point of the last interval as max{r ij } + j p ij. Summarizing I(i, k, ) intervals Although in our formal definition we treat I(i, k, l) as a collection of x ijt variables, it is instructive to think I(i, k, l) as an interval of time from [t L, t R ] where the LP processed 2 k units of jobs belonging to class k. Keeping this picture in mind, we say the interval I(i, k, l) intersects [t 1, t 2 ] to mean [t 1, t 2 ] [t L, t R ]. Moreover, for every interval I(i, k, l), we observe that t R t L 2 k. This follows from the capacity constraints of the LP (10) as at most 1 unit of jobs can be processed at each time slot. We also observe that two consecutive class k intervals may overlap at only one time instant. Constructing bipartite graph Given the definition of intervals I(i, k, l) for each class k on each machine i, we define a bipartite graph B = (J, M, E) as follows. The left side vertex set J corresponds to the set of jobs; we create one vertex for each job j = 1,... n. The right side vertex set M corresponds to I(i, k, l) intervals; We create a vertex v ikl for every interval {I(i, k, l)} i,k,l, and define M := {v ikl : i, k, l}. Observe that for each (i, k) pair, there are exactly t j:p ij =2k x ijt /2k vertices of type v ikl M. This corresponds to the number of jobs of class k processed on machine i. 7

9 There is an edge e := (j, v ikl ) in E if job j is of class k on machine i and x ijt I(i, k, l); there is also an edge e := (j, v ikl ) in E if job j is a boundary job and either x ijt (1) I(i, k, l) or x ijt (2) I(i, k, l). An edge e between (j, v ikl ) means that in the LP solution, the job j belonging to class k was scheduled on machine i in the interval I(i, k, l). Let w e denote the weight of edge e. We set w e as the total fraction of job j that was scheduled in the interval I(i, k, l). Formally, we define w e as follows: If job j is not a boundary job in the interval I(i, k, l), then w e = ( t I(i,k,l) x ijt )/p ij. If job j is a boundary job, we set w e := ( x ijt L (2) + ) t [t L 1,t R 1] x ijt + x ijt R (1) /p ij if x ijt L (2), x ijt R (1) I(i, k, l) ( ) t [tl,tr 1] x ijt + x (1) /p ijtr ij if x ijt L (2) I(i, k, l), x ijt R (1) I(i, k, l) ( x ijt L (2) + ) t [t L 1,t R ] x ijt /p ij if x ijt L (2) I(i, k, l), x ijt R (1) I(i, k, l) where t L and t R denote the left and right end points of the interval I(i, k, l). Let c e denote the cost of edge e. For an edge e between (j, v ikl ), we set c e = h ij, where h ij is the cost of assigning job j to machine i. From our construction e B w e c e = j i h ij ( d ij t:t r ij x ijt /p ij ), which is the assignment cost incurred by the LP solution x. Given an edge weighted bipartite graph, we say that a vertex is fractionally matched if the total weight of the edges incident on the vertex is equal to 1. From our construction of the bipartite graph B and from the service constraints of the LP (9), we observe that job nodes in B are fractionally matched; That is, dij t:t>r ij x ijt p ij = 1. Now consider a vertex v M. Each such vertex for all u B, e:e u w e = i corresponds to an I(i, k, l) interval, and the set of edges incident on it are precisely from the class k jobs whose x ijt I(i, k, l). Therefore, the total weight of edges incident on a vertex v ikl is also equal to 1. Only exception to this are the vertices corresponding to the last I(i, k, l) intervals for each machine i and class k, for which the total weight may be less than 1. A beautiful result from matching theory states that if there is a fractional matching of vertices of B then there is also an integral matching with the same cost [30]. Theorem 3.2. Let G := (U, V, E) be a bipartite graph with edge weights w e : E [0, 1] and edge costs c e : E R +. Suppose u U, e:e u w e = 1 and v V, e: v w e 1. Then there exists an integral matching M : U V, M E such that 1) every vertex u U is matched 2) e M c e e E w ec e. Tentative Schedule Our assignment of jobs to machines is given by finding an integral matching M(B) on graph B with the minimum cost. From Theorem 3.2 we have e M(B) c e j i h ij ( d ij t:t r ij x ijt /p ij). (13) Since our algorithm never changes the assignment of jobs to machines, it follows that the assignment cost of our solution is at most the LP cost. Therefore, it only remains to argue that every job completes by its deadline. Observe that in our assignment of jobs to machines using M(B), each job is in fact matched to an interval I(i, k, l). Our intention is to schedule the job in the interval I(i, k, l) such that it does not miss the deadline. For now, we treat this as a tentative schedule of jobs. One of the problems with this tentative assignment is that the total size of jobs that are assigned within a time period may be more than the actual capacity. Although this is true, we argue that the total extra size of jobs assigned in any time period does not deviate too much from the actual LP solution. 8

10 Bounding the load For the rest of the proof, we fix a machine i, and argue that all the jobs tentatively assigned to machine i can be scheduled on that machine, given a constant speed up. For the rest of this subsection, for a given machine i, we show that no interval of time is too overloaded in a certain sense formalized in Lemma 3.3. For a fixed time period [t 1, t 2 ] (on machine i) define SIZE-LP(t 1, t 2 ) := j SIZE-LP k (t 1, t 2 ) := t 2 j:p ij =2k t=t 1 x ijt (14) t 2 t=t 1 x ijt (15) SIZE-LP denotes the total size of jobs scheduled in the interval [t 1, t 2 ], and SIZE-LP k (t 1, t 2 ) denote the total size of jobs belonging to class k scheduled in the interval [t 1, t 2 ] in the LP solution on machine i. (For the sake of simplicity we drop the subscript i from all notation.) We define SIZE-TENT k as the total size of jobs belonging to class at most k that are tentatively assigned to an interval intersecting [t 1, t 2 ]. For any i, k and l, let I 1 (i, k, l) denote the job j that is assigned to the interval I(i, k, l); more precisely, the job j that got matched to the vertex v ikl in the matching M(B). Let J k (t 1, t 2 ) denote the set of jobs belonging to class at most k that are tentatively assigned to an interval intersecting [t 1, t 2 ]. Formally, J k (t 1, t 2 ) := {I 1 (i, k, l) : k k, [t 1, t 2 ] I(i, k, l) φ}. SIZE-TENT k (t 1, t 2 ) := j J k (t 1,t 2 ) p ij. Lemma 3.3. For any time period [t 1, t 2 ], any machine i and class k, SIZE-TENT k (t 1, t 2 ) SIZE-LP(t 1, t 2 ) k Proof. We distinguish the intervals that intersect with [t 1, t 2 ] into two types: Those that are completely contained in [t 1, t 2 ] and those intervals that overlap the left and right end points. For each class k k, let I(i, k, l L ) and I(i, k, l R ) denote the intervals that overlap at the left end point (t 1 ) and right end point (t 2 ). Let J L (t 1, t 2 ) J k (t 1, t 2 ) and J R (t 1, t 2 ) J k (t 1, t 2 ) denote the set of jobs that are assigned to the intervals that overlap at the boundaries of [t 1, t 2 ]. Let J 1 (t 1, t 2 ) = J L (t 1, t 2 ) J R (t 1, t 2 ) and let J 2 (t 1, t 2 ) = J k (t 1, t 2 ) \ J 1 (t 1, t 2 ). First, consider the jobs in J 2 (t 1, t 2 ), and using the definition of J 2 we have, j J 2 (t 1,t 2 ) p ij = k k = k k l:i(i,k,l) [t 1,t 2 ] p ii 1 (i,k,l) l:i(i,k,l) [t 1,t 2 ] x ijt I(i,k,l) x ijt (16) SIZE-LP(t 1, t 2 ). (17) The proof of equality 16 follows from the definition of I(i, k, l). The last inequality above follows from the observation that the x ijt variables contained in the intervals I(i, k, l) for different ls are disjoint. Now consider jobs in J 1 (t 1, t 2 ). For each class k k we can have at most 1 interval overlapping [t 1, t 2 ] at the left end point and 1 interval at the right end point. Therefore we conclude, 2 k 4 2 k. (18) j J 1 (t 1,t 2 ) p ij 2 k k 9

11 Putting it all together, from inequalities 17 and 18, we get SIZE-TENT k (t 1, t 2 ) = p ij = p ij + p ij 4 2 k + SIZE-LP(t 1, t 2 ). j J k (t 1,t 2 ) j J 1 (t 1,t 2 ) j J 2 (t 1,t 2 ) 3.3 Scheduling on Each Machine Now we describe the algorithm we use to convert the tentative assignment into an actual schedule on each machine. Our algorithm consists of two parts: 1) we assign each job to an instant of time t j r j which is the first time at which we start to consider the job j for scheduling. We say that a job j is ready to be scheduled at time t if t t j and it is not complete yet. 2) We assign priorities to jobs. The actual schedule is to simply process the highest priority job that is ready at that time. Assigning intervals to each job: Consider the tentative schedule produced by our LP rounding. Suppose job j is assigned to the interval I(i, k, l). Let t L and t R be the beginning and end points of this interval. Note that it cannot be that [r ij, d ij ] [t L, t R ], since it would imply that the LP solution is infeasible. Further, from our construction of the bipartite graph, [r ij, d ij ] [t L, t R ]. As a result the following set of cases in the definition of t j is mutually exhaustive. t L if [t L, t R ] [r ij, d ij ] t j := r ij if r ij > t L d ij p ij if d ij < t R. For every job j, we show that we can process the job in the interval [t j, t j + p ij ]. We call [t j, t j + p ij ] the interval of job j, and denote it by I j. Assigning priorities to each job: A job j can preempt a job j, denoted by j j, if and only if the intervals of the the jobs intersect: I j I j, and either j belongs to a smaller class than j, or they both belong to the same class and the interval j was assigned to in the tentative assignment precedes that assigned to j. From the definition of our priority rules, it is easy to verify that it gives a total ordering on jobs that are ready at any time instant. Our algorithm at each time instant t schedules the job with the highest priority. This completes the description of our scheduling policy. The following lemma follows directly from the definition of I(i, k, l) intervals. Lemma 3.4. Let job j be assigned to the interval I(i, k, l) in the tentative schedule. If I j I(i, k, l ), then l is either l 1, l or l + 1. Proof. Proof of the lemma follows from the observation that for each I(i, k, l) interval with t L and t R as the left and right end points, t R t L 2 k and p ij = 2k. Speed augmentation analysis It remains to show that every job is completely processed in the interval Ij = [t j, t j + p ij ], if we give each machine O(1) extra speed. The main idea behind the proof is that if we consider the interval [t j, t j + p ij ], then Lemma 3.3 shows that the total size of jobs assigned in the tentative schedule is at most p ij +4 2k, if job j belongs to class k. However, our actual assignment of jobs to intervals may increase the volume due to shifting of jobs. Next we argue that this increase is not too much. For a job j belonging to class k that is assigned to machine i, let J >j denote the set of jobs that can preempt j: J >j := {j : j j}. 10

12 Lemma 3.5. For every job j j J >j p ij 7 p ij Proof. Once again, we partition J >j into two parts. The first set consists of those jobs whose tentative assignment intersects with I j, and the rest of the jobs are in the second set. Recall that J k(t 1, t 2 ) denote the set of jobs belonging to class at most k that are tentatively assigned to an interval intersecting [t 1, t 2 ]. J 1 >j := J >j J k (t j, t j + p ij ) and J 2 >j := J >j \ J 1 >j. We can bound the total processing lengths of jobs in J>j 1 and the job j as follows. p ij + j J 1 >j p ij SIZE-TENT k(t j, t j + p ij ) SIZE-LP(t j, t j + p ij) k p ij k 5p ij (19) The first inequality is by definition. The second one is an application of Lemma 3.3. The third one follows from the capacity constraints of the LP. Since job j belongs to class k, we have that p ij = 2k, giving us the last inequality. The processing lengths of jobs in J>j 2 are bounded as follows. From Lemma 3.4, for each class k < k, there are at most 2 jobs belonging to that class in J>j 2, each of them contributing at most 2k to the sum. For the class k, there is at most 1 other job in that class that is also in J>j 2. Hence the total length of such jobs is j J>j 2 p ij k <k 2 2k + 2 k 2 2 k + 2 k 3 p ij. (20) The lemma now follows from 20 and 19. Putting everything together, we get the proof of Lemma 3.1 which implies Theorem 1.3. Proof of Lemma 3.1. From Equation 13, the assignment of cost our solution is at most the LP cost (8-12). From the definition of our algorithm, in the interval [t j, t j + p ij ], only jobs that can preempt job j are the jobs in J >j. From Lemma 3.5 the total size of those jobs is at most 7 p ij. Therefore, at most 8 p ij units of jobs is scheduled in the interval [t j, t j + p ij ]. However, the actual processing length of a job j can be at most 2p ij. Thus, actual processing scheduled in the interval [t j, t j + p ij ] can be 16 p ij. Since we are given a speed of 16 and the job j is ready to be scheduled at time t j, we will complete the job j before t j + p ij d ij. 3.4 Additional Related Work To our knowledge, no results are known for the general delay costs problem in multiple machines setting except for the result by Fox et al [19] who study a special case of this problem in the online setting, where f j is same for all j and is convex. They show that Shortest Elapsed Time First (SETF), which allows processing of jobs on multiple machines, is 2-speed O(1)-approximation to the problem on identical machines. However, several important special cases of the general delay costs problem have been extensively studied. As the general delay costs problem captures almost all the objective functions, it is impossible to mention all the known results in literature. We refer the readers to the following excellent books and survey articles on the topic [13, 24, 27, 31]. Below, we only mention results for the unrelated machines setting by grouping them based on the objective functions. Makespan: As we already mentioned, the landmark result of Lenstra, Shmoys, and Tardos gave a 2- approximation algorithm to the makespan problem on unrelated machines [29] by exploiting nice structural 11

13 properties of vertex point solutions of LPs. They also showed a lowerbound of 1.5 on the approximation factor. Despite some recent improvements for special cases [17, 36], even today, after more than 25 years, it remains the best known approximation algorithm for the problem, and one of the most important open problems in the area of approximation algorithms. Completion Time: Another widely studied special case of the general delay costs problem is of minimizing the weighted completion time of jobs. A remarkable recent result by Bansal, Srinivasan, and Svensson gives 3/2 ɛ approximation to the problem based on lift and project methods [9]. This result improves upon previous results in [33, 35]. In another recent breakthrough work, Im and Li [21] design approximation to the problem when jobs have release dates. Despite all these impressive developments, the exact approximability of the problem is elusive. Flow-time: Perhaps the most important special case of the general delay costs problem is minimizing flow-time of jobs. For the objective of minimizing unweighted total flow-time, a recent result by Bansal and Kulkarni [6] gives an O(log n log P ) approximation to the problem based on iterated rounding technique, where as there is Ω(log P ) lowerbound on the approximation factor even on identical machines. In a sharp contrast, in the speed augmentation model, elegant results by [2, 11, 15] give constant approximation based on primal-dual methods even in the online setting. Another widely studied flow-time objective is minimizing the maximum flow-time of jobs. For this objective, Bansal and Kulkarni [6] give a O(log n) approximation without any speed augmentation, where as Anand et al [1] design a constant approximation to the problem in speed augmentation setting. Deadline Scheduling: Much of the literature on deadline scheduling has focused on machine minimization problem for the identical machines setting. Here, the goal is to find the minimum number of machines such that every job can be feasibly scheduled within its deadline. The current best result for the problem is by Chuzhoy et al [14] who design an O(min{OP T, ( log n/ log log n)})-approximation to the problem. Getting a constant approximation factor to the problem has been an important open problem in scheduling literature. On the other hand, Im et al [22] show that with some small extra speed, there exists a quasi-polynomial time constant approximation to the problem. References [1] S. Anand, Karl Bringmann, Tobias Friedrich, Naveen Garg, and Amit Kumar. Minimizing maximum (weighted) flow-time on related and unrelated machines. In Automata, Languages, and Programming - 40th International Colloquium, ICALP 2013, Riga, Latvia, July 8-12, 2013, Proceedings, Part I, pages 13 24, , 1, 3.4 [2] S. Anand, Naveen Garg, and Amit Kumar. Resource augmentation for weighted flow-time explained by dual fitting. In SODA, pages , [3] Arash Asadpour and Amin Saberi. An approximation algorithm for max-min fair allocation of indivisible goods. In Proceedings of the 39th Annual ACM Symposium on Theory of Computing, San Diego, California, USA, June 11-13, 2007, pages , [4] Nikhil Bansal, Ho-Leung Chan, Rohit Khandekar, Kirk Pruhs, Clifford Stein, and Baruch Schieber. Non-preemptive min-sum scheduling with resource augmentation. In 48th Annual IEEE Symposium on Foundations of Computer Science (FOCS 2007), October 20-23, 2007, Providence, RI, USA, Proceedings, pages , [5] Nikhil Bansal, Ravishankar Krishnaswamy, and Viswanath Nagarajan. Better scalable algorithms for broadcast scheduling. In ICALP (1), pages ,

14 [6] Nikhil Bansal and Janardhan Kulkarni. Minimizing flow-time on unrelated machines. In Proceedings of the Forty-Seventh Annual ACM on Symposium on Theory of Computing, STOC 2015, Portland, OR, USA, June 14-17, 2015, pages , , 3.4 [7] Nikhil Bansal and Kirk Pruhs. Server scheduling in the weighted lp norm. In LATIN, pages , [8] Nikhil Bansal and Kirk Pruhs. The geometry of scheduling. In IEEE Symposium on the Foundations of Computer Science, pages , , 1 [9] Nikhil Bansal, Aravind Srinivasan, and Ola Svensson. Lift-and-round to improve weighted completion time on unrelated machines. In Proceedings of the 48th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2016, Cambridge, MA, USA, June 18-21, 2016, pages , , 3.4 [10] Nikhil Bansal and Maxim Sviridenko. The santa claus problem. In Proceedings of the 38th Annual ACM Symposium on Theory of Computing, Seattle, WA, USA, May 21-23, 2006, pages 31 40, [11] Jivitej S. Chadha, Naveen Garg, Amit Kumar, and V. N. Muralidhara. A competitive algorithm for minimizing weighted flow time on unrelatedmachines with speed augmentation. In Symposium on Theory of Computing, pages , , 3.4 [12] Chandra Chekuri, Sungjin Im, and Benjamin Moseley. Online scheduling to minimize maximum response time and maximum delay factor. Theory of Computing, 8(1): , [13] Chandra Chekuri and Sanjeev Khanna. Approximation algorithms for minimizing averageweighted completion time. In Handbook of Scheduling - Algorithms, Models, and Performance Analysis [14] Julia Chuzhoy, Sudipto Guha, Sanjeev Khanna, and Joseph Naor. Machine minimization for scheduling jobs with interval constraints. In 45th Symposium on Foundations of Computer Science (FOCS 2004), October 2004, Rome, Italy, Proceedings, pages 81 90, [15] Nikhil R. Devanur and Zhiyi Huang. Primal dual gives almost optimal energy efficient online algorithms. In Proceedings of the Twenty-Fifth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2014, Portland, Oregon, USA, January 5-7, 2014, pages , [16] Yefim Dinitz, Naveen Garg, and Michel X. Goemans. On the single-source unsplittable flow problem. Combinatorica, 19(1):17 41, [17] Tomáš Ebenlendr, Marek Krčál, and Jiří Sgall. Graph balancing: A special case of scheduling unrelated parallel machines. In Proceedings of the Nineteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 08, pages , Philadelphia, PA, USA, Society for Industrial and Applied Mathematics. 3.4 [18] Uriel Feige. On allocations that maximize fairness. In Proceedings of the Nineteenth Annual ACM- SIAM Symposium on Discrete Algorithms, SODA 2008, San Francisco, California, USA, January 20-22, 2008, pages , [19] Kyle Fox, Sungjin Im, Janardhan Kulkarni, and Benjamin Moseley. Online non-clairvoyant scheduling to simultaneously minimize all convex functions. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques - 16th International Workshop, APPROX 2013, and 17th International Workshop, RANDOM 2013, Berkeley, CA, USA, August 21-23, Proceedings, pages ,

15 [20] Kyle Fox and Benjamin Moseley. Online scheduling on identical machines using srpt. In SODA, pages , [21] Sungjin Im and Shi Li. Better unrelated machine scheduling for weighted completion time via random offsets from non-uniform distributions. FOCS, [22] Sungjin Im, Shi Li, Benjamin Moseley, and Eric Torng. A dynamic programming framework for non-preemptive scheduling problems on multiple machines [extended abstract]. In Proceedings of the Twenty-Sixth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2015, San Diego, CA, USA, January 4-6, 2015, pages , , 1, 3.4 [23] Sungjin Im and Benjamin Moseley. Online scalable algorithm for minimizing ;k-norms of weighted flow time on unrelated machines. In SODA, pages , [24] Sungjin Im, Benjamin Moseley, and Kirk Pruhs. A tutorial on amortized local competitiveness in online scheduling. SIGACT News, 42(2):83 97, [25] Sungjin Im, Benjamin Moseley, and Kirk Pruhs. Online scheduling with general cost functions. In SODA, pages , [26] Bala Kalyanasundaram and Kirk Pruhs. Speed is as powerful as clairvoyance. Journal of the ACM, 47(4): , [27] David Karger, Cliff Stein, and Joel Wein. Scheduling algorithms. In Algorithms and theory of computation handbook, pages Chapman & Hall/CRC, [28] EL Lawler. A fully polynomial approximation scheme for the total tardiness problem. Operations Research Letters, 1(6): , [29] Jan K. Lenstra, David B. Shmoys, and Éva Tardos. Approximation algorithms for scheduling unrelated parallel machines. Math. Program., 46: , , 1, 3.4 [30] László Lovász and Michael D Plummer. Matching theory, volume 367. American Mathematical Soc., [31] Kirk Pruhs, Jirí Sgall, and Eric Torng. Online scheduling. In Handbook of Scheduling - Algorithms, Models, and Performance Analysis [32] Prabhakar Raghavan and Clark D. Thompson. Randomized rounding: a technique for provably good algorithms and algorithmic proofs. Combinatorica, 7(4): , [33] Andreas S. Schulz and Martin Skutella. Random-based scheduling: New approximations and lp lower bounds. In RANDOM, pages , [34] David B. Shmoys and Éva Tardos. An approximation algorithm for the generalized assignment problem. Math. Program., 62: , , 1.1, 3.2 [35] Martin Skutella. Convex quadratic and semidefinite programming relaxations in scheduling. J. ACM, 48(2): , [36] Ola Svensson. Santa claus schedules jobs on unrelated machines. SIAM J. Comput., 41(5): , , 3.4 [37] David P Williamson and David B Shmoys. The design of approximation algorithms. Cambridge university press,