An O(logm)-Competitive Algorithm for Online Machine Minimization

Size: px
Start display at page:

Download "An O(logm)-Competitive Algorithm for Online Machine Minimization"

Transcription

1 An O(logm)-Competitive Algorithm for Online Machine Minimization Downloaded 10/18/16 to Redistribution subject to SIAM license or copyright; see Abstract Lin Chen Nicole Megow Kevin Schewior We consider the online machine minimization problem in which jobs with hard deadlines arrive online over time at their release dates. The task is to determine a feasible preemptive schedule on a minimum number of machines. Our main result is a general O(log m)-competitive algorithm for the online problem, where m is the optimal number of machines used in an offline solution. This is the first improvement on an intriguing problem in nearly two decades. To date, the best known result is a O(log(p max /p min ))- competitive algorithm by Phillips et al. (STOC 1997) that depends on the ratio of maximum and minimum job sizes, p max and p min. Even for m = 2 no better algorithm was known. Our algorithm is in this case constant-competitive. When applied to laminar or agreeable instances, our algorithm achieves a competitive ratio of O(1) even independently of m. The following two key components lead to our new result. Firstly, we derive a new lower bound on the optimum value that relates the laxity and the number of jobs with intersecting time windows. Then, we design a new algorithm that is tailored to this lower bound and balances the delay of jobs by taking the number of currently running jobs into account. 1 Introduction Minimizing resource usage is a key to achieving economic, environmental, or societal goals. We consider the fundamental problem of minimizing the number of machines that is necessary for feasibly scheduling preemptive jobs with release dates and hard deadlines. We consider the online variant of this problem in which every job becomes known to the This research was supported by the German Science Foundation (DFG) under contract ME 3825/1. The third author was supported by the DFG within the research training group Methods for Discrete Structures (GRK 1408). Technische Universität München, Zentrum für Mathematik, Garching, Germany. {lchen,nmegow}@ma.tum.de. Technische Universität Berlin, Institut für Mathematik, Berlin, Germany. schewior@math.tu-berlin.de. October 12, 2015 online algorithm only at its release date. We denote this problem as the online machine minimization problem. We will show that we may restrict to the semi-online problem variant in which the online algorithm is given slightly more information, namely, the optimal number of machines, m, in advance. In their seminal paper, Phillips, Stein, Torng, and Wein [9] presented a O(log(p max /p min ))- competitive algorithm, where p max and p min denote the maximum and minimum job processing times. It remained a wide open question if the problem admits a constant-competitive online algorithm [9,10]. It was not even known whether such an algorithm exists for m = 2. Despite serious efforts within the community, no significant improvement has been made within nearly two decades [10]. In this paper we present an O(log m)-competitive algorithm for the preemptive online machine minimization problem. This is the first result, that depends only on the optimum value, m, instead of other input parameters. Our algorithm is O(1)-competitive when m is bounded or when all jobs have processing time windows which are either agreeable or laminar. Further related results. The preemptive semionline machine minimization problem, in which the optimal number of machines is known in advance, has been investigated extensively by Phillips et al. [9]. They show a general lower bound of 5/4 and leave a huge gap to the upper bound O(log(p max /p min )) on the competitive ratio for the so-called Least Laxity First (LLF) Algorithm. Not surprisingly, they rule out that the Earliest Deadline First (EDF) Algorithm may improve on the performance of LLF by showing a lower bound of Ω(log(p max /p min )). The non-preemptive variant of our online problem is quite hopeless. In fact, no algorithm can achieve a competitive ratio sublinear in the number of jobs [11]. The non-preemptive problem with unit processing times was studied in a series of papers [4,6,7,11,12] and implicitly in the context of energy minimization in [1]. It has been shown that an optimal online algorithm has the exact competitive ratio of e 2.72 [1,4]. In a closely related problem variant, an online 155 Copyright by SIAM.

2 algorithm is given extra speed to the given number of machines instead of additional unit-speed machines. The goal is to find an algorithm that requires the minimum extra speed. This problem seems much better understood and speedup factors around 2 are known (see [8, 9]). However, the power of speed is much stronger than that of additional machines since it can be viewed to allow parallel processing of jobs to some extent. None of the algorithms that are known to perform well for the speed problem, e.g., EDF and LLF, admit an f(m)-competitive algorithm for any function f for the machine minimization problem [9]. Notwithstanding, giving a small amount of extra speed allows for a constant competitive ratio also for the machine minimization problem [8]. We also mention that the offline problem, in which all jobs are known in advance, can be solved optimally in polynomial time if job preemption is allowed [5]. The solution of the natural linear programming (LP) formulation can be rounded in a straightforward way by assigning fractionally assigned workload in a round robin fashion over all machines within a time unit. However, both solutions, the optimum and the LP solutions, may drastically change under online job arrivals. Our contribution. Our main contribution is a new preemptive online algorithm with a competitive ratio O(logm), where m is the optimum number of machines. It is the first improvement upon the longstanding best-known competitive ratio of O(log(p max /p min )) by Phillips et al. [9] even for m = 2. Our algorithm is O(1)-competitive if the optimum value m is bounded. Moreover, the same algorithm is also O(1)-competitive ratio for two important complementary classes of instances, namely laminar and agreeable instances it achieves the ratio of 96 for laminar instances and 176 for agreeable instances. We firstly observe that we may restrict to the semi-online model, in which an online algorithm is given the optimum number of machines m in advance. Furthermore, we show that jobs with a small processing time relative to the entire time window ( loose jobs) are easy to schedule. The difficult task is to schedule tight jobs. The two key components that lead to our new result are a new lower bound on the optimum offline solution m and a new sophisticated delaying scheme for processing jobs. Our lower bound is tailored to tight jobs only. While more standard bounds rely ontheloadinagiveninterval,werelateforagivenset of time intervals the number of jobs with intersecting time windows in these intervals to the fraction that thelaxityofthosejobstakesofthetotalinterval. The laxity of a job is (informally) the maximum amount of time that a job can be delayed without violating the deadline. For a given optimum value m, our new lower bound construction actually gives an upper bound on the number of jobs with intersecting time intervals, which is how we utilize the result. To get some intuition for our algorithm, we interpretthelaxityofajobasthemaximumbudgetfordelaying a job. Whenever a job is not processing (during its feasible time window), its budget is charged by the amount of this delay. Taking this viewpoint, the well-known algorithm Least Laxity First (LLF) is the algorithm that gives priority to the jobs with smallest remaining budgets. Such a naive charging scheme does not give any good bound for general instances [9]. It may seem promising that LLF performs much better when restricting to tight jobs. However, this turns out to be not the case as we show LLF does not achieve a competitive ratio of f(m) for any function f even for instances consisting of only tight jobs. The reason for failing is that LLF considers only the absolute remaining laxity and ignores the total size of jobs and the amount of time they spent already in the system. In particular, a huge job with huge laxity will be delayed until it is too late while batches of smaller jobs with smaller laxity arrive. To overcome this problem, we need a more balanced scheme for decreasing the laxity or, equivalently, for using the budget for not-processing a job. Driven by the new lower bound, we design an algorithm that balances the delay of jobs by taking the number of jobs with intersecting intervals into account. We open m = O(mlogm) machines and partition the total budget for not-processing a job (i.e., its laxity) into m +1 sub-budgets. The i-th subbudget can be accessed only at time points when i 1 jobs are already being processed. We consider the available jobs in decreasing order of release dates and process those with an empty corresponding subbudget. All other jobs pay for not being processed from their corresponding sub-budgets. Our main analysis is concerned with relating the algorithm then to the lower bound. Outline. In Section 2, we define the problem and give general structural insights. We derive a new lower bound on the optimum number of machines in Section 3. The description of our new algorithm is in Section 4 followed by its analysis in Section 5. Finally, in Section 6, we analyze the performance of our algorithm when being applied to agreeable and to laminar instances, respectively. 156 Copyright by SIAM.

