Online packet scheduling under adversarial errors

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.1 (1-18)

Theoretical Computer Science ••• (••••) •••–•••

Contents lists available at ScienceDirect

Theoretical Computer Science www.elsevier.com/locate/tcs

Online packet scheduling under adversarial errors ✩ a,∗ ´ Paweł Garncarek a , Tomasz Jurdzinski , Dariusz R. Kowalski b,c , Krzysztof Lory´s a a b c

Institute of Computer Science, University of Wrocław, Poland Department of Computer Science, University of Liverpool, UK SWPS University of Social Sciences and Humanities, Warsaw, Poland

a r t i c l e

i n f o

Article history: Received 16 October 2017 Received in revised form 28 December 2018 Accepted 2 August 2019 Available online xxxx Communicated by L.A. Gasieniec Keywords: Packet scheduling Dynamic packet arrivals Adversarial errors Online algorithms Competitive throughput Resource augmentation

a b s t r a c t We consider the problem of scheduling packets of different sizes via a directed communication link prone to errors, where dynamic packet arrivals and errors are modeled by an adversary. Packets arrive over time to be transmitted over a channel in which instantaneous errors occur at times not known to the algorithm in advance. We focus on estimating the competitive throughput of online scheduling algorithms defined as the ratio between the total size of packets successfully transmitted by an online algorithm and the largest total size of packets which can be transmitted for the same arrival and error patterns. First, we design two online algorithms with optimal competitive throughput in various scenarios. One algorithm works for any f ≥ 1 channels and attains the competitive throughput 1/2 provided that sizes of packets satisfy the divisibility property (i.e., any larger size is divisible by any smaller). The other algorithm achieves the optimal competitive throughput in (1/3, 1/2] for arbitrary sizes of packets on one communication channel, where the exact value of the competitive throughput depends on the sizes of packets. Second, we focus on algorithms working with speedup s ≥ 1. In this setting, online algorithms transmit packets s times faster than the offline optimum solution they are compared against. We design an algorithm which attains the competitive throughput 1 if it works with speedup 2 in the case that sizes of packets satisfy the divisibility property and with speedup s ∈ [4, 6) for arbitrary sizes of packets. This demonstrates that throughput of the best online fault-tolerant scheduling algorithms scales well with resource augmentation. © 2019 Elsevier B.V. All rights reserved.

1. Introduction We study a fundamental problem of online packet scheduling via unreliable link consisting of f ≥ 1 independent parallel channels, when transmitted packets may be interrupted by errors. This problem was introduced by Fernandez Anta et al. [6] and analyzed for two different packet sizes and one channel. In our work, an arbitrary number of packet sizes is considered. Packets arrive dynamically to one end of the link, called a sender, and need to be transmitted in full, i.e., without any in-between error, to the other end (called a receiver). Errors are immediately discovered by the sender. As errors might require restarts of the scheduler, it is assumed that information about history of transmissions is lost after an occurrence of

✩ Some preliminary results of this paper were published in the Proceedings of Approximation and Online Algorithms - 12th International Workshop, (WAOA), 2014, pp. 193–206, [10]. Corresponding author. ´ E-mail address: [email protected] (T. Jurdzinski).

*

https://doi.org/10.1016/j.tcs.2019.08.003 0304-3975/© 2019 Elsevier B.V. All rights reserved.

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.2 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

2

the error. We analyze all possible scenarios, including worst case ones, which we model as an adversary who controls both packet arrivals and errors on the channels. The adversary is unrestricted, in the sense that it may generate any arrival and error pattern. The main objective of the online scheduling protocol is to achieve as high throughput as possible, where the throughput is the amount of data transmitted successfully per a time unit. (Other measures, such as queue sizes and packet latency, are not considered in this work — it is known that they both require resource augmentation in order to achieve competitiveness, cf., [7,8].) Because of the online setting, we consider the competitive throughput measure, which is the ratio between the total size of packets successfully transmitted by a considered online algorithm and the largest size of packets which might be transmitted by an algorithm which has access to information about all adversarial arrivals and errors. Previous work. The framework considered in this work was recently introduced in [6] in the context of two packet sizes and one channel. The authors showed that general offline version of this problem, in which the scheduling algorithm knows a priori when errors will occur and it is supposed to determine an optimal schedule, is NP-hard, cf., [6]. They also considered algorithms and upper limitations for the competitive throughput in case of two packet sizes. In particular, they proved that the competitive throughput of any online scheduling protocol cannot be bigger than ρ /(ρ + ρ ), where ρ is the ratio between the largest and the smallest packet sizes and ρ = ρ . (Note that the upper bound becomes 1/2 if the bigger packet size is a multiple of the smaller packet size.) They also designed a protocol with optimal competitive throughput, i.e., equal to the upper bound ρ /(ρ + ρ ). After every error, their protocol schedules a specific preamble of smaller packets followed by the Longest_First rule. On the other hand, the competitive throughput of simpler protocols, such as Longest_First itself or Shortest_First, is smaller than the upper bound ρ /(ρ + ρ ) [6]. It remained open whether there is an online scheduling protocol reaching the optimal competitive throughput for arbitrary number of packet sizes; we answer this question in the affirmative in this work, using alternative techniques. Recently, Fernandez Anta et al. [8] analyzed four popular scheduling algorithms in the same framework: FIFO, LIFO, Longest_First and Shortest_First. Among others, they proved that, for any packet sizes, the competitive throughput of the first three algorithms is equal to 0 while the competitive throughput of the last algorithm is equal to 1+1 ρ < 12 , even for the case that sizes of packets satisfy the divisibility property. Moreover, none of the four algorithms reaches the competitive throughput 1 for any speedup smaller than ρ . All results in [6,8] hold also for competitive throughput (for sufficiently large additive constant). Our contribution. We design a deterministic online scheduling algorithm achieving optimal competitive throughput for an arbitrary number k of fixed packet sizes min = 1 < 2 < . . . < k = max under crash errors (Section 3). We first design an algorithm for the case that packet sizes satisfy the divisibility property (i.e., any larger is divisible by any smaller). This algorithm achieves optimal competitive throughput 1/2 on arbitrary number of f ≥ 1 channels. Remaining results of the paper are designed and analyzed for a link with one communication channel. We extend the first algorithm so that it does not rely on the assumption that sizes  of packets  satisfy the divisibility property. The modified algorithm achieves the competitive throughput

γ = min1≤ j
ρ i , j  ρi , j +ρi , j

, where

ρi, j = i / j is the ratio between the ith and the jth packet

γ is the optimal competitive throughput of an online algorithm. Note that γ is in the range ( 13 , 12 ], which is independent of ρ = max /min , and it reaches 12 if the divisibility property is satisfied. size. We also show that

A natural question arises whether a better competitive throughput could be achieved if some additional resources are provided to an online scheduler. Such a model where an online algorithm uses additional resources is called the model with resource augmentation. We consider speedup, a natural type of resource augmentation for our scenario, where an online scheduler can transmit packets s ≥ 1 times faster than an offline algorithm which knows adversary’s decisions in advance. We design another deterministic online algorithm which is a generalization of the preamble protocols proposed in [6] and [7] in the case of only two packet sizes. Our algorithm achieves competitive throughput 1 on one channel for speedup 2 when the divisibility property holds and for speedup s ∈ [4, 6) in the general case. Remark. Some preliminary results of this paper were published in [10]. However, in that paper, we consider jamming errors, which are weaker than crash errors considered here. The result of a jamming error at time t and the channel ϕ is that a transmission of a packet on ϕ taking place at t is corrupted. A crash error at time t and the channel ϕ is stronger than the jamming error in the sense that, apart from the interruption of the current transmission, information about history of transmissions on channel ϕ is lost.1 Related work. Packet scheduling [11] is one of the most fundamental problems in computer networks. Online arrival of input data [4,13], is a natural scenario here and therefore a competitive analysis [1,15] is often used to evaluate the performance of proposed solutions. Online scheduling was considered in a number of models; for more information the reader is referred to [12] and [13]. There are relatively few results assuming both online packet arrivals and errors. Apart from the already mentioned work [6], the authors in [7] studied optimization of buffer sizes of online scheduling protocols on error-prone channel. In order to obtain a positive competitive throughput with respect to the buffer sizes, additional resources need to be given

1

A crash error might be considered as an event that an execution of a scheduling algorithm is interrupted.

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.3 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

3

