Optimal Online Buffer Scheduling for Block Devices *

Transcription

1 Optimal Online Buffer Sheduling for Blok Devies * ABSTRACT Anna Adamaszek Department of Computer Siene and Centre for Disrete Mathematis and its Appliations (DIMAP) University of Warwik, Coventry, UK [email protected] Matthias Englert Department of Computer Siene and Centre for Disrete Mathematis and its Appliations (DIMAP) University of Warwik, Coventry, UK [email protected] We introdue a buffer sheduling problem for blok operation devies in an online setting. We onsider a stream of items of different types to be proessed by a blok devie. The blok devie an proess all items of the same type in a single step. To improve the performane of the system a buffer of size k is used to store items in order to redue the number of operations required. Whenever the buffer beomes full a buffer sheduling strategy has to selet one type and then a blok operation on all elements with this type that are urrently in the buffer is performed. The goal is to design a sheduling strategy that minimizes the number of blok operations required. In this paper we onsider the online version of this problem, where the buffer sheduling strategy must make deisions without knowing the future items that appear in the input stream. Our main result is the design of an O(log log k)- ompetitive online randomized buffer sheduling strategy. The bound is asymptotially tight. As a byprodut of our LPbased tehniques, we obtain a randomized offline algorithm that approximates the optimal number of blok operations to within a onstant fator. Categories and Subjet Desriptors F.2.2 [Analysis of Algorithms and Problem Complexity]: Nonnumerial Algorithms and Problems Sequening and sheduling Researh supported by the Centre for Disrete Mathematis and its Appliations (DIMAP), University of Warwik, EP- SRC award EP/D063191/1, by EPSRC grant EP/F043333/1, and by EPSRC grant EP/G069034/1. Permission to make digital or hard opies of all or part of this work for personal or lassroom use is granted without fee provided that opies are not made or distributed for profit or ommerial advantage and that opies bear this notie and the full itation on the first page. To opy otherwise, to republish, to post on servers or to redistribute to lists, requires prior speifi permission and/or a fee. STOC 12, May 19 22, 2012, New York, New York, USA. Copyright 2012 ACM /12/05...$ Artur Czumaj Department of Computer Siene and Centre for Disrete Mathematis and its Appliations (DIMAP) University of Warwik, Coventry, UK [email protected] Harald Räke Institut für Informatik Tehnishe Universität Münhen Munih, Germany [email protected] General Terms Theory, Algorithms Keywords Online Algorithms, Online Primal-Dual, Buffer Management, Reordering Buffer, Sorting Buffer 1. INTRODUCTION We onsider a buffer sheduling problem for blok operation devies. A stream of items of different types (e.g. olors) have to be proessed by a blok devie. For example the items ould be data that has to be written to the hard dis and two items have the same type if they are loated in the same blok on the hard dis. The blok devie an proess all items with the same type in a single step. To improve the performane of the whole system a buffer of size k an be used to store items in order to redue the number of operations required. Whenever the buffer beomes full (i.e., ontains k elements) a buffer sheduling strategy has to selet one olor and then a blok operation on all elements with this olor that are urrently stored in memory is performed. The proessed elements are then removed from the buffer and free up spae for new elements from the input stream. The goal is to design a sheduling strategy that minimizes the number of blok operations required to proess all elements from the input sequene. In this paper our fous lies on the online version of this problem, where the buffer sheduling strategy must make deisions without knowing the future items that appear in the input stream. Our main result is the design of an O(log log k)- ompetitive online randomized buffer sheduling strategy. The problem of minimizing the number of blok operations for a buffer is losely related to the reordering buffer problem ([22]). The reordering buffer problem has the same basi setup; the only differene is that the proessing devie does not perform blok operations but instead it has different states (one for eah olor), and it an proess items of olor if and only if it is in state. Both problems give a simple yet versatile framework for modelling real world buffer problems (see e.g., [5, 11, 18, 21, 22] for the reordering buffer problem). It is lear that the number of blok operations required in