3 2 Problem Definition and Preliminary Results Problem Definition. Given is a set of n jobs where each job j {1,2,...,n} has a processing timep j N, areleasedater j Nwhichistheearliest possible time at which the job can be processed, and a deadline d j N by which it must be completed. The task is to open a minimum number of machines such that there is a feasible schedule in which no job misses its deadline. In a feasible schedule each job j is scheduled for p j units of time within the time window [r j,d j ). Each opened machine can process at most one job at any time, and no job is running on multiple machines at the same time. We allow job preemption, i.e., a job can be preempted at any moment in time and may resume processing later on the same or any other machine. To evaluate the performance of our online algorithms, we perform a competitive analysis (see e.g. [2]). We call an online algorithm ρ-competitive if m machines with m ρ m suffice to guarantee a feasible solution for any instance that admits a feasible schedule on m machines. Notation. For a job j, the laxity is defined as l j = d j r j p j. We call a job α-loose, for some α < 1, if p j α(d j r j ) and α-tight otherwise. The (processing) interval of j is I(j) = [r j,d j ), and j is said to cover each t I(j). For a set of jobs S, we define I(S) = j S I(j). For I = k i=1 [a i,b i ) where [a 1,b 1 ),...,[a k,b k ) are pairwise disjoint, we define the length of I to be I = k i=1 (b i a i ). Indexing. Throughout this paper we assume w.l.o.g. that jobs are indexed in increasing order of release dates, and we break ties in decreasing order of deadlines. Hence, for any two jobs j,j with j < j one of the three cases holds: (i) r j < r j, (ii) r j = r j and d j > d j, or (iii) I(j) = I(j ). Characterization of the Optimum. Given an intervali, the contribution of ajob j to I is C(j,I) := max{0, I I(j) l j }, i.e., the minimum processing time that j must receive during I in any feasible schedule. The contribution of a job set S to I is the sum of the individual contributions of jobs in S, and wedenoteitbyc(s,i). Clearly, ifs admitsafeasible schedule on m machines, C(S, I)/ I must not exceed m. Interestingly, this bound is tight, which we prove in the full version of the paper. Theorem 2.1. Let m be the minimum number of machines needed to schedule a given job set S feasibly. There exists a union of intervals I with C(S,I)/ I = m but none with C(S,I)/ I > m. Reduction to the Semi-Online Problem. We show that we may assume that the optimum number of machines m is known in advance by losing at most a factor 4 in the competitive ratio. To do so, we employ the general idea of doubling an unknown parameter [3]. More specifically, we open additional machines whenever the optimum solution has doubled. Theorem 2.2. Given a ρ-competitive algorithm for semi-online machine minimization, there is a doubling-based algorithm that is 4ρ-competitive for online machine minimization. In the rest of the paper we will thus be concerned with the semi-online problem. Scheduling α-loose Jobs. We show that, for any fixed α < 1, α-loose jobs are easy to handle via a simple greedy algorithm called Earliest Deadline First (EDF) on m = ρ m machines with ρ = O(1). This algorithm schedules at any time m unfinished jobs with the smallest deadline. Theorem 2.3. Let α (0,1). EDF is an 1/(1 α) 2 - competitive algorithm for any instance that consists only of α-loose jobs. Scheduling α-tight Jobs. In the remaining part of the paper we assume that all jobs are α-tight for a fixed α (0,1). The good performance of EDF on α-loose jobs, does not apply to instances with α-tight jobs only. In fact, we show the following strong lower bound. Theorem 2.4. For arbitrary α (0,1), EDF has a competitive ratio of Ω(n) even if m = 2 and every job is α-tight. The Algorithm Least Laxity First (LLF) seems a promising candidate for this case. LLF schedules at any time m unfinished jobs with smallest remaining laxity. However, we show the following negative result. Theorem 2.5. For arbitrary α (0,1), LLF is not O(1)-competitive even if m = 2 and every job is α- tight. 3 A Lower Bound on the Optimum In this section we derive a new lower bound on m, the offline optimum number of machines. Basic lower bounds for this problem rely on the total load that can be shown to contribute to a (family of) time intervals. To obtain our new bound, we restrict now explicitly to α-tight jobs for some constant α (0,1), 157 Copyright by SIAM.

4 i.e., p j > α(d j r j ) for any job j. This enables us to relate to the laxity of jobs. The main new ingredient is to take into account the number of intervals covering the time points in a given set of intervals and relate it to the laxity of those jobs. This new lower bound might be of independent interest. In our setting we are given the optimum m. In that case, the new lower bound allows us to upper bound the number of jobs with intersecting time intervals, which is how we utilize the result. We use the following definition. Definition 3.1. Let G be a set of α-tight jobs and let T be a non-empty finite union of time intervals. For some µ N and β (0,1), a pair (G,T) is called (µ, β)-critical if (i) each t T is covered by at least µ distinct jobs in G, (ii) T I(j) βl j for any j G. In this section, we show the following theorem. Theorem 3.1. If there exists( a (µ, β)-critical ) pair, then m µ 4 4 log8/β 8+8/α log8/β = Ω µ log 1/β. If m is given, this theorem immediately implies the following upper bound on the number of jobs covering the relevant intervals. Corollary 3.1. If there exists a (µ, β)-critical pair, then µ = O(mlog1/β). To show the theorem by contradiction, we consider a (µ,β)-critical pair (G,T), and show how to select jobs from G with a total load contribution to some superset of T that contradicts Theorem 2.1. To that end, the following simple lemma will be useful several times. Lemma 3.1. Let S be a set of jobs. There exists a subset S S such that each time in I(S) is covered by at least one and at most two different jobs in S. A simple greedy algorithm finds such a subset. This result is surely folkloric, but as we could not find a proof, we provide one in the full version of the paper. Using this simple lemma, we show the first of two important properties of critical pairs. Lemma 3.2. Let (G,T) be a (µ,β)-critical pair. There exist pairwise disjoint subsets G 1,...,G µ/4 of G such that (i) T I(G 1) I(G µ/4 ), (ii) j G l j 4 T /β for every 1 i µ/4. i Proof. We first select disjoint subsets G 1,...,G µ/2 of G with a laminar interval structure, i.e., I(G 1 ) I(G µ/2 ), such that each time point in T is covered by at least one and at most two distinct jobs from each G i : Starting from i = µ/2, the iterative procedure selects a job set G i from G + i := G\(G i+1 G µ/2 ) using Lemma 3.1. To also satisfy (ii), we will later further select certain subsets from G 1,...,G µ/2. Before that, we show that indeed T I(G 1 ) I(G µ/2 ). Firstly, we show that I(G i ) I(G i+1 ) for every i. This follows from the fact that I(G + 1 ) I(G+ µ/2 ) (by definition of G+ i ) and I(G i ) = I(G + i )foralli(bylemma3.1). Secondly, we show T I(G 1 ), i.e., each time point in T is covered by at least one job in G 1. Recall that every time point in T is covered by at least µ distinct jobs in G and, according to Lemma 3.1, covered by at most two distinct jobs in G i for every i. Hence, any point in T is covered by at least µ 2( µ/2 1) 1 jobs in G + 1 = G\(G 2 G µ/2 ), andt I(G + 1 ) = I(G 1). Next we apply a counting argument to show an averaging alternative of Condition (ii). We set G = G 1 G µ/2, and note that each time in T is covered by at most 2 µ/2 distinct jobs in G because, as shown above, it is covered by at most two distinct jobs in each G i. Also using T I(G 1 ) I(G µ/2 ), we get T = (T I(j)) j G j G T I(j) (3.1) 2 µ/2 j G βl j, 2 µ/2 where the last inequality follows from the definition of a (µ, β)-critical pair. Now we argue that we can further choose G 1,...,G µ/4 from the family of job sets G 1,...,G µ/2 such that Condition (ii) is true. Suppose there are no such sets, i.e., we have j G i l j > 4 T /β for µ/2 µ/4 +1 µ/2 /2 different i. Then the total laxity of G is > l j = j G ( µ 2 µ/2 i=1 µ 4 j G i l j +1 which is a contradiction to (3.1). ) 4 T β 2 µ/2 T, β The following lemma states that, for arbitrary disjoint sets of α-tight jobs with a laminar interval 158 Copyright by SIAM.

5 structure, the total size of the covered time intervals is geometrically increasing. Lemma 3.3. Let S 1,...,S 2m/α be pairwise disjoint sets of α-tight jobs such that I(S 1 ) I(S 2m/α ). Then we have I(S 2m/α ) 2 I(S 1 ). Proof. Suppose on the contrary that I(S 2m/α ) < 2 I(S 1 ). We will show a contradiction based on the totalcontributionofallthejobstoi(s 2m/α ). Byassumption we have I(S i ) I(S 1 ) > I(S 2m/α ) /2 for all i {1,..., 2m/α }. Each of these sets S i consists of α-tight jobs only, i.e., p j > α(d j r j ) for any j, and thus, a workload of at least α I(S i ) α I(S 2m/α ) /2 has to be processed within the interval I(S 2m/α ). There are 2m/α different such sets S i, and consequently the total workload that has to be processed within I(S 2m/α ) is C 2m/α S i i=1, I(S 2m/α ) 2m > α I(S 2m/α ) m I(S 2m/α ), α 2 which is a contradiction to Theorem 2.1. We are now ready to prove the main theorem. Proof. [Proof of Theorem 3.1.] Let (G,T) be a (µ,β)-critical pair. Let G 1,...,G µ/4 be subsets of G that satisfy the two conditions of Lemma 3.2, i.e., (i) T I(G 1) I(G µ/4 ), and (ii) j G l j 4 T /β, for all i {1,..., µ/4 }. The i proof idea is to bound the contribution of certain subsetsg q,...,g µ/4 totheintervali(g q)andshow the bound on m by achieving a contradiction to the load bound in Theorem 2.1. In the following, we will fix k := log8/β and q := 2m/α k, and we distinguish two cases. If G q does not exist, i.e., q > µ/4, we obtain m α(µ 4 4k) 8k > µ 4 4 log8/β 8+8/α log8/β as claimed. Otherwise, G q does exist, and it follows from T I(G 1) and repeatedly applying Lemma 3.3 that I(G q ) = I(G 2m/α k ) 2k T. Now consider any G i, for i {1,..., µ/4 }. Using property (ii) of the subsets, we conclude, (3.2) I(G q) 2 k T 2 k β 4 l j 2 l j, where we use k = log8/β in the last step. For i q, the contribution of G i to I(G q) can be bounded from below as follows: C(G i,i(g q)) = max{0, I(G q) I(j) l j } ( ) I(G q ) I(j) l j I(G i) I(j) = I(G i) I(G q) l j. For i q, Equation (3.2) and I(G q) I(G i ) imply C(G i,i(g q)) I(G q) /2. We now show that m > ( µ/4 q)/2. Suppose this is not true. Then µ/4 q + 2m, and thus, we have at least 2m + 1 disjoint sets G i such that C(G i,i(g q)) I(G q) /2. Hence, µ C G i, I(G q) (2m+1) I(G q) 2 i=q > m I(G q). This is a contradiction to Theorem 2.1. We conclude by noting that indeed m µ 4 4 log8/β 8+8/α log8/β, using m > ( µ/4 q)/2 and our choice of q = 2m/α k = 2m/α log8/β. We will utilize Theorem 3.1 to construct an O(log m)-competitive algorithm. To show that this algorithm is O(1)-competitive for the special cases (laminar or agreeable instances), we use a slightly weaker definition of a (µ, β)-critical pair. We replace the job-individual Condition (ii) in Definition 3.1 by an averaging condition. Definition 3.2. Let G be a set of α-tight jobs and let T be a non-empty finite union of time intervals. For some µ N and β (0,1), a pair (G,T) is called weakly (µ, β)-critical if (i) each t T is covered by at least µ distinct jobs in G, (ii) T β/µ j G l j. It is easy to verify that the proofs above apply also to weakly (µ, β)-critical pairs. (Indeed, the only difference is that we do not need the counting argument to obtain Inequality (3.1) in the proof of Lemma 3.2.) Hence, we have the following theorem. l j 159 Copyright by SIAM.