to the online algorithm, e.g., so-called speedup. This form of resource augmentation appeared to be efficient: there exists a deterministic online scheduling algorithm which is 1-competitive with respect to buffer sizes for some speedup smaller than 2. Recently, a multi-channel scenario was considered in the context of competitive throughput with simultaneous errors on all channels [9]. In contrast to the model with independent errors on parallel channels, there exists an online algorithm with competitive throughput larger than 1/2, provided that errors appear simultaneously on all f > 1 channels. Wireless packet scheduling was also considered in models with physical constraints included, such as radio networks or SINR. Anantharamu et al. [2] considered packet scheduling on a multiple access channel with signal interference, provided that packet arrivals and channel errors satisfy specific constraints. Richa et al. [14] analyzed competitive throughput of randomized scheduling protocols on multiple access channels with signal interference, where errors are controlled by an omniscient and adaptive adversary. In both papers, the authors studied a stronger objective measure than the competitive throughput considered in this paper: maximum time from packet arrival to its successful delivery. Therefore, these results cannot be directly compared with ours. Andrews and Zhang [3] studied buffer stability (i.e., the property that sizes of buffers are bounded at each time) of online packet scheduling on a wireless channel, where both transmission rate and the data arrivals are controlled by an adversary. They also assumed bounded adversary, as otherwise stability could not be reached in their model. 2. Model and notations We consider a uni-directional point-to-point link in which one end point, called a sender, transmits packets to the other end point, called a receiver. The sender is equipped with unlimited buffer (or a queue), in which the arriving packets are queued. Packets may be of different sizes, and may arrive at any time. We assume that time is continuous, and a scheduling algorithm has access to packets as soon as they arrive. There are k ≥ 2 different packet sizes, denoted by min = 1 < 2 < · · · < k = max . For simplicity, we will use the names “i -packets” and “packets i ” for packets of size i , for any 1 ≤ i ≤ k. We say that the packet sizes satisfy the divisibility property if i /i −1 is an integer for each 1 < i ≤ k. We denote ρ = max /min . We assume that all packets are transmitted at the same bit rate, hence the transmission time is proportional to the sizes of transmitted packets. That is, transmission of a packet of size  requires time interval of size . The link is prone to (crash) errors, that is, transmissions of packets might be corrupted at any time point. Arrival models. We consider adversarial packet arrivals: the packets’ arrival time and size are governed by an adversary. We define an adversarial arrival pattern as a possibly infinite collection of packet arrivals, where each element of this collection determines the size of a packet and its arrival time. Channels. Packets can be transmitted on f ≥ 1 independent parallel channels. The scheduling algorithm needs to choose a channel for each scheduled packet. Crash errors. We consider an adversarial model of crash errors (or simple crashes or errors), in which the adversary decides at which time to cause an error and at which channel. The error event at time t on the channel ϕ ∈ {1, 2, . . . , f } corrupts a transmission of a packet on ϕ at t and information about history of transmissions on channel ϕ is lost. A corrupted transmission of a packet is unsuccessful in the sense that the packet is not received by the receiver and it needs to be retransmitted in full, not necessarily right after the error — a scheduling algorithm may decide to postpone it and transmit another packet instead on the channel ϕ . We assume that scheduling algorithms cannot voluntarily stop transmitting packets before the end of the transmission, unless they get instantaneous feedback about an error. An error event corresponds to a time point t at which a current transmission is interrupted. An adversarial error pattern is defined as a possibly infinite collection of error events on the channels caused by the adversary. Efficiency metric: We would like to measure throughput of the communication link(s). However, due to adversarial errors and packet injections, the size of packets which might be transmitted per time unit may vary in time. Therefore, following [6], we pursue a competitive analysis. Let A be an arrival pattern and E an error pattern. For a given deterministic online algorithm ALG, let L ALG (A, E , t ) be the total size of all the successfully transmitted (i.e., non-corrupted) packets by time t under arrival pattern A and error pattern E . Let OFF be an (arbitrary) algorithm that knows the exact arrival and error patterns in advance. We define the competitive throughput of a deterministic algorithm ALG with respect to OFF as the biggest value T ALG satisfying the following equation

L ALG (A, E , t ) ≥ T ALG · L OFF (A, E , t ) − a ,

(1)

for each arrival pattern A, each adversarial error pattern E and each time t, where a is called the additive constant, depending only on the model parameters, but not on time. The competitive throughput of ALG is equal to the minimum of the values of T ALG over all offline algorithms. In general, we are interested in determining the largest value of the competitive throughput for an online algorithm. However, the additive constant is also evaluated in some cases.

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.4 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

4

Speedup. We say that an online algorithm works with speedup s ≥ 1 if it transmits packets s times faster than the offline solution it is compared against. If the speedup s is equal to 1, we say that an algorithm works without speedup. The competitive throughput under speedup s ≥ 1 is defined as before, but the value of L ALG (A, E , t ) is calculated under the assumption that ALG works with speedup s. 2.1. Notations We use the notations [n, m] = { p ∈ N | n ≤ p ≤ m} and [n] = [1, n]. Assume that an arrival pattern and an injection pattern are chosen arbitrarily and are fixed (during the analysis), so we could omit them from formulas. For an algorithm A, let q A (i , t ) denote the sum of sizes of i -packets in the queue of A at the time t. That ni is the number of i -packets in the queue of A  is, q A (i , t ) = ni · i for a fixed time t, where  q ( j , t ) and, analogously, q (≤ i , t ) = q at t. Let q A (< i , t ) = A A j
• the total size of i -packets whose transmissions were started and finished inside τ ; • t − t 1 for each i -packet such that t ∈ τ is the end of the successful transmission of that i -packet and this transmission started before

τ;

• t 2 − t  for each i -packet such that t  ∈ τ is the beginning of the transmission of that i -packet, this transmission is lasting at t 2 and it is successfully finished after

τ.

Similarly, let I (i , t ) denote the sum of sizes of i -packets injected by an adversary until the time t. The notions L A (< i , t ), L A (≤ i , t ), L A (< i , τ ), and L A (≤ i , τ ) for time t and time interval τ are defined analogously to q A (< i , t ), q A (≤ i , t ), q A (< i , τ ) and q A (≤ i , τ ). Similarly, we define I (< i , t ), I (≤ i , t ), I (< i , τ ), and I (≤ i , τ ) for time t and time interval τ . If a packet is during a transmission at time t and its transmission is not finished yet, the packet is not in the queue, even though the transmission might be crashed. Thus, the above notations satisfy the inequalities

I (α , t ) − f k ≤ L A (α , t ) + q A (α , t ) ≤ I (α , t ) for α ∈ {i , < i , ≤ i }, where i ∈ [k], t ≥ 0 and f ≥ 1 is the number of communication channels. That is, the size of injected packets until t is “approximately” equal to the size of transmitted packets plus the size of packets still in the queue. We also use the above introduced notations without the first argument, i.e., q A (t ), q A (τ ), L A (t ), and L A (τ ), which are shorthands for q A (≤ k, t ), q A (≤ k, τ ), L A (≤ k, t ) and L A (≤ k, τ ), respectively. An algorithm A is busy at time t if one of the following three conditions is satisfied for each channel ϕ :

• A is transmitting a packet on ϕ at t, • A has finished a successful transmission on ϕ at t, • a transmission on ϕ is interrupted by an error at t. Otherwise A is idle at t. 3. Packet scheduling for arbitrary k ≥ 2 sizes of packets In this section we present online algorithms which achieve the optimal competitive throughput in various settings. First, in Section 3.1, the upper bound on the competitive throughput of any online algorithm is given. Then, we present the algorithm GreedyDiv which achieves the optimal competitive throughput 12 under the assumption that i /i −1 ∈ N for each 1 < i < k on f ≥ 1 channels. Finally, in Section 3.3, we analyze another algorithm Greedy (based on a similar idea as GreedyDiv) which achieves the optimal competitive throughput on one channel only but for arbitrary sizes of packets. 3.1. Upper bound on competitive throughput Let ρi , j = i / j for 1 ≤ j < i ≤ k. The upper bound on the competitive throughput from [6] (Theorem 1 in [6]) naturally generalizes to the following result. Theorem 1. The competitive throughput of any online scheduling algorithm under crashes on f ≥ 1 channels is at most



γ = min

1≤ j
ρi , j  ρi , j  + ρi , j



.

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.5 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

5

Fig. 1. An example illustrating transmissions of an algorithm which prefers sending short packets (part a) and an optimal schedule (part b). Errors are denoted by vertical dashed lines.

Fig. 2. An example illustrating GreedyDiv in the situation that there are three lengths of packets: 1, 3, and 12. An adversary injects 5 packets of size 1 (grey) and 3 packet of size 3 (white) at time t = 0.

Proof. First, consider the model with one channel. The result easily follows from Theorem 1 in [6], where the bound stated in our theorem is proved for two sizes of packets (k = 2) and for the model with jamming errors, i.e., where an error on the channel does not cause that an algorithm loses information about history of earlier computation. First note that crashes in place of jamming errors make the situation harder for an online algorithm. Therefore, if the adversary schedules merely ρ 

i, j packets i and  j , for i , j minimizing the expression ρ + ρi, j , the strategy described in the proof of Theorem 1 in [6] gives i, j our result. The above stated upper bound holds for f > 1 channels, since the adversary can make errors preventing transmission of any packet on all but the first channel. Then, the multi-channel scenario reduces to the case with one channel. 2