2 the blok devie sheduling problem is at least as large as the number of state hanges in the orresponding reordering buffer instane. In fat it ould be muh larger as a sequene of length n onsisting of a single olor requires only one state hange but n blok operations. k+1 The reordering buffer problem is quite well studied in the literature. It was introdued by Räke et al. [22] who gave an O(log 2 k)-ompetitive online algorithm. This was improved by Englert and Westermann [16] to O(log k). Aboud [1] showed that with the proof tehnique from [16] it is not possible to derive online algorithms with a ompetitive ratio o(log k). Nevertheless, Avigdor-Elgrabli and Rabani [5] were able to go beyond the logarithmi threshold by presenting an online algorithm with ompetitive ratio O(log k/ log log k) using linear programming based tehniques. This result was later improved by Adamaszek et al. [2] who provide a deterministi algorithm with ompetitive ratio of O( log k) and show lower bounds of Ω( log k/ log log k) and Ω(log log k) on the ompetitive ratio for deterministi and randomized strategies, respetively. In fat, the above lower bounds on the ompetitive ratio of a reordering buffer strategy also hold in the model where we have blok operations, beause, with a minor modifiation, the sequenes onsidered in [2] do not use the fat that it is possible to proess items that were not in the buffer when the orresponding state hanges ourred. Hene, the O(log log k)-ompetitive algorithm that we develop in this paper obtains an asymptotially optimal ompetitive ratio. 1.1 Further related work The reordering buffer problem has been also studied in the offline setting, and it was shown by Chan et al. [13] and independently by Asahiro et al. [4] that the problem is NPhard. Until reently no offline approximation algorithms that ahieve better bounds than the best online algorithm from [2] have been known. However, in a very new development, Avigdor-Elgrabli and Rabani [6] reported a onstant fator offline approximation for the reordering buffer problem. Our tehniques also give a onstant fator approximation algorithm for the offline version of the blok devie sheduling problem. Let us also mention that there have been extensive studies of more general versions of the uniform reordering buffer problem mentioned above. Khandekar and Pandit [19], and Gamzu and Segev [17] onsidered the problem where the olors orrespond to points in a line-metri with appropriately defined osts of hanging the olors. Englert et al. [14] studied a more general version where olors orrespond to arbitrary points in a metri spae (C, d) and the ost for swithing from olor to olor is the distane d(, ) between the orresponding points in the metri spae. Researh has also been done on the maximization version of the problem, where the ost measure is the number of olor hanges that the output sequene saved over the unordered input sequene. For this version there exist onstant fator approximation algorithms due to Kohrt and Pruhs [20] and Bar-Yehuda and Laserson [10]. 1.2 Our results and tehniques In this paper we present asymptotially tight results for the blok devie sheduling problem. We present a randomized online algorithm that obtains a ompetitive ratio of O(log log k). As a byprodut of our tehniques, we obtain a randomized offline algorithm that approximates the optimal number of blok operations to within a onstant fator. While our problem is losely related to the reordering buffer problem mentioned above, our approah differs signifiantly from the ombinatorial approah used in earlier works for the latter problem [5, 2, 16, 22]. Our tehniques are similar to the approah used by Bansal et al. in online algorithms for weighted ahing [8] and generalized ahing [9], and use also ideas developed for improved generalized ahing in [3]. In all these papers one first formulates a paking/overing linear program that forms a relaxation of the original problem. Then one solves the linear program in an online-manner using the online primal-dual framework for paking and overing problems introdued by Buhbinder and Naor [12]. In the final step, one gives a randomized rounding algorithm to transform the frational solution into an integral one. This approah has been shown to be very suessful in the study of online ahing algorithms and in other related online problems (see, e.g., [7]), and in this paper we demonstrate its power in the buffer management senario. We begin in Setion 2 by formulating a relaxation of our problem that is a paking/overing linear program with an exponential number of onstraints. This formulation uses so-alled Knapsak over inequalities that, for example, have also been used for the generalized ahing problem [9]. However, applying the online primal-dual framework diretly to this LP would lead to a ompetitive ratio of O(log k). Therefore in Setion 2 we first modify the LP in suh a way that applying the primal-dual tehnique leads to an O(log log k) ompetitive ratio. In Setion 3 we apply the online primal-dual framework. Although this follows more or less the standard primal-dual tehnique, it is somewhat non-standard beause we apply some of the main arguments not to individual variables but to sums of variables. The rounding is done in Setion 4. Here, we present an algorithm that transforms a solution to the LP into a distribution over deterministi buffer sheduling strategies with expeted ost at most a onstant times larger than the ost of the LP solution. These results ombined together yield a randomized online algorithm that obtains a ompetitive ratio of O(log log k). Sine we an show that the linear program (despite its exponential size) an be solved in polynomial time, and sine the rounding yields a onstant fator approximation of the LP, our approah gives us a polynomial time onstant fator approximation randomized offline algorithm, as well. 2. LP FORMULATION Our model is the following. At any point in time the buffer an store k elements. At a time-step t 1 a new item appears. If the number of items urrently stored in the buffer is at most k 1, the new item an simply be added to the buffer. Otherwise, an output operation has to be performed. For this, a buffer-management algorithm selets a olor and all elements among the set of k + 1 visible elements (i.e. the k elements stored in the buffer plus the new element that arrived in time-step t) that have olor are removed from the buffer. The goal is to minimize the total number of output operations. For this model we set up a linear program as follows. We have variables x (τ) for every time-step τ and every olor. This variable reflets that we swith to olor at time

3 τ, and remove all elements of this olor. We model the buffer onstraint at time t, as follows. Suppose, that we fix a time-step s < t for every olor and that we onsider only elements of olor that appear after time s (s an be viewed as a time-step at whih we performed an output operation for olor ; note that we allow s = 0 so that the onstraint s < t an be obtained for every time-step t 1). We use w (s, t) to denote the number of elements of olor that appear between time s and t (exluding s but inluding t). For simpliity, we extend this notation to a vetor s that represents the hosen time-steps for all olors, i.e., w ( s, t) := w (s, t). We will also allow s t, in whih ase we simply set w (s, t) := 0. The total number of elements that appear until time t (but after their respetive time-step s ) is then W ( s, t) := w( s, t). Of ourse, if W ( s, t) > k the buffer onstraint at t is violated, unless we remove some elements. If we perform an output operation for olor at time τ > s we remove at most w ( s, τ) elements that appear between time s and τ (and if there are no other output operations between s and τ we remove exatly w ( s, τ) elements). Summing this over all olors gives that for every vetor s w ( s, τ) x (τ) W ( s, t) k is a valid onstraint (reall that w ( s, τ) = 0 if τ s ). In an integral setting, the onstraint still remains valid if we tighten it by replaing w ( s, τ) by w ( s, τ, t) defined as follows: w ( s, τ, t) := max{min{w ( s, τ), W ( s, t) k}, 0}. Our linear program is the following min x (τ) τ s.t. s, t with W ( s, t) k : w ( s, τ, t) x (τ) W ( s, t) k τ, : x (τ) 0 (LP k ) 2.1 Modifying the LP For solving our LP online, we will use the following slightly modified LP in whih we replae k by k = (1 ε) k 1, where ε will later be hosen as 1/ log k. min x (τ) τ s.t. s, t with W ( s, t) k : w ( s, τ, t) x (τ) W ( s, t) k τ, : x (τ) 0 Here the above linear program uses the definition: w ( s, τ, t) := max{min{w ( s, τ), W ( s, t) k }, 0}. (Primal) This means that LP Primal is obtained by using LP k and removing onstraints for s, t with k W ( s, t) < k. We will relate the optimal value of Primal LP to the ost of an optimal algorithm. To this end, we ompare the ost of an optimal offline solution utilizing a buffer of size k with the ost of an optimal offline solution utilizing a buffer of size k = (1 ε) k. The proof is an adapted and generalized version of Theorem 2.1 in [15]. Theorem 2.1. For any input sequene, the ost OPT k of an optimal offline solution utilizing a buffer of size k = (1 ε) k is at most a fator of (2 + ε ln k )/(1 ε) larger than the ost OPT k of an optimal offline solution utilizing a buffer of size k. Proof. Fix any input sequene and onsider an optimal offline algorithm using a buffer of size k. Without loss of generality, we may assume that eah blok operation in the optimum solution proesses a different olor. Indeed, if two operations were to proess the same olor, we ould re-olor the elements proessed in one of the operations to a ompletely new olor. This does not hange OPT k and an only inrease OPT k. We number the olors in the order of the respetive blok operations, i.e., the i-th blok operation proesses items of olor i and the number of different olors equals OPT k. Now, we design an offline strategy to proess the input sequene with a buffer of size k. We all a olor finished at some time t, if all elements of that olor have been proessed by our strategy by time t. Every other olor is alled unfinished, and in partiular, we use ω to denote the unfinished olor that has the smallest index. Let n() denote the number of elements of olor stored in the buffer. The potential φ() of an unfinished olor is defined as ( ω + 1) n(). Note that ω, n(), and φ() hange over time but we do not indiate this, sine the time will always be lear from the ontext. Now onsider the following strategy to proess the input sequene with a buffer of size k. The strategy maintains a ounter p(i) for eah unfinished olor i that is initialized with 0 and gives a lower bound on the number of items with olor i or larger that have already been proessed. (1) Let ω be the unfinished olor with the smallest index. (2) If the last element for olor ω is either in the buffer or is the next element, perform a blok operation for ω. (3) Otherwise, identify a olor q with maximum potential and perform a blok operation for q. If after this, the last element for ω is still neither in the buffer nor the next element, inrease p(i) by n(q) for eah i, ω i q. (4) Repeat. We start our analysis by giving a bound on the values of the ounters p(i). Fat 2.2. At any point in time and for any i, p(i) εk. Proof. For an arbitrary fixed time, we give a bound on p(ω), where ω is the first unfinished olor at that time. This bound implies the laim sine, due to the way the ounters are inreased, p(i) p(i + 1) for every i ω. Let l be the number of elements with a olor smaller than ω. Preeding the blok operation to proess olor ω, the optimal solution for buffer size k proessed exatly these l