6 decreasing in index j r j... t dj 2-nd budget empty, process 2-nd budget positive, charge it and preempt 1-st budget empty, process 1-st budget positive, charge it and preempt Figure 1: Illustration of our algorithm. At time t, we consider all relevant jobs in reverse order of their indices. After having found i active jobs, we check the (i+1)-th budget of the current job. If this budget is not empty, we charge it and preempt/delay the job; otherwise the job becomes active. Theorem 3.2. If there exists ) a weakly (µ, β)-critical pair, then m = Ω. ( µ log 1/β 4 Description of the Algorithm We assume that the optimum number of machines m is known in advance, and every job is α-tight. We open m machines and will choose m later appropriately as a function of m. The idea for our algorithm is the following. We view the laxity of a job as the budget for delaying it. Whenever a job is delayed for some time, then we pay this delay from its budget. If the budget is empty, we must process the job. Greedily decreasing the budget, as LLF does, fails. Instead, we aim at balancing the decrease of the budget by taking the number of currently processing jobs into account. To that end, we partition the total budget of each job intom +1equal-sizesmallerbudgets, numberedfrom 1tom +1. Thatis, ajobj hasm +1budgets, eachof size l j /(m +1). The i-th budget of a job is reserved for time points when i 1 other jobs (with larger index) are being processed, which means that their corresponding 1-st, 2-nd,, (i 1)-st budgets have become 0. Once i 1 such jobs are already running and the currently considered job has an empty i-th budget, then we process this job even if its other budgets are not empty. We now describe our algorithm in detail (pseudocode can be found in the full version of the paper). Figure1givesanillustration. Atatimet, weconsider all jobs with a time window covering t and call them relevant jobs at t. We must decide which jobs to process and which jobs to delay/preempt. We call the jobs that are processed at time t active jobs at time t and denote them by a 1 (t),a 2 (t),... At any computation time t, which we will specify later, we consider all relevant jobs at t in reverse order of their indices, i.e., in decreasing order of release dates. One after the other, we inspect the 1-st budget of each of these jobs. As long as it is positive, we do not process the corresponding job and charge its 1-st budget by the time duration until the next computation time. Once we find a job whose 1-st budgetis0, thisjobbecomesthefirstactivejoba 1 (t), and each of its budgets remains unchanged until the next computation time. We continue considering jobs in the reverse order of indices, i.e., we consider jobs with index smaller than a 1 (t). Now, we inspect the 2- nd budget of jobs (instead of the 1-st budget; because we have one active job). As long as the 2-nd budgets are non-empty we delay the jobs and charge their 2- nd budgets; once we find a job with an empty 2-nd budget, this job becomes the second active job a 2 (t). Then we continue with verifying the 3-rd budgets, etc. The computation times for our algorithm are release dates, deadlines, and time points at which the remaining budget of some job becomes 0. Since the number of budgets per job is m + 1, our algorithm has a polynomial running time if the chosen number of machines m is polynomial. If we ever find an (m +1)-th active job, we say that our algorithm fails. We will, however, show that we can choose m such that the algorithm never fails. 5 Analysis of the Algorithm for the General Case We prove the following theorem. Theorem 5.1. Our algorithm is O(log m)- competitive. By definition of our algorithm, a job s total budget never becomes negative, i.e., it is preempted no longer than its laxity. So we only have to show that our algorithm never finds too many active jobs, i.e., it never finds an (m +1)-th active job. To prove this, we will assume the contrary and will construct a 160 Copyright by SIAM.

7 critical pair, from whose existence the theorem then follows by Corollary 3.1. Lemma 5.1. If our algorithm fails, then there exists a (µ,1/µ)-critical pair where µ = m +1. Proof. As our algorithm fails, there is some time t at which an (m + 1)-th active job j is found. We construct a (µ,1/µ)-critical pair (F,T) which, intuitively speaking, is a minimal subset of jobs still causing the failure. More specifically, we have F = F 1 F µ as well as T = T 1 T µ and, from i = µ down to i = 1, we define F i as well as T i as follows. We set F µ := {j } and T µ := {t the µ-th budget of j is charged at t}. Moreover, for all i = µ 1,...,1, we define F i := {j j = a i (t) and T i := {t the i-th budget for some t T i+1 T µ } of some j F i is charged at t}. We show that (F,T) is indeed a (µ,1/µ)-critical pair. We first show that Condition (i) in Definition 3.1 is satisfied, i.e., each t in T is covered by µ different jobs in F. By definition of T, for any t T there is an i such that t T i. Using the definition of T i, there is some job j i F i such that its i-th budget is charged at t. Notice that the i-th budget of j i is charged at time t because there are i 1 active jobs a 1 (t),...,a i 1 (t), all with larger index than j i and time intervals covering t. Thus, there are at least i jobs j with j j i that cover t. Weclaimthatthereareatleastµ idifferentjobs j with j < j i that cover t. Assume this is true, then with the claim above, each t in T is indeed covered by µ different jobs in F. We now prove the claim by(downward) induction on i. Clearly it holds for i = µ. Assume the claim is true for all h = i + 1,...,µ. We now show it for i: According to the definition of F i, j i is the i-th active job at some t T k for k > i, where t < t because the remaining i-th budget of j i at t is still positive, whereas it becomes 0 at t. By the definition of T k, there also exists a job j k F k whose k-th budget is chargedattimet. Weapplytheinductionhypothesis for k to obtain that there are µ k different jobs j with j < j k < j i covering t. As j < j i implies r j r ji and we have t < t, all these µ k jobs also cover t. Similarly j k also satisfies j k < j i and covers t, so it covers t, too. To finish the proof of the claim, we show that there are k i 1 different jobs j with j k < j < j i that cover t. As the k-th budget of j k is charged at time t, there must exist active jobs a i+1 (t ),...,a k 1 (t ), each of which covers time t, and we have j k < a h (t ) < j i for all h {i+1,...,k 1}. Again using r ah (t ) r ji t t, all of these k i 1 jobs cover time t. Hence in total there are µ i different jobs j with j < j i that cover t. We conclude that each t in T is indeed covered by µ different jobs in F. Finally, we show that also the second property of a (µ,1/µ)-critical pair is fulfilled by (F,T). Indeed, T I(j) > l j /µ holds for each j F: By definition, there is an i such that j F i, and thus j is an i-th active job at some time t. As the i-th budget (which initially amounted to l j /µ) is exhausted at time t, it follows by definition of T i that T i I(j) l j /µ, and the lemma follows. We are now ready to prove the main theorem. Proof. [Proof of Theorem 5.1.] We show that our algorithm never fails, i.e., it never finds an (m +1)- st active job, when using m = O(mlogm) machines. This is sufficient for proving the theorem, as the algorithm opens m machines and processes at any time the active jobs. All other jobs have a positive corresponding budget and get preempted/delayed. No job is preempted/delayed for more time than its total laxity (budget). We assume that the algorithm fails, which implies the existence of a (µ,1/µ)-critical pair with µ = m + 1 by Lemma 5.1. Now, Corollary 3.1 implies µ cmlogµ for some constant c. Thus, there exists a constant c such that m c mlogm, i.e., the algorithm fails only if m c mlogm. For m sufficiently large, this inequality is not true. Thus, for m = O(mlogm) the algorithm does not fail. Remark. Careful calculations show that for m = 2, our algorithm opens m = 236 machines for tight jobs (taking α = 4/5). Including loose jobs (Theorem 2.3) and applying Theorem 2.2 when not knowning m, our algorithm requires 1044 machines in total, and is thus 522-competitive for the online machine minimization problem when m = 2. We remark that we did not optimize the parameters that we choose in the proofs. E.g., in the proof of Theorem 3.1, a more careful analysis could replace I(G 2m/α k ) 2k T by I(G 2m/α k+1 ) 2k T, which already leads to a better ratio of 414 form = 2. 6 Analysis of the Algorithm for Special Cases In this section we show that our algorithm is constant-competitive for two important special cases, namely, laminar and agreeable instances. In laminar instances, any two jobs j and j with I(j) I(j ) 161 Copyright by SIAM.

8 satisfy I(j) I(j ) or I(j ) I(j). In agreeable instances, r j < r j implies d j d j for any two jobs j and j. Theorem 6.1. For laminar and agreeable instances, our algorithm is O(1)-competitive. Recall that we only consider α-tight jobs. As in the general case, our proof strategy is to construct a (here: weakly) critical failure pair whenever our algorithm finds a µ-th active job j. To prove a constant competitive ratio, however, we use a slightly different construction in which we drop active jobs with intersecting intervals, and obtain a weakly (µ, β)-critical pair (H,T) where β = 1. This directly implies the theorembycorollary Infact,theconstructionis identical for both special cases. We construct job set H := H 1 H µ and time points T := T 1 T µ by (downward) inductively defining H µ := {j }, T µ := {t the µ-th budget of j is charged at t}, F i := {j j = a i (t) for some t T i+1 T µ }, H i := {j F i there does not exist j F i s.t. I(j) I(j ) and j < j}, and T i := {t the i-th budget of some j H i is charged at t}, for all i = µ 1,...,1. Note that the only difference from the construction for the general case is that for each set F i we additionally maintain a set H i F i in which we keep for any two intersecting intervals in F i only one. We call (H,T) the failure pair. To make more concise statements about the structure of the constructed pair, we introduce the notation S 1 S 2 (or equivalently, S 2 S 1 ) for two sets of jobs S 1 and S 2. Specifically, this means that for every job j 2 S 2 there exists a job j 1 S 1 such that I(j 1 ) I(j 2 ) and j 1 < j 2. Note that is not an order as it does not necessarily obey transitivity. The following structural lemma is true for both special cases; see the full version of the paper for the individual proofs. Lemma 6.1. Consider a laminar or agreeable instance, and let (H,T) be a failure pair. Then the following statements are true: (i) For all H i,h i with i < i, we have H i H i. (ii) For all H i, we have T I(H i ). 1 We are dropping constants by writing m = Ω(µ/log(1/β)) in Theorem 3.2. The logarithm is actually taken over 8/β instead of 1/β (see Equation (3.2)), and thus, β = 1 does not cause a problem in computation. With Lemma 6.1, we can prove Theorem 6.1 without using any further structural information. Proof. [Proof of Theorem 6.1.] We show that our algorithm never finds a µ-th active job if µ 1 = m = cm for a sufficiently large constant c. To this end, assume the contrary and let (H,T) be the corresponding failure pair, which we claim to be weakly (µ, 1)-critical. Given this claim, the theorem directly follows from Theorem 3.2. The first property of a weakly (µ, 1)-critical pair, that is, that each t T is covered by µ different jobs in H, is easy to see: By Lemma 6.1 (ii), there is a job in each H i that covers t. Also, all these jobs are distinct: If there exists a job j H i H i where i < i, Lemma 6.1 (i) implies the existence of j H i with j < j and I(j) I(j ). This would be a contradiction tothe construction of (H,T) as j would not be taken over from F i to H i because j H i, I(j) I(j ), and j < j. As an intermediate step, we claimthat T 1,...,T µ are pairwise disjoint. To see this, suppose there exists some t T i T i where i < i. By definition of T i, there exists a job j H i such that the i-th budget of j is charged at t. Similarly, there also exists some job whose i -th budget is charged at t, implying that at time t there exists an i-th active job a i (t) as i < i. We distinguish three cases, each of them yielding a contradiction: Case 1: We have a i (t) < j. Note that a i (t) F i by definition of F i. As t I(j) I(a i (t)), we get a contradiction as, by definition of H i, it does not include j. Case 2: We have a i (t) = j. Then the i-th budget of j is already exhausted at t, which is a contradiction to the fact that it is charged at t. Case 3: We have a i (t) > j. Recall that the algorithm considers jobs one by one in decreasing order of indices. After it found an i-th active job a i (t) at t, it will never check the i-th budget of jobs of lower indices. Hence the i-th budget of job j < a i (t) cannot be charged at t. It remains to show the second property of a weakly (µ,1)-critical pair, i.e., we have T j F l j/µ. For each H i, every j H i is an i-th active job at some time t and thus its i-th budget is exhausted at t. Consequently, there are times at which this budget is charged, implying T i I(j) l j /µ. Using that H i does not contain distinct jobs j and j 162 Copyright by SIAM.

9 with I(j) I(j ) (by definition), we obtain T i = j H i T i I(j) j H i l j µ. As T 1,...,T µ are pairwise disjoint, by summing up these inequalities for all H i, we get: T = µ T i i=1 µ l j µ = l j µ, j H i j H i=1 which concludes the proof. Remark. Careful calculations show that, when restricting to only α-tight jobs, the algorithm is ( 8/α + 4)-competitive for laminar instances, and ( 16/α + 8)-competitive for agreeable instances. Note that the factor of two between the ratios is due to that fact that for laminar instances the H i s we derive already satisfies a laminar structure, i.e., I(H 1 ) I(H 2 ) I(H µ ), while for agreeable instanceswestillneedtoapplylemma3.1togetsucha structure. When additionally handling loose jobs by EDF (Theorem 2.3), we derive a 24-competitive algorithm for laminar instances and a 44-competitive algorithm for agreeable instances if the offline optimum m is known (by taking α = 1/2). If m is not known, using Theorem 2.2 we derive a 96-competitive algorithm for laminar instances and a 176-competitive algorithm for agreeable instances. 7 Conclusions We presented an improved online algorithm for the preemptive machine minimization problem. Our general O(log m)-competitive algorithm yields a competitive ratio of O(1) for several special cases, such as, laminar and agreeable instances as well as instances wheretheoptimumvaluemisboundedbyaconstant. Our methodology is based on a new lower bound construction which may be of independent interest. We cannot rule out that a different construction of a failure set in the analysis may give a (µ,β)- critical pair with a constant β, which would prove directly a constant competitive ratio. Indeed, we show how to achieve this for laminar and agreeable instances. The results on these special cases verify the applicability of our general method, but we mention that algorithm and analysis are not optimized to give best possible constants. References [1] N. Bansal, T. Kimbrel, and K. Pruhs. Speed scaling to manage energy and temperature. J. ACM, 54(1), [2] A. Borodin and R. El-Yaniv. Online Computation and Competitive Analysis. Cambridge University Press, [3] M. Chrobak and C. Kenyon-Mathieu. SIGACT news online algorithms column 10: Competitiveness via doubling. SIGACT News, 37(4): , [4] N. R. Devanur, K. Makarychev, D. Panigrahi, and G. Yaroslavtsev. Online algorithms for machine minimization. CoRR, abs/ , [5] W. A. Horn. Some simple scheduling algorithms. Naval Research Logistics Quarterly, 21(1): , [6] M.-J. Kao, J.-J. Chen, I. Rutter, and D. Wagner. Competitive design and analysis for machineminimizing job scheduling problem. In Proc. of ISAAC, pages 75 84, [7] A. J. Kleywegt, V. S. Nori, M. W. P. Savelsbergh, and C. A. Tovey. Online resource minimization. In Proc. of SODA, pages , [8] T. W. Lam and K.-K. To. Trade-offs between speed and processor in hard-deadline scheduling. In Proc. of SODA, pages , [9] C. A. Phillips, C. Stein, E. Torng, and J. Wein. Optimal time-critical scheduling via resource augmentation. In Proc. of STOC, pages , [10] K. Pruhs. In Collection of Open Problems in Scheduling, Dagstuhl Scheduling Seminar, [11] B. Saha. Renting a cloud. In Proc. of FSTTCS, pages , [12] Y. Shi and D. Ye. Online bin packing with arbitrary release times. Theor. Comput. Sci., 390(1): , Copyright by SIAM.

The Power of Migration in Online Machine Minimization

The Power of Migration in Online Machine Minimization The Power of Migration in Online Machine Minimization Lin Chen Magyar Tudományos Akadémia (MTA SZTAKI) Budapest, Hungary chenlin198662@gmail.com Nicole Megow Technische Universität München Zentrum Mathematik

More information

arxiv: v2 [cs.ds] 27 Sep 2014

arxiv: v2 [cs.ds] 27 Sep 2014 New Results on Online Resource Minimization Lin Chen Nicole Megow Kevin Schewior September 30, 2014 arxiv:1407.7998v2 [cs.ds] 27 Sep 2014 Abstract We consider the online resource minimization problem in

More information

arxiv: v1 [cs.ds] 18 Jun 2015

arxiv: v1 [cs.ds] 18 Jun 2015 An O(m 2 logm)-competitive Algorithm for Online Machine Minimization Lin Chen 1, Nicole Megow 2, and Kevin Schewior 1 arxiv:1506.05721v1 [cs.ds] 18 Jun 2015 1 Technische Universität Berlin, Institut für

More information

A general framework for handling commitment in online throughput maximization

A general framework for handling commitment in online throughput maximization A general framework for handling commitment in online throughput maximization Lin Chen Franziska Eberle Nicole Megow Kevin Schewior Cliff Stein November 20, 2018 Abstract We study a fundamental online

More information

Scheduling Parallel Jobs with Linear Speedup

Scheduling Parallel Jobs with Linear Speedup Scheduling Parallel Jobs with Linear Speedup Alexander Grigoriev and Marc Uetz Maastricht University, Quantitative Economics, P.O.Box 616, 6200 MD Maastricht, The Netherlands. Email: {a.grigoriev, m.uetz}@ke.unimaas.nl

More information

On-line Bin-Stretching. Yossi Azar y Oded Regev z. Abstract. We are given a sequence of items that can be packed into m unit size bins.

On-line Bin-Stretching. Yossi Azar y Oded Regev z. Abstract. We are given a sequence of items that can be packed into m unit size bins. On-line Bin-Stretching Yossi Azar y Oded Regev z Abstract We are given a sequence of items that can be packed into m unit size bins. In the classical bin packing problem we x the size of the bins and try

More information

Online Scheduling of Parallel Jobs on Two Machines is 2-Competitive

Online Scheduling of Parallel Jobs on Two Machines is 2-Competitive Online Scheduling of Parallel Jobs on Two Machines is 2-Competitive J.L. Hurink and J.J. Paulus University of Twente, P.O. box 217, 7500AE Enschede, The Netherlands Abstract We consider online scheduling

More information

Online Scheduling with Bounded Migration

Online Scheduling with Bounded Migration Online Scheduling with Bounded Migration Peter Sanders Universität Karlsruhe (TH), Fakultät für Informatik, Postfach 6980, 76128 Karlsruhe, Germany email: sanders@ira.uka.de http://algo2.iti.uni-karlsruhe.de/sanders.php

More information

Polynomial Time Algorithms for Minimum Energy Scheduling

Polynomial Time Algorithms for Minimum Energy Scheduling Polynomial Time Algorithms for Minimum Energy Scheduling Philippe Baptiste 1, Marek Chrobak 2, and Christoph Dürr 1 1 CNRS, LIX UMR 7161, Ecole Polytechnique 91128 Palaiseau, France. Supported by CNRS/NSF

More information

A lower bound for scheduling of unit jobs with immediate decision on parallel machines

A lower bound for scheduling of unit jobs with immediate decision on parallel machines A lower bound for scheduling of unit jobs with immediate decision on parallel machines Tomáš Ebenlendr Jiří Sgall Abstract Consider scheduling of unit jobs with release times and deadlines on m identical

More information

SCHEDULING UNRELATED MACHINES BY RANDOMIZED ROUNDING

SCHEDULING UNRELATED MACHINES BY RANDOMIZED ROUNDING SIAM J. DISCRETE MATH. Vol. 15, No. 4, pp. 450 469 c 2002 Society for Industrial and Applied Mathematics SCHEDULING UNRELATED MACHINES BY RANDOMIZED ROUNDING ANDREAS S. SCHULZ AND MARTIN SKUTELLA Abstract.

More information

Completion Time Scheduling and the WSRPT Algorithm

Completion Time Scheduling and the WSRPT Algorithm Connecticut College Digital Commons @ Connecticut College Computer Science Faculty Publications Computer Science Department Spring 4-2012 Completion Time Scheduling and the WSRPT Algorithm Christine Chung

More information

Online Interval Coloring and Variants

Online Interval Coloring and Variants Online Interval Coloring and Variants Leah Epstein 1, and Meital Levy 1 Department of Mathematics, University of Haifa, 31905 Haifa, Israel. Email: lea@math.haifa.ac.il School of Computer Science, Tel-Aviv

More information

arxiv: v1 [cs.ds] 29 Jul 2014

arxiv: v1 [cs.ds] 29 Jul 2014 Speed-scaling with no Preemptions Evripidis Bampis 1, Dimitrios Letsios 2, and Giorgio Lucarelli 1 arxiv:1407.7654v1 [cs.ds] 29 Jul 2014 1 LIP6, Université Pierre et Marie Curie, France {Evripidis.Bampis,

More information

Machine Minimization for Scheduling Jobs with Interval Constraints

Machine Minimization for Scheduling Jobs with Interval Constraints Machine Minimization for Scheduling Jobs with Interval Constraints Julia Chuzhoy Sudipto Guha Sanjeev Khanna Joseph (Seffi) Naor Abstract The problem of scheduling jobs with interval constraints is a well-studied

More information

SPT is Optimally Competitive for Uniprocessor Flow

SPT is Optimally Competitive for Uniprocessor Flow SPT is Optimally Competitive for Uniprocessor Flow David P. Bunde Abstract We show that the Shortest Processing Time (SPT) algorithm is ( + 1)/2-competitive for nonpreemptive uniprocessor total flow time

More information

Dispersing Points on Intervals

Dispersing Points on Intervals Dispersing Points on Intervals Shimin Li 1 and Haitao Wang 1 Department of Computer Science, Utah State University, Logan, UT 843, USA shiminli@aggiemail.usu.edu Department of Computer Science, Utah State

More information

arxiv: v1 [cs.ds] 6 Jun 2018

arxiv: v1 [cs.ds] 6 Jun 2018 Online Makespan Minimization: The Power of Restart Zhiyi Huang Ning Kang Zhihao Gavin Tang Xiaowei Wu Yuhao Zhang arxiv:1806.02207v1 [cs.ds] 6 Jun 2018 Abstract We consider the online makespan minimization

More information

Weighted flow time does not admit O(1)-competitive algorithms

Weighted flow time does not admit O(1)-competitive algorithms Weighted flow time does not admit O(-competitive algorithms Nihil Bansal Ho-Leung Chan Abstract We consider the classic online scheduling problem of minimizing the total weighted flow time on a single

More information

arxiv: v1 [cs.ds] 30 Jun 2016

arxiv: v1 [cs.ds] 30 Jun 2016 Online Packet Scheduling with Bounded Delay and Lookahead Martin Böhm 1, Marek Chrobak 2, Lukasz Jeż 3, Fei Li 4, Jiří Sgall 1, and Pavel Veselý 1 1 Computer Science Institute of Charles University, Prague,

More information

Minimizing Mean Flowtime and Makespan on Master-Slave Systems

Minimizing Mean Flowtime and Makespan on Master-Slave Systems Minimizing Mean Flowtime and Makespan on Master-Slave Systems Joseph Y-T. Leung,1 and Hairong Zhao 2 Department of Computer Science New Jersey Institute of Technology Newark, NJ 07102, USA Abstract The

More information

Multiprocessor Scheduling I: Partitioned Scheduling. LS 12, TU Dortmund

Multiprocessor Scheduling I: Partitioned Scheduling. LS 12, TU Dortmund Multiprocessor Scheduling I: Partitioned Scheduling Prof. Dr. Jian-Jia Chen LS 12, TU Dortmund 22/23, June, 2015 Prof. Dr. Jian-Jia Chen (LS 12, TU Dortmund) 1 / 47 Outline Introduction to Multiprocessor

More information

A Robust APTAS for the Classical Bin Packing Problem

A Robust APTAS for the Classical Bin Packing Problem A Robust APTAS for the Classical Bin Packing Problem Leah Epstein 1 and Asaf Levin 2 1 Department of Mathematics, University of Haifa, 31905 Haifa, Israel. Email: lea@math.haifa.ac.il 2 Department of Statistics,

More information

How much can lookahead help in online single machine scheduling

How much can lookahead help in online single machine scheduling JID:IPL AID:3753 /SCO [m3+; v 1.80; Prn:16/11/2007; 10:54] P.1 (1-5) Information Processing Letters ( ) www.elsevier.com/locate/ipl How much can lookahead help in online single machine scheduling Feifeng

More information

This means that we can assume each list ) is

This means that we can assume each list ) is This means that we can assume each list ) is of the form ),, ( )with < and Since the sizes of the items are integers, there are at most +1pairs in each list Furthermore, if we let = be the maximum possible