3.2. Packet scheduling with sizes satisfying the divisibility property In this section we present an online algorithm GreedyDiv (Algorithm 1, page 6) and analyze its performance under the assumption that sizes of packets satisfy the divisibility property. First, we provide some intuitions behind our online algorithm. Assume for a while that there are only two sizes of packets min (small packets) and max (large packets) and one communication channel. The main idea behind our algorithms is to keep transmitting as many small packets as possible (shortest-first strategy), subject to some balancing constraints. Observe that it is difficult for any offline algorithm OFF to get substantial advantage over any online algorithm ALG when ALG sends small packets from its queue. Thus, preference for small packets ensures that ALG can be as efficient as any OFF, as long as ALG has small packets in its queue. However, if OFF transmits large packets during transmission of small packets by ALG, it can afterwards transmit small packets when ALG does not have any of them in its queue. Simultaneously, when OFF is transmitting small packets, the adversary can generate errors preventing ALG from successful transmissions of large packets. Fig. 1 illustrates such a situation for 2 packets of size 1 (grey) and 1 packet of size 3 (white) injected at time t = 0. The part a) shows that if ALG sends all small packets first, then the adversary can cause errors (denoted by vertical dashed lines) every 1 time unit afterwards, preventing ALG from sending the packet of size 3. Part b) shows that an optimal algorithm OFF for that error pattern can send all small packets and the large packet in only 5 time units. Despite the above described disadvantage of a greedy approach, we show that an appropriate implementation of this strategy, using some balancing constraints, provides an optimal solution with respect to competitive throughput, and thus against any arrival and failure patterns. The actual algorithm has to adjust to arbitrary k ≥ 2 packet sizes, thus the notion of small/large packets might change dynamically depending on the sizes of packets injected by the adversary. Our specific modification of the greedy shortest-first strategy is based on sending packets in groups. We explain it first for two sizes of packets min , max and one communication channel. If the number of min -packets in the queue is at least ρ = max /min , the algorithm builds a group, which consists of ρ small packets, and keeps sending them. If there are less than ρ small packets in the queue at the moment when a transmission of a group is finished (or an error just occurred), a large packet is transmitted. This idea is then recursively applied for the case when there are k > 2 sizes of packets. As an example, consider the situation that there are three lengths of packets: 1, 3 and 12 (see Fig. 2). An adversary injects 5 packets of size 1 (grey) and 3 packet of size 3 (white) at time t = 0. Then, GreedyDiv would start from a block of size 12 (first row) and try to fill it with packets’ sizes smaller than 12. Packets of sizes smaller than 12 sum up to 5 · 1 + 3 · 3 = 14 ≥ 12. Therefore GreedyDiv splits size 12 into 4 blocks of size 3 each (second row). Then GreedyDiv takes

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.6 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

6

Algorithm 1 GreedyDiv on the channel ψ ≤ f . 1: loop k 2: while i =1 i ni < f k do 3: Stay idle 4:

TransmitGroupDiv(k)

ni : the number of awaiting i -packets An execution of Algorithm 2

Algorithm 2 TransmitGroupDiv( j ) on the channel ψ ≤ f . 1: loop 2: 3: 4:

 j −1

 n ≥ f  j then i =1 i i for a = 1 to  j / j −1 do TransmitGroupDiv( j − 1) return Transmit  j ; return if

ni : the number of awaiting i -packets

first such block and tries to split it further. Since packets of sizes smaller than 3 sum up to size 5 · 1 = 5 ≥ 3, it splits the first block of size 3 into 3 blocks of size 1 (third row). It cannot split blocks of size 1 anymore. Once it sends 3 packets of size 1, it reaches another block of size 3 and tries to split it. Since there are only 2 remaining packets of size 1, GreedyDiv cannot cover the block by packets of size 1. Therefore GreedyDiv sends packets of size 3 from now on until it fills the entire block of size 12. A pseudo-code of our greedy algorithm GreedyDiv for packet sizes satisfying the divisibility property is presented as Algorithm 1, with its recursive subroutine given as Algorithm 2. In the pseudo-codes, ni denotes the number of i -packets which are currently waiting in the queue for transmission. Performance analysis of Algorithm 1 (GreedyDiv) Consider a time interval τ = [t 1 , t 2 ]. Our goal is to compare the size of packets transmitted by GreedyDiv and the size of packets transmitted by OFF in τ . We say that an algorithm A is m-busy (with respect to OFF) in the time interval τ = [t 1 , t 2 ] if the following conditions are satisfied: 1. A is busy at each time t ∈ τ ; 2. A does not transmit i -packets for i > m during τ ; 3. q A (i , t 1 ) ≥ qOFF (i , t 1 ) for each i ∈ [m]. (That is, at time t 1 A has at least as many i -packets in its queue as OFF, for each i ≤ m.) Below, we state a simple but useful property of GreedyDiv. Fact 1. Assume that GreedyDiv is m-busy in a time interval τ for m ∈ [k]. Let τ  ⊆ τ be a time interval of size m without an error inside τ  . Then, a successful transmission of a group of packets G of size m by an execution of TransmitGroupDiv(m) is finished at some time point t ∈ τ  . Now, we prove lemmas regarding intervals in which GreedyDiv is m-busy for some m ∈ [k]. These lemmas eventually lead to the proof of the fact that the competitive throughput of GreedyDiv is 1/2 provided i /i −1 ∈ N for i ∈ [2, k]. Due to an upper bound on the competitive throughput from Theorem 1, our algorithm achieves the optimal competitive throughput for packet sizes satisfying the divisibility property. When considering an m-busy interval, we say that a packet is large if its size is at least m and the packet is small otherwise. First, we make an observation that, if GreedyDiv does not use packets of size larger than m for m ∈ [k], then the total size of packets transmitted by GreedyDiv is at least as large as the total size of packets of size at least m transmitted by OFF (minus some constant). Lemma 1. Assume that GreedyDiv is m-busy in a time interval L GreedyDiv (τ ) ≥ L OFF (≥ m, τ ) − 3 f m .

τ = [t 1 , t 2 ], m ≤ k and the divisibility property holds. Then,

Proof. Consider an i -packet for i ≥ m successfully transmitted by OFF in the time interval [t , t + i ] ⊂ τ on the channel ϕ ∈ [ f ]. Let us split the time interval [t , t + i ] into i /m consecutive blocks of length m . If a block is not the leftmost nor the rightmost block in τ on the channel ϕ (which implies that it is fully contained in τ ), a successful transmission of a group of packets of size m is finished during τ on the channel ϕ , caused by an execution of TransmitGroupDiv(m) (Algorithm 2) – see Fact 1. We can assign this group of packets of size m transmitted by GreedyDiv to the considered block. However, the leftmost block of size m fully contained in τ may be assigned a group of packets of size m transmitted by GreedyDiv that is not fully contained in τ . Therefore, on each channel, up to 3 blocks that started or finished in τ may not have assigned packets transmitted by GreedyDiv whose transmissions started and finished in τ .

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.7 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

7

The above describe assignment shows that, for each channel ϕ , the total size of packets transmitted by GreedyDiv on ϕ in τ is not smaller than the total size of large packets transmitted by OFF on ϕ in τ , minus 3m . Thus, the inequality L GreedyDiv (τ ) ≥ L OFF (≥ m, τ ) − 3 f m is satisfied. 2 Next, assuming that GreedyDiv does not transmit packets of sizes larger than m in τ , we determine the lower bound on the size of packets transmitted by GreedyDiv. This bound depends on the size of packets transmitted by OFF in τ (L OFF (τ )) and the size of small packets in the queue of OFF at the end of τ (qOFF (< m, t 2 )). However, the bound in the following lemma holds only for an interval which ends by a transmission of an m -packet by GreedyDiv. Lemma 2. Assume that GreedyDiv is m-busy in a time interval τ = [t 1 , t 2 ], m ≤ k and GreedyDiv starts transmitting an m -packet at t 2 on some channel ϕ ∈ [ f ]. Then,

2L GreedyDiv (τ ) ≥ L OFF (τ ) + qOFF (< m, t 2 ) − 6 f m , provided that divisibility property is satisfied. Proof. Lemma 1 implies that L GreedyDiv (τ ) ≥ L OFF (≥ m, τ ) − 3 f m . Thus, it is sufficient to show that L GreedyDiv (τ ) ≥ L OFF (< m, τ ) + qOFF (< m, t 2 ) − 3 f m . Observe that the total size of packets of size smaller than m transmitted by GreedyDiv in τ = [t 1 , t 2 ] is at least

L GreedyDiv (< m, τ ) ≥ qGreedyDiv (< m, t 1 ) + I (< m, τ ) − qGreedyDiv (< m, t 2 ) − f m−1 ,

(2)

i.e., the size of packets injected in τ plus the size of packets available in queues at the beginning of τ minus the size of packets still in queues at the end of τ and minus the size of small packets whose transmissions were only started inside τ but finished or were interrupted later (which is at most f m−1 ). Similarly, the total size of packets of size smaller than m transmitted by OFF in τ = [t 1 , t 2 ] is at most

L OFF (< m, τ ) ≤ qOFF (< m, t 1 ) + I (< m, τ ) − qOFF (< m, t 2 ) + 2 f m−1 , where “+2 f m−1 ” corresponds to packets (if any) whose transmissions started before

(3)

τ or ended after τ . Moreover,

