An O(logm)-Competitive Algorithm for Online Machine Minimization
|
|
- Meagan Jennings
- 6 years ago
- Views:
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 Lin Chen Magyar Tudományos Akadémia (MTA SZTAKI) Budapest, Hungary chenlin198662@gmail.com Nicole Megow Technische Universität München Zentrum Mathematik
More informationarxiv: 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 informationarxiv: 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 informationA 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 informationScheduling 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 informationOn-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 informationOnline 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 informationOnline 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 informationPolynomial 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 informationA 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 informationSCHEDULING 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 informationCompletion 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 informationOnline 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 informationarxiv: 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 informationMachine 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 informationSPT 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 informationDispersing 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 informationarxiv: 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 informationWeighted 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 informationarxiv: 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 informationMinimizing 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 informationMultiprocessor 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 informationA 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 informationHow 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 informationThis 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 informationOn-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 informationAdvances 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 informationSpeed-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 information2 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 informationMachine 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 informationOnline 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 informationChapter 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 informationRUN-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 informationCSE101: 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 informationNon-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 informationRate-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 informationA 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 informationCS 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 informationPREEMPTIVE 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 informationTask 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 informationSemi-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 informationNon-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 informationReal-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 informationScheduling 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 informationEmbedded 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 informationSchedulability 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 informationThere 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 informationOpen 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 informationPreemptive 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 informationAperiodic 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 informationBincoloring 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 informationMultiprocessor 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 informationMultiprocessor 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 informationAlgorithm 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 informationA 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 informationCMSC 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 informationLecture 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 informationMultiprocessor 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 informationThe 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 informationStochastic 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 informationA 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 informationLecture 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 informationNetworked 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 informationSpeed 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 informationCompetitive 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 informationbound 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 informationSpeed 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 informationDecomposition 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 informationResource 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 informationAS 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 informationPriority-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 informationReal-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 informationOnline 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 informationApproximating 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 informationSpeed 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 informationEmbedded 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 informationAndrew 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 informationThe 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 informationA 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 informationScheduling 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 informationReal-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 informationDeadline-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 informationthe 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 information8 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 informationSimple 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 informationOnline 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 informationOnline 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 informationReal-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 informationA 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 informationEDF 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 informationARobustPTASforMachineCoveringand 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 informationNew 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 informationLecture 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 informationTopic: 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 informationFrom 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 informationCommon-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 informationSanta 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 informationCPU 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 informationReal-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