More information

On-line Scheduling to Minimize Max Flow Time: An Optimal Preemptive Algorithm

On-line Scheduling to Minimize Max Flow Time: An Optimal Preemptive Algorithm On-line Scheduling to Minimize Max Flow Time: An Optimal Preemptive Algorithm Christoph Ambühl and Monaldo Mastrolilli IDSIA Galleria 2, CH-6928 Manno, Switzerland October 22, 2004 Abstract We investigate

More information

Advances in processor, memory, and communication technologies

Advances in processor, memory, and communication technologies Discrete and continuous min-energy schedules for variable voltage processors Minming Li, Andrew C. Yao, and Frances F. Yao Department of Computer Sciences and Technology and Center for Advanced Study,

More information

Speed-scaling with no Preemptions

Speed-scaling with no Preemptions Speed-scaling with no Preemptions Evripidis Bampis 1, Dimitrios Letsios 2, and Giorgio Lucarelli 1,3 1 Sorbonne Universités, UPMC Univ. Paris 06, UMR 7606, LIP6, Paris, France. Evripidis.Bampis@lip6.fr

More information

2 Martin Skutella modeled by machine-dependent release dates r i 0 which denote the earliest point in time when ob may be processed on machine i. Toge

2 Martin Skutella modeled by machine-dependent release dates r i 0 which denote the earliest point in time when ob may be processed on machine i. Toge Convex Quadratic Programming Relaxations for Network Scheduling Problems? Martin Skutella?? Technische Universitat Berlin skutella@math.tu-berlin.de http://www.math.tu-berlin.de/~skutella/ Abstract. In