4 elements. Sine the blok operation for olor ω proesses all input elements of olor ω and the buffer an only hold k elements, all elements of olor ω must appear among the first l + k + 1 elements of the input sequene. Assume for ontradition that p(ω) is inreased beyond ɛk in Step (3). This means in partiular that not all elements of olour ω have yet appeared. Further, we have proessed at least ɛk elements with a olor ω or larger (sine p(ω) > ɛk), and we have proessed all l elements with olor less than ω. The buffer stores k = k ɛk elements, and the next element is not the last element of olor ω (as otw. we would not inrease p(ω)). Altogether the first l + ɛk + k ɛk + 1 = l + k + 1 elements do not ontain all elements of olor ω. This is a ontradition. Next, we give a lower bound on the potential φ(q) that olor q has in Step (3) of our strategy. Fat 2.3. φ(q) k /(1 + ln k ). Proof. Define s := k /(1 + ln k ) to shorten notation. Suppose there is no olor with φ() s. We know that for every olor < ω, n() = 0 (these are the finished olors) and for ω 1 + s, n() = 0 (sine we assume that every olor has potential less than s). However, sine in total there are k elements in the buffer, ω 1+ s =ω n() = k. On the other hand, for every, ( ω + 1) n() = φ() < s. This gives a ontradition sine k = ω 1+ s =ω i=1 ω 1+ s n() < s =ω 1 ω + 1 s 1 = s i = s H s s (ln(s) + 1) k, and the laim follows. Putting everything together we get: For eah olor, there is at most one blok operation due to Step (2). Every blok operation in Step (3), exept OPT k many (one for eah olor), results in an inrease of i p(i) by k /(1 + ln k ) due to Fat 2.3. Sine i p(i) is bounded by εk OPT k by Fat 2.2, we onlude that there an be at most εk OPT k (1 + ln k )/k = (1 + ln k ) ε/(1 ε) OPT k suh blok operations. In total, we have at most (2 + (1 + ln k ) ε/(1 ε)) OPT k < (2 + ε ln k )/(1 ε) OPT k blok operations as laimed. Using Theorem 2.1, we an easily prove the following lemma. Lemma 2.4. For ε = 1/ log k, the value of LP Primal is at most a onstant fator larger than the ost OPT k of an optimal offline algorithm using a buffer of size k. Proof. By the hoie of ε and Theorem 2.1, the value of LP k is at most OPT k O(1) OPT k. LP Primal is obtained from LP k by deleting onstraints k W ( s, t) < k. Of ourse, this an only derease the ost of the optimum solution. 3. SOLVING THE LP ONLINE In this setion we show how to solve the linear program Primal from Setion 2.1 in an online fashion using the primal dual tehnique introdued by Buhbinder and Naor [12]. The ost of the online solution will turn out to be at most O(log log k) opt(primal), where opt(primal) denotes the ost of an optimum solution to the LP. In Setion 4 we then show how to turn suh an online frational solution into an online algorithm while only inreasing the ost by another onstant fator. Reall LP Primal: min x (τ) τ s.t. s, t with W ( s, t) k : w ( s, τ, t) x (τ) W ( s, t) k τ, : x (τ) 0 The dual is the following max α s,t (W ( s, t) k ) s.t. ( s,t) τ, : w ( s, τ, t) α s,t 1 ( s,t):t τ s, t with W ( s, t) k α s,t 0 (Primal) (Dual) Note that the LP Dual has variables α s,t for W ( s, t) k. For simpliity of notation we define α s,t := 0 for W ( s, t) < k as this allows to write summations in a simpler form. The following definition uses a onstant saling fator γ defined in Setion 4. For this setion we only require γ 2. Definition 3.1. A onstraint ( s, t) of LP Primal is alled a proper onstraint for a variable assignment x if the following holds for every olor : a) s x(τ) 1/γ; b) s < x(τ) < 2/γ; ) x (τ) < 1/γ for all τ {s + 1,..., t}. The online algorithm in Setion 4 suessively generates proper violated onstraints and feeds them to Algorithm 1. The algorithm then inreases x (τ)-values until either the onstraint ( s, t) is satisfied, or not proper anymore. In addition the algorithm from Setion 4 also guarantees that the onstraints are monotone, i.e., for two onseutive onstraints ( s 1, t 1) and ( s 2, t 2), s 1 s 2 and t 1 t 2. In this setion we show that the assignment to LP Primal onstruted by alls to Algorithm 1 has ost no more than O(log log k) opt(primal). Given a primal onstraint ( s, t), the algorithm inreases the dual variable α s,t for the onstraint by an infinitesimal amount dα s,t (Line 15). It also omputes for every primal variable x τ (), τ {s +1,..., t} a value (τ, ) that speifies an inrease to x (t) wished by variable x (τ) (Lines 7 and 11). Then in Line 13 the x (t)-value is inreased by the maximum of the (τ, )-values taken over all τ s.