(a) qGreedyDiv (< m, t 1 ) ≥ qOFF (< m, t 1 ), by the item 3. of the definition of an m-busy interval; (b) qGreedyDiv (< m, t 2 ) < f m – otherwise, GreedyDiv does not start transmitting an m -packet at t 2 ; (c) qOFF (< m, t 2 ) ≥ 0. Thus, by combining the above inequalities (a)–(c) with (2) and (3), we have

L GreedyDiv (< m, τ ) − L OFF (< m, τ ) ≥ qOFF (< m, t 2 ) − f m − 3 f m−1

(4)

≥ qOFF (< m, t 2 ) − 3 f m as claimed, since 3m−1 ≤ 2m due to the divisibility property. As L GreedyDiv (< m, τ ) ≤ L GreedyDiv (τ ), the statement of the lemma follows from (4) and Lemma 1.

2

Using previous lemmas, we prove by induction that L OFF (τ ) (minus some constant) is at most twice larger than L GreedyDiv (τ ) in each intervals τ which is m-busy for GreedyDiv, where m ∈ [k]. Lemma 3. Assume that GreedyDiv is m-busy in a time interval τ , for m ≤ k. Then,

2L GreedyDiv (τ ) ≥ L OFF (τ ) − 14 f m , provided the sizes of packets satisfy the divisibility property. Proof. The proof goes by induction with respect to m. For m = 1 the result is an immediate consequence of Lemma 1, since L OFF (≥ 1, τ ) = L OFF (τ ). For the inductive step, assume that the lemma holds for some m < k. We will show the correctness of the lemma for the case that the largest size of a packet sent by GreedyDiv in τ is m+1 . We split τ = [t 0 , t 3 ] into three subintervals (see Fig. 3):

• τ1 = [t 0 , t 1 ), where t 1 is the last time during τ at which GreedyDiv starts a transmission of m+1 ; • τ2 = [t 1 , t 2 ) such that either GreedyDiv finishes a successful transmission (which started at t 1 ) of m+1 at t 2 or this transmission of m+1 is interrupted by an error at t 2 ; • τ3 = [t 2 , t 3 ].

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.8 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

8

Fig. 3. The subintervals considered in Lemma 3.

Lemma 2 implies that

2L GreedyDiv (τ1 ) ≥ L OFF (τ1 ) + qOFF (< m + 1, t 1 ) − 6 f m+1 . Consider OFF’ which acts in exceptions:

(5)

τ exactly as OFF (that is OFF’ transmits the same packets as OFF) with the following

(a) OFF’ starts τ2 without i -packets in its queue for each i < m + 1, and it stays idle each time OFF is transmitting a packet which was in its queue at the beginning of τ2 and therefore it was not in the queue of OFF’. Because of this difference between OFF and OFF’, the size of packets transmitted by OFF’ is smaller than the size of packets transmitted by OFF by at most qOFF (< m + 1, t 1 ). (b) Additionally, for each i ∈ [m] such that qOFF (i , t 2 ) > qGreedyDiv (i , t 2 ), we remove qOFF (i , t 2 ) − qGreedyDiv (i , t 2 ) copies of i -packets from the queue of OFF’ at t 2 . Since OFF’ starts τ2 = [t 1 , t 2 ) without i -packets in its queue for each i ∈ [m] by (a), the difference qOFF (t 2 ) − qGreedyDiv (t 2 ) is smaller or equal to the size of i -packets transmitted by GreedyDiv in τ2 . As GreedyDiv transmits in τ2 (of size ≤ m+1 ) packets of total size ≤ f m+1 , the size of packets removed from the queue of OFF’ at t 2 is at most f m+1 . Recall that the size of

τ2 is at most m+1 . Therefore, L OFF (τ2 ) ≤ f m+1 and thus

2L GreedyDiv (τ2 ) ≥ L OFF (τ2 ) − f m+1 .

(6)

At the beginning of τ3 , it holds that qGreedyDiv (i , t 2 ) ≥ qOFF (i , t 2 ) for each i ≤ m (see (a)–(b) above). Therefore, the inductive hypothesis applies to the interval τ3 for the largest packet size transmitted by GreedyDiv equal to m and OFF’ in the place of OFF:

2L GreedyDiv (τ3 ) ≥ L OFF (τ3 ) − 14 f m .

(7)

Next, recall that OFF’ differs from OFF only such that it cannot transmit packets of sizes smaller than m+1 , which appear in the queue of OFF at time t 1 , of total size qOFF (< m + 1, t 1 ) and packets removed from the queues of OFF’ at t 2 of total size at most f m+1 . Thus,

L OFF (τ2 ∪ τ3 ) ≥ L OFF (τ2 ∪ τ3 ) − qOFF (< m + 1, t 1 ) − f m+1 .

(8)

The inequalities (5)–(7) summed up yield:

2L GreedyDiv (τ ) ≥ L OFF (τ1 ) + L OFF (τ2 ∪ τ3 ) + qOFF (< m + 1, t 1 ) − 7m+1 − 14m

≥ L OFF (τ ) − 14m+1 , where the second inequality follows from (8) and from the divisibility property implying m+1 ≥ 2m .

2

Given the above lemmas, we can prove the main result of this section. Theorem 2. The competitive throughput of GreedyDiv is equal to 1/2 with the additive constant O ( f k ), provided li /li −1 ∈ N for each i ∈ [2, k]. Proof. Let us split an execution of GreedyDiv into intervals τ1 , τ1 , τ2 , τ2 , . . . such that GreedyDiv is idle for the whole τi and it is busy for the whole τi for each i ≥ 1, each interval but (possibly) τ1 is non-empty. As GreedyDiv is idle only in the case that the size of all packets in its queues is smaller than f k ,

L GreedyDiv (t ) ≥ L OFF (t ) − f k for each t ∈ τi , i ≥ 1. For the sake of analysis assume that OFF has successfully transmitted all packets injected before the starting time t of a busy interval τi = [t , t  ] for i ≥ 1 and OFF does not transmit any packet in time intervals in which it actually transmits

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.9 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

9

those packets injected before t. Note that the actual total size of packets transmitted in [0, t  ] by OFF for t  ∈ τi is not larger than the total size of packets transmitted by OFF in [0, t  ] under the additional assumption that OFF has successfully transmitted all packets injected before the starting time t of τi . With the above assumption, GreedyDiv is k-busy against OFF in τi . Lemma 3 and the fact that GreedyDiv is idle only in the case that the total size of packets in its queue is smaller than f k imply that:

L GreedyDiv (t ) ≥ L OFF (t ) − f k 2L GreedyDiv ([t , t  ]) ≥ L OFF ([t , t  ]) − 14 f k for each t  ∈ [t , t  ]. Thus, 2L GreedyDiv (t  ) ≥ L OFF (t ) − 15 f k which finishes the proof.

2

As γ defined in Theorem 1 is equal to 1/2 when the divisibility property is satisfied, Theorems 1 and 2 directly imply the following corollary. Corollary 1. The algorithm GreedyDiv achieves the optimal competitive throughput on f ≥ 1 channels with additive constant O ( f k ) provided that the divisibility property is satisfied, i.e., i /i −1 ∈ N for each i ∈ [2, k]. 3.3. Packet scheduling for arbitrary sizes of packets and one channel In this section we discuss an application of the ideas behind the algorithm GreedyDiv (Algorithm 1, page 6) to the general case, i.e., when the divisibility property is not satisfied. However, from now on, we restrict to the model with one communication channel. A natural generalization of GreedyDiv would be that, instead of ρi ,i −1 = i /i −1 groups of packets of size i −1 on the i-th level of recursion, we make recursive calls on the (i − 1)st level of recursion, until the size of transmitted packets is at least i (“rounding up”) or until the size of transmitted packets is at least i − i −1 (“rounding down”). However, the advantage of OFF over GreedyDiv following from rounding does not allow GreedyDiv to achieve the competitive throughput γ from Theorem 1, as illustrated in the following example. Example 1. First, consider the “rounding up” approach. Let k = 2 and let the sizes of packets be 1 = 17 and 2 = 50. Assume that three 1 -packets and two 2 -packets are injected at times t 0 , t 1 , . . . , tn−1 for t i = 100i and arbitrary n ∈ N . Moreover, crashes appear at times t 0 , . . . , tn and at times tn + 17 j for each natural j > 0. Then, it is possible to transmit all 2n copies of 2 -packets and all 3n copies of 1 packets which gives packets of total size 151n. The greedy approach with rounding up works as follows. In each interval [t i , t i +1 ] for i ∈ [0, n − 1], the online algorithm first transmits three 1 -packets which lasts 51 units of time and then unsuccessfully attempts transmitting 2 -packet. There are no 1 -packets in its queue at tn and therefore the algorithm does not transmit any more packets. Total size of transmitted packets is 51n. Thus, the competitive throughput is at most 51/151 ≈ 0.338. On the other hand,

γ=

ρ2,1  ≈ 0.405, ρ2,1  + ρ2,1