More information

Machine scheduling with resource dependent processing times

Machine scheduling with resource dependent processing times Mathematical Programming manuscript No. (will be inserted by the editor) Alexander Grigoriev Maxim Sviridenko Marc Uetz Machine scheduling with resource dependent processing times Received: date / Revised

More information

Online algorithms for parallel job scheduling and strip packing Hurink, J.L.; Paulus, J.J.

Online algorithms for parallel job scheduling and strip packing Hurink, J.L.; Paulus, J.J. Online algorithms for parallel job scheduling and strip packing Hurink, J.L.; Paulus, J.J. Published: 01/01/007 Document Version Publisher s PDF, also known as Version of Record (includes final page, issue

More information

Chapter 11. Approximation Algorithms. Slides by Kevin Wayne Pearson-Addison Wesley. All rights reserved.

Chapter 11. Approximation Algorithms. Slides by Kevin Wayne Pearson-Addison Wesley. All rights reserved. Chapter 11 Approximation Algorithms Slides by Kevin Wayne. Copyright @ 2005 Pearson-Addison Wesley. All rights reserved. 1 Approximation Algorithms Q. Suppose I need to solve an NP-hard problem. What should

More information

RUN-TIME EFFICIENT FEASIBILITY ANALYSIS OF UNI-PROCESSOR SYSTEMS WITH STATIC PRIORITIES

RUN-TIME EFFICIENT FEASIBILITY ANALYSIS OF UNI-PROCESSOR SYSTEMS WITH STATIC PRIORITIES RUN-TIME EFFICIENT FEASIBILITY ANALYSIS OF UNI-PROCESSOR SYSTEMS WITH STATIC PRIORITIES Department for Embedded Systems/Real-Time Systems, University of Ulm {name.surname}@informatik.uni-ulm.de Abstract:

More information

CSE101: Design and Analysis of Algorithms. Ragesh Jaiswal, CSE, UCSD

CSE101: Design and Analysis of Algorithms. Ragesh Jaiswal, CSE, UCSD Course Overview Material that will be covered in the course: Basic graph algorithms Algorithm Design Techniques Greedy Algorithms Divide and Conquer Dynamic Programming Network Flows Computational intractability

More information

Non-Work-Conserving Non-Preemptive Scheduling: Motivations, Challenges, and Potential Solutions

Non-Work-Conserving Non-Preemptive Scheduling: Motivations, Challenges, and Potential Solutions Non-Work-Conserving Non-Preemptive Scheduling: Motivations, Challenges, and Potential Solutions Mitra Nasri Chair of Real-time Systems, Technische Universität Kaiserslautern, Germany nasri@eit.uni-kl.de

More information

Rate-monotonic scheduling on uniform multiprocessors

Rate-monotonic scheduling on uniform multiprocessors Rate-monotonic scheduling on uniform multiprocessors Sanjoy K. Baruah The University of North Carolina at Chapel Hill Email: baruah@cs.unc.edu Joël Goossens Université Libre de Bruxelles Email: joel.goossens@ulb.ac.be

More information

A robust APTAS for the classical bin packing problem

A robust APTAS for the classical bin packing problem A robust APTAS for the classical bin packing problem Leah Epstein Asaf Levin Abstract Bin packing is a well studied problem which has many applications. In this paper we design a robust APTAS for the problem.

More information

CS 374: Algorithms & Models of Computation, Spring 2017 Greedy Algorithms Lecture 19 April 4, 2017 Chandra Chekuri (UIUC) CS374 1 Spring / 1

CS 374: Algorithms & Models of Computation, Spring 2017 Greedy Algorithms Lecture 19 April 4, 2017 Chandra Chekuri (UIUC) CS374 1 Spring / 1 CS 374: Algorithms & Models of Computation, Spring 2017 Greedy Algorithms Lecture 19 April 4, 2017 Chandra Chekuri (UIUC) CS374 1 Spring 2017 1 / 1 Part I Greedy Algorithms: Tools and Techniques Chandra

More information

PREEMPTIVE RESOURCE CONSTRAINED SCHEDULING WITH TIME-WINDOWS

PREEMPTIVE RESOURCE CONSTRAINED SCHEDULING WITH TIME-WINDOWS PREEMPTIVE RESOURCE CONSTRAINED SCHEDULING WITH TIME-WINDOWS Kanthi Sarpatwar IBM Research Joint Work With: Baruch Schieber (IBM Research) Hadas Shachnai (Technion) Kanthi Kiran Sarpatwar 1 / 22 Introduction

More information

Task Models and Scheduling

Task Models and Scheduling Task Models and Scheduling Jan Reineke Saarland University June 27 th, 2013 With thanks to Jian-Jia Chen at KIT! Jan Reineke Task Models and Scheduling June 27 th, 2013 1 / 36 Task Models and Scheduling

More information

Semi-Online Multiprocessor Scheduling with Given Total Processing Time

Semi-Online Multiprocessor Scheduling with Given Total Processing Time Semi-Online Multiprocessor Scheduling with Given Total Processing Time T.C. Edwin Cheng Hans Kellerer Vladimir Kotov Abstract We are given a set of identical machines and a sequence of jobs, the sum of

More information

Non-clairvoyant Scheduling for Minimizing Mean Slowdown

Non-clairvoyant Scheduling for Minimizing Mean Slowdown Non-clairvoyant Scheduling for Minimizing Mean Slowdown N. Bansal K. Dhamdhere J. Könemann A. Sinha April 2, 2003 Abstract We consider the problem of scheduling dynamically arriving jobs in a non-clairvoyant

More information

Real-time operating systems course. 6 Definitions Non real-time scheduling algorithms Real-time scheduling algorithm

Real-time operating systems course. 6 Definitions Non real-time scheduling algorithms Real-time scheduling algorithm Real-time operating systems course 6 Definitions Non real-time scheduling algorithms Real-time scheduling algorithm Definitions Scheduling Scheduling is the activity of selecting which process/thread should

More information

Scheduling Algorithms for Multiprogramming in a Hard Realtime Environment

Scheduling Algorithms for Multiprogramming in a Hard Realtime Environment Scheduling Algorithms for Multiprogramming in a Hard Realtime Environment C. Liu and J. Layland Journal of the ACM, 20(1):46--61, January 1973. 2 Contents 1. Introduction and Background 2. The Environment

More information

Embedded Systems 14. Overview of embedded systems design

Embedded Systems 14. Overview of embedded systems design Embedded Systems 14-1 - Overview of embedded systems design - 2-1 Point of departure: Scheduling general IT systems In general IT systems, not much is known about the computational processes a priori The

More information

Schedulability analysis of global Deadline-Monotonic scheduling

Schedulability analysis of global Deadline-Monotonic scheduling Schedulability analysis of global Deadline-Monotonic scheduling Sanjoy Baruah Abstract The multiprocessor Deadline-Monotonic (DM) scheduling of sporadic task systems is studied. A new sufficient schedulability

More information

There are three priority driven approaches that we will look at

There are three priority driven approaches that we will look at Priority Driven Approaches There are three priority driven approaches that we will look at Earliest-Deadline-First (EDF) Least-Slack-Time-first (LST) Latest-Release-Time-first (LRT) 1 EDF Earliest deadline

More information

Open Problems in Throughput Scheduling

Open Problems in Throughput Scheduling Open Problems in Throughput Scheduling Jiří Sgall Computer Science Institute of Charles University, Faculty of Mathematics and Physics, Malostranské nám. 25, CZ-11800 Praha 1, Czech Republic. sgall@iuuk.mff.cuni.cz

More information

Preemptive Online Scheduling: Optimal Algorithms for All Speeds

Preemptive Online Scheduling: Optimal Algorithms for All Speeds Preemptive Online Scheduling: Optimal Algorithms for All Speeds Tomáš Ebenlendr Wojciech Jawor Jiří Sgall Abstract Our main result is an optimal online algorithm for preemptive scheduling on uniformly

More information

Aperiodic Task Scheduling

Aperiodic Task Scheduling Aperiodic Task Scheduling Jian-Jia Chen (slides are based on Peter Marwedel) TU Dortmund, Informatik 12 Germany Springer, 2010 2017 年 11 月 29 日 These slides use Microsoft clip arts. Microsoft copyright

More information

Bincoloring 1. Sven O. Krumke a Willem E. de Paepe b Jörg Rambau c Leen Stougie d Kaiserslautern, Germany.

Bincoloring 1. Sven O. Krumke a Willem E. de Paepe b Jörg Rambau c Leen Stougie d Kaiserslautern, Germany. Bincoloring 1 Sven O. Krumke a Willem E. de Paepe b Jörg Rambau c Leen Stougie d a Department of Mathematics, University of Kaiserslautern. Paul-Ehrlich-Str. 14, 67653 Kaiserslautern, Germany. Email: krumke@mathematik.uni-kl.de

More information

Multiprocessor Scheduling II: Global Scheduling. LS 12, TU Dortmund

Multiprocessor Scheduling II: Global Scheduling. LS 12, TU Dortmund Multiprocessor Scheduling II: Global Scheduling Prof. Dr. Jian-Jia Chen LS 12, TU Dortmund 28, June, 2016 Prof. Dr. Jian-Jia Chen (LS 12, TU Dortmund) 1 / 42 Global Scheduling We will only focus on identical

More information

Multiprocessor jobs, preemptive schedules, and one-competitive online algorithms

Multiprocessor jobs, preemptive schedules, and one-competitive online algorithms Multiprocessor jobs, preemptive schedules, and one-competitive online algorithms Jiří Sgall 1 and Gerhard J. Woeginger 2 1 Computer Science Institute of Charles University, Praha, Czech Republic, sgall@iuuk.mff.cuni.cz.

More information

Algorithm Design. Scheduling Algorithms. Part 2. Parallel machines. Open-shop Scheduling. Job-shop Scheduling.

Algorithm Design. Scheduling Algorithms. Part 2. Parallel machines. Open-shop Scheduling. Job-shop Scheduling. Algorithm Design Scheduling Algorithms Part 2 Parallel machines. Open-shop Scheduling. Job-shop Scheduling. 1 Parallel Machines n jobs need to be scheduled on m machines, M 1,M 2,,M m. Each machine can

More information

A Greedy Approximation Algorithm for Minimum-Gap Scheduling

A Greedy Approximation Algorithm for Minimum-Gap Scheduling A Greedy Approximation Algorithm for Minimum-Gap Scheduling Marek Chrobak 1, Uriel Feige 2, Mohammad Taghi Hajiaghayi 3, Sanjeev Khanna 4, Fei Li 5, and Seffi Naor 6 1 Department of Computer Science, Univ.

More information

CMSC 451: Lecture 7 Greedy Algorithms for Scheduling Tuesday, Sep 19, 2017

CMSC 451: Lecture 7 Greedy Algorithms for Scheduling Tuesday, Sep 19, 2017 CMSC CMSC : Lecture Greedy Algorithms for Scheduling Tuesday, Sep 9, 0 Reading: Sects.. and. of KT. (Not covered in DPV.) Interval Scheduling: We continue our discussion of greedy algorithms with a number

More information

Lecture 13. Real-Time Scheduling. Daniel Kästner AbsInt GmbH 2013

Lecture 13. Real-Time Scheduling. Daniel Kästner AbsInt GmbH 2013 Lecture 3 Real-Time Scheduling Daniel Kästner AbsInt GmbH 203 Model-based Software Development 2 SCADE Suite Application Model in SCADE (data flow + SSM) System Model (tasks, interrupts, buses, ) SymTA/S

More information

Multiprocessor EDF and Deadline Monotonic Schedulability Analysis

Multiprocessor EDF and Deadline Monotonic Schedulability Analysis Multiprocessor EDF and Deadline Monotonic Schedulability Analysis Ted Baker Department of Computer Science Florida State University Tallahassee, FL 32306-4530 http://www.cs.fsu.edu/ baker Overview 1. question

More information

The Partitioned Dynamic-priority Scheduling of Sporadic Task Systems

The Partitioned Dynamic-priority Scheduling of Sporadic Task Systems The Partitioned Dynamic-priority Scheduling of Sporadic Task Systems Abstract A polynomial-time algorithm is presented for partitioning a collection of sporadic tasks among the processors of an identical

More information

Stochastic Submodular Cover with Limited Adaptivity

Stochastic Submodular Cover with Limited Adaptivity Stochastic Submodular Cover with Limited Adaptivity Arpit Agarwal Sepehr Assadi Sanjeev Khanna Abstract In the submodular cover problem, we are given a non-negative monotone submodular function f over

More information

A Framework for Scheduling with Online Availability

A Framework for Scheduling with Online Availability A Framework for Scheduling with Online Availability Florian Diedrich, and Ulrich M. Schwarz Institut für Informatik, Christian-Albrechts-Universität zu Kiel, Olshausenstr. 40, 24098 Kiel, Germany {fdi,ums}@informatik.uni-kiel.de

More information

Lecture 24: April 12

Lecture 24: April 12 CS271 Randomness & Computation Spring 2018 Instructor: Alistair Sinclair Lecture 24: April 12 Disclaimer: These notes have not been subjected to the usual scrutiny accorded to formal publications. They

More information

Networked Embedded Systems WS 2016/17

Networked Embedded Systems WS 2016/17 Networked Embedded Systems WS 2016/17 Lecture 2: Real-time Scheduling Marco Zimmerling Goal of Today s Lecture Introduction to scheduling of compute tasks on a single processor Tasks need to finish before

More information

Speed Scaling to Manage Temperature

Speed Scaling to Manage Temperature Speed Scaling to Manage Temperature Leon Atkins 1, Guillaume Aupy 2, Daniel Cole 3, and Kirk Pruhs 4, 1 Department of Computer Science, University of Bristol, atkins@compsci.bristol.ac.uk 2 Computer Science

More information

Competitive Management of Non-Preemptive Queues with Multiple Values

Competitive Management of Non-Preemptive Queues with Multiple Values Competitive Management of Non-Preemptive Queues with Multiple Values Nir Andelman and Yishay Mansour School of Computer Science, Tel-Aviv University, Tel-Aviv, Israel Abstract. We consider the online problem

More information

bound of (1 + p 37)=6 1: Finally, we present a randomized non-preemptive 8 -competitive algorithm for m = 2 7 machines and prove that this is op

bound of (1 + p 37)=6 1: Finally, we present a randomized non-preemptive 8 -competitive algorithm for m = 2 7 machines and prove that this is op Semi-online scheduling with decreasing job sizes Steve Seiden Jir Sgall y Gerhard Woeginger z October 27, 1998 Abstract We investigate the problem of semi-online scheduling jobs on m identical parallel

More information

Speed Scaling in the Non-clairvoyant Model

Speed Scaling in the Non-clairvoyant Model Speed Scaling in the Non-clairvoyant Model [Extended Abstract] ABSTRACT Yossi Azar Tel Aviv University Tel Aviv, Israel azar@tau.ac.il Zhiyi Huang University of Hong Kong Hong Kong zhiyi@cs.hku.hk In recent

More information

Decomposition of Riesz frames and wavelets into a finite union of linearly independent sets

Decomposition of Riesz frames and wavelets into a finite union of linearly independent sets Decomposition of Riesz frames and wavelets into a finite union of linearly independent sets Ole Christensen, Alexander M. Lindner Abstract We characterize Riesz frames and prove that every Riesz frame

More information

Resource Augmentation for Weighted Flow-time explained by Dual Fitting

Resource Augmentation for Weighted Flow-time explained by Dual Fitting Resource Augmentation for Weighted Flow-time explained by Dual Fitting S. Anand Naveen Garg Amit Kumar Abstract We propose a general dual-fitting technique for analyzing online scheduling algorithms in

More information

AS computer hardware technology advances, both

AS computer hardware technology advances, both 1 Best-Harmonically-Fit Periodic Task Assignment Algorithm on Multiple Periodic Resources Chunhui Guo, Student Member, IEEE, Xiayu Hua, Student Member, IEEE, Hao Wu, Student Member, IEEE, Douglas Lautner,

More information

Priority-driven Scheduling of Periodic Tasks (1) Advanced Operating Systems (M) Lecture 4

Priority-driven Scheduling of Periodic Tasks (1) Advanced Operating Systems (M) Lecture 4 Priority-driven Scheduling of Periodic Tasks (1) Advanced Operating Systems (M) Lecture 4 Priority-driven Scheduling Assign priorities to jobs, based on their deadline or other timing constraint Make scheduling

More information

Real-Time and Embedded Systems (M) Lecture 5

Real-Time and Embedded Systems (M) Lecture 5 Priority-driven Scheduling of Periodic Tasks (1) Real-Time and Embedded Systems (M) Lecture 5 Lecture Outline Assumptions Fixed-priority algorithms Rate monotonic Deadline monotonic Dynamic-priority algorithms

More information

Online Coloring of Intervals with Bandwidth

Online Coloring of Intervals with Bandwidth Online Coloring of Intervals with Bandwidth Udo Adamy 1 and Thomas Erlebach 2, 1 Institute for Theoretical Computer Science, ETH Zürich, 8092 Zürich, Switzerland. adamy@inf.ethz.ch 2 Computer Engineering

More information

Approximating maximum satisfiable subsystems of linear equations of bounded width

Approximating maximum satisfiable subsystems of linear equations of bounded width Approximating maximum satisfiable subsystems of linear equations of bounded width Zeev Nutov The Open University of Israel Daniel Reichman The Open University of Israel Abstract We consider the problem

More information

Speed Scaling Functions for Flow Time Scheduling based on Active Job Count

Speed Scaling Functions for Flow Time Scheduling based on Active Job Count Speed Scaling Functions for Flow Time Scheduling based on Active Job Count Tak-Wah Lam 1, Lap-Kei Lee 1, Isaac K. K. To 2, and Prudence W. H. Wong 2 1 Department of Computer Science, University of Hong

More information

Embedded Systems 15. REVIEW: Aperiodic scheduling. C i J i 0 a i s i f i d i

Embedded Systems 15. REVIEW: Aperiodic scheduling. C i J i 0 a i s i f i d i Embedded Systems 15-1 - REVIEW: Aperiodic scheduling C i J i 0 a i s i f i d i Given: A set of non-periodic tasks {J 1,, J n } with arrival times a i, deadlines d i, computation times C i precedence constraints

More information

Andrew Morton University of Waterloo Canada

Andrew Morton University of Waterloo Canada EDF Feasibility and Hardware Accelerators Andrew Morton University of Waterloo Canada Outline 1) Introduction and motivation 2) Review of EDF and feasibility analysis 3) Hardware accelerators and scheduling

