Online Scheduling to Minimize Maximum Response Time and Maximum Delay Factor ∗

: This paper presents several online scheduling algorithms for two related performance metrics, namely maximum response time and maximum delay-factor, and also their weighted versions. The delay factor metric is new (introduced in Chang et al. (SODA’08)), while special cases of maximum weighted response time have been considered before. We study both the standard scheduling model where each arriving job requires its own processing, as well as the broadcast scheduling model where multiple requests/jobs can be simultaneously satisﬁed. Motivated by strong lower bounds, we consider the resource augmentation model introduced in Kalyanasundaram and Pruhs (JACM’95) where the algorithm is given a machine with faster speed than the adversary. We give scalable algorithms; that is, algorithms that when given ( 1 + ε ) -speed are O ( poly ( 1 / ε )) -competitive for any ﬁxed ε > 0. Our main contributions are for broadcast scheduling. Along the way we also show that the FIFO (ﬁrst-in-ﬁrst-out) algorithm is 2-competitive for broadcast scheduling even when pages have non-uniform sizes. We complement our algorithmic results by showing that a natural greedy


Introduction
Scheduling requests (or jobs 1 ) that arrive online is a fundamental problem faced by many systems and consequently there is a vast literature on this topic.A variety of models and performance metrics are studied in order to capture the requirements of a system.In this paper we consider two related performance metrics, namely response time (also referred to as flowtime) and a recently suggested performance metric called delay factor [17].We also address their weighted versions.In particular, we are interested in scheduling to minimize the maximum (weighted) response time (over all requests) or to minimize the maximum delay factor.We consider both the traditional setting where requests are independent and require separate processing from the machine and also the more recent setting of broadcast scheduling where different requests may ask for the same page (or data) and can be simultaneously satisfied by a single transmission of the page.We first describe the traditional setting, which we refer to as the unicast setting, to illustrate the definitions and and then describe the extension to the broadcast setting.
We assume that requests arrive online.A request J i and its properties are known only when it arrives to the system.We use a i to denote its arrival time and i to denote its processing time.In the weighted case J i has a non-negative weight w i ; the unweighted case corresponds to w i = 1 for all i.Consider an online scheduling algorithm A. Let f A i denote the completion time or finish time of J i under A. The response time of J i under A is f A i − a i , in other words the total duration spent by J i in the system before its processing is finished.Now we define the delay factor metric.Here it is assumed that each request J i has a deadline d i that is known upon its arrival.We refer to the quantity S i = (d i − a i ) as the slack of request J i .If f A i is the finish time of J i under some schedule A then its delay factor is defined as max{1, ( f A i − a i )/(d i − a i )}.Thus, delay factor measures the ratio of the response time and the slack, unless the request finishes by its deadline in which case we set its delay factor to 1.In this paper we are interested in algorithms that minimize the maximum response time and the maximum delay factor.Given an online request sequence σ and an algorithm A, let α A (σ ) = max J i ∈σ γ A i where γ A i is either the response time or the delay factor of J i in A; in the weighted case α A (σ ) = max J i ∈σ w i γ A i .We measure the performance of an algorithm A via worst-case competitive analysis: A is r-competitive if for all request sequences σ we have α A (σ ) ≤ rα * (σ ) where α * (σ ) is the value of an optimum offline schedule for σ .Now we discuss broadcast scheduling where multiple requests can be satisfied simultaneously.This model is motivated by applications in wireless and local area networks where information is transmitted over a broadcast medium [8,2,1,10]; this allows all clients interested in a particular piece of information to access it at the same time.The model is also motivated by batch scheduling problems [27,26,45,9] and more recent applications [25,14].In the formal model, there are n distinct pages or pieces of data that are available in the system, and a request from a client specifies a page of interest.This is called the pull-model since the clients initiate the request and we focus on this model in this paper (in the push-model the server transmits the pages according to some frequency).Multiple outstanding requests for the same page p are satisfied by a single transmission of page p.We use J p,i to denote i'th request for a page p ∈ {1, 2, . . ., n}; here we assume that the requests for the same page are ordered by arrival time with ties broken arbitrarily.We let a p,i denote the arrival time of the request J p,i .Requests may also have deadlines, denoted d p,i and non-negative weights w p,i .The finish time f A p,i of a request J p,i in a given schedule A is defined to be the earliest time after a p,i when the page p is transmitted by the schedule A. Note that multiple requests for the same page can have the same finish time.The response time and delay factor for a request J p,i are defined as ( f A p,i − a p,i ) and max{1, ( f A p,i − a p,i )/(d p,i − a p,i )} respectively.As before, given an online request sequence σ and an algorithm A, we let α A (σ ) = max J p,i ∈σ γ A p,i where γ A p,i is either the response time or the delay factor of J p,i in A; in the weighted case α A (σ ) = max J i ∈σ w p,i γ A p,i .Here too we are interested in competitive analysis.A significant portion of the broadcast scheduling literature focused on the case where all page sizes are the same which can be assumed to be one (unit) without loss of generality.We call this the uniform page size setting.We also consider the non-uniform page size setting where pages have potentially different sizes.When page sizes are non-uniform, one has to carefully define when a request for a page is satisfied if it arrives midway through the transmission of that page.In this paper we consider the sequential model [28], the most restrictive one, where the server broadcasts each page sequentially and a client receives the page sequentially without buffering; see [43] for the relationship between different models.When pages have non-uniform sizes, each page p is divided into an ordered list of uniform sized pieces (1, p), (2, p), . . ., ( p , p) where p is the size of page p.In the sequential setting, a client must receive the pieces in sequential order.
Motivation There are a variety of metrics in the scheduling literature and perhaps the best known metric in the online setting is to minimize the average (equivalently total) response time.Minimizing average response time can potentially delay some requests at the expense of others and can lead to starvation and unfairness.Other metrics can be and are used to overcome this issue.A more stringent metric is to minimize the maximum response time and for unicast scheduling it is easy to see that the non-preemptive first-in-first-out algorithm (FIFO) is optimal on a single machine.Interestingly, FIFO was considered for minimizing maximum response time in broadcast scheduling in one of the early papers on broadcast scheduling by Bartal and Muthukrishnan [10] where it was claimed to be 2-competitive.It was only fairly recently that a formal proof was established by Chang et al. [17].Maximum response time and FIFO do not distinguish between requests of different sizes.Bender, Chakrabarti and Muthukrishnan [11] introduced the metric of minimizing the maximum stretch where the stretch of a request is the ratio between the response time to its processing time.They reasoned that requests are sensitive to delay in proportion to their processing time, and were also motivated by scheduling applications in databases and web servers; see [13,37,44] for further discussion.
The metrics we consider, in addition to their inherent interest, also generalize maximum stretch in different ways.One can easily see that stretch is a special case of weighted response time where the weight is the inverse of the processing time.Weights allow more flexibility in assigning priority to requests.Surprisingly, this natural generalization has not received attention in the literature.Delay factor is motivated by a variety of applications, in particular real-time systems, where requests naturally have deadlines associated with them.In real-time systems, a hard deadline implies that it cannot be missed, while a soft deadline implies some flexibility in violating it.In online settings it is difficult to respect hard deadlines.Previous work has addressed hard deadlines by either considering periodic tasks or other restrictions [15], or by focusing on maximizing throughput (the number of requests completed by their deadline) [39,16,46].It was recently suggested by Chang et al. [17] that delay factor is a useful and natural relaxation to consider in situations with soft deadlines where we still desire all requests to be satisfied.Moreover, we note that if we set d i = a i + i (in the unicast setting) the delay factor of a request is identical to its stretch in any schedule.