where ρ2,1 = 50/17. Now, consider the “rounding down” approach. Let k = 3 and let the sizes of packets be 1 = 30, 2 = 41 and 4 = 100. Assume that two 1 -packets, one 2 -packet and one 3 -packet are injected at times t 0 , t 1 , . . . , tn−1 for t i = 100i and arbitrary n ∈ N . Moreover, crashes appear at times t 0 , . . . , tn and at times tn + 30 j for each natural j > 0. Then, it is possible to transmit all n copies of 3 -packets and all 2n copies of 1 packets which gives packets of total size 160n. The greedy approach with rounding down works as follows. In each interval [t i , t i +1 ] for i ∈ [0, n − 1], the online algorithm first transmits two 1 -packets which lasts 60 units of time and then unsuccessfully attempts transmitting 2 -packet. There are no 1 -packets in its queue at tn and therefore the algorithm does not transmit any more packets successfully. Overall, the size of transmitted packets is 60n. Thus, the competitive throughput is at most 60/160 = 0.375. On the other hand,

γ= where

ρ2,1  ≈ 0.423, ρ2,1  + ρ2,1

ρ2,1 = 41/30. 2

Given weaknesses of the algorithm GreedyDiv, we design and analyze its modified version called Greedy. The pseudocode of the algorithm Greedy is given in Algorithm 3 and the pseudo-code of its recursive subroutine TransmitGroup is given in Algorithm 4. In the pseudo-codes, ni denotes the number of i -packets in the queue. In order to overcome limitations of the approach described above, we keep sending packets of a fixed size i in an interval of size ≥ c k for some large enough constant c, specified later. Let a phase denote a time interval τ = [t 1 , t 2 ] such that errors occur at t 1 (or t 1 = 0)

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

Algorithm 3 Greedy.

c : the constant determined by

1: C ← {i | ni i ≥ c k } 2: loop 3: while {i | i ni ≥ c k } = ∅ do Stay idle 4:

[m3G; v1.260; Prn:26/08/2019; 15:12] P.10 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

10

γ , see (10)

ni : the number of awaiting i -packets

An execution of Algorithm 4

TransmitGroup

Algorithm 4 TransmitGroup. 1: 2: 3:

C ← {i | i ni ≥ c k } i ← min(C ) for a = 1 to c k /i do Transmit i

and at t 2 and there are no errors inside [t 1 , t 2 ]. At the beginning of a phase, the set C = {i | ni i ≥ c k } of sizes of packets is determined, where ni denotes the number of i -packets in the queue. Then, the interesting size i is set i = min(C ) when C becomes nonempty and the algorithm starts transmitting i -packets for the interval of size c k or until a crash (if the crash appears earlier). The interesting size can change only if a crash occurs or c k /i packets of size i are successfully transmitted. As the total size of packets in the queue whose sizes are not interesting is at most k · c k , these packets increase only the additive constant, not the value of the competitive throughput. In the following theorem, we prove that Greedy achieves optimal competitive throughput (see also Theorem 1). Theorem 3. Greedy achieves the optimal competitive throughput



γ = min

1≤ j
 ρi , j  , ρi , j  + ρi , j

where ρi , j = i / j . The remaining part of this section is devoted to a proof of Theorem 3. The key part of the proof is given in Lemmas 4, 5 and 6, analogs of Lemmas 1, 2 and 3. Here, we have to deal with the fact that divisibility property is not satisfied. On the other hand, our modified algorithm does not guarantee O (k ) additive constant. Therefore, evaluation of additive constants will be simpler. ρ Let δi , j = ρi, j  and let δ = maxi > j {δi , j }. Then, the constants γ and δ satisfy: i, j



γ = min

1≤ j
ρi , j  ρi , j  + ρi , j

 =

1 1+δ

.

(9)

The constant c from the algorithm Greedy is set as the smallest natural number such that c −c 1 ≥ 1δ , i.e.,



c = min c  ∈ N |

c − 1 c

≥

1

δ



.

(10)

As we consider the case that the divisibility property is not satisfied, the constant δ is strictly larger than 1. Therefore, the constant c satisfying the above property can be chosen. We say that a phase τ = [t 1 , t 2 ] is short when t 2 − t 1 ≤ c k and a phase is long otherwise. Below, we prove analogs of Lemmas 1–3 for Greedy. Lemma 4. Assume that Greedy is m-busy in a time interval τ = [t 1 , t 2 ], m ≤ k. Then, δ · L Greedy (τ ) ≥ L OFF (≥ m, τ ) − 2c k . Proof. First, consider any i -packet, for i ≥ m, successfully transmitted by OFF in a short phase included in τ . Then, Greedy calls TransmitGroup and sends consecutive i -packets for a fixed i ≤ m ≤ i during the whole transmission of i by OFF. And, there are at least ρi ,i  = i /i  successful transmissions of i -packets by Greedy during a transmission of each i -packet by OFF. Thus, a successful transmission of size i by OFF corresponds to successful transmissions of size

ρi ,i 

ρi ,i

i =

1

δi ,i

1

i ≥ i δ

by Greedy. Now, consider packets transmitted by OFF in a long phase τ  ⊆ τ of size  ≥ c k such that the size of its intersection with τ is  ≥ c k . As Greedy is m-busy, it successfully transmits packets of size L Greedy (τ  ) ≥  − m inside τ  , while OFF transmits packets of size L OFF (τ  ) ≤ . Thus,

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.11 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

11

Fig. 4. The subintervals considered in Lemma 6.

L Greedy (≥ m, τ  ) L OFF (≥ m, τ  )

≥

 − m (c − 1)k c − 1 ≥ ≥ 1/δ, ≥  c k c

where the last inequality follows from (10). The above analyzed cases do not apply to such a phase that the size of its intersection with τ is at most c k . Therefore, we exclude them from the above consideration which corresponds to the subtrahend −2c k in the final inequality in the lemma. 2 Lemma 5. Assume that Greedy is m-busy in a time interval Then,

τ = [t 1 , t 2 ], m ≤ k and Greedy starts transmitting an m -packet at t 2 .

(1 + δ) L Greedy (τ ) ≥ L OFF (τ ) + qOFF (< m, t 2 ) − (m + 3) · c k . Proof. By Lemma 4

δ · L Greedy (τ ) ≥ L OFF (≥ m, τ ) − 2c k .

(11)

Note also that (a) as Greedy starts transmitting an m -packet at t 2 , qGreedy (< m, t 2 ) < (m − 1)c k , (b) qGreedy (< m, t 1 ) ≥ qOFF (< m, t 1 ) by the definition of an m-busy interval. Observe also that

L Greedy (< m, τ ) ≥ qGreedy (< m, t 1 ) + I (< m, τ ) − qGreedy (< m, t 2 ) − m−1 ,

(12)

where the subtrahend m−1 corresponds to a packet (if any) whose transmission started before t 2 , but finished after t 2 . Moreover,

L OFF (< m, τ ) ≤ qOFF (< m, t 1 ) + I (< m, τ ) − qOFF (< m, t 2 ) + m−1 ,

(13)

where the summand m−1 corresponds to a packet whose transmission (possibly) started before By combining (12)-(13) with (a)-(b) we get

L Greedy (< m, τ ) ≥ L OFF (< m, τ ) − (m − 1)c k + qOFF (< m, t 2 ) − 2m−1 . The lemma holds by combining (11), (14) and the inequalities m−1 ≤ k ≤ c k .

τ and finished in τ . (14)

2

Consider a time interval τ which is m-busy for Greedy, for some m ∈ [k]. Using previous lemmas, we prove by induction that the total size of packets transmitted by OFF (minus some constant) in τ is at most 1 + δ times larger than the total size of packets transmitted by Greedy in τ . Lemma 6. Assume that Greedy is m-busy in a time interval τ , for m ≤ k. Then,

(1 + δ) L Greedy (τ ) ≥ L OFF (τ ) − 3k2 c k . Proof. The proof goes by induction with respect to m. For m = 1 the result is an immediate consequence of Lemma 4, since L OFF (≥ 1, τ ) = L OFF (τ ). For the inductive step, assume that the lemma holds for some m < k. We will show the correctness of the lemma for the case that the largest size of a packet sent by Greedy in τ is m+1 . We split τ = [t 0 , t 3 ] into three subintervals (see Fig. 4):

• τ1 = [t 0 , t 1 ), where t 1 is the last time during τ at which Greedy starts a transmission of m+1 ; • τ2 = [t 1 , t 2 ) such that either Greedy finishes a successful transmission (which started at t 1 ) of m+1 at t 2 or this transmission of m+1 is interrupted by an error at t 2 ;

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.12 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

12

• τ3 = [t 2 , t 3 ]. Lemma 5 implies that

(1 + δ) L Greedy (τ1 ) ≥ L OFF (τ1 ) + qOFF (< m + 1, t 1 ) − (m + 4) · c k . Consider OFF’ which transmits the same packets as OFF in

(15)

τ with the following exception: OFF’ starts τ2 without

i -packets for each i < m + 1, and it stays idle each time OFF is transmitting a packet which was in its queue at the beginning of τ2 and therefore it was not in the queue of OFF’. Note that the size of τ2 is at most m+1 . Therefore, L OFF (τ2 ) ≤ m+1 ≤ k , and consequently,