More information

The Power of Preemption on Unrelated Machines and Applications to Scheduling Orders

The Power of Preemption on Unrelated Machines and Applications to Scheduling Orders MATHEMATICS OF OPERATIONS RESEARCH Vol. 37, No. 2, May 2012, pp. 379 398 ISSN 0364-765X (print) ISSN 1526-5471 (online) http://dx.doi.org/10.1287/moor.1110.0520 2012 INFORMS The Power of Preemption on

More information

A CONSTANT-FACTOR APPROXIMATION FOR MULTI-COVERING WITH DISKS

A CONSTANT-FACTOR APPROXIMATION FOR MULTI-COVERING WITH DISKS A CONSTANT-FACTOR APPROXIMATION FOR MULTI-COVERING WITH DISKS Santanu Bhowmick, Kasturi Varadarajan, and Shi-Ke Xue Abstract. We consider the following multi-covering problem with disks. We are given two

More information

Scheduling Maintenance Jobs in Networks

Scheduling Maintenance Jobs in Networks Scheduling Maintenance Jobs in Networks Fidaa Abed, Lin Chen, Yann Disser, Martin Groß 4, Nicole Megow 5, Julie Meißner 6, Alexander T. Richter 7, and Roman Rischke 8 University of Jeddah, Jeddah, Saudi