Results
We give the first non-trivial results for online scheduling to minimize the maximum delay factor and weighted response time in both the unicast and broadcast settings.Throughout we assume that requests are allowed to be preempted without any penalty.We remark that weighted response time and delay factor, though formally not equivalent, behave similarly in terms of algorithmic development.At a heuristic level, one can interpret the term 1/(d i − a i ) in the delay factor metric as the weight w i .For this reason, we mainly discuss results for delay factor below and point out how they generalize to weighted response time.
We first prove strong lower bounds on online competitiveness for delay factor.
• For unicast setting no online algorithm is ∆ 0.4 /2-competitive where ∆ is the ratio between the maximum and minimum slacks.
• For broadcast scheduling with n uniform sized pages there is no n/4-competitive algorithm.
We resort to resource augmentation analysis, introduced by of Kalyanasundaram and Pruhs [35], to overcome the above lower bounds.In this analysis the online algorithm is given a faster machine than the optimal offline algorithm.For s ≥ 1, an algorithm A is said to be s-speed r-competitive if A, when given s-speed machine(s), achieves a competitive ratio of r compared to the optimum schedule given 1-speed machine(s).We prove the following.
• For unicast setting, for any ε ∈ (0, 1], there are (1 + ε)-speed O(1/ε)-competitive algorithms in both single and multiple machine cases.Moreover, the algorithm for the multiple machine case immediately dispatches an arriving request to a machine, and is non-migratory.An algorithm is non-migratory if it processes each request on a single machine to which it is first assigned.
• For broadcast setting, for any ε ∈ (0, 1], there is a (1 + ε)-speed O(1/ε 2 )-competitive algorithm for uniform pages.For non-uniform sized pages, for any ε ∈ (0, 1], there is a Our results for minimizing maximum delay factor can be easily extended to the problems of minimizing maximum weighted response time and minimizing maximum weighted delay factor.We also address the problem of minimizing the maximum response time in broadcast scheduling.We already mentioned that FIFO is 2-competitive when pages have uniform sizes [17].In this paper we show the following.
• FIFO is 2-competitive for minimizing the maximum response time for non-uniform sized pages in the broadcast model.
The above result was claimed in [10] but it was only in [17] that a formal proof was given for uniform sized pages with integer arrival times for all requests.The proof in [17] is short but delicate and it does not appear to generalize when page sizes are non-uniform.Our proof differs from the one in [17] and is inspired by our analysis for the delay factor metric.A competitive ratio of 2 is the best positive result that can be achieved; for any fixed ε > 0 there is a lower bound of (2 − ε) on the competitive ratio for minimizing the maximum response time, even if randomization is allowed [19].
Our final result is a lower bound on the performance of a simple greedy algorithm to minimize the maximum delay factor.Recall that minimizing the maximum delay factor metric is a generalization of the problem of minimizing the maximum response time.For the latter FIFO is optimal for unicast scheduling and is 2-competitive for broadcast scheduling.What are natural ways to generalize FIFO to minimize maximum delay factor and weighted response time?One natural algorithm that extends FIFO is to schedule the request in the queue that has the largest current delay factor (or current weighted response time).We call this greedy algorithm LF (longest first) since it can be seen as an extension of the well-studied algorithm LWF (longest-wait-first) for minimizing average response time.It is known that LWF is O(1)-competitive with O(1)-speed for average response time [29].In [21] we showed that LF is O(1)-speed O(1)-competitive also for L k norms of response time for small values of k.It is therefore natural to ask if LF is O(1)-speed O(1)-competitive for minimizing the maximum weighted response time and delay factor.We show that this is not the case even for unicast scheduling.
• For any constants s, c > 1, LF is not c-competitive with s-speed for minimizing maximum delay factor (or weighted response time) in unicast scheduling of uniform sized requests.
Our results for the unicast setting are related to, and borrow ideas from, previous work on minimizing L p norms of response time and stretch [7] in the single machine and parallel machine settings [3,20].Our main results are for broadcast scheduling.Broadcast scheduling has posed considerable difficulties for algorithm design.Much previous work has focused on the offline setting [36,31,32,33,5,4] and several of these use resource augmentation.The difficulty in broadcast scheduling arises from the fact that the online algorithm may transmit a page multiple times to satisfy distinct requests for the same page, while the offline optimum, which knows the sequence in advance, can save work by gathering them into a single transmission.Online algorithms that maximize throughput [39,16,46,24] get around this by eliminating requests.Few positive results are known in the online setting where all requests need to be scheduled [10,28,29,30] and the analysis in all of these is quite non-trivial.
Our algorithm and analysis are direct and explicitly demonstrate the value of making requests wait for some duration to take advantage of potential future requests for the same page.We hope this idea can be further exploited in broadcast scheduling.We mention that prior to our work, even in the offline setting, the only algorithm known for minimizing the maximum delay factor was a 2-speed optimal algorithm that was based on rounding a linear-programming relaxation [17].Our algorithm, when viewed as an offline algorithm, gives a (1 + ε)-speed O(1/ε 2 )-approximation for uniform page sizes (and O(1/ε 3 )-approximation for non-uniform page sizes) and is quite simple.

Other related work
We refer the reader to the survey on online scheduling by Pruhs, Sgall and Torng [42] for a comprehensive overview of results and algorithms (see also [41]).For requests with deadlines, the well-known earliest-deadline-first (EDF) algorithm can be used in the offline setting to check if all the requests can be completed before their deadline.A substantial amount of literature exists in the real-time systems community in understanding and characterizing restrictions on the request sequence that allow for schedulability of requests with deadlines when they arrive online or periodically.Previous work on soft deadlines is also concerned with characterizing inputs that allow for bounded tardiness.We refer the reader to [40] for the extensive literature on scheduling issues in real-time systems.
Closely related to our work is that on minimizing the maximum stretch [11] where it is shown that no online algorithm is O(P 0.3 ) competitive where P is the ratio of the largest job size to the smallest job size.[11] also gives an O( √ P) competitive algorithm which was further refined in [13].Resource augmentation analysis for L p norms of response time and stretch from the work of Bansal and Pruhs [7] implicitly shows that the shortest job first (SJF) algorithm is a (1 + ε)-speed O(1/ε)-competitive algorithm for minimizing the maximum stretch.Our work shows that this analysis can be generalized for the delay factor metric.For multiple processors our analysis is inspired by the ideas from [3,20].In [12], the authors suggest the delay factor metric as a performance measure under the name of maximum interval stretch.They consider a model where the processing speed a request receives increases as the request approaches its deadline.Implicit in their work is a resource augmentation result in the unicast setting when there exists an offline schedule that finishes all the requests by their deadline.
Broadcast scheduling has seen a substantial amount of research in recent years; apart from the work that we have already cited we refer the reader to [18,38], the recent paper of Chang et al. [17], and the surveys [42,41] for several pointers to known results.Our work on delay factor is inspired by [17].As we mentioned already, a large amount of the work on broadcast scheduling has been on offline algorithms including NP-hardness results and approximation algorithms (often with resource augmentation).For minimizing the maximum delay factor there is a 2-speed optimal algorithm in the offline setting and it is also known that unless P = NP there is no (2 − ε) approximation [17].Besides the works already mentioned, in the online setting the following results are currently known.For minimizing the average response time, several algorithms that are O(1)-competitive with O(1)-speed were developed starting with the work of Edmonds and Pruhs [28].This work has recently culminated in scalable algorithms that are O(1)-competitive with (1 + ε)-speed for any fixed ε > 0 [34,6].Constant competitive online algorithms were given for maximizing throughput [39,16,46,24] when pages have uniform sizes.
Notation We let S i = d i − a i denote the slack of J i in the unicast setting.When requests have nonuniform processing times (or lengths) we use i to denote the length of J i .We assume without loss of generality that S i ≥ i .In the broadcast setting, J p,i denotes the i'th request for page p.We assume that the requests for a page are ordered by arrival time and hence a p,i ≤ a p, j for i < j.In both settings we use ∆ to denote the ratio of maximum slack to the minimum slack in a given request sequence.When pages have non-uniform sizes, p denotes the size of page p.For an interval I = [a, b] on the real line we use |I| for the length of the interval (b − a).We say a request is alive at t if has arrived by t but has not yet finished.
Organization We discuss algorithms for unicast scheduling in Section 2. Our main results on broadcast scheduling are presented in Section 3. We mainly describe algorithms for minimizing the maximum delay factor.These can be extended relatively easily for weighted delay factor and weighted response time.
THEORY OF COMPUTING, Volume 8 (2012), pp.We give details of this extension only for broadcast scheduling, in Section 4. The lower bound for LF is described in Section 5.