5 Proedure 1 fix-onstraint(( s, t), x, α) Input: A violated, proper onstraint ( s, t), urrent variable assignments x and α. Output: New assignments for x and α. Return if ( s, t) is satisfied or not proper anymore. 1: while ( s, t) is proper violated onstraint do 2: for eah variable x (τ), s < τ t do 3: (τ, ) := 0 4: if ( ( s,t):t τ w( s, τ, t) α s,t == 1) then 5: // onstraint for (τ, ) is tight 6: if (X [τ, t] < 1 log 3 k ) then 7: (τ, ) := 1 log 3 k 8: ˆx (τ) := 1 log 3 k 9: if ( ( s,t):t τ w( s, τ, t) α s,t > 1) then 10: // onstraint for (τ, ) is violated 11: (τ, ) := X [τ, t] w ( s, τ, t)dα s,t 12: dx (t) := max τ:s< (τ, ) 13: : x (t) := x (t) + dx (t) 14: // inrease variable α s,t by infinitesimal amount 15: α s,t = α s,t + dα s,t The following analysis is lose to the standard analysis using the primal dual sheme. The important part is that we an initialize the x (τ)-values with 1/log 3 k. For most algorithms that use the online primal-dual sheme this initialization is 1, whih results in an LP-solution with approximation guarantee O(log n). Another aspet that differs from n the standard analysis is that we do not apply the standard arguments to individual variables but to sums of variables (namely X [τ, t] := τ i t x(i)). Step 1: show that the solution is approximately feasible for the dual. Let v(τ, ) = ( s,t): w( s, τ, t)α s,t 1 denote the amount by whih the dual onstraint for variable x (τ) is violated. Let X [τ, t] = t i=τ x(i). The violation an inrease if the α s,tmultiplier for some primal onstraint ( s, t) is inreased during Proedure 1. However, note that only primal onstraints ( s, t) with τ {s + 1,..., t} will result in an inrease of v(τ, ) as for others w ( s, τ, t) = 0. Furthermore, ( s, t) is proper whih gives X [s +1, t] < 2/γ. Therefore, one a dual onstraint (τ, ) fulfills X (τ, t) 2/γ its violation v(τ, ) will not be inreased anymore. In the following we analyze how large the violation an beome until X [τ, t] 2/γ. For this we need the following laim. Claim 3.2. A violated dual onstraint fulfills X [τ, t] exp(v(τ, )). 1 log 3 k Proof. When the dual onstraint (τ, ) beomes tight (i.e., v(τ, ) = 0) the algorithm sets (τ, ) := 1 in log 3 k Line 7. This means that at this point (after the end of the iteration) we have and the laim holds. X [τ, t] 1 log 3 exp(v(τ, )) (1) k During the following iterations a dual variable α s,t is inreased by dα s,t (Line 15) whih inreases the violation v(τ, ) by w (s, τ, t)dα s,t. This means that the right hand side of Equation 1 inreases by 1 log 3 k exp(v(τ, )) w(s, τ, t)dα s,t However, at the same time X [τ, t] inreases by at least X [τ, t] w ( s, τ, t)dα s,t 1 log 3 k exp(v(τ, )) w(s, τ, t)dα s,t aording to Line 11 of the algorithm. From the above lemma it follows that the violation of a dual onstraint an grow to at most O(log log k) until X (τ, t) beomes 2/γ after whih the violation does not inrease anymore. Hene, saling down the dual variables by a fator of O(log log k) leads to a feasible dual solution. The primal ost of the solution (the total value of all x (τ)- variables) omes from two soures. There may be an inrease of 1/log 3 k if a dual onstraint beomes tight (Line 7) or there is the normal inrease in Line 11. We will split the primal ost into two types aording to their soure. Let Ĉ denote the ost indued by inreases in Line 7 and C denote ost indued by inreases in Line 11. Note that Ĉ τ, ˆx(τ) sine we set ˆx (τ) = 1/log 3 k, whenever we make an inrease in Line 7 of the algorithm. Step 2: show that ˆx (τ ) s fulfill primal slakness onditions. We show that ˆx (τ) > 0 ( s,t):t τ w( s, τ, t) α s,t 1. This is immediate as the algorithm only assigns ˆx (τ) a non-zero value if the dual onstraint orresponding to variable x (τ) is tight. One a onstraint is tight in the online algorithm it means that in the end the onstraint will either be tight or violated. Step 3: show that ˆx (τ ) s fulfill dual slakness onditions. Here we show α s,t > 0 w( s, τ, t) ˆx(τ) W ( s, t) k. Fix a olor. We partition the time-steps τ {s + 1,..., t} into lasses aording to the value of w (s, τ), The lass T j,, j 0 ontains the time-steps for whih w (s, τ) [2 j, 2 j+1 ). Claim 3.3. A lass T j, inludes at most O(log log k) timesteps τ that have ˆx (τ) > 0. Proof. Sine α s,t > 0 the onstraint ( s, t) has been fed to Proedure 1 at some point. We first analyze how many time-steps τ with ˆx (τ) > 0 an have been reated before Proedure 1 was alled with onstraint ( s, t). Beause of the monotoniity of onstraints we know that all onstraints ( s, t ) among these that have led to an inrease in ˆx (τ)- values fulfill s s and t t. Fix a lass T j, and let τ 1, τ 2,... denote its time-steps that have ˆx (τ i) > 0 in inreasing order. Consider a time-step τ i. When the algorithm sets ˆx (τ i) to 1/log 3 k it must be at a time t i < τ i+1. The reason is that setting ˆx (τ i) = 1/log 3 k also triggers an inrease of 1/log 3 k to x (t i). If τ i+1 t i this high value of x (t i) would prevent ˆx(τ i+1) from being inreased as this only happens if X [τ i+1, t i+1] < 1/log 3 k.