More information

Real-Time Systems. Event-Driven Scheduling

Real-Time Systems. Event-Driven Scheduling Real-Time Systems Event-Driven Scheduling Hermann Härtig WS 2018/19 Outline mostly following Jane Liu, Real-Time Systems Principles Scheduling EDF and LST as dynamic scheduling methods Fixed Priority schedulers

More information

Deadline-driven scheduling

Deadline-driven scheduling Deadline-driven scheduling Michal Sojka Czech Technical University in Prague, Faculty of Electrical Engineering, Department of Control Engineering November 8, 2017 Some slides are derived from lectures

More information

the currently active 1 job whose deadline parameter is the smallest, is an optimal scheduling algorithm in the sense that if a system can be scheduled

the currently active 1 job whose deadline parameter is the smallest, is an optimal scheduling algorithm in the sense that if a system can be scheduled Priority-driven scheduling of periodic task systems on multiprocessors Λ Joël Goossens Shelby Funk Sanjoy Baruah Abstract The scheduling of systems of periodic tasks upon multiprocessor platforms is considered.

More information

8 Knapsack Problem 8.1 (Knapsack)

8 Knapsack Problem 8.1 (Knapsack) 8 Knapsack In Chapter 1 we mentioned that some NP-hard optimization problems allow approximability to any required degree. In this chapter, we will formalize this notion and will show that the knapsack