(1 + δ) L Greedy (τ2 ) ≥ 0 ≥ L OFF (τ2 ) − k .

(16)

At the beginning of τ3 , it holds that qGreedy (i , t 2 ) ≥ qOFF (i , t 2 ) for each i ≤ m, since Greedy did not transmit i -packets for i ≤ m during τ2 and OFF starts τ2 without packets of sizes smaller than m+1 . Therefore, the inductive hypothesis applies to the interval τ3 for the largest packet size transmitted by Greedy equal to m and OFF’ in the place of OFF:

(1 + δ) L Greedy (τ3 ) ≥ L OFF (τ3 ) − 3m2 · c k .

(17)

Next, recall that OFF’ transmits the same packets as OFF apart from packets of sizes smaller than m+1 , which appear in the queue of OFF at time t 1 ; the total size of those packets is equal to qOFF (< m + 1, t 1 ). Thus,

L OFF (τ2 ∪ τ3 ) ≥ L OFF (τ2 ∪ τ3 ) − qOFF (< m + 1, t 1 ) .

(18)

The inequalities (15)–(17) summed up yield:

(1 + δ) L Greedy (τ ) ≥ L OFF (τ1 ) + L OFF (τ2 ∪ τ3 ) + qOFF (< m + 1, t 1 ) − (m + 4) · c k − k − 3m2 · c k ≥ L OFF (τ ) − 3(m + 1)2 · c k , where the second inequality follows from (18) and the fact that 3m2 + m + 4 + 1/c ≤ 3(m + 1)2 for c , m ≥ 1.

2

Now, we can prove Theorem 3 using Lemma 6 similarly as Lemma 3 was used in the proof of Theorem 2. The formal proof of Theorem 3 is presented below. Proof of Theorem 3. Let us split an execution of Greedy into the intervals τ1 , τ1 , τ2 , τ2 , . . . such that Greedy is idle for the whole τi and it is busy for the whole τi for each i ≥ 1, each interval but (possibly) τ1 is non-empty. As Greedy is idle only in the case that the size of all packets in its queues is smaller than ckk ,

L Greedy (t ) ≥ L OFF (t ) − ckk for each t ∈ τi , i ≥ 1. For the sake of analysis assume that OFF has successfully transmitted all packets injected before the starting time t of a busy interval τi = [t , t  ] for i ≥ 1 and OFF does not transmit any packet in time intervals in which it actually transmits those packets injected before t. Note that the actual total size of packets transmitted in [0, t  ] by OFF for t  ∈ τi is not larger than the total size of packets transmitted by OFF in [0, t  ] under the additional assumption that OFF has successfully transmitted all packets injected before the starting time t of τi . With the above assumption, Greedy is k-busy against OFF in τi . Lemma 6 and the fact that Greedy is idle only in the case that the total size of packets in its queue is smaller than ckk imply that:

L Greedy (t ) ≥ L OFF (t ) − ckk

(1 + δ) L Greedy ([t , t  ]) ≥ L OFF ([t , t  ]) − 3k2 c k for each t  ∈ [t , t  ]. Thus, (1 + δ) L Greedy (t  ) ≥ L OFF (t  ) − (3k2 + k)c k which implies that the competitive throughput of Greedy is at least

1 1+δ

=γ,

by (9). On the other hand, the competitive throughput of any online algorithm is at most imply correctness of Theorem 3. 2

γ , by Theorem 1. These two facts

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.13 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

13

4. An algorithm for a scenario with speedup In this section, our goal is to determine the smallest s ≥ 1 such that there exists an online algorithm whose competitive throughput is equal to 1, provided that the algorithm works with speedup s. A natural conjecture is that there is linear scalability of competitive throughput with the increase of speedup. In order to illustrate this conjecture, let us consider the case that the divisibility property is satisfied. Given that the optimal competitive throughput with no speedup is equal to 12 , we expect that the competitive throughput gradually increases with speedup and reaches the value 1 for speedup 2. The four popular algorithms analyzed in [8] in the model with k ≥ 2 lengths of packets attain the competitive throughput 1 only in the case that speedup is ≥ ρ ≥ k /1 . This fact implies that the algorithms analyzed in [8] are not scalable with resource augmentation. The greedy protocols from the previous section do not achieve the competitive throughput 1 with speedup 2, either. As shown in the following example, the competitive throughput of greedy algorithms from Section 3 with speedup 2 is at most 2/3. Example 2. Consider the scenario with two types of packets of sizes 1 = 1 and 2 = 3. Assume that an adversary:

• injects six 1 -packets and one 2 -packet at times i 2 for i = 0, 1, . . . , n − 1, • makes errors at i 2 for i = 0, 1, . . . , n and at n2 + j 1 for j ≥ 0, where n is an arbitrary large natural number. The algorithm Greedy will transmit only 1 -packets of total size 6n1 for this injection and error patterns, while it is possible to transmit all packets, of total size 6n1 + n2 = 9n1 . 2 Given weaknesses of the above described algorithms, we design a new algorithm Prudent (Algorithm 5 on page 14) adjusted to the model with speedup. We distinguish between the divisible case which corresponds to the model in which the divisibility property is satisfied and the general case, where the lengths of packets are arbitrary. In Section 4.2 we show that speedup 2 is in fact sufficient in the divisible case. More precisely, we show that the algorithm Prudent achieves the competitive throughput 1 with speedup s = 2 for the divisible case. Then, we show that Prudent achieves the competitive throughput 1 in the general case with speedup s ∈ [4, 6) depending on the actual sizes of packets. However first, in Section 4.1, we provide a high level description of the algorithm. 4.1. The idea of an algorithm with speedup As before, let a phase be a time interval between two consecutive errors. The idea of our algorithm is as follows: at each time t when a successful transmission of a packet ends, we start sending a packet of maximal size which does not exceed the total size of packets successfully sent in the current phase so far. This approach is based on the following intuition. Let  be the size of a phase. Assume that the queue of packets is not empty at each time t of that phase. Then, if the proposed algorithm has sent at least one packet during the phase, the time interval corresponding to successful transmissions is at least 12 of the size of the phase . As the speedup s satisfies s ≥ 2, the online algorithm transmits packets of total size not smaller than the size  of the phase, while the (offline) algorithm working without speedup (i.e., with speedup s = 1) can send packets of total size at most . Note that the above strategy implies that, if the online algorithm has transmitted packets of total size ≥ k in a phase, it transmits the packets of the largest size in its queue in the remaining part of that phase. Therefore, we split a phase into the preamble and the tail. The preamble consists of the initial part of the phase which ends when the total size of packets successfully transmitted by our algorithm is at least k . The tail consists of the remaining part of the phase. Two issues remain unclear in the above idea: how to choose the first packet to send in a phase and how to deal in the analysis with phases in which the online algorithm does not send successfully any packet, while the offline algorithm without speedup can send some packets in such phases. The former issue is resolved by preferring small packets. That is, we start from transmitting small packets. However, in order to facilitate the formal analysis of the competitive throughput, we consider only such sizes of packets i that the number of i -packets in the queue is sufficient to finish the preamble using i -packets only (see line 4 in Algorithm 5). The latter issue (i.e., 0 competitive throughput in the phases in which our online algorithm does not send any packet successfully) makes the actual analysis much more complicated than the idea described above. As we are not able to guarantee that the size of packets transmitted by our algorithm is larges than the size of packets transmitted by OFF in each phase, our actual proofs (inductively) show that the total size of packets with sizes ≥ k−i transmitted by our online algorithm is larger than the total size of those packets transmitted by OFF for i = 0, 1, . . . , k − 1, on the whole execution. 4.2. The algorithm and its analysis In this section we analyze the algorithm Prudent which implements the above described ideas. It achieves competitive throughput 1 for appropriate speedup, depending on the sizes of packets. The pseudocode of a phase of Prudent is presented in Algorithm 5. In the pseudocode, ni denotes the number of i -packets in the queue at a given time. We split a phase into:

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.14 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

14

One phase of the algorithm

Algorithm 5 Prudent.

ni : number of awaiting i -packets The void prefix

1: while {i | i ni ≥ k } = ∅ do 2: Stay idle 3: 4: 5: 6: 7: 8: 9: 10: 11:

L sent ← 0 I ← {i | i ni ≥ k } i ← min( I ) j←i while L sent < k do transmit (i +1 − L sent )/ j  packets of size  j ; L sent ← L sent + (i +1 − L sent )/ j  ·  j i ← max{ p |  p ≤ L sent } j ← max{ p | p ∈ I and p ≤ i }

The preamble

The tail

12: loop 13: transmit a packet of the largest size in the queue

• the void prefix in which the algorithm stays idle, since the set I = {i | i ni ≥ k } is empty (line 1 of the algorithm); • the preamble (lines 3–11) in which the algorithm chooses packets with size smaller or equal to the size of already transmitted packets (which is smaller than k ); • the tail (lines 12–13) in which the algorithm (after sending packets of total size ≥ k ) always transmits a packet with the largest size from its queue. Note that the preamble ends when the size of transmitted packets is (at least) k or at the end of the phase – if the error appears when the size of packets successfully transmitted is smaller than k . Moreover, the algorithm is not idle at any time during the preamble. Observe also that the i -packets for i ∈ [k] are considered for transmission in the preamble only for the case that the number of these packets is sufficient to cover the whole preamble (i.e., there are k /i  copies of i -packets at the beginning of the preamble). Now, we introduce some auxiliary notations. Using these notations, we determine the speedup for which our algorithm achieves the competitive throughput 1 in the general case. A sequence of natural number (a1 , . . . , a j ) for j ≤ k is Prudent-consistent when the following conditions are satisfied:

• a j > 0,  p −1  p −1 • for each p ∈ [2, j − 1]: if a p = 0 then a  = 0 or  p ≤ a  < 2 p . j =0 j j j =0 j j Observe that, if Prudent sends in a preamble a1 packets of length 1 , followed by a2 packets of length 2 and so on until sending a j > 0 packets of lengths  j , then the sequence (a1 , . . . , a j ) is Prudent-consistent. Indeed, the latter condition in the definition of a Prudent-consistent sequence corresponds to the fact that an  p -packet can be transmitted in a preamble either as the first one or at the earliest time when the size of smaller packets transmitted so far (in the considered preamble) is larger or equal to  p . Let

si

i 

= max{

j =1 a j  j

|

0 < i  < i , (a1 , . . . , ai  ) is Prudent-consistent,

i 

j =1 a j  j

≥ i and

i 

j =1 a j  j

− i  < i }.

Note that si corresponds to the largest possible size of packets transmitted in a preamble before the first transmission of an i -packet in that preamble, provided that a packet of size smaller than i is chosen as the first in the preamble. Now, we put βi = si /i . That is, the size of the longest possible prefix of a preamble before an i -packet can be transmitted is si = βi i , provided that the preamble started by sending a packet whose size is smaller than i . Finally, let β = maxi ∈[k] {βi }. It is clear from the definition that i ≤ si < 2i for each i ∈ [k] and therefore 1 ≤ β < 2. Theorem 4. For any algorithm OFF and at any time t,

L Prudent (t ) ≥ L OFF (t ) − 5kk , provided that the algorithm Prudent works with speedup s = 2 + 2β or the algorithm Prudent works with speedup s = 2 and i /i −1 ∈ N for each i ∈ [2, k]. In the following part of this section we present a formal proof of Theorem 4. Therefore, we assume that Prudent works with speedup s specified in the theorem. First, we make an observation regarding the divisible case. We show that Prudent finishes successful transmissions of packets after specific intervals of time, starting from the beginning of the preamble. Proposition 1. Assume that the divisibility property is satisfied and Prudent works with speedup s = 2. Moreover, assume that Prudent starts the preamble of a phase at tb , by transmitting an i -packet for some i ∈ [k]. Then, Prudent finishes a transmission of a packet at

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.15 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

15

tb + c  j /2 for each i ≤ j < k and natural c ≤  j +1 / j such that tb + c  j /2 ≤ t e , where [tb , t e ] is the time interval of the considered phase. Proof. The statement can be proved inductively for j = i , i + 1, . . . , k. Certainly, successful transmission end at tb + c i /2 for each c ∈ [1, i +1 /i ] such that tb + c i /2 ≤ t e . Now, assume that successful transmissions end at tb + c  j /2 for j ∈ [i , k − 2] and each c ∈ [1,  j +1 / j ] such that tb + c  j /2 ≤ t e . In particular, if t e ≥ tb +  j +1 /2, a successful transmission ends at

tb + ( j +1 / j ) ·  j /2 = tb +  j +1 /2. At tb +  j +1 /2, the algorithm chooses j  ∈ [i , j + 1] and sends ( j +2 −  j +1 )/ j  packets of the size  j  . Thus, in particular, the algorithm finishes successful transmissions at tb + c  j +1 /2 for c = 2, 3, . . . ,  j +2 / j +1 . The last of these transmissions is  finished at tb +  j+2 ·  j +1 /2 = tb +  j +2 /2. 2 j +1

In the proof of Theorem 4, we consider potential gain of OFF over Prudent restricted to k − i largest sizes of packets for i = k − 1, . . . , 0. The proof is inductive. Proposition 2, the base of the induction, shows that Prudent sends at least as many k -packets as OFF. Then, in Proposition 3, we make the inductive step. Proposition 2. L Prudent (k, t ) ≥ L OFF (k, t ) for any time t, provided that Prudent works with speedup s ≥ 2 in the divisible case and s ≥ 2 + 2β in the general case. Proof. Suppose for a contradiction that L Prudent (k, t ) < L OFF (k, t ) for some time t. Let t be the earliest time such that L Prudent (k, t ) < L OFF (k, t ). Thus, OFF just finishes a transmission of an k -packet at t and therefore:

• there were no errors in the interval τ = [t − k , t ], • an k -packet was in the queue of OFF and in the queue of Prudent at t − k . (Indeed, otherwise Prudent has less k -packets in its queue than OFF at t − k and no more k -packets than OFF at t. This in turn contradicts the choice of t.) Note that the preamble lasts at most k /2 in the divisible case and βk /s ≤ k /2 in the general case. Thus, either Prudent has transmitted enough packets until t − k /2 to send k -packets or, for each j < k, the inequality n j  j < k was satisfied at time t − k . (Recall that, as we argued earlier, Prudent has an k -packet in its queue at t − k .) Therefore, in both cases, Prudent would finish a transmission of an k -packet in (t − k , t ]. This fact contradicts the choice of t and therefore L Prudent (k, t ) is not smaller than L OFF (k, t ). 2 Proposition 3. For any time t and any 1 ≤ i < k, if

L Prudent (≥ j , t ) ≥ L OFF (≥ j , t ) − 5(k − j )k , for all j > i then

L Prudent (≥ i , t ) ≥ L OFF (≥ i , t ) − 5(k − i )k .

(19)

Proof. Packets of sizes ≥ i are called large and packets with sizes < i are called small throughout the proof. First, we characterize some cases which easily lead to correctness of the proposition. Claim 1. Proposition 3 is satisfied if, for some t  ∈ (t − 3k , t ), one of the following conditions holds: (a) (b) (c) (d)

Prudent is idle at t  , Prudent is in the tail at t  and it starts transmitting a small packet, Prudent is in the preamble at t  , it is after the initial interval of size i /2 of the preamble and it starts transmitting a small packet, Prudent starts the preamble at t  and it chooses to transmit  j -packet for j > i.

Proof of Claim 1. Each of the above conditions implies that the total size of i -packets in the queue of Prudent at some t  ∈ [t  −k /2, t  ] is smaller than k . Indeed, (a), (b) and (d) imply that L Prudent (i , t  ) ≤ k which, combined with the assumption of the proposition, implies (19). In (c), the algorithm has already transmitted packets of size ≥ si /2 ≥ i in the preamble. Thus, the choice of a small packet in (c) means that the total size of i -packets is smaller than k at the beginning t  ∈ [t  −k /2, t  ] of the (current) preamble. Hence, L Prudent (i , t  ) ≥ L OFF (i , t  ) − k , and, since t  − t  ≤ k ,

L Prudent (i , t  ) ≥ L OFF (i , t  ) − 2k .

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.16 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

16

Table 1 Description of the cases considered in the proof of Proposition 3, where tb denotes the beginning of a phase. Case

How/where handled

(a), (b), (c) or (d) t − t b < i t − tb > 3k t − tb ∈ [i , 3k ]

Claim 1 OFF does not transmit large packets Claim 2 Claim 3

As OFF can transmit i -packets of size at most 3k in [t  , t ] for t  ∈ (t − 3k , t ), the above inequality implies that L Prudent (i , t ) ≥ L OFF (i , t ) − 5k and, by the assumption hypothesis,

L Prudent (≥ i , t ) = L Prudent (i , t ) + L Prudent (≥ i + 1, t )

≥ L OFF (i , t ) − 5k + L OFF (≥ i + 1, t ) − 5(k − (i + 1))k = L OFF (≥ i , t ) − 5(k − i )k . (Claim 1)

2

Given Claim 1, it is sufficient to consider the case that the above conditions (a)-(d) do not hold. Suppose for a contradiction that t is the earliest time at which the inequality (19) does not hold. Let tb < t be the beginning of the phase containing time t, let τ = [tb , t ). The further proof is split into the cases determined by the value of tb − t, described in the Table 1, where all the cases except the first one are considered under the assumption that none of the conditions (a)–(d) is satisfied. If t − tb < i then OFF does not send any large packet in [tb , t ), and we get contradiction with the assumption that t is the smallest value for which the claimed inequality (19) does not hold. In the remaining part of the proof, we consider separately the case that t − tb > 3k and the case that t − tb ≤ 3k (see Table 1). First, we consider the case that t − tb > 3k . Claim 2. If t − tb > 3k and the conditions (a)-(d) do not hold, then L Prudent (≥ i , [t − 3k , t ]) ≥ L OFF (≥ i , [t − 3k , t ]). Proof. First, consider the divisible case. As the conditions (a)-(d) do not hold, Prudent could transmit small packets only during the preamble (of size ≤ k /2, since Prudent works with speedup s = 2) and only the last transmission lasting at most k /2 might be unsuccessful. Thus, Prudent transmits large packets of size at least