6 Define L(τ i) := ( s,t):τ i t w( s, τi, t) α s,t to be the load of τ i (the left hand side of the onstraint (τ i, ) in the dual). Note that an inrease of L(τ i), i > 1 by w(s, τ i, t )dα s,t in Line 15 is onneted with an inrease of L(τ 1) by w(s, τ 1, t )dα s,t whih is approximately the same up to a onstant fator as τ 1 and τ i are in the same lass (note that if τ 1 and τ 2 are in the same lass w.r.t. s they are also in the same lass w.r.t. s ). In order for a τ i to set its ˆx (τ i)-value, it first needs to ollet a load of 1 as its onstraint needs to be tight. Consequently, for every τ i with ˆx (τ i) > 0, the load L(τ 1) will inrease by at least 1/2. Sine the dual solution is almost feasible the load L(τ 1) is at most O(log log k). This gives that before onstraint ( s, t) at most O(log log k) time-steps τ {s + 1,..., t} ould ahieve ˆx (τ) > 0. After this at most one time-step within {s + 1,..., t} an have its x (τ)-value inreased. This holds beause after the next inrease (at time t t) x (t ) will be at least 1/ log 3 k. Again this prevents any ˆx (τ)-value with τ t from being inreased. Let n j, denote the number of time-steps τ in lass T j, that have ˆx (τ) > 0. Then we have w ( s, τ, t) ˆx (τ) 2 j+1 1 n j, log 3 k j>0 O(log log k) w (s, t) 1 log 3 k W ( s, t)/log k W ( s, t) k. Note that the last inequality follows from the transformation of our LP in Setion 2, and is the key for obtaining a ompetitive ratio of O(log log k). Step 4: onlude that ost of ˆx (τ ) s is not too large. From the slakness onditions we derive a bound on the ost Ĉ as follows. τ ˆx(τ) ( s,t) [ τ ( s,t):t τ w ( s, τ, t) α s,t ] ˆx (τ) α s,t w ( s, τ, t) ˆx (τ) ( s,t) α s,t (W ( s, t) k ). The last term is the profit of an approximately feasible dual solution. Hene, it is at most an O(log log k)-fator larger than the ost of an optimal primal solution. Step 5: show that C is small. The ost C that is reated in Line 11 and Line 12 an be estimated as follows. In one iteration the dual profit inreases by (W ( s, t) k ) dα s,t. We now estimate the inrease of C during the same iteration. Fix a olor. In Line 11 every τ {s + 1,..., t} makes a wish for an inrease of x (t) of X [τ, t] w ( s, τ, t)dα s,t. In Line 12 the maximum is taken. This means that dx (t) = max X τ [τ, t] w ( s, τ, t)dα s,t τ w ( s, τ, t) x (τ) dα s,t. Summing this over all olors gives that the inrease in Algorithm 2 RANDOM-STEP(t) 1: // buffer onstraints may be violated due to new item 2: if ( s, t) not proper then reompute s 3: while onstraint ( s, t) is violated do 4: fix-onstraint(( s, t), x, α) // hange urrent solution 5: adjust distribution µ to reflet new x (τ)-values 6: if ( s, t) not proper then reompute s 7: // buffer onstraints are fulfilled primal ost is at most w ( s, τ, t)x (τ) dα s,t (W ( s, t) k ) dα s,t. τ Here the last inequality follows sine the onstraint ( s, t) is violated. Hene, the inrease in the ost C is at most the inrease in dual profit of an approximately feasible dual solution, whih is at most O(log log k) times the ost of an optimal primal solution. 4. ROUNDING THE LP-SOLUTION IN AN ONLINE MANNER The randomized algorithm RANDOM for the buffer management problem uses an LP-solver for obtaining assignments to LP Primal and LP Dual with low primal ost and then uses these solutions to generate a distribution µ over deterministi buffer management strategies with low expeted ost. Algorithm 2 shows the general struture of one step for RANDOM. RANDOM maintains a vetor s and together with the urrent time-step t the pair ( s, t) forms a primal onstraint of the LP that RANDOM tries to satisfy. For this, RANDOM feeds the urrent primal and dual assignments together with ( s, t) to an LP-routine. This sub-routine ould e.g. be Algorithm 1 from Setion 3. However, it ould also be a routine that is simply based on knowing the optimal LPsolution (for the design of offline approximation algorithms we an assume that we know the optimum LP-solution as we have a separation orale (see Setion A)). The LP-subroutine inreases some primal variables x (τ) with s < τ t until the onstraint ( s, t) is either satisfied or the onstraint ( s, t) is not proper anymore. Then, RANDOM adjusts the distribution over buffer management strategies to reflet the hanged variables x (τ) in the primal LP. In ase the LP-routine returned beause ( s, t) is not proper, RANDOM omputes a new vetor s and repeats the proess. When finally the onstraint ( s, t) is satisfied all deterministi buffer management strategies in the distribution µ fulfill their buffer-onstraint (for time t). Observe that the assignment for the primal LP may not be feasible as RANDOM only feeds some onstraints to the LP-routine. Further, note that the assignment to the dual LP is not used by RANDOM at all (but may be used by the LP-routine). A deterministi buffer management strategy is given by a funtion D : T C N 0 with the meaning that D(τ, ) desribes the number of output operations for olor performed right after the τ-th item appeared. We allow D(τ, ) > 1, i.e., we will allow that the strategy performs several onseutive output operations for the same olor. We show that eah strategy in the support of µ fulfills the bufferonstraints and that the ost for updating the distribution is only O(primal-ost), where primal-ost is the ost of the primal assignment generated by the alls to the LP-routine.