Unicast scheduling
In this section we address the unicast setting where requests are independent and consider the delay factor metric.For a request J i , recall that a i , d i , i , f i denote the arrival time, deadline, processing time/size, and finish time, respectively.An instance with all i = 1 (or more generally the processing times are uniform) is referred to as a uniform processing time instance.It is easy to see that preemption does not help much for uniform processing time instances when the maximum delay factor metric is considered.Assuming that the processing times are integer valued, in the single machine setting one can reduce an instance with non-uniform processing times to an instance with uniform processing times as follows: replace J i , with processing time i by i uniform sized requests with the same arrival time and deadline as that of J i .
We remarked earlier that scheduling to minimize the maximum stretch is a special case of scheduling to minimize the maximum delay factor.In [11] a lower bound of P 1/3 is shown for minimizing the maximum stretch where P is the ratio of the maximum processing time to the minimum processing time.They show that this lower bound holds even when P is known to the algorithm.This implies a lower bound of ∆ 1/3 for minimizing the maximum delay factor.Here we improve the lower bound for minimizing maximum stretch to P 0.4 /2 when the online algorithm is not aware of P. The lower bound example is similar to that given in [11].
Theorem 2.1.Any 1-speed deterministic algorithm has competitive ratio at least P 0.4 /2 for minimizing the maximum stretch when P is not known in advance to the algorithm.
Proof.P will denote the ratio of the maximum to minimum processing time.For the example created, P will depend on the decisions the online algorithm makes.For the sake of contradiction, assume that some online algorithm A achieves a competitive ratio better than P 0.4 /2.Now consider the following example, where L is chosen so that the parameters in the following example are integral.
Type 1: At time 0 a request with processing time L arrives.
], let a request with processing time L 0.6 arrive.
Consider time L 1.16 .If this is the entire sequence of requests, then the optimal schedule can be described as follows.It schedules these requests in a first-in-first-out fashion.The optimal schedule finishes the request of type 1 by time L, and hence the stretch of this request is 1.The requests of type 2 finish 2L 0.6 time units after their arrival.Thus, the maximum stretch of any request in the optimal schedule is 2L 0.6 /L 0.6 = 2.
The ratio of maximum to minimum processing time of the requests seen so far is P = L/L 0.6 = L 0.4 .Thus, the maximum stretch algorithm A can have is (L 0.4 ) 0.4 /2 = L 0.16 /2, by assumption.Suppose A does not finish the request of type 1 by time L 1.16 .In this case, the stretch of this request in the algorithm's schedule will be at least L 1.16 /L = L 0.16 .Thus, the algorithm has a competitive ratio at least L 0.16 /2 = P 0.4 /2, a contradiction.Therefore, by time L 1.16 the algorithm A must have finished the request of type 1. Immediately after this time, requests of type 3 arrive.Type 3: Starting at time L 1.16 a set of L 1.2 − L 0.6 unit processing time requests arrive as follows.These requests arrive one after another; one such request arrives at each integer time step during [L 1.16 This is the entire request sequence.We now analyze the behavior of an optimum schedule for this sequence and compare it to that of A. An optimal schedule for this sequence schedules the request of type 1 from time 0 until time L − L 0.6 .At time L − L 0.6 , the type 1 request has L 0.6 remaining processing time left; the optimal solution schedules requests of type 2 and type 3 requests as they arrive.It is easy to verify that the stretch of requests of type 2 and 3 is 1 in this schedule.At time L 1.16 + L 1.2 − L 0.6 the optimum schedule finishes the request of type 1.Thus the maximum stretch of this schedule is for the type 1 request and is equal to As we argued earlier, A must have completely scheduled the request of type 1 by time L 1.16 .Thus the last request it finishes is either of type 2 or type 3. A has a volume of at least L 0.6 of type 2 requests left to complete at time L 1.16 .If the last request completed by A is of type 2 then this request must have waited for all requests of type 3 to finish.Since the arrival time of a type 2 request is at most L 1.16 − L 0.6 and the request is completed by time L 1.16 + L 1.2 − L 0.6 at the earliest (this time is the latest arrival of a type 3 request), the total time this request waits to be satisfied is Thus the stretch of this request is at least L 1.2 /L 0.6 = L 0.6 .If the last request satisfied by the algorithm is of type 3, then this request must have waited for L 0.6 time since a L 0.6 volume of processing time of type 2 requests remained in the algorithm's queue when type 3 requests began arriving.The stretch of this request is therefore at least L 0.6 .Notice that the ratio of maximum to minimum processing time is P = L.In either case, the competitive ratio of the algorithm is at least L 0.6 /2L 0.2 = L 0.4 /2 = P 0.4 /2, a contradiction.
Recall that ∆ is the ratio of the maximum slack to the minimum slack in a given sequence of requests.
From the above we have the following corollary for delay factor.Corollary 2.2.Any deterministic online algorithm has competitive ratio at least ∆ 0.4 /2 for minimizing the maximum delay factor when requests have uniform sizes and ∆ is not known in advance to the algorithm.
In the next two subsections we show that with (1 + ε) resource augmentation simple algorithms achieve an O(1/ε) competitive ratio.

Single machine scheduling
In this section we consider a simple greedy algorithm for minimizing the maximum delay factor on a single machine when requests have non-uniform sizes.We analyze the simple shortest-slack-first (SSF) algorithm which at any time t schedules the request with the shortest slack.Recall that the slack of a request J i is d i − a i and that we have assumed without loss of generality that all requests have uniform sizes.

Algorithm: SSF
• Let Q(t) be the set of alive requests at t.
• Let J i be the request with the minimum slack among requests in Q(t), ties broken by arrival time.
• Preempt the current request and schedule J i if it is not being processed.
Theorem 2.3.The algorithm SSF is an (1 + ε)-speed 1/ε-competitive online algorithm for minimizing the maximum delay factor in the unicast setting.
Proof.Consider an arbitrary request sequence σ and let α SSF be the maximum delay factor achieved by SSF on σ .If α SSF = 1 there is nothing to prove, so assume that α SSF > 1.Let J i be the request that witnesses α SSF , that is Since all these requests have slack at most S i and have arrived before f i , it follows that α * ≥ ε( f i − a i )/S i where α * is the maximum delay factor of the optimal offline algorithm with 1-speed machine.Therefore, we have that α SSF /α * ≤ 1/ε.
Remark 2.4.For uniform processing time requests, the algorithm that non-preemptively schedules requests with the shortest slack is a (1 + ε)-speed 2/ε-competitive online algorithm for minimizing the maximum delay factor.

Multiple machine scheduling
We now consider minimizing the maximum delay factor when there are m machines.In the multiple machine setting, at any time a machine can choose to process at most one request and a request can be processed by at most one machine at a given time.A request is allowed to migrate and be processed by different machines at different times; as we remarked earlier, a schedule or algorithm is non-migratory if it does not migrate any request.To adapt SSF to this setting we take intuition from previous work on minimizing L k norms of flow time and stretch [7,3,20].We develop an algorithm that immediately dispatches an arriving request to a machine, and further does not migrate an assigned request to a different machine once it is assigned.Each machine essentially runs the single machine SSF algorithm and thus the only remaining ingredient to describe is the dispatching rule.For this purpose the algorithm groups requests into classes based on their slack.A request J i is said to be in class ).The algorithm maintains the total processing time of requests (referred to as volume) that have been assigned to machine x in each class k.Let U x =k (t) denote the total processing time of requests assigned to machine x by time t of class k.With this notation, the algorithm SSF-ID (for SSF with immediate dispatch) can be described.