2(t − tb − 2 ·

k 2

) ≥ 2(3k − k ) = 4k

in the interval [t − 3k , t ]. On the other hand, OFF transmits large packets of size at most 3k during [t − 3k , t ]. Now, consider the general case with arbitrary sizes of packets and s = 2 + 2β . As the conditions (a)-(d) do not hold, Prudent could transmit small packets only during the preamble of size ≤ βk /s and can lose the last transmission lasting at most k /s. Thus, Prudent transmits large packets of size ≥ s(3k − k /s − βk /s) ≥ 4k during [t − 3k , t ] for s = 2 + 2β . On the other hand, OFF transmits large packets of size at most 3k during [t − 3k , t ]. (Claim 2) 2 Claim 2 shows that the inequality t − tb > 3k contradicts the assumption that t is the earliest time moment at which (19) is not satisfied. As the case t − tb < i has been excluded as well (see Table 1), we can assume that the items (a)–(d) do not hold and i ≤ t − tb ≤ 3k , where tb is time at which Prudent starts the preamble. The following claim finishes the proof of Proposition 3 and Theorem 4. Claim 3. Assume that the items (a)-(d) do not hold and i ≤ t − tb ≤ 3k . Then, L Prudent (≥ i , [tb , t )) ≥ L OFF (≥ i , [tb , t )). Proof. The divisible case. The assumptions of the claim imply that Prudent starts the preamble at tb by choosing  j -packet for j ≤ i (see (d)) and it finishes transmitting small packets exactly at tb + i /2, according to Proposition 1 and the assumption that (c) does not hold. Now, we show that the total size of large packets transmitted by Prudent in [tb , tb + d] is not smaller than the total size of large packets transmitted by OFF in [tb , tb + d] for each d such that d ∈ [i , 3k ]. By Proposition 1 and (c)–(d), the following properties Prudent sends large packets in [tb +i /2, tb + c  j /2], it starts transmitting a packet at tb +i /2 and it finishes transmitting a packet at tb + c  j /2. hold for each j ∈ [i , k − 1] and c ∈ [2,  j +1 / j ] as well as for j = k and each c such that c k /2 ≤ d (since we assume that (c) does not hold). Thus, for each natural j ≥ i, natural c ∈ [2,  j +1 / j ] and real d ∈ [c  j /2, (c + 1) j /2):

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.17 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

17

• Prudent transmits large packets of size at least

 2

c j 2

−

i

 = c  j − i ,

2

(20)

in [tb , tb + d), • as the sizes of large packets are divisible by i , the size of large packets successfully transmitted by OFF in [tb , tb + d) is not larger than c  i < (c + 1) j /2 for the largest c  ∈ N satisfying this inequality, since d < (c + 1) j /2. One can check that

c  i =

⎧ ⎨

(c +1) j

⎩

(c +1) j

2 2

− i −

i 2

for odd c ,

(21)

for even c .

Therefore, (20) and (21) imply that the size of large packets transmitted by Prudent is at least the size of large packets transmitted by OFF in [tb , tb + d), because:

• c ≥ c+2 1 , for odd c ≥ 1, • c  j − i ≥ c+2 1  j − 2i for even c ≥ 2 and j ≥ 2. The general case. In the general case, transmissions of small packets by Prudent ends at

t  ≤ tb +

βi s

≤ tb +

i 2

,

provided (a)–(d) do not hold. Let us consider the size of large packets transmitted in [tb , tb + d] for d ≥ i . As Prudent always chooses a packet of size smaller or equal to the total size of packets transmitted so far in the phase, it does not transmit successfully (because of possible error) only in the suffix of the interval [tb , t b + d] of size ≤ d/s ≤ d/2. Therefore, Prudent

transmits successfully large packets for (at least) the interval tb +

βi s

, tb +

d 2

. And the size of large packets transmitted by

Prudent in [tb , tb + d) is at least



d 2

−

βi s

 ·s≥d

provided that s = 2 + 2β , while the size of packets transmitted by OFF is at most d.

(Claim 3)

2

By examination of various cases we have shown that the assumption that (19) does not hold at some t leads to contradiction. Thus, the statement of Proposition 3 is true. (Proposition 3) 2 5. Conclusion We presented efficient and reliable algorithms for online scheduling of packets of different sizes. The competitive throughput of the first algorithms is optimal for any fixed f ≥ 1 channels, provided that the lengths of packets satisfy the divisibility property. The second algorithm attains the optimal competitive throughput for arbitrary lengths of packets. However, this algorithm works only for one communication channel. Another algorithm achieves the competitive throughput 1 when run with speedup 2 if the divisibility property holds and speedup s ∈ [4, 6) in the general case. These results suggest linear scalability with speedup. A recent report [5] gives further improvement in determining the smallest speedup guaranteeing that the competitive throughput is equal to 1. The considered framework is very general, and therefore it leaves a number of open extensions for further study. For example, what is the competitive throughput if packet arrivals are modeled by a random process. In the case that there are just two different sizes of packets, it has been shown in [6] that, for some stochastic distributions of injections of packets, the competitive throughput is higher than 1/2. It would be interesting to give a characterization of the stochastic arrivals’ case for arbitrary number of packet sizes. Another interesting research direction is to consider restricted classes of arrival and/or error patterns, e.g., motivated by specific physical or mobility scenarios. Other extensions could involve packet deadlines, priorities, or dependencies between errors on various channels. Declaration of competing interest No conflict of interest.

JID:TCS AID:12122 /FLA

Doctopic: Algorithms, automata, complexity and games

[m3G; v1.260; Prn:26/08/2019; 15:12] P.18 (1-18)

P. Garncarek et al. / Theoretical Computer Science ••• (••••) •••–•••

18

Acknowledgement This research was supported by the National Science Centre, Poland, grant DEC-2012/06/M/ST6/00459. References [1] M. Ajtai, J. Aspnes, C. Dwork, O. Waarts, A theory of competitive analysis for distributed algorithms, in: Proceedings of the 35th Annual Symposium on Foundations of Computer Science (FOCS), IEEE, 1994, pp. 401–411. [2] L. Anantharamu, B.S. Chlebus, D.R. Kowalski, M.A. Rokicki, Deterministic broadcast on multiple access channels, in: Proceedings of the 29th IEEE International Conference on Computer Communications (INFOCOM), IEEE, 2010, pp. 146–150. [3] M. Andrews, L. Zhang, Scheduling over a time-varying user-dependent channel with applications to high-speed wireless data, J. ACM 52 (5) (Sept. 2005) 809–834. [4] B. Awerbuch, S. Kutten, D. Peleg, Competitive distributed job scheduling, in: Proceedings of the Twenty-Fourth Annual ACM Symposium on Theory of Computing (STOC), ACM, 1992, pp. 571–580. [5] M. Böhm, L. Jez, J. Sgall, P. Veselý, On packet scheduling with adversarial jamming and speedup, CoRR, arXiv:1705.07018, 2017. [6] A. Fernández Anta, C. Georgiou, D.R. Kowalski, J. Widmer, E. Zavou, Measuring the impact of adversarial errors on packet scheduling strategies, J. Sched. 19 (2) (2016) 135–152. [7] A. Fernández Anta, C. Georgiou, D.R. Kowalski, E. Zavou, Online parallel scheduling of non-uniform tasks: trading failures for energy, Theor. Comput. Sci. 590 (2015) 129–146. [8] A. Fernández Anta, C. Georgiou, D.R. Kowalski, E. Zavou, Competitive analysis of fundamental scheduling algorithms on a fault-prone machine and the impact of resource augmentation, Future Gener. Comput. Syst. 78 (2018) 245–256. [9] P. Garncarek, T. Jurdzinski, K. Lorys, Fault-tolerant online packet scheduling on parallel channels, in: 2017 IEEE International Parallel and Distributed Processing Symposium, IPDPS 2017, Orlando, FL, USA, May 29 - June 2, 2017, 2017, pp. 347–356. [10] T. Jurdzinski, D.R. Kowalski, K. Lorys, Online packet scheduling under adversarial jamming, in: Approximation and Online Algorithms - 12th International Workshop, WAOA 2014, Wrocław, Poland, September 11–12, in: Revised Selected Papers, vol. 2014, 2014, pp. 193–206. [11] C. Meiners, E. Torng, Mixed criteria packet scheduling, in: Algorithmic Aspects in Information and Management, 2007, pp. 120–133. [12] M.L. Pinedo, Scheduling: Theory, Algorithms, and Systems, Springer, 2012. [13] K. Pruhs, J. Sgall, E. Torng, Online Scheduling, CRC Press, 2003, pp. 115–124. [14] A. Richa, C. Scheideler, S. Schmid, J. Zhang, Competitive throughput in multi-hop wireless networks despite adaptive jamming, Distrib. Comput. (2012) 1–13. [15] D.D. Sleator, R.E. Tarjan, Amortized efficiency of list update and paging rules, Commun. ACM 28 (2) (1985) 202–208.