7 This means that if the LP-routine is the proedure from Setion 3 we obtain an online algorithm with ompetitive ratio O(log log k). If we implement it using the optimal LPsolution we obtain an offline approximation algorithm with a onstant approximation fator. In order to show a bound on the update ost, we show that any hange to the LP that inreases the LP-ost by ɛ results in a hange to the distribution over buffer management strategies with expeted ost O(ɛ). 4.1 Ensuring Buffer Constraints Suppose that RANDOM just finished its step at time t (Algorithm 2), and that s is the vetor maintained by RANDOM. RANDOM will always guarantee that s, and the assignment x fulfill 1/γ τ {s +1,...,t} x(τ) < 3/γ and x(τ) 1/γ, and that s is monotonially inreasing (the latter property is only important for the implementation of the LP-routine in Setion 3 that assumes that the onstraints that are fed to the routine have this property). We will use the fat that the onstraint ( s, t) is fulfilled to show that the strategies in the support of µ fulfill the buffer-onstraints. We first set up some properties that the strategies in µ have to fulfill. The fat that buffer-onstraints hold will follow from these properties. In order to define these properties we introdue the following notation. Let γ denote a saling fator to be determined later. We use z (τ) := max{γx (τ), 1} to denote a saled version of the urrent assignment to LP Primal. We partition the pairs (τ, ) with τ {s + 1,..., t} into lasses aording to the value of w (s, τ). We say a pair (τ, ) is in lass S i if w (s, τ) [2 i, 2 i+1 ) (we do not are about (τ, )-pairs that have w (s, τ) = 0). We further use S to denote the set {(τ, ) τ {s + 1,..., t}} and S = S. In addition to sets S i we also define a set L that ontains (τ, )-pairs with a large w (τ, )-value. Formally, we first selet pairs in dereasing order of w (τ, )-value until L ontains pairs whose z (τ)-values sum up to at least λ + 1 (for a parameter λ γ to be hosen later) or L = S; then if the z (τ)-values sum up to more than λ + 1 we remove the last element added. Hene, if L S we have λ (τ,) L z(τ) λ + 1, as the z(τ) s are at most 1. A buffer management strategy D has to fulfill the following properties. 1. For every olor, s D(τ, ) 1, i.e., D removed the olor at least one between time s and t. 2. D mirrors the frational solution of the LP on the sets S i: S i : z (τ,) S (τ) D(τ, ). i (τ,) S i 3. D mirrors the frational solution of the LP on the set L of large (τ, )-pairs: (τ,) L z(τ) D(τ, ). (τ,) L 4. For every olor and for every lass S i, we have (τ,) S i S D(τ, ) 9, this means D did not remove the same olor very often in the same lass. We first show that a buffer management strategy D that fulfills the above properties also fulfills buffer-onstraints provided that the onstraint for ( s, t) in the primal LP is satisfied. Property 1 guarantees that elements/items of olor that appeared at time s or before do not influene the buffer-onstraint for D at time t, sine all these items have already been removed. Hene, the following formula speifies exatly the number of items in D s buffer at time t: buffer(t) = W ( s, t) max w (s, τ). (2) τ:d(τ,)=1 This holds beause the term w (s, τ) (for the maximum τ with D(τ, ) = 1) speifies the items that appeared after time s (exluding s ) and are evited at time τ or before. Let j denote the index of the largest lass that ontains a pair (τ, ) with D(τ, ) = 1. Then max w (s, τ) 2 j 1 j 9 2 i+1 τ:d(τ,)=1 36 i=0 1 D(τ, ) w (s, τ), 36 (τ,) S where the last step uses Property 4 (the fat that D does not evit a olor too often in the same lass). Plugging the above into Equation 2 yields buffer(t) W ( s, t) 1 36 (τ,) S D(τ, ) w(s, τ). We need to show that this is at most k. This means we want to show that (τ,) S D(τ, ) w (s, τ) 36(W ( s, t) k). This is enapsulated in the following lemma. Lemma 4.1. Let ( s, t) be a proper, satisfied onstraint. A buffer sheduling strategy that fulfills property 1, 2, 3, or 4 fulfills (τ,) S D(τ, ) w(s, τ) 36(W ( s, t) k). Proof. For this we need the following laim. Claim 4.2. Either we have λ (τ,) L z(τ) (λ + 1) or W ( s, t) k. Proof. The onstraint for ( s, t) in LP Primal is fulfilled. Therefore, w (s, τ, t) x (τ) W ( s, t) k. s < If W ( s, t) k 0 then w (s, τ, t) w( s, t). Therefore, the x (τ) must sum to at least one. Saling by γ gives that the z (τ) s sum up to at least γ. Hene, L will ontain a z (τ)-weight of at least λ and at most λ + 1, as λ γ. In order to show the lemma we an assume that W ( s, t) k > 0 as otherwise the equation trivially holds as the left hand side is always positive. The above laim then gives (τ,) L z(τ) λ. Now assume that i l, the lass-index of the pair (τ, ) L with smallest w (s, τ)-value, fulfills 2 i l W ( s, t) k. Then w (s, τ) D(τ, ) w (s, τ) D(τ, ) (τ,) S (τ,) L 2 i l (τ,) L D(τ, ) λ(w ( s, t) k) 36(W ( s, t) k), by hoosing λ 36. In the following we an assume 2 i l

8 (W ( s, t) k). We have w (s, τ)d(τ, ) (τ,) S Then γ 2 w (s, τ)d(τ, ) i il (τ,) S i 2 i D(τ, ) i il (τ,) S i 2 i( ) z (τ) 1 i il (τ,) S i = 1 2 i+1 z (τ) 2 i 2 i i l (τ,) S i i i l 1 w (s, τ)z (τ) 2 il+1 2 i i l (τ,) S i γ w (s, τ, t)x (τ) 2(W ( s, t) k). 2 (τ,) S i i i l L\S il w (s, τ, t)x (τ) 1 2 (τ,) L (W ( s, t) k) w (s, τ, t)z (τ) (τ,) L (λ + 1)(W (S) k) z (τ) where the last inequality follows from (τ,) L λ + 1. Adding the inequality 0 γ 2 L\S il w (s, τ, t)x (τ) (λ + 1)(W (s), t k) to Equation 3 gives w (s, τ)d(τ, ) (τ,) S γ 2 (τ,) S 36(W ( s, t) k), w (s, τ, t)x (τ) (λ + 2)(W ( s, t) k) where the last inequality holds for large enough γ, and uses the fat that the onstraint for ( s, t) in LP Primal is fulfilled. 5. UPDATING THE DISTRIBUTION It remains to show how to update the distribution in an online manner so that the buffer management strategies fulfill Properties 1, 2, 3, and 4. Instead of onstruting µ diretly we will first onstrut distributions µ 1, µ 2, µ 3. A random buffer management strategy aording to µ is then hosen by sampling strategies µ 1 D 1, µ 2 D 2, µ 3 D 3 and omputing the strategy D by setting D(τ, ) := max{d 1(τ, ), D 2(τ, ), D 3(τ, )}. Any strategy, whether in the support of µ 1, µ 2, or µ 3 fulfills, S i (τ,) S i S D(τ, ) 3. Hene, the strategy D = max{d 1, D 2, D 3} fulfills, S i (τ,) S i D(τ, ) 9 (Property 4). In addition strategies in the support of µ 1 fulfill Property 1, strategies from µ 2 fulfill Property 2, and strategies from µ 3 (3) fulfill Property 3. Hene, D will fulfill all these properties and onsequently D will obey the buffer-onstraints. 5.1 Maintaining µ 1, µ 2, and µ 3 In the following we desribe how to update µ 1, µ 2, and µ 3, and make sure that the strategies in their support fulfill their respetive properties. The distributions µ 1 and µ 2 will always fulfill D µi(d) D(τ, ) = z(τ), i.e., the expeted number of times the olor is removed at time τ by a random strategy D is equal to the saled LP-variable z (τ) (reall that we allow a strategy to remove a olor several times in the same step). It would be diffiult to maintain the above property without allowing hanges in the past. Therefore, we will allow a strategy at time t to alter its past behavior and to inrease or derease D(τ, ) for τ < t (suh a hange may inur a ost, of ourse). In reality, dereasing a D(τ, )- value only makes fulfilling buffer-onstraints more diffiult, so allowing this does not give additional power to the algorithm. Similarly, inreasing a D(τ, )-value with τ < t is never better than inreasing D(t, ) instead, sine we only are about the buffer-onstraint at t as the others have already been met. There are two types of hanges that require updating the distributions. Firstly, the z (τ)-values may inrease due to exeuting the LP-subroutine. We will assume that these hanges are infinitesimal, i.e., in eah step we have to reat to an inrease of a z (τ)-value from z (τ) to z (τ) + ɛ. The other type of hange is a hange to the vetor s triggered in Line 2 or Line 6 of Algorithm 2. The reomputation of s is done as follows. Let denote a olor that either has a τ {s + 1,..., t} with x ( τ) 1/λ or has s x(τ) 2/γ. In the first ase we set < s = τ. In the seond ase we ompute the largest s suh that s x(τ) 1. Then we set γ s to this value. We do this for all olors independently. The above proedure guarantees that the following properties always hold (τ,):s < z(τ) < 3. A onstraint ( s, t) is only proper if (τ,):s zτ < () 2. When feeding suh a onstraint to Algorithm 1 from Setion 3, the z-values are at most inreased by γ/log 3 k within a single step. For large enough k this means that the above sum never exeeds 3. s z(τ) 1 In the end we want that every strategy D from µ has every olor removed at least one within the range {s,..., t}. Therefore this property is important. Whenever s hanges (τ,):s < z(τ) dereases by at least 1. Therefore a fixed pair (τ, ) is only involved in at most 3 different onstraints ( s, t). For inreasing z (τ)-values we show that an inrease in ɛ results in an expeted ost of O(ɛ) for the maintenane operation. We also implement a maintenane operation with O(ɛ) expeted ost when a z (τ)-value dereases. With this derement operation we implement a hange of the vetor s as follows. Suppose we want to hange the -th oordinate of s from s to s. This may make all properties that depend on the values w (s, τ) invalid. We derement all z (τ)-values with τ {s + 1,..., t} to 0. Then we hange s to s, and after that we inrease the z (τ)-values again. The ost for this is O(z (τ)) for every (τ, )-pair involved. Sine eah (τ, )-pair is only involved in a onstant number of these derement