More information

Simple Dispatch Rules

Simple Dispatch Rules Simple Dispatch Rules We will first look at some simple dispatch rules: algorithms for which the decision about which job to run next is made based on the jobs and the time (but not on the history of jobs

More information

Online Non-preemptive Scheduling of Equal-length Jobs on Two Identical Machines

Online Non-preemptive Scheduling of Equal-length Jobs on Two Identical Machines Online Non-preemptive Scheduling of Equal-length Jobs on Two Identical Machines MICHAEL H. GOLDWASSER and MARK PEDIGO Saint Louis University We consider the non-preemptive scheduling of two identical machines

More information

Online Optimization of Busy Time on Parallel Machines

Online Optimization of Busy Time on Parallel Machines Online Optimization of Busy Time on Parallel Machines Mordechai Shalom 1 Ariella Voloshin 2 Prudence W.H. Wong 3 Fencol C.C. Yung 3 Shmuel Zaks 2 1 TelHai College, Upper Galilee, 12210, Israel cmshalom@telhai.ac.il

More information

Real-Time Systems. Event-Driven Scheduling

Real-Time Systems. Event-Driven Scheduling Real-Time Systems Event-Driven Scheduling Marcus Völp, Hermann Härtig WS 2013/14 Outline mostly following Jane Liu, Real-Time Systems Principles Scheduling EDF and LST as dynamic scheduling methods Fixed

More information

A note on semi-online machine covering

A note on semi-online machine covering A note on semi-online machine covering Tomáš Ebenlendr 1, John Noga 2, Jiří Sgall 1, and Gerhard Woeginger 3 1 Mathematical Institute, AS CR, Žitná 25, CZ-11567 Praha 1, The Czech Republic. Email: ebik,sgall@math.cas.cz.

More information

EDF Feasibility and Hardware Accelerators

EDF Feasibility and Hardware Accelerators EDF Feasibility and Hardware Accelerators Andrew Morton University of Waterloo, Waterloo, Canada, arrmorton@uwaterloo.ca Wayne M. Loucks University of Waterloo, Waterloo, Canada, wmloucks@pads.uwaterloo.ca

More information

ARobustPTASforMachineCoveringand Packing

ARobustPTASforMachineCoveringand Packing ARobustPTASforMachineCoveringand Packing Martin Skutella and José Verschae Institute of Mathematics, TU Berlin, Germany {skutella,verschae}@math.tu-berlin.de Abstract. Minimizing the makespan or maximizing

More information

New Approximations for Broadcast Scheduling via Variants of α-point Rounding

New Approximations for Broadcast Scheduling via Variants of α-point Rounding New Approximations for Broadcast Scheduling via Variants of α-point Rounding Sungjin Im Maxim Sviridenko Abstract We revisit the pull-based broadcast scheduling model. In this model, there are n unit-sized

More information

Lecture 6. Real-Time Systems. Dynamic Priority Scheduling

Lecture 6. Real-Time Systems. Dynamic Priority Scheduling Real-Time Systems Lecture 6 Dynamic Priority Scheduling Online scheduling with dynamic priorities: Earliest Deadline First scheduling CPU utilization bound Optimality and comparison with RM: Schedulability

More information

Topic: Balanced Cut, Sparsest Cut, and Metric Embeddings Date: 3/21/2007

Topic: Balanced Cut, Sparsest Cut, and Metric Embeddings Date: 3/21/2007 CS880: Approximations Algorithms Scribe: Tom Watson Lecturer: Shuchi Chawla Topic: Balanced Cut, Sparsest Cut, and Metric Embeddings Date: 3/21/2007 In the last lecture, we described an O(log k log D)-approximation

More information

From Preemptive to Non-preemptive Speed-Scaling Scheduling

From Preemptive to Non-preemptive Speed-Scaling Scheduling From Preemptive to Non-preemptive Speed-Scaling Scheduling Evripidis Bampis a, Alexander Kononov b, Dimitrios Letsios a,c, Giorgio Lucarelli a,c, Ioannis Nemparis a,d a LIP6, Université Pierre et Marie

More information

Common-Deadline Lazy Bureaucrat Scheduling Problems

Common-Deadline Lazy Bureaucrat Scheduling Problems Common-Deadline Lazy Bureaucrat Scheduling Problems Behdad Esfahbod, Mohammad Ghodsi, and Ali Sharifi Computer Engineering Department Sharif University of Technology, Tehran, Iran, {behdad,ghodsi}@sharif.edu,

More information

Santa Claus Schedules Jobs on Unrelated Machines

Santa Claus Schedules Jobs on Unrelated Machines Santa Claus Schedules Jobs on Unrelated Machines Ola Svensson (osven@kth.se) Royal Institute of Technology - KTH Stockholm, Sweden March 22, 2011 arxiv:1011.1168v2 [cs.ds] 21 Mar 2011 Abstract One of the

More information

CPU SCHEDULING RONG ZHENG

CPU SCHEDULING RONG ZHENG CPU SCHEDULING RONG ZHENG OVERVIEW Why scheduling? Non-preemptive vs Preemptive policies FCFS, SJF, Round robin, multilevel queues with feedback, guaranteed scheduling 2 SHORT-TERM, MID-TERM, LONG- TERM

More information

Real-time Scheduling of Periodic Tasks (1) Advanced Operating Systems Lecture 2

Real-time Scheduling of Periodic Tasks (1) Advanced Operating Systems Lecture 2 Real-time Scheduling of Periodic Tasks (1) Advanced Operating Systems Lecture 2 Lecture Outline Scheduling periodic tasks The rate monotonic algorithm Definition Non-optimality Time-demand analysis...!2

More information