Algorithm: SSF-ID
• When a new request J i of class k arrives at time t, assign it to a machine x where U x =k (t) = min y U y =k (t).
• Use SSF on each machine separately.
The rest of this section is devoted to the proof of the following theorem.
We need a fair amount of notation.For each time t, machine x, and class k we define several quantities.For example U x =k (t) is the total volume assigned to machine x in class k by time t.We use the predicate "≤ k" to indicate classes 1 to k.Thus U x ≤k (t) is the total volume assigned to machine x in classes 1 to k.We let R x =k (t) to denote the remaining processing time on machine x at time t and let P x =k (t) denote the total volume that x has finished on requests in class k by time t.Note that P x =k (t) = U x =k (t) − R x =k (t).All these quantities refer to the algorithm SSF-ID.We use V * =k (t) and V =k (t) to denote the remaining volume of requests in class k in an optimal offline algorithm with speed 1 and SSF-ID with speed (1 + ε), respectively.Observe that V =k (t) = ∑ x R x =k (t).The quantities V * ≤k (t) and V ≤k (t) are defined analogously.The algorithm SSF-ID balances the amount of processing time for requests with similar slack.Note that the assignment of requests is not based on the current volume of unfinished requests on the machines, rather the assignment is based on the volume of requests that were assigned in the past to different machines.We begin our proof by showing that for any k the total volume of requests of class at most k that is assigned is balanced across the machines.This easily follows from the dispatching policy of the algorithm.Several of the lemmas below and their proofs follow from the work in [3,20].
Proposition 2.6.For any time t and two machines x and y, Proof.The first inequality holds since all of the requests of class k are of size ≤ 2 k+1 .The second inequality follows easily from the first.
Lemma 2.7.Consider any two machines x and y.At any time t, the difference in volume of requests that already have been processed is bounded as Proof.Suppose the lemma is false.Then there is the first time t 0 when P x ≤k (t 0 ) − P y ≤k (t 0 ) = 2 k+2 and small constant δt > 0 such that P x ≤k (t 0 + δt) − P y ≤k (t 0 + δt) > 2 k+2 .Let t = t 0 + δt.For this to occur, x processes a request of class ≤ k during the interval I = [t 0 ,t ] while y processes a request of class > k.Since each machine uses SSF, it must be that y had no requests in classes ≤ k during I which implies that U y ≤k (t ) = P y ≤k (t ).Therefore, However, this implies that a contradiction to Proposition 2.6.
Lemma 2.8.At any time t the difference between the residual volume of requests that needs to be processed, on any two different machines x and y, is bounded as Proof.Combining Proposition 2.6, Lemma 2.7, and the fact that R x ≤k (t) = U x ≤k (t) − P x ≤k (t) for any x and k by definition then, We are now ready to upper bound the competitiveness of SSF-ID when given (1 + ε)-speed in a similar fashion to the single machine case.Consider an arbitrary request sequence σ and let J i be the request that witnesses the maximum delay factor α SSF-ID of SSF-ID.Let k be the class of J i and let x be the machine J i was processed on by SSF-ID.We know that α SSF-ID = ( f i − a i )/S i by definition of J i .We use α * to denote the delay factor of some fixed optimal algorithm that uses m machines of speed 1.
Let t be the last time before a i when machine x processed a request of class > k under SSF-ID's schedule.Note that t ≤ a i since x does not process any request of class > k in the interval [a i , f i ].At time t we know by Corollary 2.9 that V * ≤k (t) ≥ V ≤k (t) − m2 k+3 .If f i ≤ a i + 2 k+4 then SSF-ID achieves a competitive ratio of 16 since J i is in class k.Thus we will assume from now on that f i > a i + 2 k+4 .
During the interval I = [t, f i ), SSF-ID completes a total volume of (1 + ε)( f i − t) work on machine x.Using Lemma 2.7, any other machine y also processes a volume of (1 + ε)( f i − t) − 2 k+3 work during I of requests in classes at most k .Thus the total volume processed by SSF-ID during I of requests in classes at most k is at least m(1 + ε)( f i − t) − m2 k+3 .During I, the optimal algorithm schedules at most a m( f i −t) volume of work for requests in classes at most k.Combining this with Corollary 2.9, we see that In the last inequality we use the fact that . Without loss of generality assume that no requests arrives exactly at f i .Therefore V * ≤k ( f i ) is the total volume of requests in classes 1 to k that the optimal algorithm has left to finish at time f i and all these requests have arrived before f i .The earliest time that the optimal algorithm can finish all these requests is f i + ε( f i − t) and therefore it follows that α * ≥ ε( Thus α SSF-ID ≤ max{16, 2α * /ε} which completes the proof of Theorem 2.5.

Broadcast scheduling
We now move our attention to the broadcast model where multiple requests can be satisfied by the transmission of a single page.Most of the literature in broadcast scheduling is concerned with the case where all pages have uniform sizes which is assumed to be unit.Here we consider both the case where pages have uniform and non-uniform sizes.We start by focusing on minimizing the maximum response time of a schedule and then shift our focus to minimizing the maximum delay factor.

Response time
In this section we analyze FIFO for minimizing maximum response time when page sizes are non-uniform.
As mentioned previously, it is known that FIFO is 2-competitive when pages have uniform sizes [17].
We first describe the algorithm FIFO.FIFO broadcasts pages non-preemptively; the optimal solution is allowed to use preemption.Consider a time t when FIFO finished broadcasting a page or a request arrives when FIFO has no unsatisfied requests just before time t.Let J p,i be the request in FIFO's queue with earliest arrival time breaking ties arbitrarily.FIFO begins broadcasting page p at time t.At any time during this broadcast, we will say that J p,i forced FIFO to broadcast page p at this time.When broadcasting a page p all requests for page p that arrived before or at the start of the broadcast are simultaneously satisfied when the broadcast completes.Any request for page p that arrives during the broadcast are not satisfied until the next full transmission of p. Recall that we are assuming the sequential model where the client does not buffer.The rest of this section will be devoted to proving the following theorem.
Theorem 3.1.FIFO is a 2-competitive online algorithm for minimizing the maximum response time in broadcast scheduling when pages have non-uniform sizes.
We do not assume speed augmentation when analyzing FIFO.Let σ be an arbitrary sequence of requests.Let OPT denote some fixed optimum schedule and let ρ * denote the optimum maximum response time and ρ FIFO denote FIFO's maximum response time.We will show that ρ FIFO ≤ 2ρ * .For the sake of contradiction, assume that FIFO witnesses a response time cρ * by some request J q,k for some c > 2. Let t * be the time J q,k is satisfied, that is t * = f q,k .Let t 1 be the smallest time less than t * such that at any time t during the interval [t 1 ,t * ] the request which forces FIFO to broadcast a page at time t has response time at least ρ * when satisfied.Note that t 1 ≤ t * − q where q is the length of page q.We let I denote the interval [t 1 ,t * ].Let J I denote the requests which forced FIFO to broadcast during I. Notice that during the interval I, all requests in J I are completely satisfied during this interval.In other words, any request in J I starts being satisfied during I and is finished during I.
We say that OPT merges two distinct requests for a page p if they are satisfied by the same broadcast.
Lemma 3.2.OPT cannot merge any two requests in J I into a single broadcast.
Proof.Let J p,i , J p, j ∈ J I such that i < j.Note that J p,i is satisfied before J p, j .Let t be the time that FIFO starts satisfying request J p,i .By the definition of I, request J p,i has response time at least ρ * .The request J p, j must arrive after time t , that is a p, j > t , otherwise request J p, j is satisfied by the same broadcast of page p that satisfied J p,i .Therefore, it follows that if OPT merges J p,i and J p, j then the finish time of J p,i in OPT is strictly greater than its finish time in FIFO which is already at least ρ * ; this is a contradiction to the definition of ρ * .
Lemma 3.3.All requests in J I arrived no earlier than time t 1 − ρ * .
Proof.For the sake of contradiction, suppose some request J p,i ∈ J I arrived at time a p,i < t We are now ready to prove Theorem 3.1, stating that FIFO is 2-competitive.
Proof.Recall that all requests in J I are completely satisfied during I. Thus we have that the total size of requests in J I is |I|.By definition J q,k witnesses a response time greater than 2ρ * and therefore t * − a q,k > 2ρ * .Since J q,k ∈ J I is the last request done by FIFO during I, all requests in J I must arrive no later than a q,k .Therefore, these requests must be finished by time a q,k + ρ * by the optimal solution.From Lemma 3.3, all the requests J I arrived no earlier than t 1 − ρ * .Thus OPT must finish all requests in J I , whose total volume is |I|, during which simplifies to t * ≤ a q,k + 2ρ * .This is a contradiction to the assumption that t * − a q,k > 2ρ * .Note that a q,k and a q,k + ρ * are not necessarily contained in I.
We now discuss the differences between our proof of FIFO for non-uniform sized pages and the proof given by Chang et al. in [17] showing that FIFO is 2-competitive for uniform sized pages.In [17] it is shown that at anytime t, F(t), the set of unique pages in FIFO's queue satisfies the following property: is the set of unique pages in OPT's queue.This easily implies the desired bound.To establish this, they use a slot model in which uniform sized pages arrive only during integer times which allows one to define unique pages.This may appear to be a technicality, however when considering non-uniform sized pages, it is not clear how one defines unique pages since this number varies during the transmission of p as requests accumulate.Our approach avoids this issue in a clean manner by not assuming a slot model or uniform sized pages.

Delay factor
In this section we consider minimizing the maximum delay factor in the broadcast setting.We start by showing that no 1-speed online algorithm can be (n/4)-competitive for minimizing the maximum delay factor where n is the number of pages.We then prove the following theorem Theorem 3.4.There is an online algorithm that is (1 + ε)-speed O(1/ε 2 )-competitive for minimizing the maximum weighted delay factor in the broadcast setting where pages have uniform size.For non-uniform sized pages there is a (1 + ε)-speed O(1/ε 3 )-competitive online algorithm.
In Section 3.2.1 we show a (1 + ε)-speed O(1/ε 2 )-competitive online algorithm for uniform sized pages and uniform weight requests.Finally, we extend our algorithm and analysis to the case of nonuniform page sizes and uniform weight requests to obtain a (1 + ε)-speed O(1/ε 3 )-competitive online algorithm in Section 3.2.2.In Section 4 we show how to extend these results to the case where requests have non-uniform weights.Theorem 3.5.Every 1-speed online deterministic algorithm for broadcast scheduling to minimize the maximum delay factor has a competitive ratio of at least n/4 where n is the number of pages even when pages have uniform sizes.
Proof.The lower bound instance we construct is inspired by a lower bound given in [17].Let A be any online 1-speed algorithm and let n be a multiple of 4. We consider the following adversary.At time 0, the adversary requests pages 1, . . ., n/2, all which have a deadline of n/2.Between time 1 and n/4 the adversary requests whatever page the online algorithm A broadcasts immediately after that request is broadcast; this new request also has a deadline of n/2.It follows that at time t = n/2 the online algorithm A has n/4 requests for distinct pages in its queue.However, the adversary can finish all these requests by time n/2.Then starting at time n/2 the adversary requests n/2 new pages, say (n/2) + 1, . . ., n.These new pages are requested, one at each time step, in a cyclic fashion for n 2 cycles.More formally, for i = 1, . . ., n/2, page (n/2) + i is requested at times j • (n/2) + i − 1 for j = 1, . . ., n.Each of these requests has a slack of one which means that their deadline is one unit after their arrival.The adversary can satisfy these requests with delay since it has no queue at any time; thus its maximum delay factor is 1.However, the online algorithm A has n/4 requests in its queue at time n/2; each of these has a slack of n/2.We now argue that the delay factor of A is at least n/4.If the algorithm satisfies two slack 1 requests for the same page by a single transmission, then its delay factor is n/2; this follows since the requests for the same page are n/2 time units apart.Otherwise, the algorithm does not merge any requests for the same page and hence finishes the the last request by time n/2 + n 2 /2 + n/4.If the last request to be finished is a slack 1 request, then its delay factor is at least n/4 since the last slack 1 requests is released at time n/2 + n 2 /2.If the last request to be finished is one of the requests with slack n/2, then its delay factor is at least (n 2 /2)/(n/2) = n.

Uniform sized pages
In this section we develop an online algorithm, for uniform sized pages, that is competitive given extra speed.Simple examples show that natural generalizations of the algorithm SSF to the broadcast setting fail to be constant competitive with any constant resource augmentation.The reason for this is that an algorithm that focuses on requests with the smallest slack can be made to do an arbitrary amount of "extra" work over the optimal schedule by repeatedly requesting the same page and giving the page small slack.The algorithm will repeatedly broadcast the same page while the adversary waits and satisfies multiple requests for this page with a single transmission.Further, we will show in Section 5 that another greedy algorithm modeled after the well-studied algorithm Longest-Wait-First is not constant competitive with any fixed constant resource augmentation.
We begin by developing a variant of SSF that adaptively introduces a waiting time for requests.The algorithm uses a single real-valued parameter c < 1 to control the waiting period.The algorithm SSF-W (SSF with waiting) is formally defined below.We note that the algorithm is non-preemptive in that a request once scheduled is not preempted.As we mentioned earlier, for uniform sized requests, preemption is not very helpful.At each time, the algorithm computes the delay factor of all requests in the algorithm's queue, and considers requests for scheduling only when their delay factor is comparable to the request with maximum delay factor among the unsatisfied requests.Since our algorithm SSF schedules only the requests that have waited sufficiently long, the adversary cannot delay those requests to satisfy them with a less number of transmissions.We formalize this intuition in Lemma 3.6.

Algorithm: SSF-W
• The algorithm is non-preemptive.Let t be a time that the machine is free (either because a request has just finished or there are no requests to process).
• Let Q(t) be the set of alive requests at time t and let max 1, t − a p,i S p,i be the maximum current delay factor of requests in Q(t).
• Let be the set of requests in Q(t) with current delay factor at least 1 c α t .
• Let J p,i be the request in Q (t) with the smallest slack.Broadcast page p nonpreemptively.
We analyze SSF-W when it is given a (1 + ε)-speed machine.Let c > 1 + 2/ε be the constant which parameterizes SSF-W.Let σ be an arbitrary sequence of requests.We let OPT denote some fixed offline optimum schedule and let α * and α SSF-W denote the maximum delay factor achieved by OPT and SSF-W, respectively.We will show that α SSF-W ≤ c2 α * .For the sake of contradiction, suppose that SSF-W witnesses a delay factor greater than c 2 α * .We consider the first time t * when SSF-W has some request in its queue with delay factor c 2 α * .Let the request J q,k be a request which achieves the delay factor c 2 α * at time t * .Let t 1 be the smallest time less than t * such that at each time t during the interval (t 1 ,t * ] if SSF-W is forced to broadcast by request J p,i at time t it is the case that (t − a p,i )/S p,i > α * and S p,i ≤ S q,k .We let I = [t 1 ,t * ]. 2  We let J I denote the requests which forced SSF-W to broadcast during the interval [t 1 ,t * ].We now show that any two requests in J I cannot be satisfied with a single broadcast by the optimal solution.Intuitively, the most effective way the adversary performs better than SSF-W is to merge requests of the same page into a single broadcast.Here we will show this is not possible for the requests in J I .Lemma 3.6.OPT cannot merge any two requests in J I into a single broadcast.
Proof.Let J x,i , J x, j ∈ J I such that i < j.Let t be the time that SSF-W starts satisfying request J x,i .By the definition of I, request J x,i must have delay factor greater than α * at time f x,i .We also know that the request J x, j must arrive after time t , otherwise request J x, j must also be satisfied at time t .If the optimal solution combines these requests into a single broadcast then the request J x,i must wait until the request J x, j arrives to be satisfied.However, this means that the request J x,i must achieve a delay factor greater than α * by OPT, a contradiction to the definition of α * .
To fully exploit the advantage of speed augmentation, we need to ensure that the length of the interval I is sufficiently long.
Proof.The request J q,k has delay factor greater than cα * at any time during I = [t ,t * ], where t = t * − (c 2 − c)S q,k α * .Let τ ∈ I .The largest delay factor any request can have at time τ is less than c 2 α * by definition of t * being the first time SSF-W witnesses delay factor c 2 α * .Hence, α τ ≤ c 2 α * .Thus, the request J q,k is in the queue Q(τ) because cα * ≥ α τ /c.Moreover, this means that any request that forced SSF-W to broadcast during I , must have delay factor greater than α * and since J q,k ∈ Q(τ) for any τ ∈ I , the requests scheduled during I must have slack at most S q,k .
We now explain a high level view of how a contradiction is found.From Lemma 3.6, we know any two requests in J I cannot be merged by OPT.Thus if we show that OPT must finish all these requests during an interval which is not long enough to include all of them, we will have a contradiction.More precisely, we will show that all requests in J I must be finished during I OPT by OPT, where It is easy to see that all these requests already have delay factor α * by time t * , thus the optimal solution must finish them by time t * .We first lower bound the arrival times of the requests in J I .Lemma 3.8.Any request in J I must have arrived no earlier than t 1 − 2S q,k α * c.
Proof.For the sake of contradiction, suppose that some request J p,i ∈ J I arrived at time t < t 1 − 2S q,k α * c.Recall that J p,i has a slack no bigger than S q,k by the definition of I. Therefore at time t 1 − S q,k α * c, J p,i has a delay factor greater than cα * .Thus any request scheduled during the interval I = [t 1 − S q,k α * c,t 1 ] has a delay factor greater than α * .We observe that J p,i is in Q(τ) for τ ∈ I ; otherwise there must be a request with a delay factor bigger than c 2 α * at time τ and this is a contradiction to the assumption that t * is the first time that SSF-W witnessed a delay factor of c 2 α * .Therefore any request scheduled during I has a slack no bigger than S p,i .Also we know that S p,i ≤ S q,k .In sum, we showed that any request done during I had slack no bigger than S q,k and a delay factor greater than α * , which is a contradiction to the definition of t 1 .Now we are ready to prove the competitiveness of SSF-W.
Proof.For the sake of contradiction, suppose that α SSF-W > c 2 α * .During the interval I, the number of broadcasts which SSF-W transmits is (1 + ε)|I|.From Lemma 3.8, all the requests processed during I have arrived no earlier than t 1 − 2cα * S q,k .We know that the optimal solution must process these requests before time t * because these requests have delay factor greater than α * by t * .By Lemma 3.6 the optimal solution must make a unique broadcast for each of these requests.Thus, the optimal solution must finish all of these requests in 2cα * S q,k + |I| time steps.Thus, it must hold that (1 + ε)|I| ≤ 2cα * S q,k + |I|.Using Lemma 3.7, this simplifies to c ≤ 1 + 2/ε, which is a contradiction to c > 1 + 2/ε.
The previous lemmas proves that SSF-W is a (1 + ε)-speed O(1/ε 2 )-competitive algorithm for minimizing the maximum delay factor in broadcast scheduling with uniform sized pages when c = 1+3/ε.

Non-uniform sized pages
Here we extend our ideas to the case where pages can have non-uniform sizes for the objective of minimizing the maximum delay factor.For this problem, in [23] we developed a generalization of SSF-W and showed that it is a (4 + ε)-speed O(1/ε 2 )-competitive algorithm.Later, we gave a (2 + ε)-speed O(1/ε 2 )-competitive algorithm using a similar proof technique as used in the uniform page size setting given in the paper [22].In this paper we show a (1 + ε)-speed O(1/ε 3 )-competitive online algorithm by improving our analyses based on the technique developed by Bansal, Krishnaswamy and Nagarajan [6] which considers fractional schedules.
We elaborate on the model for non-uniform page sizes.Each page p has size p , which we assume for simplicity is an integer.Page p consists of uniform sized pieces (1, p), (2, p), . . .( p , p).In a time slot one piece of a unique page can be broadcast by the server.A request J p,i is satisfied if it receives each of the pieces of page p in sequential order; in other words, we assume that the clients do not buffer the pieces if they are sent out of order.We assume preemption is allowed, and pieces of different pages can be interspersed.We call this model the integral broadcast setting.We now describe a relaxed notion of a schedule that we call a fractional schedule.In a fractional schedule the pieces of a page p are indistinguishable and the only relevant information are the time slots during which p is transmitted.Now a request J p,i is satisfied once p pieces of page p have been broadcast.That is, J p,i is satisfied once the server devotes p time slots to page p after a p,i .A reduction in [6] gives a scheme that translates an algorithm with 1 speed for the fractional broadcast setting into a (1 + ε )-speed integer schedule where the flow time, f i − a i , of each request increases by a factor of at most 8/ε for any fixed ε > 0. Using this technique, any schedule that is s-speed c-competitive for the fractional setting can be converted online into a schedule that is s(1 + ε )-speed O(c/ε )-competitive for the integral setting.The algorithm used in [6] simulates the fractional schedule.The algorithm gives priorities to pages based on the unsatisfied requests for the page.The priority of a request is based on the flow time of the request in the fractional schedule; a smaller flow time corresponds to higher priority.Generally, the algorithm broadcasts the page with the highest priority unsatisfied request.We now restrict our attention to the fractional model.
We outline the details of modifications to SSF-W.As before, at any time t, the algorithm considers the alive requests Q(t) and a subset Q (t) of requests that have waited sufficiently long; that is those with current delay factor at least α t /c where α t is the maximum current delay factor for requests in Q(t).Among all requests in Q (t) the algorithm picks the one with the smallest slack and broadcasts a unit amount of the page for that request; ties are broken arbitrarily.Recall that since the fractional setting is considered, the algorithm only needs to specify the page being broadcast and not the piece of the page.The algorithm may preempt the broadcast of p that is forced by request J p,i if another request J p , j becomes available for scheduling such that S p , j < S p,i .A key issue that differentiates the algorithms in [23,22] from the one here is that those algorithms directly generate an integral schedule; therefore they have to not only specify the page but also the piece of the page.In particular the algorithms in [23,22] could preempt the transmission of a page p for a request J p,i and transmit p again from the start if a new request J p,i for p arrives and has much smaller slack than that of J p,i .In the sequential model this means that the work done for J p,i is "wasted" and it would be satisfied at the same time as J p,i .In the fractional setting and the algorithm considered here J p,i would continue to be satisfied as if J p,i did not arrive and prior transmission would not be wasted.
We now analyze the algorithm assuming that it has a (1 + ε)-speed advantage over the optimal offline algorithm.As before, let σ be an arbitrary sequence of requests.We let OPT denote some fixed offline optimum schedule and let α * denote the optimum delay factor.Let c > 1 + 3/ε be the constant that parameterizes SSF-W.We will show that α SSF-W ≤ c 2 α * .For the sake of contradiction, suppose that SSF-W witnesses a delay factor greater than c 2 α * .We consider the first time t * when SSF-W has some request in its queue with delay factor c 2 α * .Let the request J q,k be a request which achieves the delay factor c 2 α * at time t * .Let t 1 be the smallest time less than t * such that at each time t during the interval (t 1 ,t * ] if SSF-W is forced to broadcast by request J p,i at time t it is the case that (t − a p,i )/S p,i > α * and S p,i ≤ S q,k .Again, let I = [t 1 ,t * ].Notice that some requests that force SSF-W to broadcast during I could have started being satisfied before t 1 .We now show a lemma analogous to Lemma 3.6.We say that two requests for the same page p are satisfied simultaneously at time t if both requests are unsatisfied prior to t, p is broadcast at time t, and both requests receive p units of p after their arrival.Lemma 3.10.Consider any two distinct requests J x, j and J x,i for some page x.If J x, j forces SSF-W to broadcast during I before a x,i , then OPT cannot satisfy J x, j and J x,i simultaneously at any time.
Proof.Let t be the time that SSF-W is forced to broadcast page x by J x, j where t < a x,i .By the definition of I, request J x, j must have delay factor greater than α * at time t .Hence, if OPT satisfies J x,i and J x, j simultaneously then J x, j will have delay factor strictly larger than α * in OPT, a contradiction.
The following Lemmas 3.11 and 3.12 can be proved in the same way that Lemmas 3.7 and 3.8 are proved.This is because the algorithm SSF-W is designed to be oblivious to page sizes.Indeed, the key definitions in the proofs including the first time t * that SSF-W witnesses delay factor c 2 α * , the request J q,k that has delay factor c 2 α * at t * , and t = t * − (c 2 − c)S q,k α * stay the same regardless of whether pages have a uniform size or not.The advantage of thinking about a fractional schedule is that the work conservation argument can be applied once we have Lemma 3.10.
Lemma 3.12.Any request which forced SSF-W to schedule a page during I must have arrived after time t 1 − 2S q,k α * c.
Using the previous lemmas we can bound the competitiveness of SSF-W.
Proof.For the sake of contradiction, suppose that α SSF-W > c 2 α * .During the interval I, the number of broadcasts which SSF-W transmits is (1 + ε)|I|.From Lemma 3.12, all the requests that forced SSF-W to broadcast during I have arrived no earlier than t 1 − 2cα * S q,k .We know that the optimal solution must process these requests before time t * because these requests have delay factor greater than α * by t * .By Lemma 3.10 the optimal solution cannot simultaneously satisfy two requests J x,i and J x, j that forced SSF-W to broadcast during I if a x,i is later than when J x,i forced SSF-W to broadcast.This implies the optimal solution must broadcast at least (1 + ε)|I| units in 2cα * S q,k + |I| time steps.Thus, it must hold that (1 + ε)|I| ≤ 2cα * S q,k + |I|.Using Lemma 3.11, this simplifies to c ≤ 1 + 2/ε, which is a contradiction to c > 1 + 2/ε.By setting c = 1 + 3/ε we have the following theorem.
Theorem 3.14.The algorithm SSF-W is (1 + ε)-speed O(1/ε 2 )-competitive for minimizing the maximum delay factor in a fractional schedule when pages have non-uniform sizes.
Using the reduction of [6] previously discussed, we have shown the second part of Theorem 3.4.

Weighted response time and weighed delay factor
We show the connection of our analysis of SSF and SSF-W to the problem of minimizing the maximum weighted response time.In the unicast setting for the problem of minimizing the maximum weighted response time, requests do not have deadlines, but have weights.Each request J i has a positive weight w i .The goal is to minimize max i w i ( f i − a i ).Similar to the algorithm SSF, we give the following algorithm called BWF (Biggest-Weight-First).The algorithm BWF always schedules the request with the largest weight.

Algorithm: BWF
• Let Q(t) be the set of alive requests at t.
• Let J i be the request with the largest weight among requests in Q(t), ties broken by arrival time.
• Preempt the current request and schedule J i if it is not being processed.Similarly we can think of the problem of minimizing the maximum weighted delay factor.Here a request J i has a deadline d i and a weight w i .The objective now is to minimize max i w i max{1, ( f i − a i )/S i }.Let the modified weight of a request J i be defined as w i = w i /S i .The algorithm BWF above when implemented with modified weights is the algorithm SRF (Smallest Ratio First).It is not difficult to adapt the analysis for SSF in Section 2 to show that BWF is (1 + ε)-speed O(1/ε)-competitive for the problem of minimizing the maximum weighted response time, and that SRF is (1 + ε)-speed O(1/ε)-competitive for the problem of minimizing the maximum weighted delay factor.Now consider the problem of minimizing the maximum weighted response time in broadcast scheduling when pages have uniform sizes.A request J p,i has a weight w p,i .The goal is to minimize the maximum weighted response time max p,i w p,i ( f p,i − a p,i ).We extend the algorithm BWF to get an algorithm called BWF-W for Biggest-Wait-First with Waiting.The algorithm is parameterized by a constant c > 1.At any time t before broadcasting a page, BWF-W determines the largest weighted wait time of any request which has yet to be satisfied.Let this value be ρ t .The algorithm then chooses to broadcast a page corresponding to the request with largest weight amongst the requests whose current weighted wait time at time t is larger than ρ t /c.

Algorithm: BWF-W
• The algorithm is non-preemptive.Let t be a time that the machine is free (either because a request has just finished or there are no requests to process).
• Let Q(t) be the set of alive requests at time t and let ρ t = max J p,i ∈Q(t) w p,i (t − a p,i ).
• Let J p,i be the request in Q (t) with the largest weight.Broadcast page p nonpreemptively.
Although minimizing the maximum delay factor and minimizing the maximum weighted flow time are very similar metrics, the problems are not equivalent.It may also be of interest to minimize the maximum weighted delay factor.In this setting each request has a deadline and a weight.The goal is to minimize max p,i w p,i max{1, ( f p,i − a p,i )/S p,i }.For this setting we can simply alter BWF-W where we use modified weights for requests: w p,i for request J p,i is defined as w p,i /S p,i .We call the resulting algorithm SRF-W (Smallest-Ratio-First with Waiting).
For the problems of minimizing the maximum weighted response time and weighted delay factor, the upper bounds shown for SSF-W in this paper also hold for BWF and SRF-W, respectively.The analysis of BWF and SRF-W is very similar to that of SSF-W.To illustrate how the proofs extend, we prove that SRF-W is (1 + ε)-speed O(1/ε 2 )-competitive for minimizing the maximum weighted delay factor in broadcast scheduling where all pages are uniform sized and there is a single machine.This is the most general problem discussed as it is a generalization of weighted response time and the delay factor.We analyze SRF-W when it is given a (1 + ε)-speed machine.Let c > 1 + 2/ε be the constant which parameterizes SRF-W.Let σ be an arbitrary sequence of requests.We let OPT denote some fixed offline optimum schedule and let α * and α SRF-W denote the maximum weighted delay factor achieved by OPT and SRF-W, respectively.We will show that α SRF-W ≤ c 2 α * .For the sake of contradiction, suppose that SRF-W witnesses a weighted delay factor greater than c 2 α * .We consider the first time t * when SRF-W has some request in its queue with weighted delay factor c 2 α * .Let the request J q,k be a request which achieves the weighed delay factor c 2 α * at time t * .Let t 1 be the smallest time less than t * such that at each time t during the interval (t 1 ,t * ] if SRF-W is forced to broadcast by request J p,i at time t it is the case that w p,i ( f p,i − a p,i ) S p,i > α * and S p,i w p,i ≤ S q,k w q,k .
Throughout this section we let We let J I denote the requests which forced SRF-W to schedule broadcasts during the interval [t 1 ,t * ].We now show that any two request in J I cannot be satisfied with a single broadcast by the optimal solution.Lemma 4.1.OPT cannot merge any two requests in J I into a single broadcast.
Proof.Let J x,i , J x, j ∈ J I such that i < j.Let t be the time that SRF-W satisfies request J x,i .By the definition of I, request J x,i must have weighted delay factor greater than α * at this time.We also know that the request J x, j must arrive after time t , otherwise request J x, j must also be satisfied at time t .If the optimal solution combines these requests into a single broadcast then the request J x,i must wait until the request J x, j arrives to be satisfied.However, this means that the request J x,i must achieve a weighted delay factor greater than α * by OPT, a contradiction.
As in the analysis of SSF-W we show that interval I is sufficiently long.
Proof.The request J q,k has weighted delay factor cα * at time The largest weighted delay factor any request can have at time t is less than c 2 α * by definition of t * being the first time SRF-W witnesses weighted delay factor c 2 α * .Hence, α t ≤ c 2 α * .Thus, the request J q,k is in Q(t ) because cα * ≥ α t /c.Moreover, this means that any request that forced SRF-W to broadcast during [t ,t * ], must have weighted delay factor greater than α * and since J q,k ∈ Q(t ), the requests scheduled during [t ,t * ] must have a ratio of slack over weight of at most S q,k /w q,k .
Lemma 4.3.Any request in J I must have arrived after time t 1 − 2 S q,k w q,k α * c.
Proof.For the sake of contradiction, suppose that some request J p,i ∈ J I arrived at time Recall that S p,i /w p,i ≤ S q,k /w q,k by the definition of I. Therefore at time J p,i has a weighted delay factor greater than cα * .Thus any request scheduled during the interval has a weighted delay factor greater than α * .We observe that J p,i is in Q(τ) for τ ∈ I ; otherwise there must be a request with weighted delay factor bigger than c 2 α * at time τ and this is a contradiction to the assumption that t * is the first time that SRF-W witnessed a weighted delay factor of c 2 α * .Therefore any request scheduled during I has a slack over weight no bigger than S p,i /w p,i .Also we know that S p,i /w p,i ≤ S q,k /w q,k .In sum, we showed that any request done during I had slack over weight no bigger than S q,k /w q,k and a delay factor greater than α * , which is a contradiction to the definition of t 1 .
Now we are ready to prove the competitiveness of SRF-W.
Proof.For the sake of contradiction, suppose that α SRF-W > c 2 α * .During the interval I, the number of broadcasts which SRF-W transmits is (1 + ε)|I|.From Lemma 4.3, all the requests processed during I have arrived no earlier than t 1 − 2cα * S q,k /w q,k .We know that the optimal solution must process these requests before time t * because these requests have weighted delay factor greater than α * by t * .By Lemma 4.1 the optimal solution must make a unique broadcast for each of these requests.Thus, the optimal solution must finish all of these requests in 2cα * S q,k /w q,k + |I| time steps.Thus it must hold that Using Lemma 4.2, this simplifies to c ≤ 1 + 2/ε, which is a contradiction to c > 1 + 2/ε.

Lower bound for a natural greedy algorithm LF
In this section, we consider a natural algorithm for minimizing the maximum delay factor which is similar to SSF-W.This algorithm, which we will call LF for Longest Delay First, always schedules the page which has the largest delay factor.We will consider the algorithm LF in the unicast scheduling setting when all requests have uniform sizes.Recall that the non-uniform requests setting can be reduced to the uniform request setting when preemption is permissible.

Algorithm: LF
• The algorithm is non-preemptive.Let t be a time that the machine is free (either because a request has just finished or there are no requests to process).
• Let Q(t) be the set of alive requests at t.
• Let J i be the request in Q(t) that maximizes t−a i S i .Schedule J i non-preemptively.
Notice that LF is the same as SSF-W when c = 1.However, we are able to show a negative result on this algorithm for minimizing the maximum delay factor.This demonstrates the importance of the trade-off between scheduling a request with smallest slack and scheduling the request with a large delay factor.The algorithm LF was suggested and analyzed in our work [21] and is inspired by LWF [21,29].In [21] LF is shown to be O(k)-competitive with O(k)-speed for L k norms of flow time and delay factor in broadcast scheduling when pages have uniform sizes.It was suggested in [21] that LF may be competitive for minimizing the maximum delay factor (the L ∞ -norm).The rest of this section will be devoted to showing the following theorem.
Theorem 5.1.For any constant s > 1, LF is not constant competitive with s-speed for minimizing the maximum delay factor (or weighted response time) in the unicast scheduling setting when requests have uniform sizes.
Since LF processes the request J i such that (t − a i )/S i is maximized, it would be helpful to formally define the quantity.Let us define the wait ratio of J i at time t ≥ a i as (t − a i )/S i ; recall that a i and S i are the arrival time and slack size of J i respectively.Note that J i 's wait ratio at time C i is the same as its delay factor if J i has delay factor no smaller than 1.Further note that J i 's delay factor is equal to max{1, ( f i − a i )/S i }.The algorithm LF schedules the request with the largest wait ratio at each time.LF can be seen as a natural generalization of FIFO.This is because FIFO schedules the request with largest wait time at each time.Recall that SSF-W makes requests to wait to be scheduled to help merge potential requests in a single broadcast.The algorithm LF behaves similarly since it implicitly delays each request until it is the request with the largest wait ratio, potentially merging many requests into a single broadcast.Hence, this algorithm is a natural candidate for the problem of minimizing the maximum delay factor and it does not need any parameters as the algorithm SSF-W does.We show however that this algorithm does not have a constant competitive ratio with any constant speed.
We construct the following adversarial instance σ for any integral speed-up s > 1 and any integer c ≥ 2; the assumption of s and c being integral can be easily removed by multiplying the parameters in the instance by a sufficiently large constant.For this problem instance we will show that LF has wait ratio at least c, while OPT has wait ratio at most 1.In the instance σ there is a sequence of groups of requests, J i for 0 ≤ i ≤ k, where k is an integer to be fixed later.We now explain the requests in each group.For simplicity of notation and readability, we will allow requests to arrive at negative times.We can shift all of the arrival times later to make the arrival times positive.All requests have unit sizes.All requests in each group J i have the same arrival time and have the same slack size For notational simplicity, we override the notation S i to refer to the slack size of any request in J i , rather than to refer to the slack size of an individual request J i .There are s(sc) k+1 requests in group J 0 and s(sc) k−i requests in group J i for 1 ≤ i ≤ k.
We now explain how LF and OPT behave for the instance σ .Sometimes, we will use J i to refer to requests in J i rather than explicitly saying "requests in J i ," since all requests in the same group are indistinguishable to the scheduler.For the first group J 0 , LF keeps processing J 0 upon its arrival until completing it.On the other hand, we let OPT procrastinate J 0 until OPT finishes all requests in J 1 to J k .This does not hurt OPT, since the slack size of the requests in J 0 is large relative to other requests.For each group J i for 1 ≤ i ≤ k, OPT will start J i upon its arrival and complete each request in J i without interruption.To the contrary, for each 1 ≤ i ≤ k, LF will not begin scheduling J i until finishing all requests in J i−1 .In this way substantial delay is accumulated before LF processes J k and such a delay is critical for LF, since the slack of J k is small.We refer the reader to Figure 2. We now formally prove that LF has the maximum wait ratio c, while OPT has wait ratio at most 1 for the given problem instance σ .Let Let r i (t) denote the wait ratio of any request in J i at time t.We fix k to be an integer such that First we show that J 0 is finished during [A 0 , F 0 ] by LF.Note that before time F 0 , no request in J j , j ≥ 2 arrives, since and all requests in J j , j ≥ 2 arrive no earlier than time A 2 .We will show that J 0 has the same wait ratio as J 1 at time F 0 .Then since J 0 has a slack greater than J 1 , at any time t during [A 0 , F 0 ], r 0 (t) > r 1 (t) and hence LF will work on J 0 over J 1 .Indeed, the wait ratio of J 0 at time F 0 is which is equal to the wait ratio of J 1 at time F 0 , To complete the proof, we show that J i , i ≥ 1 is finished during [F i−1 , F i ] by LF.This proof is very similar to the above.Note that no request in J j , j ≥ i + 2 arrives before time F i , since and all requests in J j , j ≤ i + 2 arrive no earlier than time A i+2 .We will show that J i has the same wait ratio as J i+1 at time F i .Then since the slack of J i+1 is smaller than J i , at any time t during [F i−1 , F i ], J i will have wait ratio no smaller than J i+1 and hence LF will work on J i over J i+1 .Indeed, the wait ratio of J i at time F i is which is equal to the current delay factor of J i+1 at time F i , Hence LF has wait ratio at least c for a certain request in J k .
In the following lemma, we show that there exists a feasible scheduling by OPT that has wait ratio at most 1, which together with Lemma 5.2 will complete the proof of Theorem 5.1.
Lemma 5.3.Consider a schedule which processes all requests in J 0 during [F k , F k + |J 0 |] and all requests in J i during [A i , A i + |J i |] for 1 ≤ i ≤ k with speed 1.This schedule is feasible and, moreover, the maximum wait ratio of any request under this schedule is at most one.It now remains to upper bound the maximum wait ratio of any request under the suggested schedule.Consider any request in J i , i ≥ 1.The maximum wait ratio of J i under the schedule is The maximum wait ratio of any request in J 0 is The last inequality holds since k was chosen to satisfy the inequality.

Conclusions
We considered online scheduling to minimize maximum (weighted) response time and to minimize maximum (weighted) delay factor.Delay factor and the weighted response time metrics have not been previously considered.We developed scalable algorithms for these metrics in both the unicast and broadcast scheduling models.Our algorithms demonstrate an interesting trade off on whether to prioritize requests with larger weight or those that have waited longer in the system.Understanding this trade off has led to the first online scalable algorithm for minimizing average response time in broadcast scheduling [34] which has been an open problem for several years.
We close with the following open problems.Our algorithm for the maximum delay factor with uniform sized pages uses a parameter that explicitly depends on the speed given to the algorithm.Is there an algorithm that is scalable without needing this information?FIFO is 2-competitive for minimizing maximum response time in broadcast scheduling.In the offline setting can the 2-approximation implied by FIFO be improved?For the more general problem of minimizing maximum delay factor, no non-trivial offline approximation is known that does not use resource augmentation.

Figure 1 :
Figure 1: Broadcasts by FIFO satisfying requests in J I are shown in blue.Note that a q,k and a q,k + ρ * are not necessarily contained in I.

Figure 2 :
Figure 2: Comparison of scheduling of group J k , J k−1 , and J k−2 by LF and OPT.

1 . 5 . 2 .
Lemma LF, given speed s, completely schedules J 0 during [A 0 , F 0 ] and J i during[F i−1 , F i ], 1 ≤ i ≤ k.Further, the maximum wait ratio of any request in J k under LF's schedule is c.Proof.Observe that the length of the time interval [A 0 , F 0 ] is exactly the amount of time LF with speed s needs to completely process J 0 , since s|[A 0 , F 0 ]| = s(sc) k+1 = |J 0 |.Similarly we observe that the length of the time interval [F i−1 , F i ], 1 ≤ i ≤ k is exactly the amount of time LF with speed s requires to completely process J i , since s|[F i−1 , F i ]| = s(sc) k−i = |J i |.

Proof.
We first observe that the time intervals[F k , F k + |J 0 |] and [A i , A i + |J i |] for 1 ≤ i ≤ k do not overlap, since for i ≥ 1, A i+1 − (A i + |J i |) = (sc) k+1−i + (sc) k−1−i − s(sc) k−i − (sc) k−i ≥ (sc) k−i (sc − s − 1) > 0 , and F k − (A k + |J k |) = sc − s > 0.Further, all requests in J 0 can be completed during [F k , F k + |J 0 |] by a scheduler with speed 1.Likewise, this shows that all requests in J i can be completed during [A i , A i + |J i |] by a scheduler with speed 1. Hence this is a feasible schedule for a 1 speed algorithm.
1 − ρ * .During the interval [a p,i + ρ * ,t 1 ] the request J p,i must have wait time at least ρ * .However, then any request which forces FIFO to broadcast during [a p,i + ρ * ,t 1 ] must have response time at least ρ * , contradicting the definition of t 1 .