9 operations we obtain that the total ost for the hange is only O( τ, z(τ)) = O(primal ost), provided that we an implement the inrease and derease operations as laimed. Maintaining µ 1 For maintaining µ 1 we do not require a derement operation as Property 1 does not depend on w (s, τ)-values. Suppose that z (τ) inreases by ɛ. Then we first identify an ɛ-measure of strategies that have the smallest value of arg max τ {D(τ, ) > 0}, i.e., strategies that did not remove olor for a long time. For these strategies we set D(τ, ) = 1. This means that the strategies evit olor in a round-robin fashion. Sine (τ,) S D µ(d)d(τ, ) = (τ,) S z τ () 1, Property 1 follows. Maintaining µ 2 We maintain a strengthening of Property 2, namely for all S i: (τ,) S i z (τ) (τ,) S i D(τ, ) (τ,) S i z (τ). (4) Suppose that the z ( τ) value for some pair ( τ, ) is inreased by ɛ and assume that ( τ, ) S i. As we want to satisfy D µ1(d)d( τ, ) = z ( τ) we have to inrease D( τ, ) for some strategies. For this we hoose an ɛ-fration of strategies that have (τ,) S S i D(τ, ) 2 (these must exist for small enough ɛ as D (τ,) S S i D(τ, )µ 1(D) = (τ,) S S i z (τ) (τ,) S z (τ) < 3). We inrease the value of D(τ, ) for the hosen strategies. Now the onstraint in Equation 4 may be violated for lass S i. Let a = (τ,) S i z (τ) (before hanging z (τ)) and first assume that (τ,) S i z (τ) remains equal to a. Then the strategies that just have been hanged may now have (τ,) S i D(τ, ) = a + 2, whih is not allowed. In order to fix this we math these strategies to strategies that fulfill (τ,) S i D(τ, ) = a. For eah strategy D there must exist a (τ, ) suh that D(τ, ) > D (τ, ), where D denotes the strategy that D is mathed to. We derease D(τ, ) by 1 and inrease D (τ, ) by 1. This only indues an expeted ost of O(ɛ). The ase in whih (τ,) S i z (τ) hanges is analogous. Also the derement operation an be implemented this way. When z (τ) dereases we selet an ɛ-measure of strategies that fulfill D(τ, ) > 0 and derease D(τ, ) for them. Then we do a re-balaning step. Maintaining µ 3 Here we maintain a strengthened version of Property 3. Let (τ 1, 1), (τ 2, 2),... denote the sequene of (τ, )-pairs from S, in dereasing order of w (s, τ). Let (τ r, r) denote the first pair in this sequene that is not in L (note that this may not exist; then we define r as S + 1 sine L = S). Define a funtion l on the (τ, )-pairs that is zero for all (τ i, i), i > r; one for all (τ i, i), i < r and z r ( r i=1 z i (τi) (λ + 1))/z r (τ r) for (τ r, r). For all (τ i, i), i r l simply is the harateristi funtion of the set L; only for r it measures the fration by whih (τ r, r) needs to be inluded into L in order that the z (τ)-values in L sum up to exatly (1 + λ) (reall that during the onstrution of L we were aiming for it to ontain a total z-weight of λ + 1. When we overshoot we remove the last element). We maintain the onstraint that z(τ)l(τ, ) D(τ, ) (τ,) S (τ,) L (τ,) S z(τ)l(τ, ), whih is a strengthening of Property 3. In addition we maintain D D(τ, )µ3(d) = z(τ)l(τ, ). Suppose that a z (τ)-value inreases and that (τ, ) L (otherwise we don t need to do anything; observe that if z r is inreased or dereased by ɛ the value of z r (τ r)l(τ r, r) stays onstant). We inrease D(τ, ) for an ɛ-measure of strategies that have D(τ, ) < 3. In addition we derease D(τ r, r) for an ɛ-measure of strategies (only if r is defined, i.e., if L S). Now, there may be an ɛ-fration of strategies that has a value of (τ,) L D(τ, ) that is too large by 1, and there may exist an ɛ-measure of strategies for whih this value is by one too low. As before we an perform re-balaning steps in order to fix this at an expeted ost of O(ɛ). 6. REFERENCES [1] Amjad Aboud. Correlation lustering with penalties and approximating the reordering buffer management problem. Master s thesis, Computer Siene Department, The Tehnion Israel Institute of Tehnology, [2] Anna Adamaszek, Artur Czumaj, Matthias Englert, and Harald Räke. Almost tight bounds for reordering buffer management. In Proeedings of the 43rd ACM Symposium on Theory of Computing (STOC), pages , [3] Anna Adamaszek, Artur Czumaj, Matthias Englert, and Harald Räke. An O(log k)-ompetitive algorithm for generalized ahing. In Proeedings of the 23rd ACM- SIAM Symposium on Disrete Algorithms (SODA), pages , [4] Yuihi Asahiro, Kenihi Kawahara, and Eiji Miyano. NPhardness of the sorting buffer problem on the uniform metri. Unpublished manusript, [5] Noa Avigdor-Elgrabli and Yuval Rabani. An improved ompetitive algorithm for reordering buffer management. In Proeedings of the 21st ACM-SIAM Symposium on Disrete Algorithms (SODA), pages 13 21, [6] Noa Avigdor-Elgrabli and Yuval Rabani. A onstant fator approximation algorithm for reordering buffer management. arxiv: , [7] Nikhil Bansal, Niv Buhbinder, Aleksander M adry, and Joseph Naor. A polylogarithmi-ompetitive algorithm for the k-server problem. In Proeedings of the 52nd IEEE Symposium on Foundations of Computer Siene (FOCS), pages , [8] Nikhil Bansal, Niv Buhbinder, and Joseph Naor. A primal-dual randomized algorithm for weighted paging. In Proeedings of the 48th IEEE Symposium on Foundations of Computer Siene (FOCS), pages , [9] Nikhil Bansal, Niv Buhbinder, and Joseph Naor. Randomized ompetitive algorithms for generalized ahing. In Proeedings of the 30th ACM Symposium on Theory of Computing (STOC), pages , [10] Reuven Bar-Yehuda and Jonathan Laserson. Exploiting loality: Approximating sorting buffers. In Proeedings of the 3rd Workshop on Approximation and Online Algorithms (WAOA), pages 69 81, 2005.

