A general framework for handling commitment in online throughput maximization
Lin Chen, Franziska Eberle, Nicole Megow, Kevin Schewior, Cliff Stein
aa r X i v : . [ c s . D S ] N ov A general framework for handling commitmentin online throughput maximization
Lin Chen ∗ Franziska Eberle † Nicole Megow † Kevin Schewior ‡ Cliff Stein § November 21, 2018
Abstract
We study a fundamental online job admission problem where jobs with deadlines arrive online overtime at their release dates, and the task is to determine a preemptive single-server schedule which maxi-mizes the number of jobs that complete on time. To circumvent known impossibility results, we make astandard slackness assumption by which the feasible time window for scheduling a job is at least 1 + ε times its processing time, for some ε >
0. We quantify the impact that different provider commitmentrequirements have on the performance of online algorithms. Our main contribution is one universalalgorithmic framework for online job admission both with and without commitments. Without com-mitment, our algorithm with a competitive ratio of O ( / ε ) is the best possible (deterministic) for thisproblem. For commitment models, we give the first non-trivial performance bounds. If the commit-ment decisions must be made before a job’s slack becomes less than a δ -fraction of its size, we provea competitive ratio of O ( ε / (( ε − δ ) δ )) , for 0 < δ < ε . When a provider must commit upon startinga job, our bound is O ( / ε ) . Finally, we observe that for scheduling with commitment the restric-tion to the “unweighted” throughput model is essential; if jobs have individual weights, we rule outcompetitive deterministic algorithms. ∗ Department of Computer Science, University of Houston, Texas, United States. Email: [email protected] . † Department for Mathematics and Computer Science, University of Bremen, Germany. Email: { feberle,nicole.megow } @uni-bremen.de . Supported by the German Science Foundation (DFG) under contract ME3825/1. ‡ Fakult¨at f¨ur Informatik, Technische Universit¨at M¨unchen, M¨unchen, Germany; D´epartement d’Informatique, ´Ecole NormaleSup´erieure, PSL University, Paris, France. Email: [email protected] . Supported by Conicyt Grant PII 20150140 and DAADPRIME program. § Department of Industrial Engineering and Operations Research, Columbia University, New York, United States. Email: [email protected] . Research supported in part by NSF grants CCF-1421161 and CCF-1714818.
Introduction
Many modern computing environments involve a centralized system for managing the resource allocationfor processing many different jobs. Such environments are varied, including, for example, internal clustersand public clouds. These systems typically handle a diverse workload [21] with a mixture of jobs includingshort time-sensitive jobs, longer batch jobs, and everything in between.The challenge for a system designer is to implement scheduling policies that trade off between thesedifferent types of jobs and obtain good performance. There are many ways to define good performanceand in this paper, we will focus on the commonly used notion of throughput which is the number of jobscompleted, or if jobs have weights, the total weight of jobs completed.In general, throughput is a “social welfare” objective that tries to maximize total utility. By centralizingcomputing and scheduling decisions, one can potentially better utilize resources. Nevertheless, for the“greater good” it may be beneficial to abort jobs close to their deadlines in favor of many, but shorter andmore urgent tasks [11]. As companies start to outsource mission critical processes to external clouds, theymay require a certain provider-side guarantee, i.e., service providers have to commit to complete admittedjobs before they cannot be moved to other computing clusters anymore. Moreover, companies tend to rely onbusiness analytics to support decision making. Analytical tools, that usually work with copies of databases,depend on faultless data. This means, once such a copy process started, its completion must be guaranteed.More formally, we consider a fundamental single-machine scheduling model in which jobs arrive onlineover time at their release date r j . Each job has a processing time p j ≥
0, a deadline d j , and possibly a weight w j >
0. In order to complete, a job must receive a total of p j units of processing time in the interval [ r j , d j ] . We allow preemption , that is, the processing time does not need to be contiguous. If a schedulecompletes a set S of jobs, then the throughput is | S | , while the weighted throughput is ∑ j ∈ S w j . We analyzethe performance of algorithms using standard competitive analysis in which we compare the throughputof an online algorithm with the throughput achievable by an optimal offline algorithm that is given fullinformation in advance.Deadline-based objectives are typically much harder to optimize than other Quality-of-Service metricssuch as response time or makespan. Indeed, the problem becomes hopeless when preemption (interrupting ajob and resuming it later) is not allowed: whenever an algorithm starts a job j without being able to preemptit, it may miss the deadlines of an arbitrary number of jobs that would have been schedulable if j had notbeen started. For scheduling with commitment, we provide a similarly strong lower bound for the preemptiveversion of the problem in the presence of weights. Therefore, we focus on unweighted preemptive online throughput maximization.Hard examples for online algorithms tend to involve jobs that arrive and then must immediately beprocessed since d j − r j ≈ p j . It is entirely reasonable to bar such jobs from a system, requiring that any sub-mitted job contains some slack , that is, we must have some separation between p j and d j − r j . To that endwe say that an instance has ε -slack if every job satisfies d j − r j ≥ ( + ε ) p j . We develop algorithms whosecompetitive ratio depends on ε ; the greater the slack, the better we expect the performance of our algorithmto be. This slackness parameter captures certain aspects of Quality-of-Service (QoS) provisioning and ad-mission control, see e.g. [13, 19], and it has been considered in previous work, e.g., in [2, 4, 12, 14, 21, 23].Other results for scheduling with deadlines use speed scaling, which can be viewed as another way to addslack to the schedule, e.g. [1, 3, 15, 22]. In this paper we quantify the impact that different job commitmentrequirements have on the performance of online algorithms. We parameterize our performance guaranteesby the slackness of jobs. Our main contribution is a general algorithmic framework, called region algorithm, for online schedulingwith and without commitments. We prove performance guarantees which are either tight or constitute the1rst non-trivial results. We also answer open questions in previous work. We show strong lower bounds forthe weighted case and therefore our algorithms are all for the unweighted case w j = Optimal algorithm for scheduling without commitment.
We give an implementation of the region algo-rithm that achieves a competitive ratio of O ( ε ) . We prove that this is optimal by giving a matching lowerbound (ignoring constants) for any deterministic online algorithm. Impossibility results for commitment upon job arrival.
In this most restrictive model an algorithm mustdecide immediately at a job’s release date if the job will be completed or not. We show that no (randomized)online algorithm admits a bounded competitive ratio. Such a lower bound has only been shown by exploitingarbitrary job weights [21, 25]. Given our strong negative result, we do not consider this model any further.
Scheduling with commitment.
We distinguish two different models: (i) commitment upon job admission and (ii) δ -commitment . In the first model, an algorithm may discard a job any time before its start, itsadmission. This reflects the situation when the start of a process is the critical time point after which thesuccessful execution is essential (e.g. faultless copy of a database). In the second model, δ -commitment, anonline algorithm must commit to complete a job when its slack has reduced from the original slack require-ment of an ε -fraction of the size to a δ -fraction for 0 ≤ δ ≤ ε . Then, the latest time for committing to job j is d j − ( + δ ) p j . This models an early enough commitment (parameterized by δ ) for mission critical jobs.For both models, we show that implementations of the region algorithm allow for the first non-trivial per-formance guarantees. We prove an upper bound on the competitive ratio of O ( / ε ) for commitment uponadmission and a competitive ratio of O ( ε / (( ε − δ ) δ )) , for 0 < δ < ε , in the δ -commitment model. Theseare the first rigorous non-trivial upper bounds in any commitment model (excluding the special weightedsetting with w j = p j that has been resolved; see related work).Instances with arbitrary weights are hopeless without further restrictions. There is no deterministic on-line algorithm with bounded competitive ratio, neither for commitment upon admission (also shown in [2])nor for δ -commitment. In fact, our construction implies that there is no deterministic online algorithm withbounded competitive ratio in any commitment model in which a scheduler may have to commit to a jobbefore it has completed. (This is hard to formalize but may give guidance for the design of alternative com-mitment models.) Our lower bound for δ -commitment is actually more fine-grained: for any δ > ε with δ ≤ ε < + δ , no deterministic online algorithm has a bounded competitive ratio for weightedthroughput. In particular, this rules out bounded performance guarantees for ε ∈ ( , ) . We remark that forsufficiently large slackness ( ε > Our techniques.
Once a job j is admitted to the system, its slack becomes a scarce resource: To completethe job before its deadline (which may be mandatory depending on the commitment model, but is at leastdesirable), one needs to carefully “spend” the slack on admitting jobs to be processed before the deadlineof j . Our general framework for admission control, the region algorithm, addresses this issue by the conceptof “responsibility”: Whenever a job j ′ is admitted while j could be processed, j ′ becomes responsible fornot admitting similar-length jobs for a certain period, its region . The intention is that j ′ reserves time for j tocomplete. To balance between reservation (commitment to complete j ) and performance (loss of other jobs),the algorithm uses the parameters α and β , which specify the length of a region and similarity of job lengths.A major difficulty in the analysis of the region algorithm is understanding the complex interval structureformed by feasible time windows, regions, and time intervals during which jobs are processed. Here, werely on a key design principle of our algorithm: Regions are defined independently of scheduling decisions.Thus, the analysis can be naturally split into two parts: In the first part, we argue that the scheduling routine can handle the admitted jobs sufficiently well foraptly chosen parameters α and β . That means that the respective commitment model is obeyed and, if not2mplied by that, an adequate number of the admitted jobs is completed. In the second part, we can disregard how jobs are actually scheduled by the scheduling routine and arguethat the region algorithm admits sufficiently many jobs to be competitive with an optimum solution. Theabove notion of “responsibility” suggests a proof strategy mapping jobs that are completed in the optimumto the corresponding job that was “responsible” due to its region. Transforming this idea into a chargingscheme is, however, a non-trivial task: There might be many ( ≫ O ( ε )) jobs released within the regionof a single job j and completed by the optimum, but not admitted by the region algorithm due to manyconsecutive regions of varying size. It is unclear where to charge these jobs—clearly not all of them to j .We develop a careful charging scheme that avoids such overcharging. We handle the complex intervalstructure by working on a natural tree structure ( interruption tree ) related to the region construction andindependent of the actual schedule. Our charging scheme comprises two central routines for distributingcharge: Moving charge along a sequence of consecutive jobs ( Push Forward ) or to children (
Push Down ).We show that our analysis of the region algorithm is tight up to a constant factor.
Preemptive online scheduling and admission control have been studied rigorously. There are several resultsregarding the impact of deadlines on online scheduling; see, e.g., [5, 12, 14] and references therein. Impos-sibility results for jobs with hard deadlines and without slack have been known for decades [6, 7, 17, 18, 20].
Scheduling without commitment.
Most research on online scheduling does not address commitment.The only results independent of slack (or other job-dependent parameters) concern the machine utilization,i.e., weighted throughput for the special case w j = p j , where a constant competitive ratio is possible [6, 17,18, 24]. In the unweighted setting, a randomized O ( ) -competitive algorithm is known [16]. For instanceswith ε -slack, Lucier et al. [21] give an O ( ε ) -competitive algorithm in the most general weighted setting.To the best of our knowledge, no lower bound was known to date. Scheduling with commitment.
Much less is known for scheduling with commitment. In the most re-strictive model, commitment upon job arrival , Lucier et al. [21] rule out competitive online algorithms forany slack parameter ε when jobs have arbitrary weights. For commitment upon job admission , they give aheuristic that empirically performs very well but for which they cannot show a rigorous worst-case bound.In fact, later Azar et al. [2] show that no bounded competitive ratio is possible for weighted throughputmaximization for small ε . For the δ -commitment model , Azar et al. [2] design (in the context of truthfulmechanisms) an online algorithm that is O ( ε ) -competitive if the slack ε is sufficiently large. They callan algorithm in this model β -responsive algorithm . They left open if this latter condition is an inherentproperty of any committed scheduler in this model and we answer this affirmatively.Again, the machine utilization variant ( w j = p j ) is much more tractable than weighted or unweightedthroughput maximization. Simple greedy algorithms achieve the best possible competitive ratio Θ ( ε ) [10,12] in all aforementioned commitment models, even commitment upon arrival. In this section we present our general algorithmic framework which we apply to scheduling with and withoutcommitment. We assume that the slackness constant ε > δ -commitment model it is sufficient that 0 < δ < ε is known.To gain some intuition for our algorithm, we first describe informally the three underlying design prin-ciples. They also explain our algorithm’s parameters.1. A running job can be preempted only by significantly smaller jobs (parameter β ).2. A job cannot start for the first time when its remaining slack is too small (constant δ which is part ofthe input in the δ -commitment model and otherwise set to δ = ε ).3 lgorithm 1: Region algorithm
Scheduling routine : At any time t , run an admitted and not yet completed job with shortestprocessing time. Event : Upon release of a new job at time t :Call region preemption routine . Event : Upon ending of a region at time t :Call region preemption routine . Region preemption routine : k ← the job whose region contains ti ← a shortest available job at t , i.e., i = arg min { p j | r j ≤ t and d j − t ≥ ( + δ ) p j } If p i < β p k , then1. admit job i and reserve region R ( i ) = [ t , t + α p i ) ,2. update all remaining regions R ( j ) with R ( j ) ∩ [ t , ∞ ) = /0 as described below.
3. If a job preempts other jobs, then it has to take “responsibility” for a certain time interval (parameter α )with which it assures that the jobs it preempted can complete on time.The first two design principles have been used before [21]. However, to improve on existing results wecrucially need the third principle. We implement it in the following way.The region algorithm has two parameters, α ≥ < β <
1. A region is a union of time intervalsassociated with a job, and the size of the region is the sum of sizes of the intervals. We denote the region ofjob j by R ( j ) . Region R ( j ) will always have size α p j , although the particular time intervals composing theregion may change over time. Regions are always disjoint, i.e., for any i = j , R ( i ) ∩ R ( j ) = /0. Informally,whenever our algorithm starts a job i (we say i is admitted ) that arrives during the region of an alreadyadmitted job j , then the current interval of j is split into two intervals and the region R ( j ) as well as all laterregions are delayed.Formally speaking, at any time t , the region algorithm maintains two sets of jobs: admitted jobs , whichhave been started before or at time t , and available jobs . A job j is availabe if it is released before or at time t ,is not yet admitted, and it is not too close to its deadline, i.e., r j ≤ t and d j − t ≥ ( + δ ) p j . The intelligenceof the region algorithm lies in admitting jobs and (re)allocating regions. The actual scheduling decision thenis simple and independent of the regions: at any point in time, schedule the shortest admitted job that hasnot completed its processing time, i.e., we schedule admitted jobs in Shortest Processing Time (SPT) order.The region algorithm never explicitly considers deadlines except when deciding whether to admit jobs.The region algorithm starts by admitting job 1 at its release date and creates the region R ( ) : = [ r , r + α p ) . There are two events that trigger a decision of the region algorithm: the release of a job and the endof a region. If one of these events occurs at time t , the region algorithm invokes the region preemption subroutine. This routine compares the processing time of the smallest available job i with the processingtime of the admitted job k whose region contains t . If p i < β p k , job i is admitted and the region algorithmreserves the interval [ t , t + α p i ) for processing i . Since regions must be disjoint, the algorithm then modifiesall other remaining regions, i.e., the parts of regions that belong to [ t , ∞ ) of other jobs j . We refer to the setof such jobs j whose regions have not yet completed by time t as J ( t ) . Intuitively, we preempt the intervalof the region containing t and delay its remaining part as well as the remaining regions of all other jobs.Formally, this update of all remaining regions is defined as follows. Let k be the one job whose regionis interrupted at time t , and let [ a ′ k , b ′ k ) be the interval of R ( k ) containing t . Interval [ a ′ k , b ′ k ) is replaced by [ a ′ k , t ) ∪ [ t + α p i , b ′ k + α p i ) . For all other jobs j ∈ J ( t ) \ { k } , the remaining region [ a ′ j , b ′ j ) of j is replaced by [ a ′ j + α p i , b ′ j + α p i ) . Observe that, although the region of a job may change throughout the algorithm, thestarting point of a region for a job will never be changed. We summarize the region algorithm in Algorithm 1.We apply the algorithm in different commitment models with different choices of parameters α and β ,4 Figure 1:
Gantt chart of the regions (left) and the interruption tree (right) generated by the region algorithm. which we derive in the following sections. In the δ -commitment model, δ is given as part of the input. Inthe other models, i.e., without commitment or with commitment upon admission, we simply set δ = ε . Commitment.
The region algorithm commits always upon admission, i.e., at its first start. This is possiblyearlier than required in the δ -commitment model. The parameter δ determines the latest possible start timeof a job, which is then for our algorithm also the latest time the job can be admitted. Thus, for the analysis,the algorithm execution for commitment upon admission (with δ = ε ) is a special case of δ -commitment.This is true only for our algorithm, not in general. In the analysis we focus on instances with small slack as they constitute the hard case. We assume for theremainder that 0 < ε ≤
1. Notice that instances with large slack clearly satisfy a small slack assumption.We run our algorithm simply by setting ε = Theorem 1 (Scheduling without commitment) . Let < ε ≤ . With the choice of α = , β = ε , and δ = ε ,the region algorithm is Θ ( ε ) -competitive for scheduling without commitment. This is an exponential improvement upon the previously best known upper bound [21] (given forweighted throughput). For scheduling with commitment, we give the first rigorous upper bound.
Theorem 2 (Scheduling with commitment) . Let < δ < ε ≤ . Choosing α = δ , β = δ , the regionalgorithm is O ( ε ( ε − δ ) δ ) -competitive in the δ -commitment model. When the scheduler has to commit uponadmission, the region algorithm has a competitive ratio O ( ε ) for α = ε and β = ε . In Appendix C.3, we show that the analysis of our framework is tight up to constants.
To analyze the performance of the region algorithm on a given instance, we consider the final schedule andthe final regions and investigate them retrospectively. Let a j be the admission date of job j which remainedfixed throughout the execution of the algorithm. Let b j denote the final end point of j ’s region.Our analysis crucially relies on understanding the interleaving structure of the regions that the algorithmconstructs. This structure is due to the interruption by smaller jobs and can be captured well by a tree orforest. Every job is represented by one vertex. A job vertex is the child of another vertex if and only if theregion of the latter is interrupted by the first one. The leaves correspond to jobs with non-interrupted regions.By adding a machine job M with p M : = ∞ and a M = − ∞ , we can assume that the instance is represented bya tree which we call interruption tree . This idea is visualized in Figure 1, where the vertical arrows indicatethe interruption of a region by another job and intervals of the same color belong to one job. Let π ( j ) denotethe parent of j . Further, let T j be the subtree of the interruption tree rooted in job j and let the forest T − j be T j without its root j . By slightly abusing notation, we denote the tree/forest as well as its job vertices by T ∗ .A key property of this tree is that the processing times on a path are geometrically decreasing.5 emma 1. Let j , . . . , j ℓ be ℓ jobs on a path in the interruption (sub)tree T j rooted in j such that π ( j i + ) = j i .Then, p j ℓ ≤ β p j ℓ − · · · ≤ β ℓ − p j ≤ β ℓ p j and the total processing volume is ∑ ℓ i = p j i ≤ ∑ ℓ i = β i p j ≤ β − β · p j .Proof. Let the jobs j , . . . , j ℓ be indexed in decreasing order of processing times, i.e., p j ℓ ≤ p j ℓ − ≤ . . . ≤ p j .Observe that p j < β p j as otherwise the region of j shall not be preempted by j . Furthermore, forany 2 ≤ i ≤ ℓ , we claim that job j i is released after j i − . Suppose the claim is not true, then for some i job j i is released before j i − . Consider the point in time t when job j i − is admitted. The time t eitherbelongs to the region of j i , or belongs to the region of some job j ′ which interrupts the region of j i , andconsequently p j ′ < β p j i . In both cases the algorithm will not admit j i − , and therefore the claim is true. Atany point in time when the algorithm admits a job j i , then it interrupts the region of j i − and p j i < β p j i − .Thus, we have p j ℓ < β p j ℓ − < β p j ℓ − < · · · < β ℓ − p j < β ℓ p j . The total processing volume of the jobs j , . . . , j ℓ is ℓ ∑ i = p j i < ℓ ∑ i = β i p j = β ( − β ℓ ) − β · p j ≤ β − β · p j . (1) We show that the region algorithm completes sufficiently many jobs among the admitted jobs before theirdeadline. For scheduling without commitment, we show how to choose α , β , and δ to ensure that at leasthalf of all admitted jobs are completed on time. For scheduling with commitment, we provide a choiceof α , β , and δ such that every admitted job is guaranteed to complete on time. In this section we fix δ = ε for 0 < ε ≤
1. We show the following result.
Theorem 3.
Let α = and β = ε . Then the region algorithm completes at least half of all admitted jobsbefore their deadline. The intuition for setting α = | R ( j ) | = p j , for any j , is that inthe model without commitment, a job does not need to block extra time in the future, (a region larger thanthe job) to ensure the completion of preempted jobs.The scheduling routine SPT guarantees the following. Observation 1.
For α ≥ , the region algorithm always prioritizes a job within its own region. Hence, for α =
1, every job j completes at the end of the region at b j . Thus, j completes on time if andonly if the region R ( j ) ends before d j , i.e., b j ≤ d j . We prove Theorem 3 by showing that at least half of allregions end before the deadline of their respective jobs. Lemma 2.
W.l.o.g. we restrict to instances on which the region algorithm admits all jobs.
We want to show that the existence of a late job j implies that the subtree T j rooted in j contains morefinished than unfinished jobs. We fix a job j ∈ J that was admitted by the region algorithm at a j and whoseregion completes at b j . We want to analyze the structure of all regions R in [ a j , b j ) , i.e., the regions of alljobs in T j . Let F j denote the set of jobs in T j that finish on time . Similarly, we denote the set of jobs in T j that complete after their deadlines, i.e., that are unfinished at their deadline , by U j .6 emma 3. Let α = and β = ε , with ε > . If b j − a j ≥ ( ℓ + ) p j for ℓ > , then | F j | − | U j | ≥ ⌊ ℓ ε ⌋ .Proof sketch. Assume for the sake of contradiction that there is an instance such that the interruption treegenerated by the region algorithm contains a subtree T j with b j − a j ≥ ( ℓ + ) p j and | F j | − | U j | < ⌊ ℓ ε ⌋ .Let I be such an instance that uses a minimal number of jobs in total. The goal is to construct an instance I ′ that satisfies b j − a j ≥ ( ℓ + ) p j and | F j | − | U j | < ⌊ ℓ ε ⌋ although it uses less jobs than I .To this end, we modify I in several steps such that we can merge three jobs to one larger job withoutviolating b j − a j ≥ ( ℓ + ) p j , changing | F j | or | U j | , or making the instance infeasible. The three jobs willbe leaves with the same parent i in T j . If i is an unfinished job that has children which are all leaves, thenthere have to be at least three jobs that interrupt i . After merging the three jobs, we adapt the release dateand deadline of i to guarantee that the modified instance remains feasible. For all these modification steps,it is crucial that we can restrict to instances in which all jobs appear in the interruption tree (Lemma 2).However, this modification might lead to b i ≤ d ′ i which implies that i finishes on time. This changes thevalues of | F j | and | U j | . Clearly, in this case, | U ′ j | = | U j | −
1. By a careful analysis, we see that the numberof finished jobs decreases by one as well because the three children of i are replaced by only one finishedjob. Hence, | F ′ j | − | U ′ j | = | F j | − | U j | . If i does not finish by d ′ i , then | F ′ j | − | U ′ j | = ( | F j | − ) − | U j | . Thus, themodified instance I ′ also violates | F ′ j | − | U ′ j | ≥ ⌊ ℓ ε ⌋ but uses less jobs than I does; a contradiction. Proof of Theorem 3.
Let U be the set of jobs that are unfinished by their deadline but whose ancestors (ex-cept machine job M ) have all completed on time. Every job j ∈ U was admitted by the algorithm at sometime a j with d j − a j ≥ ( + δ ) p j . With δ = ε this implies b j − a j > d j − a j ≥ ( + ε ) p j . By Lemma 3 followsthat | F j | − | U j | ≥ ⌊ · ε / ε ⌋ =
2. Then, | T j | = | F j | + | U j | ≤ | F j | − < | F j | . This completes the proof.
We analyze the region algorithm for scheduling with commitment. For both models, commitment at ad-mission and δ -commitment, we show that there is a choice of α and β such that every job that has startedprocessing will be completed before its deadline. Recall that we can restrict to analyzing the algorithm inthe δ -commitment model since it runs with δ = ε for commitment at admission. Theorem 4.
Let ε , δ > be fixed with δ < ε . If α ≥ and < β < satisfy the condition that α − α · + δ − β − β ! ≥ , (2) then any job j that is admitted by the algorithm at time a j ≤ d j − ( + δ ) p j will be finished by d j .Proof. Consider a job j that is admitted (and simultaneously accepted for completion) by time a j . It holdsthat d j − a j ≥ ( + δ ) p j . We show that j receives at least p j units of time within [ a j , d j ) . Let | R ( k ) | denotethe total length of intervals in R ( k ) , the region of job k .Let D j ⊆ T − j be the set of jobs whose region delays the region of job j , and has nonempty intersectionwith [ a j , d j ) . Notice that a job k ∈ D j can only be released after time a j . Let D ′ j ⊆ D j be the subset of jobswhose region is completely contained in [ a j , d j ) and D ′′ j = D j \ D ′ j .Consider D ′ j . Notice that (cid:12)(cid:12) S k ∈ D ′ j R ( k ) (cid:12)(cid:12) = α∑ k ∈ D ′ j p k . Thus, within regions R ( k ) of jobs k ∈ D ′ j , an α − α -fraction of the total time is available for processing job j .Consider D ′′ j = { j , j , · · · , j ℓ } and assume that p j ≥ p j ≥ · · · ≥ p j ℓ . Any interval [ a j i , b j i ) of such ajob j i in D ′′ j contains d j . This implies that π ( j i + ) = j i for 0 ≤ i < ℓ where j : = j for simplicity. ApplyingLemma 1 gives an upper bound on the total processing volume of jobs in D ′′ j , i.e., ∑ ℓ i = p j i ≤ β − β · p j . To determine the amount of time for processing j within [ a j , d j ) , we first subtract the total processingtime for jobs in D ′′ j . The remaining interval may be covered with regions of D ′ j within which we can use7n α − α -fraction as shown above. Thus, the amount of time that we can process job j within [ a j , d j ) is atleast α − α · (cid:0) d j − a j (cid:1) − ∑ j i ∈ D ′′ j p j i ! ≥ α − α · (cid:18) + δ − β − β (cid:19) · p j , where we also use the fact that d j − a j ≥ ( + δ ) p j . This bound is now independent of the actual schedule.We can conclude, if α and β satisfy Condition (2), then job j can process for p j units of time within [ a j , d j ) and completes before its deadline. We show that the region algorithm admits sufficiently many jobs, independently of the commitment model.
Theorem 5.
The number of jobs that an optimal (offline) algorithm can complete on time is at most a factor λ + larger than the number of jobs admitted by the region algorithm, where λ : = εε − δ αβ , for < δ < ε ≤ . To prove the theorem, we fix an instance and an optimal algorithm O PT . We can assume that an optimaloffline algorithm does not schedule any job it cannot complete before its deadline. Let X be the set of jobsthat O PT scheduled and the region algorithm did not admit. Let J denote the jobs that the region algorithmadmitted. Then, X ∪ J , the union of the jobs scheduled only by O PT and the jobs admitted by our algorithm,is a superset of the jobs scheduled by O PT . Thus, showing | X | ≤ λ | J | implies Theorem 5.To this end, we develop a charging procedure that assigns each job in X to a unique job in J such thateach job j ∈ J is assigned at most λ = εε − δ αβ jobs. For a job j ∈ J admitted by the region algorithm wedefine the subset X j ⊂ X based on release dates. Then, we inductively transform the laminar family ( X j ) j ∈ J into a partition ( Y j ) j ∈ J of X with | Y j | ≤ λ for all j ∈ J in the proof of Lemma 6, starting with the leaves inthe interruption tree as base case (Lemma 5). For the construction of ( Y j ) j ∈ J , we heavily rely on the keyproperty (Volume Lemma 4) and Corollary 1.More precisely, for a job j ∈ J let X j be the set of jobs x ∈ X that were released in the interval [ a j , b j ) and satisfy p x < β p π ( j ) . Let X Sj : = { x ∈ X j : p x < β p j } and X Bj : = X j \ X Sj denote the small and the big jobs,respectively, in X j . Recall that [ a j , b j ) is the convex hull of the region R ( j ) of job j and includes the convexhulls of all descendants of j in the interruption tree, i.e., jobs in T j . In particular, X k ⊂ X j if k ∈ T j . Observation 2.
1. Any job x ∈ X that is scheduled successfully by O PT and that is not admitted by the region algorithmis released within the region of some job j ∈ J, that is, S j ∈ J X j = X .2. As the region algorithm admits any job that is small w.r.t. j and released in R ( j ) , X Sj = S k : π ( k )= j X k . As observed above, to prove the main Theorem 5, it suffices to show that | X | ≤ λ | J | . By Observation2, X = X SM and, thus, it is sufficient to show that | X SM | ≤ λ | J | . In fact, we show a stronger statement.We consider each job j ∈ J individually and prove that the number of small jobs in X j is bounded, i.e., | X Sj | ≤ λτ j , where τ j is the number of descendants of j , i.e., τ j : = | T − j | .More precisely, the fine-grained definition of the sets X j in terms of the release dates and the processingtimes allows us to show that any job j with | X j | > λ ( τ j + ) has siblings j , . . . , j k such that | X j | + ∑ ki = | X j i | ≤ λ ( τ j + + ∑ ki = ( τ j i + )) . We call i and j siblings if they have the same parent in the interruption tree.Simultaneously applying this charging idea to all descendants of a job h already proves | X Sh | ≤ λτ h as X Sh = S j : π ( j )= h X j by Observation 2.We prove that this “balancing” of X j between jobs only happens between siblings j , . . . , j k with theproperty that b j i = a j i + for 1 ≤ i < k . We call such a set of jobs a string of jobs. The ellipses in Figure 1visualize the maximal strings of jobs. A job j is called isolated if it has the property that b i = a j and b j = a i holds for all children i = j of π ( j ) . 8he next lemma is a key ingredient for the proof of Theorem 5. When we talk about a subset of J , weindex the jobs in the subset in order of increasing admission points a j . Conversely, for a subset of X , weorder the jobs in increasing order of completion times, C ∗ x , in the optimal schedule. Lemma 4 (Volume Lemma) . Let f , . . . , g ∈ J be jobs with a common parent in the interruption tree. Letx ∈ S gj = f X j such that g ∑ j = f ∑ y ∈ X j : C ∗ y ≤ C ∗ x p y ≥ εε − δ ( b g − a f ) + p x . (V) Then, p x ≥ β p j ∗ , where j ∗ ∈ J ∪ { M } is the job whose region contains b g , i.e., b g ∈ R ( j ∗ ) .Proof of the Volume Lemma. Let f , . . . , g , x , and j ∗ as in the lemma. Since x ∈ X , the region algorithm didnot accept x at time b g . There are two possible reasons for this behavior: either p x ≥ β p j ∗ or x was notavailable for admission at time b g anymore.Assume for the sake of contradiction that p x < β p j ∗ and, thus, d x − b g < ( + δ ) p x . By assumption, r x ≥ a f and d x − r x ≥ ( + ε ) p x . Hence, b g − a f ≥ b g − d x + d x − r x > − ( + δ ) p x + ( + ε ) p x = ( ε − δ ) p x . By (V), the volume O PT processes between b g and C ∗ x is at least δε − δ ( b g − a f ) + p x . By applying theabove calculated lower bound, we get that δε − δ ( b g − a f ) + p x ≥ δ p x + p x = ( + δ ) p x and, hence, that C ∗ x ≥ b g + ( + δ ) p x > d x , which contradicts that O PT is a feasible schedule.The next corollary follows directly from the Volume Lemma applied to a string of jobs or to a singlejob j ∈ J (let f = j = g ). To see this, recall that X j contains only jobs that are small w.r.t. π ( j ) , i.e., all x ∈ X j satisfy p x < β p π ( j ) . We will use the corollary repeatedly to generate a contradiction. Corollary 1.
Let { f , . . . , g } ⊂ J be a string of jobs and let x ∈ S gj = f X j satisfy the Volume Condition (V) .Then, there exists a sibling j ∗ ∈ J of g in the interruption tree with b g = a j ∗ . A main part of our proof is to show (V) only relying on | X j | > λ ( τ j + ) . The relation between processingvolume and cardinality of job sets is possible due to the definition of X j based on T j . The following lemmaserves as base case for strings of leaves as well as role model for non-isolated nodes in the interruption tree. Lemma 5.
Let { f , . . . , g } ⊂ J be jobs at maximal distance from M such that ∑ ij = f | X j | > λ ( i + − f ) holdsfor all f ≤ i ≤ g. If g is the last such job, there is a sibling j ∗ of g with b g = a j ∗ and ∑ j ∗ j = f | X j | ≤ λ ( j ∗ + − f ) .Proof sketch. Observe that [ a f , b g ) = S gj = f R ( j ) because the leaves f , . . . , g form a string of jobs. Thus, byshowing that there is a job x ∈ X gf : = S gj = f X j that satisfies (V), we prove the statement with the VolumeLemma. To this end, we show that for every job f ≤ j ≤ g there exists a set Y j such that the processing vol-ume within Y j is sufficient to cover the interval [ a j , b j ) at least εε − δ times. More precisely, Y f , . . . , Y g satisfy(i) S gj = f Y j ⊂ X gf , (ii) | Y j | = λ , and (iii) Y j ⊂ { x ∈ X gf : p x ≥ β p j } for every f ≤ j ≤ g .Then, (ii) and (iii) imply ∑ y ∈ Y j p y ≥ λβ p j = εε − δ ( b j − a j ) . Thus, if we choose x among those jobs in X gf thatO PT completes last and guarantee that x / ∈ S gj = f Y j , the Volume Condition (V) is satisfied. We first describehow to find Y f , . . . , Y g before we show that these sets satisfy (i) to (iii).By assumption, | X f | > λ . Index the jobs in X f = { x , . . . , x λ , x λ + , . . . } in increasing completion times C ∗ x . Define Y f : = { x , . . . , x λ } and L f : = X f \ Y f , i.e., Y f contains the λ jobs in X f that O PT completes9rst and L f contains the last jobs. Let Y f , . . . , Y j and L j be defined for f < j + ≤ g . By assumption, | X j + ∪ L j | > λ since | Y i | = λ for f ≤ i ≤ j . We again index the jobs in X j + ∪ L j = { x , . . . , x λ , x λ + , . . . } in increasing optimal completion times. Then, Y j + : = { x , . . . , x λ } and L j + : = { x λ + , . . . } . Since we movejobs only horizontally to later siblings, we call this procedure Push Forward .By definition, (i) and (ii) are satisfied. Since f , . . . , g are leaves, the jobs in Y j ∩ X j are big w.r.t. j . Thus,it remains to show that the jobs in L j are big w.r.t. the next job j +
1. To this end, we assume that thejobs in Y f , . . . , Y j are big w.r.t. f , . . . , j , respectively. If we find an index f ≤ i ( x ) ≤ j such that x as wellas the jobs in S ji = i ( x ) Y i are released after a i ( x ) and x is completed after every y ∈ S ji = i ( x ) Y i , then the VolumeLemma 4 implies that x ∈ L j is big w.r.t. j +
1. Indeed, then ∑ ji = i ( x ) ∑ y ∈ X i : C ∗ y ≤ C ∗ x p y ≥ p x + ∑ ji = i ( x ) ∑ y ∈ Y i p y ≥ εε − δ ( b j − a i ( x ) ) + p x . We show by induction that such an index i ( x ) exists for every x ∈ L j .As the same argumentation holds for j = g , Corollary 1 implies the lemma. Lemma 6.
For all j ∈ J ∪ { M } , | X Sj | ≤ τ j λ .Proof sketch. We show that for every j ∈ J ∪ { M } , there exists a partition ( Y k ) k ∈ T − j with(i) S k ∈ T − j Y k = X Sj , (ii) Y k ⊂ { x ∈ X j : p x ≥ β p k } , and (iii) | Y k | ≤ λ for every k ∈ T − j .Then, it holds that | X Sj | = | S k ∈ T − j Y k | = ∑ k ∈ T − j | Y k | ≤ λτ j and, thus, the lemma follows.The proof consists of an outer and an inner induction. The outer induction is on the distance ϕ ( j ) of ajob j from machine job M , i.e., ϕ ( M ) : = ϕ ( j ) : = ϕ ( π ( j )) + j ∈ J . The inner induction uses theidea about pushing jobs x ∈ X j to some later sibling of j in the same string of jobs (see proof of Lemma 5).Let j ∈ J with ϕ ( j ) = ϕ max − = max { ϕ ( i ) : i ∈ J } −
1. By Observation 2, X Sj = S k : π ( k )= j X k , whereall k ∈ T − j are leaves at maximal distance from M . We distinguish three cases for k ∈ T − j : Case 1. If k ∈ T − j is isolated, | X k | ≤ λ follows directly from the Volume Lemma as otherwise ∑ x ∈ X k p x ≥ λβ p k + p x = εε − δ ( b k − a k ) + p x contradicts Corollary 1, where x ∈ X k is the last job that O PT completesfrom the set X k . Since all jobs in X k are big w.r.t. k , we set Y k : = X k . Case 2. If k ∈ T − j with | X k | > λ is part of a string, let f , . . . , g be the maximal string satisfying Lemma 5with k ∈ { f , . . . , g } . With this lemma, we find Y f , . . . , Y g and set Y g + : = X g + ∪ L g . Case 3.
We have not yet considered jobs k in a string with | X k | ≤ λ that do not have siblings f , . . . , g in thesame string with b g = a k and ∑ gi = f | X j | > ( g − f ) λ . This means that such jobs do not receive jobs x ∈ X i for i = k by the Push Forward procedure in Case 2. For such k ∈ T − j we define Y k : = X k .Then, X Sj = S k : π ( k )= j X k = S k ∈ T − j X k = S k ∈ T − j Y k and, thus, (i) to (iii) are satisfied.Let ϕ < ϕ max such that ( Y k ) k ∈ T − j satisfying (i) to (iii) exists for all j ∈ J with ϕ ( j ) ≥ ϕ . Fix j ∈ J with ϕ ( j ) = ϕ −
1. By induction and Observation 2, it holds that X Sj = S k : π ( k )= j (cid:16) X Bk ∪ S i ∈ T − k Y i (cid:17) . Now, we usethe partitions ( Y i ) i ∈ T − k for k with π ( k ) = j as starting point to find the partition ( Y k ) k ∈ T − j . Fix k with π ( k ) = j and distinguish again the same three cases as before. Case 1. If k is isolated, we show that | X k | ≤ λ ( τ k + ) and develop a procedure to find ( Y i ) i ∈ T k . Byinduction, | X Sk | ≤ λτ k . In C.2 we prove that | X Bk | ≤ λ + ( λτ k − | X Sk | ) . To construct ( Y i ) i ∈ T k , we assignmin { λ , | X Bk |} jobs from X Bk to Y k . If | X Bk | > λ , distribute the remaining jobs according to λ − | Y i | amongthe descendants of k . Then, X k = S i ∈ T k Y i . Because a job that is big w.r.t job k is also big w.r.t. alldescendants of k , every (new) set Y i satisfies (ii) and (iii). We refer to this procedure as Push Down since jobs are shifted vertically to descendants.
Case 2. If | X k | > λ ( τ k + ) , k must belong to a string with similar properties as described in Lemma 5.This means, there is a maximal string of jobs f , . . . , g containing k such that ∑ ij = f | X j | > λ ∑ ij = f τ j holdsfor all f ≤ i ≤ g and b j = a j + for all f ≤ j < g .If the Volume Condition (V) is satisfied, there exists another sibling g + X f , . . . , X g , X g + due to Corollary 1. This is shown by using Push Down within a generalization of10he
Push Forward procedure. As the jobs f , . . . , g may have descendants, we use Push Forward toconstruct the sets Z f , . . . , Z g and L f , . . . , L g with | Z k | = λ ( τ k + ) . Then, we apply Push Down to Z k and ( Y i ) i ∈ T − k in order to obtain ( Y i ) i ∈ T k such that they will satisfy Z k = S i ∈ T k Y i , Y i ⊂ { x ∈ X j : p x ≥ β p i } and | Y i | = λ for every i ∈ T k . Thus, the sets X k with f ≤ k ≤ g satisfy (V) and we can apply Corollary 1. Case 3.
Any job k with π ( k ) = j that is part of a string and was not yet considered must satisfy | X k | ≤ λ ( τ k + ) . We use the Push Down procedure for isolated jobs to get the partition ( Y i ) i ∈ T k .Hence, we have found ( Y k ) k ∈ T − j with the properties (i) to (iii). Proof of Theorem 5.
As explained before, the job set scheduled by O PT clearly is a subset of X ∪ J , theunion of jobs only scheduled by O PT and the jobs admitted by the region algorithm. Thus, it suffices toprove that | X | ≤ λ | J | . By Observation 2, X = X SM and, hence, | X SM | ≤ λ | J | implies | X | ≤ λ | J | . This is trueas Lemma 6 also holds for the machine job M . Finalizing the proofs of Theorems 1 and 2
Proof of Theorem 1.
Set α = β = ε . Theorem 3 shows that our algorithm completes at least half ofall admitted jobs on time. Theorem 5 implies that the region algorithm is ε -competitive. Proof of Theorem 2.
By Lemma 4, the choice α = δ and β = δ implies that the region algorithm completesall admitted jobs. Theorem 5 implies that our algorithm is ( ( ε − δ ) δ + In this section we give a collection of lower bounds on the competitive ratio in the different commitmentmodels and for different problem settings. To simplify notation, we formally introduce the notion of laxity .Let j be a job with processing time p j , deadline d j , and r j . The laxity ℓ j is defined as d j − r j − p j . Scheduling without commitment.
We give a lower bound matching our upper bound in Theorem 2.
Theorem 6.
Every deterministic online algorithm has a competitive ratio Ω ( ε ) . The proof idea is as follows: We release Ω ( ε ) levels of jobs. In each level, the release date of any butthe first job is the deadline of the previous job. Whenever an online algorithm decides to complete a jobfrom level i (provided no further jobs are released), then the release of jobs in level i stops and a sequenceof O ( ε ) jobs in level i + i have processing time p i = ε · p i − which is too largeto fit in the slack of the already started job. Thus, an algorithm has to discard the job started at level i to runa job of level i +
1, meaning that it can only finish one job, while the optimum can finish a job from everyother level.We now give the formal proof.
Proof.
Let ε < such that ε ∈ N and suppose there is an online algorithm with competitive ratio c < ε ,from which it is sufficient to deduce a contradiction. We construct an adversarial instance in which each job j belongs to one of 2 · ⌈ c + ⌉ levels and fulfills d j = r j + ( + ε ) · p j . The processing times are identicalacross any level, but they are decreasing by a factor of 2 ε when going from any level to the next. This (alongwith the interval structure) makes sure that no two jobs from consecutive levels can both be completedby a single schedule, which we will use to show that the online algorithm can only complete a single jobthroughout the entire instance. The decrease in processing times between levels, however, also makes surethat the optimum can finish a job from every other level, resulting in an objective value of ⌈ c + ⌉ , which isa contradiction to the algorithm being c -competitive.11he sequence starts in level 0 at time 0 with the release of one job j with processing time p ( ) = d j = + ε . We will show inductively that, for each level i , there is a time t i when there isonly a single job j i left that the algorithm can still finish, and this job is from the current level i (and, thus, p j i = p ( i ) = ( ε ) i ). We will also make sure that at t i at most a ( ) -fraction of the time window of j i haspassed. From t i on, no further jobs from level i are released, and jobs from level i + i = · ⌈ c + ⌉ −
1, we stop releasing jobs altogether). It is clear that t exists.Consider some time t i , and we will release jobs from level i + t i + . The first job j from level i + t i and, by the above constraints, d j = t i + ( + ε ) · p j where p j = p ( i + ) =( ε ) i + . As long as no situation occurs that fits the above description of t i + , we release an additional jobof level i + t i + before ε jobs from level i + ε -th job from level i + t i + ε · ( + ε ) · ε · p ( i ) , which is smaller than thedeadline of d j i since by induction d j i − t i ≥ · p ( i ) and ε < . This shows that, unless more than ε jobsfrom level i + i + j i .Note that there must be a job j ⋆ among the ε first ones in level i + j ⋆ : By induction, the algorithm can only hope to finisha single job released before time t i and the optimum could complete ε jobs from level i +
1, so j ⋆ mustexist for the algorithm to be c -competitive. Now we can define j i + to be the first such job j ⋆ and find t i + within its time window: At the release date of j ⋆ , the algorithm could only complete j i . However, sincethe algorithm finishes j i + if there are no further jobs released, and ε < , it must have worked on j i + formore than p ( i + ) units of time until r i + + · p ( i + ) = : t i + . This quantity, however, exceeds the laxity of j i ,meaning that the algorithm cannot finish j i any more. (Recall that the laxity of j i is ε p ( i ) = i ε i + .) So t i + has the desired properties.This defines t ·⌈ c + ⌉ , and indeed the algorithm will only finish a single job. We verify that an optimalalgorithm can schedule a job from every other level. Note that, among levels of either parity, processingtimes are decreasing by a factor of 4 ε between consecutive levels. So, for any job j , the total processingtime of jobs other than j that need to be processed within the time window of j adds up to less than ∞ ∑ i = ( ε ) i · p j = ε · ∞ ∑ i = ( ε ) i · p j = ε · − ε · p j ≤ ε · · − · p j < ε · p j = ℓ j . This completes the proof.
Commitment upon arrival.
We substantially strengthen earlier results for weighted jobs [21, 25] and showthat the model is hopeless even in the unweighted setting and even for randomized algorithms.
Theorem 7.
No randomized online algorithm has a bounded competitive ratio for commitment upon arrival.
In the proof of the theorem, we use the following algebraic fact.
Lemma 7.
Consider positive numbers n , . . . , n k , c ∈ R + with the following properties:(i) ∑ ki = n i ≤ ,(ii) ∑ ji = n i · i − ≥ j − c for all j = , . . . , k.Then c ≥ k + .Proof. We take a weighted sum over all inequalities in (ii), where the weight of the inequality correspondingto j < k is 2 k − j − and the weight of the inequality corresponding to j = k is 1. The result is k ∑ i = n i · k − ≥ ( k + ) · k − c ⇔ k ∑ i = n i ≥ ( k + ) c . c < k + , this contradicts (i).We proceed to the proof of the theorem. Proof of Theorem 7.
Consider any ε > γ ∈ ( , ) . Suppose there is a (possibly randomized) c -competitive algorithm, where c may depend on ε .We will choose some k ∈ N later. The adversary releases at most k waves of jobs, but the instance mayend after any wave. Wave i has 2 i jobs. Each job from the i -th wave has release date ik · γ , deadline 1, andprocessing time i · − γ + ε . Note that choosing p j ≤ − γ + ε for all jobs j makes sure that indeed ℓ j ≥ ε · p j , andobserve that the total volume of jobs in wave i adds up to no more than 1 − γ .Define n i to be the expected total processing time of jobs that the algorithm accepts from wave i . Weobserve:(i) Since all accepted jobs have to be scheduled within the interval [ , ] , we must have ∑ ki = n i ≤ i , possibly no further jobs are released after wave i . Since, in this case, the optimum schedulesall jobs from wave i and the jobs’ processing times decrease by a factor of 2 from wave to wave, itmust hold that ∑ ji = n i · i − ≥ j − c .This establishes the conditions necessary to apply Lemma 7 to n , . . . , n k , which shows that choosing k ≥ c yields a contradiction. Commitment on job admission and δ -commitment. Since these models are more restrictive than schedul-ing without commitment, the lower bound Ω ( ε ) from Theorem 6 holds. In the present setting we can providea much simpler (but asymptotically equally strong) lower bound. Commitment upon admission.
For scheduling with arbitrary weights, Azar et al. [2] rule out any boundedcompetitive ratio for deterministic algorithms. Thus, our bounded competitive ratio for the unweightedsetting (Theorem 2) gives a clear separation between the weighted and the unweighted setting.
Scheduling with δ -commitment. We give a lower bound depending on parameters ε and δ . Theorem 8.
Consider scheduling weighted jobs in the δ -commitment model. For any δ > and any ε with δ ≤ ε < + δ , no deterministic online algorithm has a bounded competitive ratio.Proof. We reuse the idea of [2] to release the next job upon admission of the previous one while heavilyincreasing the weights of subsequent jobs. However, the scheduling models differ in the fact that the δ -commitment model allows for processing before commitment which is not allowed in the commitment-upon-admission model.Assume for the sake of contradiction, that there is a c -competitive algorithm. We consider the followinginstance that consists of n tight jobs with the same deadline d : = + ε . Job j has a weight of w j : = ( c + ) j which implies that any c -competitive algorithm has to admit job j at some point even if all jobs 1 , . . . , j − δ -commitment model, the admission cannot happen later than d − ( + δ ) p j which isthe point in time when job j + r = p =
1. If jobs 1 , . . . , j have beenreleased, job j + r j + = d − ( + δ ) p j and has processing time d − r j + + ε = d − ( d − ( + δ ) p j ) + ε = + δ + ε p j = . . . = (cid:18) + δ + ε (cid:19) j − . An instance with n such jobs has a total processing volume of n ∑ j = p j = n − ∑ j = (cid:18) + δ + ε (cid:19) j = − (cid:16) + δ + ε (cid:17) n − + δ + ε . c -competitive algorithm has to complete the n jobs before d = + ε . This also holds for n → ∞ and,thus, + εε − δ ≤ + ε is implied. This is equivalent to ε ≥ + δ . In other words, if ε < + δ , there is nodeterministic c -competitive online algorithm.In particular, there is no bounded competitive ratio possible for ε ∈ ( , ) . A restriction for ε appears tobe necessary as Azar et al. [2] provide such a bound when the slackness is sufficiently large, i.e, ε >
3. Infact, our bound answers affirmatively the open question in [2] if high slackness is indeed required. Again,this strong impossibility result gives a clear separation between the weighted and the unweighted problemas we show in the unweighted setting a bounded competitive ratio for any ε > Further lower bounds.
In Appendix D, we provide a simple proof of Theorem 6 for commitment on jobadmission and δ -commitment and additional lower bounds for the setting of proportional weights ( p j = w j ). We provide a general framework for online deadline-sensitive scheduling with and without commitment.This is the first unifying approach and we believe that it captures well (using parameters) the key designprinciples needed when scheduling online, deadline-sensitive and with commitment .We give the first rigorous bounds on the competitive ratio for maximizing throughput in different com-mitment models. Some gaps between upper and lower bounds remain and, clearly, it would be interestingto close them. In fact, the lower bound comes from scheduling without commitment and it is unclear, ifscheduling with commitment is truly harder than without. It is somewhat surprising that essentially thesame algorithm (with the same parameters and commitment upon admission) performs well for both, com-mitment upon admission and δ -commitment, whereas a close relation between the models does not seemimmediate. It remains open, if an algorithm can exploit the seemingly greater flexibility of δ -commitment.We restrict our investigations to unit-weight jobs which is justified by strong impossibility results (Theo-rems 7, 8, [2,21,25]). Thus, for weighted throughput a rethinking of the model is needed. A major difficultyis the interleaving structure of time intervals which makes the problem intractable in combination withweights. However, practically relevant restrictions to special structures such as laminar or agreeable inter-vals have been proven to be substantially better tractable in related online deadline scheduling research [8,9].Furthermore, we close the problem of scheduling unweighted jobs without commitment with a best-achievable competitive ratio Θ ( ε ) . It remains open if the weighted setting is indeed harder than the un-weighted setting or if the upper bound O ( ε ) in [21] can be improved. Future research on generalizations tomulti-processors seems highly relevant. We believe that our general framework is a promising starting point.14 PPENDICESA Summary State-of-the-Art
For convenience we summarize the state of the art regarding competitive analysis for online throughputmaximization with and without commitment.no commitment commit at admission δ -commitment commit at arrival w j ≡ Θ ( ε ) Ω ( ε ) , O ( ε ) Ω ( ε ) , O ( ε ( ε − δ ) δ ) no f ( ε ) Theorems 1 and 6 Theorems 2 and 6 Theorems 2 and 6 Theorem 7 w j = p j O ( ) Θ ( ε ) Θ ( ε ) Θ ( ε ) [18] [10, 12] Theorem 10 , [10, 12] [10, 12]general w j Ω ( ε ) , O ( ε ) no f ( ε ) no f ( ε ) no f ( ε ) Theorem 6, [21] [2] Theorem 8 [21]
B Proofs of Section 3 (Completing sufficiently many jobs)
B.1 Proofs of Section 3.1
Lemma 2.
W.l.o.g. we restrict to instances on which the region algorithm admits all jobs.
More formally, we show the following lemma.
Lemma 8.
For any instance I and some job j, for which the region algorithm generates an interruptiontree T j with regions in [ a j , b j ) , there is an instance I ′ with at most | T j | + jobs such that the regions in [ a j , b j ) and the tree T j are identical.Proof. Consider an instance I of the non-committed scheduling problem, and let T j be the interruption treeconstructed by the region algorithm with its root in j . Let the interval [ a j , b j ) be the convex hull of thesubintervals belonging to the region of j . Our goal is to modify the instance I such that we can remove jobsoutside of T j without changing the interruption tree of the algorithm. We do so by setting I ′ to contain theset of jobs in T j and changing only parameters of job j (and possibly adding one auxiliary job). Note that j is, by definition, the largest job in I ′ .If d j − a j ≥ ( + ε ) p j then we set r ′ j : = a j . Otherwise, we add an auxiliary job 0 to I ′ that is tightand blocks the machine until a j . This means r = d j − ( + ε ) p j , p = ( + ε ) p j − ( d j − a j ) , and d = r + ( + ε ) p . Moreover, we modify the release date of j to r ′ j : = r . Since the auxiliary job is the smallestjob in instance I ′ at time r , the region algorithm admits this job and delays job j . Let R and R ′ be theschedule of regions in [ a j , b j ) generated by the region algorithm when applied to I and I ′ , respectively. Weshow that R and R ′ are identical in [ a j , b j ) .Consider the time t = a j . Clearly, j ’s region starts in R by assumption. If no auxiliary job was used,job j is the only available job in I ′ . Thus, the region algorithm admits j . In contrast, if 0 ∈ I ′ , it finishesat a j by definition. Since j is admitted in R , it must hold that d j − a j ≥ ( + δ ) p j . Thus, its regions alsobegins in R ′ at a j .Let a j < t < b j be the first time when the two region schedules R and R ′ are different. Since bothschedules are generated by the region algorithm, any change in the structure of the regions is due to oneof the two decision events of the region algorithm. Recall that these events where the end of a job’s region15nd the release of a new job. We distinguish two cases based on the job k that caused the difference in R and R ′ : k ∈ T j or k / ∈ T j .By definition, the region of any job outside of T j has empty intersection with [ a j , b j ) . Thus, the releaseof such a job can neither change R nor R ′ . Of course, the region of such job cannot end within [ a j , b j ) .Thus, a job k ∈ T j is the reason for the difference in R and R ′ . Let k be the job that owns time t in R . If theprocessor is idle in R after t let k be the job that owns t in R ′ . As the two schedules are identical in [ a j , t ) ,let i ∈ T j be the unique job that owns the time right before t .Consider the event that the region of i ended at t . If k is an ancestor of i , then there is no sufficiently smalljob available in I that prevents k from being restarted at t . Additionally, the amount of time that belongsto R ( k ) in [ a j , t ) is identical in R and R ′ . Thus, k also resumes processing in R ′ . If k is admitted at t in R ,it is sufficiently small to (further) preempt the ancestor of i and it is available for admission. Hence, thesetwo properties are also satisfied in I ′ and k is admitted at t in R ′ as well. Therefore R contains idle timeat t while the region of k is scheduled in R ′ . Since the jobs in I ′ are a subset of the jobs in I (except for 0),job k is also admitted and unfinished or available at t in I . This is a contradiction. Lemma 3.
Let α = and β = ε , with ε > . If b j − a j ≥ ( ℓ + ) p j for ℓ > , then | F j | − | U j | ≥ ⌊ ℓ ε ⌋ .Proof. Assume for the sake of contradiction that there is an instance such that the interruption tree generatedby the region algorithm contains a subtree T j with b j − a j ≥ ( ℓ + ) p j and | F j | − | U j | < ⌊ ℓ ε ⌋ . Let I be suchan instance with minimal number of jobs in total. By Lemma 2, we restrict to the jobs contained in T j . Thegoal is to construct an instance I ′ that satisfies b j − a j ≥ ( ℓ + ) p j and | F j | − | U j | < ⌊ ℓ ε ⌋ although it usesless jobs than I . To this end, we modify I in several steps such that we can merge three jobs to one largerjob without violating b j − a j ≥ ( ℓ + ) p j , changing | F j | or | U j | , or making the instance infeasible. The threejobs will be leaves with the same parent i in T j . In fact, if i is an unfinished job, then b i − a i ≥ ( + ε ) p i .Any job k that may postpone i satisfies p k < β p i = ε p i . Hence, if the children of i are all leaves, there haveto be at least three jobs that interrupt i .In the following argumentation we use the position of jobs in the interruption tree. To that end, we definethe height of an interruption tree to be the length of a longest path from root to leaf and the height of thenode j in the tree to be the height of T j .The roadmap of the proof is as follows: First, we show that there is an instance I ′ with an unfinishedjob of height one by proving the following facts.1. The height of the interruption tree T j is at least two.2. Any finished job of height one can be replaced by a leaf.Let i be an unfinished job of height one. We show that three of its children can be merged and becomea sibling of their former ancestor. To this end, we prove that we can assume w.l.o.g. the following twoproperties of the children of i .3. No job is completely scheduled in [ d i , b i ) .4. The children of i form a string of jobs.Ad 1. We show that the height of T j is at least two. Assume for the sake of contradiction that T j is a starcentered at j . Since any leaf finishes by definition of the region algorithm, the root j is the only jobthat could possibly be unfinished. As | F j | − | U j | ≤ ⌊ ℓ ε ⌋ −
1, this implies that there are at most ⌊ ℓ ε ⌋ leaves in T j . Then, b j − a j = ∑ i ∈ T j p i < p j + (cid:22) ℓ ε (cid:23) · ε p j ≤ p j + ℓ p j , where we used p i < β p j for each leaf i ∈ T j . This contradicts the assumption b j − a j ≥ ( ℓ + ) p j .16d 2. We show that w.l.o.g. any region of height one ends after the corresponding deadline. Let i be afinished job of height one, i.e., b i ≤ d i , let l be the last completing child of i , and let π ( i ) denote theparent of i . This job π ( i ) ∈ T j must exist because the height of T j is at least two by 1. We create a newinstance by replacing l by a new job l ′ that is released at r l ′ : = b i − p l and that has the same processingtime as l , i.e., p l ′ : = p l . The deadline is d l ′ : = r l ′ + ( + ε ) p l ′ . We argue that i finishes at r l ′ in the newinstance and that l ′ finishes at b i .As l is not interrupted, r l ′ − a l = b i − p l − a l = b i − b l , which is the remaining processing time of i at a l .If we can show that i is not preempted in [ a l , r l ′ ) in the new instance, i completes at a l + b i − b l = r l ′ .Since l is the last child of i , any job k released within [ a l , b i ) is scheduled later than b i . (Recall thatwe restrict to jobs in the interruption tree T j by Lemma 2.) Thus, p k ≥ β p i > p l . Hence, i is notinterrupted in [ a l , r l ′ ) and completes at r l ′ < b i ≤ d i . At time r l ′ , job l ′ is the smallest available joband satisfies p l ′ < ( ε ) p i < ( ε ) p π ( i ) . Thus, l ′ is admitted at r l ′ and is not interrupted until r l ′ + p l = b i by the same argumentation about the jobs k that are released in [ a l , b i ) . Hence, its region endsat r l ′ + p l ′ < d l ′ . Moreover, outside the interval [ a l , b i ) neither the instance nor the schedule of theregions are changed. Since l ′ is now released outside of the region of i , l ′ becomes a child of π ( i ) ,i.e., l ′ is directly appended to π ( i ) . This modification does not alter the length of [ a j , b j ) or the numberof finished and unfinished jobs. Inductively applying this modification to any finished job of heightone proves the claim.Next, we prove the simplifying assumptions on jobs of height one. Because of the just proven state-ments, T j must contain at least one unfinished job of height one. Let i be such a job. Since i is unfinished, itmust hold that d i < b i . For simplicity, let T : = T − i denote the set of children of i and let τ : = | T | .Ad 3. We start by showing that no region of child of i is completely contained in [ d i , b i ) . If there is a child c with d i ≤ a c < b c < b i , it does not prevent the algorithm from finishing i . Hence, it could be appendedto π ( i ) in the same way as we appended the last child of an finished job in the previous claim. Thatis, we can create a new instance in which c is appended to π ( i ) and i is still unfinished.Ad 4. We show that the regions of the children of i form an interval with endpoint max { d i , b max } where b max : = max c ∈ T b c . We further prove that they are released and admitted in increasing order oftheir processing times. More formally, we index the children in increasing order of their processingtimes, i.e, p c ≤ p c ≤ . . . ≤ p c τ . Then, we create a new instance with modified release dates such thatone child is released upon completion of the previous child. This means r c ′ τ : = max { d i , b max } − p c τ and r c ′ h − : = r c ′ h − p c ′ h − for 1 < h ≤ τ where the processing times are not changed, i.e., p c ′ h = p c h . In or-der to ensure that the modified instance is still feasible, we adapt the deadlines d c ′ h : = r c ′ h + ( + ε ) p c ′ h .It is left to show that the modifications did not affect the number of finished or unfinished jobs.Obviously, the region algorithm still admits every job in T ′ . A job k / ∈ T ′ released in [ a i , b i ) satis-fies p k ≥ β p i > p c > β p c for all c ∈ T . Hence, these jobs do not interrupt either i or any of thechildren. They are still scheduled after b i and every child c ∈ T completes before its deadline. Wealso need to prove that i still cannot finish on time. If b max ≤ d i , the region of every child is completelycontained in [ a i , d i ) . Hence, job i is still interrupted for the same amount of time before d i in I ′ as itis in I . Thus, b ′ i = a i + p i + ∑ τ h = p c ′ h = a i + p i + ∑ c ∈ T p c = b i > d i . If b max > d i , let l denote the childin I with b l = b max . Then, r c ′ τ = b max − p c ′ τ ≤ b l − p l < d i , where we used that no child is completelyprocessed in [ d i , b i ) and that c ′ τ is the child of i with the largest processing time. Thus, the delay of i in [ a i , d i ) is identical to ∑ c ∈ T p c − ( b l − d i ) . Hence, i still cannot finish on time. In this case, b ′ i = b i holds as well. Hence, the modified jobs in I ′ still cover the same interval [ a i , b i ) .So far we have modified I such that it remains an instance which achieves | F j | − | U j | < ⌊ ℓ ε ⌋ with aminimum total number of jobs. In the following, we show that the considered instance does not use a17inimal number of jobs in total which implies a contradiction and thus the lemma is proved. We do soby modifying the instance in three steps. In the first step, we merge three jobs in T − i where i ∈ T j is anunfinished job of height one such that its children satisfy the Assumptions 3 and 4. In the second step, wereplace i by a similar job i ′ to ensure that the instance is still feasible. In the third step, we adapt jobs k / ∈ T − i to guarantee that i ′ is admitted at the right point in time. Then, we we show that the resulting instance coversthe same interval [ a i , b i ) Since i is admitted at a i ≤ d i + ( + ε ) p i and not finished by the region algorithm on time, b i − a i ≥ ( + ε ) p i . As any job that may postpone the region of i satisfies p k < β p i = ε / p i , there have to be at least threejobs that interrupt i . Among these, consider the first three jobs c , c , and c (when ordered in increasingrelease dates). We create a new instance by deleting c , c , and c and adding a new job c ′ such that c ′ isreleased at the admission date of i in I and it merges c , c and c , i.e., r c ′ : = a i , p c ′ : = p c + p c + p c ,and d c ′ : = r c ′ + ( + ε ) p c ′ . In exchange, we remove the jobs c , c , and c from the instance. This completesour first step of modification.Second, we replace i by a new job i ′ that is released at r i ′ : = a i + p c ′ , has the same processing time, i.e., p i ′ = p i , and has a deadline d i ′ : = max { d i , r i ′ + ( + ε ) p i ′ } .In the third step of our modification, we replace every job k with r k ∈ [ a i , r i ] and p k ≤ p i by a new job k ′ that is released slightly after i ′ , i.e., r k ′ : = r i ′ + ρ for ρ > k ′ , i.e., p k ′ = p k and d k ′ = d k . This ensures that k ′ finishes on time if and only if k finishes on time. This modification is feasible, i.e., d k ′ − r k ′ ≥ ( + ε ) p k ′ ,because of two reasons. First, b i − r i ′ = b i − ( a i + p c ′ ) = b i − a i − ( p c + p c + p c ) ≥ p i as c , c , and c postponed the region of i by their processing times in I . Second, d k − b i ≥ ( + ε ) p k becausewe only consider jobs that were admitted at some point later than b i by the region algorithm. Then, d k ′ − r k ′ = d k − b i + b i − r i ′ − ρ ≥ ( + ε ) p k + p i − ρ ≥ ( + ε ) p k − ρ ≥ ( + ε ) p k ′ , where the last but one inequality follows from the fact that only jobs with p k ≤ p i were affected by themodification and the last inequality is due to the sufficiently small choice of ρ .So far, we have already seen that the resulting instance is still feasible. It is left to show that c ′ completesat r c ′ + p c ′ as well as that i ′ is admitted at r i ′ and its region ends at b i .Since it holds that p c ′ < ε p i < p i , at a i = r c ′ the new job c ′ is the smallest available job and any jobthat was interrupted by i is preempted by c ′ as well. The jobs in T − i are released one after the other byAssumption 4 and r c > a i . Thus, if i ′ has at least one child left after the modification, it holds that r c = r c + p c + p c + p c = a i + p c ′ + ( r c − a i ) > r i ′ . Hence, no remaining child is released in [ r c ′ , r i ′ ] in themodified instance. Any other job k ∈ T j released in [ r c ′ , r i ′ ] satisfies p k ≥ ε p i as k / ∈ T − i . Because p c ′ < p i ,this implies that p k ≥ ε p c ′ holds as well, i.e., no such job k interrupts c ′ . Therefore, c ′ completes at r ′ i .Job i ′ is admitted at r i ′ if it is the smallest available job at that time. We have already proven that noneof the remaining children of i is released in [ a i , r i ′ ] that might prevent the region algorithm from admitting i at r i ′ . Furthermore, the third step of our modification guarantees that any job k ∈ T j \ T i that is smaller than p i is released after r i ′ . Therefore, i ′ is the smallest available job at time r i ′ by construction, and it is admitted. Asargued above, the modified instance is still feasible and the interval [ a π ( i ) , b π ( i ) ) is still completely coveredby regions of jobs in T π ( i ) .However, the second step of our modification might lead to b i ′ ≤ d i ′ which implies that i ′ finishes ontime while i does not finish on time. This changes the values of | F j | and | U j | . Clearly, in the case that i ′ completes before d i ′ , | U ′ j | = | U j | −
1. By a careful analysis, we see that in this case the number of finishedjobs decreases by one as well because the three (on time) jobs c , c and c are replaced by only one job18hat finishes before its deadline. Formally, we charge the completion of c ′ to c , and the completion of i ′ to c which leaves c to account for the decreasing number of finished jobs. Hence, | F ′ j | − | U ′ j | = | F j | − | U j | .If i ′ does not finish by d i ′ , then | F ′ j | − | U ′ j | = ( | F j | − ) − | U j | . Thus, the modified instance I ′ also satisfies | F ′ j | − | U ′ j | < ⌊ ℓ ε ⌋ but uses less jobs than I does. This is a contradiction. C Proofs of Section 4 (Competitiveness)
C.1 Proof of Lemma 5
Lemma 5.
Let { f , . . . , g } ⊂ J be jobs at maximal distance from M such that ∑ ij = f | X j | > λ ( i + − f ) holdsfor all f ≤ i ≤ g. If g is the last such job, there is a sibling j ∗ of g with b g = a j ∗ and ∑ j ∗ j = f | X j | ≤ λ ( j ∗ + − f ) .Proof. Observe that [ a f , b g ) = S kj = R ( j ) because the leaves f , . . . , g form a string of jobs. Thus, by showingthat there is a job x ∈ X gf : = S gj = f X j that satisfies (V), we prove the statement with the Volume Lemma. Tothis end, we show that for every job f ≤ j ≤ g there exists a set Y j such that the processing volume within Y j is sufficient to cover the interval [ a j , b j ) at least εε − δ times. More precisely, Y f , . . . , Y g will satisfy(i) S gj = f Y j ⊂ X gf ,(ii) | Y j | = λ , and(iii) Y j ⊂ { x ∈ X gf : p x ≥ β p j } for every f ≤ j ≤ g .Indeed, by our choice of λ , ∑ y ∈ Y j p y ≥ λβ p j = εε − δ ( b j − a j ) if (i) to (iii) are satisfied. Thus, if we choose x among those jobs in X gf that O PT completes last and guarantee that x / ∈ S gj = f Y j , the Volume Condition (V)is satisfied. We first give the procedure to find the Y f , . . . , Y g before we show that the constructed sets satisfy(i) to (iii).By assumption, | X f | > λ . Let X f = { x , . . . , x λ , x λ + , . . . } be indexed in increasing completion times C ∗ x . Define Y f : = { x , . . . , x λ } and L f : = { x λ + , . . . } = X f \ Y f , i.e., Y f contains the λ jobs in X f that O PT completes first and L f contains the last jobs. For f < j + ≤ g , let Y f , . . . , Y j and L j be defined. Byassumption, | X j + ∪ L j | > λ since | Y i | = λ for 1 ≤ i ≤ j . The jobs in X j + ∪ L j = { x , . . . , x λ , x λ + , . . . } are again indexed in increasing order of optimal completion times. Then, Y j + : = { x , . . . , x λ } and L j + : = { x λ + , . . . } . Since we move jobs only horizontally to later siblings, we call this procedure Push Forward .By definition, (i) and (ii) are satisfied. Since f , . . . , g are leaves, the jobs in Y j ∩ X j are big w.r.t. j . Thus,it remains to show that the jobs in L j are big w.r.t. the next jobs j + Y f , . . . , Y j are big w.r.t. f , . . . , j , respec-tively. If we find an index f ≤ i ( x ) ≤ j such that x as well as the jobs in S ji = i ( x ) Y i are released after a i ( x ) ,i.e., a i ( x ) ≤ r y for y = x or y ∈ j [ i = i ( x ) Y i , (3)and x completes after every y ∈ S ji = i ( x ) Y i , i.e., C ∗ y ≤ C ∗ x for y ∈ j [ i = i ( x ) Y i , (4)then we can apply the Volume Lemma to show that x ∈ L j is big w.r.t. j +
1. Indeed, then j ∑ i = i ( x ) ∑ y ∈ X i : C ∗ y ≤ C ∗ x p y ≥ p x + j ∑ i = i ( x ) ∑ y ∈ Y i p y ≥ p x + j ∑ i = i ( x ) εε − δ ( b i − a i ) = εε − δ ( b j − a i ( x ) ) + p x .
19e show by induction that such an index i ( x ) exists for every x ∈ L j .Since Y f ⊂ X f , we set i ( x ) : = f for x ∈ L f . By definition of L f , C ∗ y ≤ C ∗ x for y ∈ Y f and x ∈ L f . Hence,applying the Volume Lemma as explained above shows p x ≥ β p f + .Let f < j < g . Assume that Y f , . . . , Y j and L j are defined as described above. For jobs x ∈ L j \ X j ⊂ L j − ,we have i ( x ) with the Properties (3) and (4) by induction. For x ∈ L j ∩ X j , we temporarily set i ( x ) : = j forsimplification. We have to distinguish two cases: i ( x ) also satisfies (3) and (4) for j or we have to adjust i ( x ) . Fix x ∈ L j . • L i ∩ Y j = /0 for every f ≤ i < i ( x ) . Since only jobs in L i are shifted to some later job j , this implies S i ( x ) − i = f X i ∩ Y j = /0. Thus, the jobs in Y j are released after a i ( x ) and by definition, C ∗ y ≤ C ∗ x for y ∈ Y j .By induction, x and the jobs in Y i ( x ) ∪ . . . ∪ Y j − satisfy (3) and (4). Hence, i ( x ) is a suitable choice for x and j . • L i ∩ Y j = /0 for some f ≤ i < i ( x ) . Choose the job y ∈ L j − ∩ Y j with the smallest i ( y ) . By a similarargumentation as before, S i ( y ) − i = f X i ∩ Y j = /0, which implies (3) for z ∈ Y j . Again by induction, y andthe jobs in Y i ( y ) ∪ . . . ∪ Y j − satisfy (3) and (4). Since x ∈ L j , C ∗ x ≥ C ∗ z for all z ∈ Y j . This implies C ∗ x ≥ C ∗ z for z ∈ S j − i = i ( y ) Y i because y ∈ L j − ∩ Y j . Set i ( x ) : = i ( y ) .As explained above, the Volume Lemma implies p x ≥ β p j + .The same argumentation holds for j = g although in this special case, Corollary 1 implies the statement. C.2 Proof of Lemma 6
Lemma 6.
For all j ∈ J ∪ { M } , | X Sj | ≤ τ j λ .Proof. We show that for every j ∈ J ∪ { M } , there exists a partition ( Y k ) k ∈ T − j with(i) S k ∈ T − j Y k = X Sj , (ii) Y k ⊂ { x ∈ X j : p x ≥ β p k } , and (iii) | Y k | ≤ λ for every k ∈ T − j .Then, it holds that | X Sj | = | S k ∈ T − j Y k | = ∑ k ∈ T − j | Y k | ≤ τ j λ and, thus, the lemma follows.The proof consists of an outer and an inner induction. The outer induction is on the distance ϕ ( j ) of ajob j from machine job M , i.e., ϕ ( M ) : = ϕ ( j ) : = ϕ ( π ( j )) + j ∈ J . The inner induction uses theidea about pushing jobs x ∈ X j to some later sibling of j in the same string of jobs (see proof of Lemma 5).Let j ∈ J with ϕ ( j ) = ϕ max − = max { ϕ ( i ) : i ∈ J } −
1. By Observation 2, X Sj = S k : π ( k )= j X k , whereall k ∈ T − j are leaves at maximal distance from M . We distinguish three cases for k ∈ T − j : Case 1. If k ∈ T − j is isolated, | X k | ≤ λ follows directly from the Volume Lemma as otherwise ∑ x ∈ X k p x ≥ λβ p k + p x = εε − δ ( b k − a k ) + p x contradicts Corollary 1, where x ∈ X k is the last job that O PT completesfrom the set X k . Since all jobs in X k are big w.r.t. k , we set Y k : = X k . Case 2. If k ∈ T − j with | X k | > λ is part of a string, let f , . . . , g be the maximal string satisfying Lemma 5with k ∈ { f , . . . , g } . With this lemma, we find Y f , . . . , Y g and set Y g + : = X g + ∪ L g . Case 3.
We have not yet considered jobs k in a string with | X k | ≤ λ that do not have siblings f , . . . , g in thesame string with b g = a k and ∑ gi = f | X j | > ( g − f ) λ . This means that such jobs do not receive jobs x ∈ X i for i = k by the Push Forward procedure in Case 2. For such k ∈ T − j we define Y k : = X k .Then, X Sj = S k : π ( k )= j X k = S k ∈ T − j X k = S k ∈ T − j Y k and, thus, (i) to (iii) are satisfied.Let ϕ < ϕ max such that ( Y k ) k ∈ T − j satisfying (i) to (iii) exists for all j ∈ J with ϕ ( j ) ≥ ϕ . Fix j ∈ J with ϕ ( j ) = ϕ −
1. By induction and Observation 2, it holds that X Sj = S k : π ( k )= j (cid:16) X Bk ∪ S i ∈ T − k Y i (cid:17) . Now, we use20he partitions ( Y i ) i ∈ T − k for k with π ( k ) = j as starting point to find the partition ( Y k ) k ∈ T − j . Fix k with π ( k ) = j and distinguish again the same three cases as before. Case 1. If k is isolated, we show that | X k | ≤ λ ( τ k + ) and develop a procedure to find ( Y i ) i ∈ T k . Assumefor sake of contradiction that | X k | > λ ( τ k + ) and index the jobs in X k in increasing order of completiontimes, i.e., X k = { x , . . . , x λ ( τ k + ) , x λ ( τ k + )+ , . . . } , and set L : = { x λ ( τ k + )+ , . . . } . Then, | X Bk \ L | = | X k \ L | − | X Sk \ L | = ( τ k + ) λ − ∑ i ∈ T − k | Y i \ L | = λ + ∑ i ∈ T − k ( λ − | Y i \ L | ) . By induction hypothesis, λ − | Y i \ L | ≥ i ∈ T − k . Let Y k contain λ arbitrary big jobs in X Bk \ L andassign each Y i for i ∈ T − k exactly λ − | Y i \ L | of the remaining (big) jobs in X Bk \ L . This is possiblebecause the jobs in X Bk are big for any descendant of k , i.e., they satisfy (ii). By choice of λ , each of thejust obtained sets covers the region of the corresponding job at least εε − δ times. Thus, the jobs in X k \ L have a total processing volume of at least εε − δ ( b k − a k ) . Therefore, any job x ∈ L satisfies (V) whichcontradicts the fact that k is isolated by Corollary 1. Thus, | X k | ≤ λ ( τ k + ) .To construct ( Y i ) i ∈ T k , we assign min { λ , | X Bk |} jobs from X Bk to Y k . If | X Bk | > λ , distribute the remainingjobs according to λ − | Y i | among the descendants of k . Then, X k = S i ∈ T k Y i . Because a job that is bigw.r.t job k is also big w.r.t. all descendants of k , every (new) set Y i satisfies (ii) and (iii). We refer to thisprocedure as Push Down since jobs are shifted vertically to descendants.
Case 2. If | X k | > λ ( τ k + ) , k must belong to a string with similar properties as described in Lemma 5,i.e., there are jobs f , . . . , g containing k such that1. ∑ ij = f | X j | > λ ∑ ij = f τ j for all f ≤ i ≤ g and2. b j = a j + for all f ≤ j < g .Choose { f , . . . , g } maximal with those two properties. We show that the Volume Lemma implies theexistence of another sibling g + X f , . . . , X g , X g + . This is done by using the PushDown procedure within a generalization of the
Push Forward procedure.As the jobs f , . . . , g may have descendants, we use Push Forward to construct the sets Z f , . . . , Z g and L f , . . . , L g with | Z k | = λ ( τ k + ) . Then, we show that we can apply Push Down to Z k and ( Y i ) i ∈ T − k inorder to obtain ( Y i ) i ∈ T k . This means the newly obtained partition satisfies(iv) Y k ∪ S i ∈ T − k Y i = Z k ,(v) Y i ⊂ { x ∈ X j : p x ≥ β p i } and(vi) | Y i | = λ for every i ∈ T k .This implies that the set Z k covers [ a k , b k ) at least εε − δ times. Thus, the sets X k with f ≤ k ≤ g satisfy (V)and we can apply Corollary 1.To define Z f , . . . , Z g , we index the jobs in X f = { x , . . . , x λ f , x λ f + , . . . } in increasing order of optimalcompletion times and set Z f : = { x , . . . , x λ k } and L f = X f \ Z f . Assume that Z f , . . . , Z k and L f , . . . , L k are defined. Index the jobs in X k + ∪ L k = { x , . . . , x λ k + , x λ k + + , . . . } in increasing order of completiontimes and set Z k + : = { x , . . . , x λ k + } and L k + = ( X k + ∪ L k ) \ Z k + . Use the Push Down procedure toobtain the partition ( Y i ) i ∈ T k .If we can show that any job x ∈ L k is big w.r.t. k +
1, we have that Z k + \ X Sk + only contains big jobsw.r.t. k +
1, which are also big w.r.t. every i ∈ T − ( k + ) . As in Case 1, | Z k + \ X Sk + | = | Z k + | − | X Sk + \ L k + | = λ + ∑ i ∈ T − ( k + ) ( λ − | Y i \ L k + | ) . ( Y i ) i ∈ T k satisfies (iv) to (vi).As in the proof for Lemma 5, we show by induction that every x ∈ L k exhibits an index i ( x ) with a i ( x ) ≤ r y (5) C ∗ y ≤ C ∗ x (6)for y = x or y ∈ S ji = i ( x ) Z i . Then, the Volume Lemma implies that p x ≥ β p k + .For x ∈ L f , set i ( x ) = f . Thus, Equations (5) and (6) are trivially satisfied. Since Z f ⊂ X f , we have that Z f \ X Sf only contains big jobs w.r.t. f .Let f < k < g . Assume that Z f , . . . , Z k and L k are defined as described above. For jobs x ∈ L k \ X k , wehave i ( x ) with the Properties (5) and (6) by induction. For x ∈ L k ∩ X k , we temporarily set i ( x ) : = k forsimplification. We have to distinguish two cases: i ( x ) also satisfies (5) and (6) for k or we have to adjust i ( x ) . Fix x ∈ L k . • L i ∩ Z k = /0 for every f ≤ i < i ( x ) . Since only jobs in L i are shifted to some later job k , this implies S i ( x ) − i = f X i ∩ Z k = /0. Thus, the jobs in Z k are released after a i ( x ) and by definition, C ∗ y ≤ C ∗ x for y ∈ Z k .By induction, x and the jobs in Z i ( x ) ∪ . . . ∪ Z k − satisfy (5) and (6). Hence, i ( x ) is a suitable choicefor x and k . • L i ∩ Z k = /0 for f ≤ i < i ( x ) . Choose the job y ∈ L k − ∩ Z k with the smallest i ( y ) . By a similarargumentation as before, S i ( y ) − i = f X i ∩ Z k = /0, which implies (5) for z ∈ Z k . Again by induction, y and the jobs in Z i ( y ) ∪ . . . ∪ Z k − satisfy (5) and (6). Since x ∈ L k , C ∗ x ≥ C ∗ z for all z ∈ Z k . Thisimplies C ∗ x ≥ C ∗ z for z ∈ S k − i = i ( y ) Z i because y ∈ L k − ∩ Y k . Set i ( x ) : = i ( y ) .As explained above, the Volume Lemma implies p x ≥ β p k + .For k + = g , the above argumentation can be combined with Corollary 1 to prove that the sibling g + Z g + : = X g + ∪ L g and use Push Down to construct ( Y i ) i ∈ T ( g + ) . Case 3.
Any job k with π ( k ) = j that is part of a string and was not yet considered must satisfy | X k | ≤ ( τ k + ) λ . We use the Push Down procedure for isolated jobs to get the partition ( Y i ) i ∈ T k .Hence, we have found ( Y k ) k ∈ T − j with the properties (iv) to (vi). C.3 Analysis of the Region Algorithm is Tight
The region algorithm is best possible (up to constants) for scheduling without commitment as the matchinglower bound in Theorem 6 proves. Consider now algorithms that must commit to job completions. Weshow that the analysis of the region algorithm is tight in the sense that the competitive ratio of the regionalgorithm is Ω ( α / β ) . Moreover, we give examples that show that for the commitment upon admissionmodel the choice α ∈ Ω ( / ε ) and β ∈ O ( / ε ) is best possible. Lemma 9.
Let < ε ≤ , α ≥ , and < β < . Then, the competitive ratio of the region algorithm isbounded from below by α / β .Proof. We consider an instance where a job 0 with processing time p = [ r , r + α + ) is released first. Then, the region algorithm blocks the region [ r , r + α ] for this job.During this interval, ⌊ α / β ⌋ jobs of size p j = β arrive. They all fit into R ( ) but the jobs are to big relativeto 0 to be admitted. Then, an offline optimum would process all small jobs until r + α before starting job 0.Hence, the region algorithm completes one job while it is optimal to complete ⌊ α / β ⌋ + α d − β − β = ( + δ ) p · · · · · · r r r r r r r r · · · d Figure 2:
The structure of the regions and the schedule generated by the region algorithm when faced with the instance I m ( c ) .The darkest shades of a color mean that jobs are scheduled there. The light yellow and blue parts show that the region is currentlyinterrupted. The only time slots where 0 can be processed are the lighter parts of the green regions, i.e., the regions belongingto B ( c ) . More formally, let r = p = d = α +
1. Fix 0 < ϕ < β <
1. For 1 ≤ j ≤ ⌊ α / β ⌋ let r j =( j − ) β + ϕ , p j = β and d j = r j + ( + ε ) p j . The region algorithm admits job 0 at time 0 and blocks theinterval [ , α ) for 0. Thus, the region algorithm cannot admit any of the small jobs and completes only job 0.This behavior does not depend on the commitment model.An optimal offline algorithm processes the jobs 1 , . . . , ⌊ α / β ⌋ one after the other in the inter-val [ ϕ , ⌊ α / β ⌋ β + ϕ ) ⊂ [ , α + ) . At the latest at time α + ⌊ α / β ⌋ + ≥ α / β . Lemma 10.
The competitive ratio of the region algorithm in the scheduling with commitment model isbounded from below by Ω ( / ε ) .Proof. The proof consists of two parts. First we show an upper bound on the choice of β in terms of δ .Then, we use this observation to show an upper bound on β depending on α .It is obvious that β ≤ δ must hold as otherwise a job that is admitted at d j − ( + δ ) p j and interruptedby another job i with p i = β p j − ϕ cannot finish on time. Hence, β < δ ≤ I m ( c ) that depends on two natural numbers m , c ∈ N where c is chosensuch that 1 β ( c + ) < α ≤ β c . (7)Each instance consists of four types of jobs, a job 0 that cannot be finished unless α and β satisfy certainbounds, an auxiliary job − d − ( + δ ) p and two sets of jobs, B ( c ) and G ( n ) that block as much time in [ a , d ) as possible. A visualization of the instance can be seen inFigure 2.More precisely, at time t =
0, an auxiliary job − p − = d − = ( + ε ) p − . Theregion algorithm admits this job and assigns it the region R ( − ) = [ , α ) . At time α − ( ε − δ ) job 0 isreleased with p = d = α + + δ . Obviously, this job is admitted at time α as it is still available.Fix ϕ > α + ϕ the sequence B ( c ) of c identical jobs is released one after the other such that the releasedate of one job coincides with the end of the region of the previous job. For 0 ≤ i ≤ c −
1, a tight job is23eleased at r i : = α + i / c + ϕ with processing time p i = β − ϕ and deadline d i = r i + ( + ε ) p i . Since r i + α p i ≤ α + i / c + ϕ + β / ( β c ) − αϕ < α + ( i + ) / c + ϕ = r i + each of these jobs is admitted by the region algorithm at their release date. The last of these regions ends at α + ( c − ) / c + ϕ + α ( β − ϕ ) = α + c − c + ϕ + c − αϕ ≤ α +
1. Thus, in the limit ϕ →
0, they block c β units of time in [ a j , a j + d j ) .At time d − β − β , a sequence of m geometrically decreasing jobs G ( m ) is released. For 1 ≤ j ≤ m , job j is released at r j = d − β − β + ∑ ji = β i with processing time p j = ( β − ϕ ) j and deadline d j = r j + ( + ε ) p j .Then, p j + = ( β − ϕ ) p j < β p j . Thus, the region algorithm admits each of the m jobs. Again, in thelimit n → ∞ and ϕ →
0, the processing volume of G ( m ) sums up to β − β .Putting the two observations together, we obtain β − β + c β ≤ δ as otherwise job 0 cannot finish on time. Hence, 0 ≤ c β − ( + c + δ ) β + δ . Solving for the two roots, β + and β − , we obtain β + = + c + δ + p ( + c + δ ) − c δ c = + c + δ + p ( + c ) + ( + c ) δ + δ − c δ c ≥ + c + δ + √ c + δ − c δ c = + c + δ + p ( c − δ ) c > . As we have seen by the first example, β < β is in the interval ( , β − ) . By a similar calculation, it follows that β − ≤ δ c . As we know by Lemma 9, thecompetitive ratio is bounded from below by α / β . Combined with the two bounds on α , β ( c + ) < α ≤ β c ,we obtain αβ ≥ β ( c + ) β = c δ ( c + ) . Since the right hand side is increasing in c for positive c , the expression is minimized for c =
1. This impliesthat β ∈ O ( ε ) and therefore α ∈ Ω ( / ε ) . D Additional Lower Bounds
D.1 Lower Bounds: Commitment upon arrival
D.1.1 Proportional weights ( w j = p j ) We consider the setting of proportional weights in which w j = p j for all jobs j . It has been previously knownthat deterministic algorithms can achieve a competitive ratio of Θ ( ε ) for this setting [10]. In Theorem 10below, we provide a lower bound of Ω ( log ε ) for randomized algorithms in the less restrictive setting ofcommitment upon job admission. This implies the following corollary. Corollary 2.
Consider proportional weights (w j = p j ). The competitive ratio of any randomized algorithmis Ω ( log 1 / ε ) for scheduling with commitment upon arrival. D.2 Lower bounds: Commitment on job admission and δ -commitment Lower bounds for arbitrary weights and commitment on job admission have already been shown [21]. Werule out bounded performance ratios even for unit weights and give a lower bound for proportional weights.24 .2.1 Unit weights ( w j = ) The lower bound for scheduling without commitment in Theorem 6 immediately carries over to any modelfor scheduling with commitment. However, we provide a much simpler proof for the setting we study here.
Simple proof of Theorem 6 for commitment on job admission and δ -commitment. Let ε < and δ < ε . Attime 0, job 1 is released with p = d j = + ε . To be competitive in the case that no further jobs arereleased, the algorithm has to finish this job. Hence, independently of the respective commitment model,the algorithm needs to have committed to this job at time 2 ε . At this time, there are ⌊ − εε ⌋ = Ω ( ε ) jobs withprocessing time ε and deadline 1 released. While the optimum can finish all of them, the laxity of job 1admits only that the online algorithm accepts one additional job. D.2.2 Proportional weights ( w j = p j ) We first consider deterministic algorithms.
Theorem 9.
Consider proportional weights (w j = p j ). For commitment on job admission and the δ -commitment model, the competitive ratio of any deterministic algorithm is Ω ( ε ) .Proof. Let ε < and δ < ε . At time 0, job 1 is released with p = d j = + ε . To be competitive inthe case that no further jobs are released, the algorithm has to complete this job. Hence, independently of therespective commitment model, the algorithm needs to have committed to this job at time 2 ε . At this time,job 2 is released, where p = − εε = Ω ( ε ) and its slack is 1 − ε . The optimum only schedules job 2, butthe online algorithm cannot finish it because it has committed to job 1, which still requires 1 − ε > − ε processing.We show a weaker lower bound for randomized algorithms. Theorem 10.
Consider proportional weights (w j = p j ). For commitment on job admission and the δ -commitment model, the competitive ratio of any randomized algorithm is Ω ( log ε ) .Proof. Let k = ⌊ log ( ε ) ⌋ , and consider a c -competitive algorithm. The adversary releases at most k jobs,where job j = , . . . , k arrives at r j = ε∑ j − i = i − , has processing time 2 j − and slack ε j − .Denote by n i the probability that the algorithm commits to job i . We make the following observations:(i) The release date of job j is 2 ε j − ∑ i = i − < ε · log ( ε ) ≤ , at which time any job j ′ < j that the algorithm has committed to has at least p − / = / j is however only at most ε · j − ≤ ε · ⌊ log ( ε ) ⌋− ≤ . This implies that no two jobs can both be committed to at the same time. Hence, ∑ ki = n i ≤ j < k at the latest at r j + ε j − = ε j − ∑ i = i − + ε j − < ε j ∑ i = i − = r j + , that is, unknowingly whether j + j . Hence, we have ∑ ji = n i · i − ≥ j − c .This allows us to apply Lemma 7 to n , . . . , n k , showing c ≥ k + Ω ( log ε ) .25 eferences [1] K. Agrawal, J. Li, K. Lu, and B. Moseley. Scheduling parallelizable jobs online to maximize through-put. In Proceedings of the Latin American Theoretical Informatics Symposium (LATIN) , pages 755–776, 2018.[2] Y. Azar, I. Kalp-Shaltiel, B. Lucier, I. Menache, J. Naor, and J. Yaniv. Truthful online scheduling withcommitments. In
Proceedings of the ACM Symposium on Economics and Computations (EC) , pages715–732, 2015.[3] N. Bansal, H.-L. Chan, and K. Pruhs. Competitive algorithms for due date scheduling. In
Proceedingsof the International Colloquium on Automata, Languages and Programming (ICALP) , pages 28–39,2007.[4] S. K. Baruah and J. R. Haritsa. Scheduling for overload in real-time systems.
IEEE Trans. Computers ,46(9):1034–1039, 1997.[5] S. K. Baruah, J. R. Haritsa, and N. Sharma. On-line scheduling to maximize task completions. In
Proceedings of the IEEE Real-Time Systems Symposium (RTSS) , pages 228–236, 1994.[6] S. K. Baruah, G. Koren, D. Mao, B. Mishra, A. Raghunathan, L. E. Rosier, D. E. Shasha, and F. Wang.On the competitiveness of on-line real-time task scheduling.
Real-Time Systems , 4(2):125–144, 1992.[7] R. Canetti and S. Irani. Bounding the power of preemption in randomized scheduling.
SIAM J.Comput. , 27(4):993–1015, 1998.[8] L. Chen, N. Megow, and K. Schewior. An O ( log m ) -competitive algorithm for online machine mini-mization. In Proceedings of the ACM-SIAM Symposium on Discrete Algorithms (SODA) , pages 155–163, 2016.[9] L. Chen, N. Megow, and K. Schewior. The power of migration in online machine minimization. In
Proceedings of the ACM Symposium on Parallelism in Algorithms and Architectures (SPAA) , pages175–184, 2016.[10] B. DasGupta and M. A. Palis. Online real-time preemptive scheduling of jobs with deadlines. In
Proceedings of the International Conference on Approximation Algorithms for Combinatorial Opti-mization Problems (APPROX) , pages 96–107, 2000.[11] A. D. Ferguson, P. Bod´ık, S. Kandula, E. Boutin, and R. Fonseca. Jockey: guaranteed job latency indata parallel clusters. In
Proceedings of the European Conference on Computer Systems (EuroSys) ,pages 99–112, 2012.[12] J. A. Garay, J. Naor, B. Yener, and P. Zhao. On-line admission control and packet scheduling withinterleaving. In
Proceedings of the IEEE International Conference on Computer Communications(INFOCOM) , pages 94–103, 2002.[13] L. Georgiadis, R. Gu´erin, and A. K. Parekh. Optimal multiplexing on a single link: delay and bufferrequirements.
IEEE Trans. Inf. Theory , 43(5):1518–1535, 1997.[14] M. H. Goldwasser. Patience is a virtue: The effect of slack on competitiveness for admission control.In
Proceedings of the ACM-SIAM Symposium on Discrete Algorithms (SODA) , pages 396–405, 1999.2615] S. Im and B. Moseley. General profit scheduling and the power of migration on heterogeneous ma-chines. In
Proceedings of the ACM Symposium on Parallelism in Algorithms and Architectures (SPAA) ,pages 165–173, 2016.[16] B. Kalyanasundaram and K. Pruhs. Maximizing job completions online.
J. Algorithms , 49(1):63–85,2003.[17] G. Koren and D. E. Shasha. MOCA: A multiprocessor on-line competitive algorithm for real-timesystem scheduling.
Theor. Comput. Sci. , 128(1–2):75–97, 1994.[18] G. Koren and D. E. Shasha. D over : An optimal on-line scheduling algorithm for overloaded uniproces-sor real-time systems.
SIAM J. Comput. , 24(2):318–339, 1995.[19] J. Liebeherr, D. E. Wrege, and D. Ferrari. Exact admission control for networks with a bounded delayservice.
IEEE/ACM Trans. Netw. , 4(6):885–901, 1996.[20] R. Lipton. Online interval scheduling. In
Proceedings of the ACM-SIAM Symposium on DiscreteAlgorithms (SODA) , pages 302–311, 1994.[21] B. Lucier, I. Menache, J. Naor, and J. Yaniv. Efficient online scheduling for deadline-sensitive jobs:extended abstract. In
Proceedings of the ACM Symposium on Parallelism in Algorithms and Architec-tures (SPAA) , pages 305–314, 2013.[22] K. Pruhs and C. Stein. How to schedule when you have to buy your energy. In
Proceedings ofthe International Conference on Approximation Algorithms for Combinatorial Optimization Problems(APROX) , pages 352–365, 2010.[23] C. Schwiegelshohn and U. Schwiegelshohn. The power of migration for online slack scheduling. In
Proceedings of the European Symposium of Algorithms (ESA) , volume 57, pages 75:1–75:17, 2016.[24] G. J. Woeginger. On-line scheduling of jobs with fixed start and end times.
Theor. Comput. Sci. ,130(1):5–16, 1994.[25] J. Yaniv.