10 [11] Dan Blandford and Guy Blelloh. Index ompression through doument reordering. In Proeedings of the Data Compression Conferene (DCC), pages , [12] Niv Buhbinder and Joseph Naor. Online primal-dual algorithms for overing and paking problems. In Proeedings of the 13th European Symposium on Algorithms (ESA), pages , [13] Ho-Leung Chan, Niole Megow, Rob van Stee, and René Sitters. The sorting buffer problem is NP-hard. CoRR, abs/ , [14] Matthias Englert, Harald Räke, and Matthias Westermann. Reordering buffers for general metri spaes. In Proeedings of the 39th ACM Symposium on Theory of Computing (STOC), pages , [15] Matthias Englert, Heiko Röglin, and Matthias Westermann. Evaluation of online strategies for reordering buffers. ACM Journal of Experimental Algorithmis, 14:3:3.3 3:3.14, [16] Matthias Englert and Matthias Westermann. Reordering buffer management for non-uniform ost models. In Proeedings of the 32nd International Colloquium on Automata, Languages and Programming (ICALP), pages , [17] Iftah Gamzu and Danny Segev. Improved online algorithms for the sorting buffer problem. In Proeedings of the 24th Symposium on Theoretial Aspets of Computer Siene (STACS), pages , [18] Kai Gutenshwager, Sven Spiekermann, and Stefan Voß. A sequential ordering problem in automotive paint shops. International Journal of Prodution Researh, 42(9): , [19] Rohit Khandekar and Vinayaka Pandit. Online and offline algorithms for the sorting buffers problem on the line metri. Journal of Disrete Algorithms, 8(1):24 35, [20] Jens S. Kohrt and Kirk Pruhs. A onstant fator approximation algorithm for sorting buffers. In Proeedings of the 6th Latin Amerian Symposium on Theoretial Informatis (LATIN), pages , [21] Jens Krokowski, Harald Räke, Christian Sohler, and Matthias Westermann. Reduing state hanges with a pipeline buffer. In Proeedings of the 9th International Fall Workshop Vision, Modeling, and Visualization (VMV), pages , [22] Harald Räke, Christian Sohler, and Matthias Westermann. Online sheduling for sorting buffers. In Proeedings of the 10th European Symposium on Algorithms (ESA), pages , of the expression min{w( s, τ), l k} x(τ). For eah olor, we define a funtion f : N R +. The value of f (y) is defined as follows. Set s to the largest time step, suh that w (s, t) = y. This gives f (y) := min{w(s, τ), l k} x(τ). With this notation, we have to find values y suh that f(y) is minimized and y = l. The following lemma shows that this an be done in polynomial time. Lemma A.1. Given n funtions f 1,..., f n : N R + and a value l, we an find, in polynomial time, values x 1,..., x n suh that i fi(xi) is minimized and i xi = l. Proof. We solve the problem using dynami programming. For a pair of integers (j, γ) (eah between 0 and n), we ompute values x 1,..., x j suh that f 1(x 1) + + f j(x j) is minimized and x x j = γ. The solutions for (1, γ) for all values of γ are trivial to ompute. Now, in phase i > 1, we ompute the solution for (i, γ) for any fixed γ as follows. For eah integer k between 0 and γ, lookup (i 1, γ k), amend that solution by setting x i := k and ompute f 1(x 1) + + f i(x i). Choose the k that leads to the solution minimizing this sum and store it as the solution for (i, γ). In the end, the solution (n, l) is the solution we were looking for. APPENDIX A. FINDING A VIOLATED CONSTRAINT We want to find a vetor s minimizing w ( s, τ, t) x (τ) (W ( s, t) k). If the minimum is smaller than 0, it means that we found a violated onstraint, if the minimum is at least 0, all onstraints are satisfied. First, notie that the value W ( s, t) is an integer between k and n. Therefore it is enough to find for eah l {k,..., n} a vetor s suh that W ( s, t) = l and s minimizes the value