Title Better bounds for online k-frame throughput maximization innetwork switches

Author(s) Kawahara, Jun; Kobayashi, Koji M.; Miyazaki, Shuichi

Citation Theoretical Computer Science (2017), 657(Part B): 173-190

Issue Date 2017-01-02

URL http://hdl.handle.net/2433/226933

Right

© 2017. This manuscript version is made available under theCC-BY-NC-ND 4.0 licensehttp://creativecommons.org/licenses/by-nc-nd/4.0/; The full-text file will be made open to the public on 2 January 2019 inaccordance with publisher's 'Terms and Conditions for Self-Archiving'.; This is not the published version. Please cite onlythe published version. この論文は出版社版でありません。引用の際には出版社版をご確認ご利用ください。

Type Journal Article

Textversion author

Kyoto University

Better Bounds for Online k-Frame Throughput Maximization

in Network Switches ∗

Jun Kawahara1, Koji M. Kobayashi2, Shuichi Miyazaki31Graduate School of Information Science, Nara Institute of Science and Technology

2 Corresponding author, National Institute of Informatics,

2-1-2, Hitotsubashi, Chiyoda-ku, Tokyo, 1018430, Japan, kobaya@nii.ac.jp3Academic Center for Computing and Media Studies, Kyoto University

Abstract

We consider a variant of the online buffer management problem in network switches, calledthe k-frame throughput maximization problem (k-FTM). This problem models the situationwhere a large frame is fragmented into k packets and transmitted through the Internet, and thereceiver can reconstruct the frame only if he/she accepts all the k packets. Kesselman et al.introduced this problem and showed that its competitive ratio is unbounded even when k = 2.They also introduced an “order-respecting” variant of k-FTM, called k-OFTM, where inputsare restricted in some natural way. They proposed an online algorithm and showed that itscompetitive ratio is at most 2kB

⌊B/k⌋ + k for any B ≥ k, where B is the size of the buffer. They

also gave a lower bound of B⌊2B/k⌋ for deterministic online algorithms when 2B ≥ k and k is a

power of 2.In this paper, we improve upper and lower bounds on the competitive ratio of k-OFTM. Our

main result is to improve an upper bound of O(k2) by Kesselman et al. to 5B+⌊B/k⌋−4⌊B/2k⌋ = O(k)

for B ≥ 2k. Note that this upper bound is tight up to a multiplicative constant factor sincethe lower bound given by Kesselman et al. is Ω(k). We also give two lower bounds. First wegive a lower bound of 2B

⌊B/(k−1)⌋ + 1 on the competitive ratio of deterministic online algorithms

for any k ≥ 2 and any B ≥ k − 1, which improves the previous lower bound of B⌊2B/k⌋ by a

factor of almost four. Next, we present the first nontrivial lower bound on the competitive ratioof randomized algorithms. Specifically, we give a lower bound of k − 1 against an obliviousadversary for any k ≥ 3 and any B. Since a deterministic algorithm, as mentioned above,achieves an upper bound of about 10k, this indicates that randomization does not help toomuch.

Keywords: Buffer management; Online problem; Competitive Analysis; Packet Fragmentation

1 Introduction

When transmitting data through the Internet, each data is fragmented into smaller pieces, and

such pieces are encapsulated into data packets. Packets are transmitted to the receiver via several

switches and routers over a network, and are reconstructed into the original data at the receiver’s

side. One of the bottlenecks in achieving high throughput is processing ability of switches and

∗A preliminary version of this paper was presented at the 24th International Symposium on Algorithms andComputation (ISAAC 2013).

1

routers. If the arrival rate of packets exceeds the processing rate of a switch, some packets must be

dropped. To ease this degradation, switches are usually equipped with FIFO buffers that temporar-

ily store packets which will be processed later. In this case, the efficiency of buffer management

policies is important since it affects the performance of the overall network.

Aiello et al. [1] initiated the analysis of buffer management problem using the competitive

analysis [10, 31]: An input of the problem is a sequence of events where each event is an arrival

event or a send event. At an arrival event, one packet arrives at an input port of the buffer (FIFO

queue). Each packet is of unit size and has a positive value that represents its priority. A buffer

can store at most B packets simultaneously. At an arrival event, if the buffer is full, the new packet

is rejected. If there is room for the new packet, an online algorithm determines whether to accept

it or not without knowing the future events. At each send event, the packet at the head of the

queue is transmitted. The gain of an algorithm is the sum of the values of the transmitted packets,

and the goal of the problem is to maximize it. If, for any input σ, the gain of an online algorithm

ALG is at least 1/c of the gain of an optimal offline algorithm for σ, then we say that ALG is

c-competitive.

Following the work of Aiello et al. [1], there has been a great amount of work related to the

competitive analysis of buffer management. For example, Andelman et al. [5] generalized the two-

value model of [1] into the multi-value model in which the priority of packets can take arbitrary

values. Another generalization is to allow preemption, i.e., an online algorithm can discard packets

existing in the buffer. Results of the competitiveness on these models are given in [17, 32, 19,

4, 3, 12]. Also, management policies not only for a single queue but also for the whole switch

are extensively studied, which includes multi-queue switches [7, 5, 2, 6, 27, 9], shared-memory

switches [14, 18, 26], CIOQ switches [20, 8, 24, 21], and crossbar switches [22, 23]. See [13] for a

comprehensive survey.

Kesselman et al. [25] proposed another natural extension, called the k-frame throughput maxi-

mization problem (k-FTM), motivated by a scenario of reconstructing the original data from data

packets at the receiver’s side. In this model, a unit of data, called a frame, is fragmented into

k packets (where the jth packet of the frame is called a j-packet for j ∈ [1, k]) and transmitted

through the Internet. At the receiver’s side, if all the k packets (i.e., the j-packet of the frame

for every j) are received, the frame can be reconstructed (in such a case, we say that the frame is

completed); otherwise, even if one of them is missing, the receiver can obtain nothing. The goal

is to maximize the number of completed frames. Kesselman et al. [25] considered this scenario on

a single FIFO queue. They first showed that the competitive ratio of any deterministic algorithm

for k-FTM is unbounded even when k = 2 (which can also be applied to randomized algorithms

with a slight modification). However, their lower bound construction somehow deviates from the

real-world situation, that is, although each packet generally arrives in order of departure in a net-

work such as an IP network, in their adversarial input sequence the 1-packet of the frame fi arrives

prior to that of the frame fi′ , while the 2-packet of fi′ arrives before that of fi. Motivated by this,

they introduced more natural setting for the input sequence, called the order-respecting adversary,

in which, roughly speaking, the arrival order of the j-packets of fi and fi′ must obey the arrival

order of the j′-packets of fi and fi′ (j′ < j) (a formal definition will be given in Sec. 2). We call

this restricted problem the order-respecting k-frame throughput maximization problem (k-OFTM).

For k-OFTM, they showed that the competitive ratio of any deterministic algorithm is at least

B/⌊2B/k⌋ when 2B ≥ k and k is a power of 2. (Note that this ratio is Ω(k).) As for an upper

bound, they designed a non-preemptive algorithm called StaticPartitioning (SP ), and showed

that it is 2kB⌊B/k⌋ + k = O(k2)-competitive for any B ≥ k. They conjecture that the true competitive

2

ratio is Θ(k).

1.1 Our Results

In this paper, we present the following results:

(i) We design a deterministic algorithm Middle-Drop and Flush (MF ) for B ≥ 2k, and

show that its competitive ratio is at most 5B+⌊B/k⌋−4⌊B/2k⌋ . This ratio is O(k), which improves O(k2)

of Kesselman et al. [25] and matches the lower bound of Ω(k) up to a constant factor. Hence we

have solved their conjecture affirmatively.

(ii) For any deterministic algorithm, we give a lower bound of 2B⌊B/(k−1)⌋ + 1 on the competitive

ratio for any k ≥ 2 and any B ≥ k − 1. This improves the previous lower bound of B⌊2B/k⌋ by a

factor of almost four. Moreover, we show that the competitive ratio of any deterministic online

algorithm is unbounded if B ≤ k − 2.

(iii) In the randomized setting, we establish the first nontrivial lower bound of k− 1 against an

oblivious adversary for any k ≥ 3 and any B. This bound matches our deterministic upper bound

mentioned in (i) up to a constant factor, which implies that randomization does not help too much

for this problem.

1.2 Used Techniques

Let us briefly explain an idea behind our algorithm MF . The algorithm SP by Kesselman et al.

[25] works as follows: (1) It virtually divides its buffer evenly into k subbuffers, each with size

A = ⌊Bk ⌋, and each subbuffer (called j-subbuffer for j ∈ [1, k]) is used for storing only j-packets.

(2) If the j-subbuffer overflows, i.e., if a new j-packet arrives when A j-packets are already stored

in the j-subbuffer, it rejects the newly arriving j-packet (the “tail-drop” policy). It can be shown

that SP behaves poorly when a lot of j-packets arrive at a burst, which increases SP ’s competitive

ratio as bad as Ω(k2) (such a bad example for SP is given in Appendix A).

In this paper, we introduce two major ideas to develop a better algorithm. One is to modify the

tail-drop policy and employ the “middle-drop” policy, which preempts the (⌊A/2⌋+ 1)st packet in

the j-subbuffer and accepts the newly arriving j-packet. The other is to preempt all of the packets

satisfying some conditions at some moment, which we call the “flush” operation. The two ideas are

crucial in improving the competitive ratio to O(k), as explained in the following. MF partitions

the whole set of given frames into blocks BL1, BL2, . . ., each with about 3B frames, using the rule

concerning the arrival order of 1-packets. (This rule is explained in Sec. 3.1 at the definition of

MF , where the block BLi corresponds to the set of frames with the block number i.) Each block

is categorized into good or bad: At the beginning of the input, all the blocks are good. At some

moment during the execution of MF , if there is no more possibility of completing at least ⌊A/2⌋frames of a block BLi (as a result of preemptions and/or rejections of packets in BLi), then BLi

turns bad. In such a case, MF completely gives up BLi and preempts all the packets belonging to

BLi in its buffer if any (which is called the flush operation). Note that at the end of input, MF

completes at least ⌊A/2⌋ frames of a good block.

Consider the moment when the block BLi turns bad from good, which can happen only when

preempting a j-packet p (for some j) of BLi from the j-subbuffer. Due to the property of the

middle-drop policy, we can show that there exist two integers i1 and i2 (i1 < i < i2) such that

(i) just after this flush operation, BLi1 and BLi2 are good and all the blocks BLi1+1, BLi1+2, . . . ,

BLi2−1 are bad, and (ii) just before this flush operation, there exist two j-packets p1 and p2 in the

3

buffer such that p1 and p2 belong to BLi1 and BLi2 , respectively, and (iii) just before this flush

operation, all the j-packets of BLi (including p) each of which belongs to a frame that still has a

chance of being completed are located between p1 and p2. The above (ii) implies that even though

i2 may be much larger than i1 (and hence there may be many blocks between BLi1 and BLi2),

the arrival times of p1 and p2 are close (since p1 is still in the buffer when p2 arrived). This means

that j-packets of BLi1 through BLi2 arrived at a burst within a very short span, and hence any

algorithm (even an optimal offline algorithm OPT ) cannot accept many of them. In this way, we

can bound the number of packets accepted by OPT (and hence the number of frames completed by

OPT ) between two consecutive good blocks. More precisely, if BLi1 and BLi2 are consecutive good

blocks at the end of the input, we can show that the number of frames in BLi1 , BLi1+1, . . . , BLi2−1

completed by OPT is at most 5B+A−4 = O(B) using (i), (ii) and (iii). Recall that MF completes

at least ⌊A/2⌋ = Ω(B/k) frames of BLi1 since BLi1 is good, which leads to the competitive ratio

of O(k). (The formal definitions of good and bad blocks are given in Sec. 3.2 and the proof of

Lemma 3.9.)

1.3 Related Results

In addition to the above mentioned results, Kesselman et al. [25] proved that for any B, the

competitive ratio of a preemptive greedy algorithm for k-OFTM is unbounded when k ≥ 3. They

also considered the offline version of k-FTM and showed some approximation hardness results.

Recently, Kawahara and Kobayashi [16] proved that the optimal competitive ratio of 2-OFTM is

3, which is achieved by a greedy algorithm.

Scalosub et al. [30] proposed a generalization of k-FTM, called the max frame goodput problem.

In this problem, a set of frames constitutes a stream, and a constraint is imposed on the arrival

order of packets within the same stream. They established an O((kMB + M)k+1)-competitive

deterministic algorithm, where M denotes the number of streams. Furthermore, they showed that

the competitive ratio of any deterministic algorithm is Ω(kM/B).

Emek et al. [11] introduced the online set packing problem and pointed out that the problem

is related to k-FTM. This problem is different from k-FTM in that each frame may consist of

different number (at most kmax) of packets. Also, a frame f consisting of s(f) packets can be

reconstructed if s(f)(1 − β) packets are transmitted, where β (0 ≤ β < 1) is a given parameter.

There is another parameter c representing the capacity of a switch. At an arrival event, several

packets arrive at an input port of the queue. The switch can transmit c of them instantly, and

operates a buffer management algorithm for the rest of the packets (if any), that is, decides whether

to accept them. Emek et al. designed a randomized algorithm Priority, and showed that it is

kmax√σmax-competitive when β = 0 and B = 0, where σmax is the maximum number of packets

arriving simultaneously. They also derived a lower bound of kmax√σmax(log log k/ log k)

2 for any

randomized algorithm. If the number of packets in any frame is exactly k, Mansour et al. [28]

showed that for any β the competitive ratio of Priority is 8k√

σmax(1− β)/c. Moreover, some

variants of this problem have been studied [15, 29].

2 Model Description and Notation

In this section, we give a formal description of the order-respecting k-frame throughput maximization

problem (k-OFTM). A frame f consists of k packets p1, . . . , pk. We say that two packets p and q

belonging to the same frame are corresponding, or p corresponds to q. There is one buffer (FIFO

4

queue), which can store at most B packets simultaneously. An input is a sequence of phases starting

from the 0th phase. The ith phase consists of the ith arrival subphase followed by the ith delivery

subphase. At an arrival subphase, one or more packets arrive at the buffer, and the task of an

algorithm is to decide for each arriving packet p, whether to accept p or reject p. An algorithm can

also discard a packet p′ existing in the current buffer in order to make space (in which case we say

that the algorithm preempts p′). If a packet p is rejected or preempted, we say that p is dropped.

If a packet is accepted, it is stored at the tail of the queue. Packets accepted at the same arrival

subphase can be inserted into the queue in an arbitrary order. At a delivery subphase, the first

packet of the queue is transmitted if the buffer is nonempty. For a technical reason, we consider

only the inputs in which at least one packet arrives.

If a packet p arrives at the ith arrival subphase, we write arr(p) = i. For every frame f =

p1, . . . , pk such that arr(p1) ≤ · · · ≤ arr(pk), we call pi the i-packet of f . Consider two frames

fi = pi,1, . . . , pi,k and fi′ = pi′,1, . . . , pi′,k such that arr(pi,1) ≤ · · · ≤ arr(pi,k) and arr(pi′,1) ≤· · · ≤ arr(pi′,k). If for every j and j′, arr(pi,j) ≤ arr(pi′,j) if and only if arr(pi,j′) ≤ arr(pi′,j′),

then we say that fi and fi′ are order-respecting. If every two frames in an input sequence σ are

order-respecting, we say that σ is order-respecting. If all the packets constituting a frame f are

transmitted, we say that f is completed, otherwise, f is incompleted. The goal of k-FTM is to

maximize the number of completed frames. k-OFTM is k-FTM where inputs are restricted to

order-respecting sequences.

For an input σ, the gain of an algorithm ALG is the number of frames completed by ALG

and is denoted by VALG(σ). If ALG is a randomized algorithm, the gain of ALG is defined as

an expectation E[VALG(σ)], where the expectation is taken over the randomness inside ALG. If

VALG(σ) ≥ VOPT (σ)/c (E[VALG(σ)] ≥ VOPT (σ)/c) for every input σ, we say that ALG is c-

competitive, where OPT is an optimal offline algorithm for σ. Without loss of generality, we can

assume that OPT never preempts packets and never accepts a packet of an incompleted frame.

3 Upper Bound

In this section, we present our algorithm Middle-Drop and Flush (MF ) and analyze its com-

petitive ratio.

3.1 Algorithm

We first give notation needed to describe MF . Suppose that n packets p1, p2, . . . , pn arrive at MF ’s

buffer at the ith arrival subphase. For each packet, MF decides whether to accept it or not one by

one (in some order defined later). Let tpj denote the time when MF deals with the packet pj , and

let us call tpj the decision time of pj . Hence if p1, p2, . . . , pn are processed in this order, we have

that tp1 < tp2 < · · · < tpn . (For convenience, in the later analysis, we assume that OPT also deals

with pj at the same time tpj .) Also, let us call the time when MF transmits a packet from the head

of its buffer at the ith delivery subphase the delivery time of the ith delivery subphase. A decision

time or a delivery time is called an event time, and any other moment is called a non-event time.

Note that during the non-event time, the configuration of the buffer is unchanged. For any event

time t, t+ denotes any non-event time between t and the next event time. Similarly, t− denotes

any non-event time between t and the previous event time.

Let ALG be either MF or OPT . For a non-event time t and a packet p of a frame f , we say

that p is valid for ALG at t if ALG has not dropped any packet of f before t, i.e., f still has a

5

chance of being completed. In this case we also say that the frame f is valid for ALG at t. Note

that a completed frame is valid at the end of the input. For a j-packet p and a non-event time t,

if p is stored in MF ’s buffer at t, we define ℓ(t, p) as “1+(the number of j-packets located before

p)”, that is, p is the ℓ(t, p)th j-packet in MF ’s queue. If p has not yet arrived at t, we define

ℓ(t, p) = ∞.

During the execution, MF virtually runs the following greedy algorithm GR1 on the same

input sequence. Roughly speaking, GR1 is greedy for only 1-packets and ignores all j(≥ 2)-packets.

Formally, GR1 uses a FIFO queue of the same size B. At the arrival of a packet p, GR1 rejects

it if it is a j-packet for j ≥ 2. If p is a 1-packet, GR1 accepts it whenever there is a space in the

queue. At a delivery subphase, GR1 transmits the first packet of the queue as usual.

MF uses two internal variables Counter and Block. Counter is used to count the number of

packets accepted by GR1 modulo 3B. Block takes a positive integer value; it is initially one and

is increased by one each time Counter is reset to zero.

Define A = ⌊B/k⌋. MF stores at most A j-packets for any j. For j = 1, MF refers to the

behavior of GR1 in the following way: Using two variables Counter and Block, MF divides 1-

packets accepted by GR1 into blocks according to their arrival order, each with 3B 1-packets. MF

accepts the first A packets of each block and rejects the rest. For j ≥ 2, MF ignores j-packets

that are not valid. When processing a valid j-packet p, if MF already has A j-packets in its queue,

then MF preempts the one in the “middle” among those j-packets and accepts p.

For a non-event time t, let b(t) denote the value of Block at t. For a packet p, we define the

block number g(p) of p as follows. For a 1-packet p, g(p) = b(t−) where t is the decision time of p,

and for a j(∈ [2, k])-packet p, g(p) = g(p′) where p′ is the 1-packet corresponding to p. Hence, all

the packets of the same frame have the same block number. We also define the block number g(f)

of a frame f is the (unique) block number of the packets constituting f . For a non-event time t

and a positive integer u, let hALG,u(t) denote the number of frames f such that f is valid for ALG

at t and g(f) = u.

Recall that at an arrival subphase, more than one packet may arrive at a queue. MF processes

the packets ordered non-increasingly first by their frame indices and then by block numbers. If

both are equal, they are processed in arbitrary order. That is, MF processes these packets by the

following rule: Consider an i-packet p and an i′-packet p′. If i < i′, p is processed before p′ and

if i′ < i, p′ is processed before p. If i = i′, then p is processed before p′ if g(p) < g(p′) and p′ is

processed before p if g(p′) < g(p). If i = i′ and g(p) = g(p′), the processing order is arbitrary. The

formal description of MF is as follows. To illustrate an execution of MF , we give an example in

Appendix B.

Middle-Drop and Flush

Initialize: Counter := 0, Block := 1.

Let p be a j-packet to be processed.

Case 1: j = 1:

Case 1.1: If GR1 rejects p, reject p.

Case 1.2: If GR1 accepts p, set Counter := Counter +1 and do the following.

Case 1.2.1: If Counter ≤ A, accept p. (We prove in Lemma 3.5(c) that MF ’s buffer has a

space whenever Counter ≤ A.)

Case 1.2.2: If A < Counter < 3B, reject p.

Case 1.2.3: If Counter = 3B, reject p and set Counter := 0 and Block := Block+ 1.

Case 2: j ≥ 2:

6

Case 2.1: If p is not valid for MF at tp−, reject p.

Case 2.2: If p is valid for MF at tp−, do the following.

Case 2.2.1: If the number of j-packets in MF ’s buffer at tp− is at most A− 1, accept p.

Case 2.2.2: If the number of j-packets in MF ’s buffer at tp− is (at least) A, then preempt

the j-packet p′ such that ℓ(tp−, p′) = ⌊A/2⌋+ 1, and accept p. Preempt all the packets

corresponding to p′ (if any).

Case 2.2.2.1: If hMF,g(p′)(tp−) ≤ ⌊A/2⌋, preempt all the packets p′′ in MF ’s buffer such

that g(p′′) = g(p′). (Call this operation “flush”.)

Case 2.2.2.2: If hMF,g(p′)(tp−) ≥ ⌊A/2⌋+ 1, do nothing.

3.2 Overview of the Analysis

Let τ be any fixed time after MF processes the final event, and let c denote the value of Counter

at τ . Also, we define M = b(τ) − 1 if c = 0, and M = b(τ) otherwise. Note that for any frame

f , 1 ≤ g(f) ≤ M . Define the set G of integers as G = M ∪ i | MF completes at least ⌊A/2⌋frames f such that g(f) = i and let m = |G|. We call a block number good if it is in G and bad

otherwise. For each j ∈ [1,m], let aj be the jth smallest integer in G. Note that aj denotes the

jth good block number, and in particular that am = M since M ∈ G. Our first key lemma is the

following, saying that the first block is always good:

Lemma 3.1 a1 = 1.

Since at the end of the input any valid frame is completed, we have VOPT (σ) =∑M

i=1 hOPT,i(τ)

and VMF (σ) =∑M

i=1 hMF,i(τ) ≥∑m

i=1 hMF,ai(τ).

We first guarantee the gain of MF for good block numbers, which follows from the definition

of G:

hMF,ai(τ) ≥ ⌊A/2⌋ for any i ∈ [1,m− 1]. (1)

We next focus on the mth good block number M . Since it has some exceptional properties, we

discuss the number of completed frames with block number M independently of the other good

block numbers as follows:

Lemma 3.2 (a) If either c = 0 or c ∈ [⌊A/2⌋, 3B−1], hMF,M (τ) ≥ ⌊A/2⌋. (b) If c ∈ [1, ⌊A/2⌋−1]

and M ≥ 2, hMF,M (τ) + B − 1 ≥ hOPT,M (τ). (c) If c ∈ [1, ⌊A/2⌋ − 1] and M = 1, hMF,M (τ) ≥hOPT,M (τ).

Also, we evaluate the number of OPT ’s completed frames from a viewpoint of good block numbers:

Lemma 3.3 (a) hOPT,M (τ) ≤ 4B−1. (b)∑a2−1

j=a1hOPT,j(τ) ≤ 4B+A−3. (c)

∑ai+1−1j=ai

hOPT,j(τ) ≤5B +A− 4 for any i ∈ [2,m− 1].

Using the above inequalities, we can obtain the competitive ratio of MF by case analysis on the

values of M and c. First, note that since at least one packet arrives, VOPT (σ) > 0 holds and M = 1

implies c ≥ 1. Now if M = 1 and c ∈ [1, ⌊A/2⌋− 1], hMF,1(τ) ≥ hOPT,1(τ) by Lemma 3.2(c). Since

hMF,1(τ) ≥ hOPT,1(τ) = VOPT (σ) > 0, VOPT (σ)VMF (σ) =

hOPT,1(τ)hMF,1(τ)

≤ 1. If M = 1 and c ∈ [⌊A/2⌋, 3B − 1],

then VOPT (σ)VMF (σ) =

hOPT,1(τ)hMF,1(τ)

≤ 4B−1⌊A/2⌋ < 5B+A−4

⌊A/2⌋ by Lemma 3.2(a) and Lemma 3.3(a).

7

If M ≥ 2 and c ∈ 0 ∪ [⌊A/2⌋, 3B − 1],

VOPT (σ) =

M∑i=1

hOPT,i(τ) =

m−1∑i=1

ai+1−1∑j=ai

hOPT,j(τ) + hOPT,am(τ)

≤ (m− 1)(5B +A− 4)−B + 1 + (4B − 1) < m(5B +A− 4)

by Lemma 3.3 (note that a1 = 1 by Lemma 3.1 and am = M). Also, VMF (σ) ≥∑m

i=1 hMF,ai(τ) ≥m⌊A/2⌋ by Eq. (1) and Lemma 3.2(a). Therefore, VOPT (σ)

VMF (σ) < 5B+A−4⌊A/2⌋ . Finally, if M ≥ 2 and

c ∈ [1, ⌊A/2⌋ − 1],

VOPT (σ) =

M∑i=1

hOPT,i(τ) =

m−1∑i=1

ai+1−1∑j=ai

hOPT,j(τ) + hOPT,am(τ)

≤ (m− 1)(5B +A− 4)−B + 1 + hOPT,M (τ)

≤ (m− 1)(5B +A− 4) + hMF,M (τ)

by Lemmas 3.2(b), 3.3(b) and 3.3(c). Also, VMF (σ) =∑m

i=1 hMF,ai(τ) ≥ (m−1)⌊A/2⌋+hMF,M (τ)

by Eq. (1). Therefore,

VOPT (σ)

VMF (σ)≤

(m− 1)(5B +A− 4) + hMF,M (τ)

(m− 1)⌊A/2⌋+ hMF,M (τ)<

5B +A− 4

⌊A/2⌋.

We have proved that VOPT (σ)VMF (σ) < 5B+A−4

⌊A/2⌋ in all the cases. By noting that 5B+A−4⌊A/2⌋ = 5B+⌊B/k⌋−4

⌊B/2k⌋ ,

we have the following theorem:

Theorem 3.4 When B/k ≥ 2, the competitive ratio of MF is at most 5B+⌊B/k⌋−4⌊B/2k⌋ .

3.3 Analysis of MF

In this section, we first show the feasibility of Case 1.2.1 of MF . We then give the proofs of Lemmas

3.1, 3.2, and 3.3 in the subsequent sections.

3.3.1 Feasibility of MF

In this section, we guarantee the feasibility of MF by proving Lemma 3.5(c). At the same time,

we prove Lemma 3.5(a) and (b) for later use. If an algorithm ALG transmits a packet p at the ith

delivery subphase, we write delALG(p) = i.

Lemma 3.5 Suppose that GR1 accepts z(≥ 2B) 1-packets. Let pi (i ∈ [1, z]) denote the ith 1-

packet accepted by GR1. Then, the following holds. (a) If z ≥ 2B, then for any j(∈ [1, z− 2B+1])

such that MF accepts pj, delMF (pj) < arr(pj+2B−1). (b) For any u(≥ 0), MF accepts all the

1-packets p3Bu+1, . . . , p3Bu+A, and their block number is u + 1. (c) If 0 ≤ Counter ≤ A − 1 just

before the decision time of a 1-packet p, MF ’s buffer has a space to accept p.

Proof. (a) Consider a 1-packet pj satisfying the condition of the lemma, and consider the non-

event time tpj+, i.e., the moment just after GR1 and MF accept pj . By definition, MF certainly

transmits any 1-packet inserted into its buffer. In addition, MF will transmit pj within B phases,

8

since the buffer size is B, and only one packet can be transmitted in one phase. That is, the

number of delivery subphases between tpj+ and the moment before MF transmits pj is at most

B − 1, which means that GR1 can also transmit at most B − 1 packets during this period. On

the other hand, GR1 accepts pj as well, and there exists at least one packet in GR1’s buffer at

tpj+. Hence there are at most B − 1 vacancies in GR1’s buffer at this moment. Therefore, the

number of packets GR1 can accept between tpj+ and the moment before MF transmits pj is at

most (B − 1) + (B − 1) = 2B − 2. In other words, MF transmits pj before GR1 accepts pj+2B−1.

This proves delMF (pj) < arr(pj+2B−1).

(b) First, recall that MF can always store up to A x-packets for x ∈ [1, k]. Due to Cases 1.2.1,

1.2.2 and 1.2.3, MF accepts packets p1, p2, · · · , pA, and rejects pA+1, pA+2, · · · , p3B. During this

period, Block stays 1. Just after MF rejects p3B, Block is incremented to 2, and Counter is reset

to 0. Since delMF (pA) < arr(pA+2B−1) by the proof of the part (a) of this lemma, delMF (pA) <

arr(p3B+1), which means that there exists no 1-packet inMF ’s queue at the non-event time tp3B+1−.

Hence, MF starts accepting p3B+1, p3B+2, . . . , p3B+A. By continuing this argument, we can prove

part (b).

(c) 0 ≤ Counter ≤ A − 1 holds just before the decision times of p3Bu+1, . . . , p3Bu+A for each

u = 0, 1, . . .. Thus, (c) is immediate from the proof of part (b).

3.3.2 Proof of Lemma 3.1

To prove Lemma 3.1, we use Lemma 3.5 and the following lemmas. Roughly speaking, Lemma 3.6

says that, for each j, block numbers of j-packets are assigned in order of arrival, and Lemma 3.7

says that, for each j′, packets in the j′-subbuffer are stored in order of block number.

Lemma 3.6 (a) Let p be any 1-packet accepted by MF and q be any 1-packet such that g(p) < g(q).

Then, arr(p) < arr(q). (b) For x ∈ [2, k], let p′ and q′ be any x-packets such that g(p′) < g(q′) and

suppose that MF accepts the 1-packet corresponding to p′. Then, arr(p′) ≤ arr(q′).

Proof. (a) Note that p is accepted by also GR1. Let q be the first 1-packet with block number g(q).

Clearly GR1 accepts q and arr(q) ≤ arr(q). Suppose that p and q are the ith and the jth packets,

respectively, accepted by GR1. By Lemma 3.5(b) and the assumption that g(p) < g(q)(= g(q)),

j − i ≥ (3B(g(q) − 1) + 1) − (3B(g(p) − 1) + A) = 3B(g(q) − g(p)) + 1 − A ≥ 3B + 1 − A > 2B.

Then by Lemma 3.5(a), p is transmitted by MF before q arrives. Therefore, arr(p) < arr(q), which

means that arr(p) < arr(q). This completes the proof.

(b) Let p1 and q1 be the 1-packets corresponding to p′ and q′, respectively. Since g(p′) < g(q′),

g(p1) < g(q1). Therefore, arr(p1) < arr(q1) by (a). Since the input is order-respecting, arr(p′) ≤arr(q′).

Lemma 3.7 Let t be a non-event time. For any x ∈ [1, k], let p be an x-packet stored in MF ’s

buffer at t, and let q be an x-packet which is stored in MF ’s buffer at t. If ℓ(t, p) < ℓ(t, q), then

g(p) ≤ g(q).

Proof. Since ℓ(t, p) < ℓ(t, q), MF processes p earlier than q, which means that arr(p) ≤ arr(q).

Thus, in the case of x = 1, if arr(p) ≤ arr(q), then g(p) ≤ g(q) by the contrapositive of Lemma 3.6.

In the same way, using the contrapositive of Lemma 3.6, g(p) ≤ g(q) if x = 1 and arr(p) < arr(q).

In the case where both x = 1 and arr(p) = arr(q), MF processes a packet with a smaller block

number earlier by definition, and hence g(p) ≤ g(q).

9

Now we are ready to prove Lemma 3.1. When M = 1, clearly a1 = 1 because M ∈ G by

definition. When M ≥ 2, we show that at any moment there are at least ⌊A/2⌋ frames f with

block number 1 such that f is valid for MF . MF accepts at least ⌊A/2⌋ 1-packets with block

number 1 according to Lemma 3.5(b). If MF does not preempt any packet with block number 1,

the statement is clearly true. Then, suppose that at an event time t, MF preempts an x(∈ [2, k])-

packet with block number 1. By Case 2.2.2 in MF , MF stores A x-packets in its buffer at t−.

Moreover, all the x-packets in MF ’s buffer are queued in ascending order of block number by

Lemma 3.7. Thus, for each x-packet p such that ℓ(t+, p) ∈ [1, ⌊A/2⌋], g(p) = 1. As a result,

hMF,1(t+) ≥ ⌊A/2⌋, which proves the lemma.

3.3.3 Proof of Lemma 3.2

In order to prove Lemma 3.2, we bound the number of 1-packets accepted by OPT during a time

interval by the number of 1-packets accepted by GR1.

Lemma 3.8 Let t1 and t2(> t1) be any non-event times. Suppose that GR1 accepts w(≥ 1) 1-

packets during time [t1, t2], and let p be the first 1-packet accepted by GR1 during time [t1, t2]. Then,

the number of 1-packets accepted by OPT during time [tp−, t2] is at most w + B − 1. Moreover,

when t1 is a time before the beginning of the input, the number of 1-packets accepted by OPT during

time [tp−, t2] is at most w.

Proof. Define OPT1 as the offline algorithm that accepts exactly the same 1-packets as accepted by

OPT and ignores j(∈ [2, k])-packets. Let x (respectively x′) be the number of 1-packets accepted

by GR1 but not accepted by OPT1 (respectively accepted by OPT1 but not accepted by GR1)

during time [tp−, t2]. Also, let x′′ be the number of 1-packets accepted by both GR1 and OPT1

during time [tp−, t2]. Since GR1 accepts w packets during time [tp−, t2], x + x′′ = w. In what

follows, we bound x′ + x′′ from above.

For a non-event time t and an algorithm ALG′(∈ OPT1, GR1), let fALG′(t) denote the number

of 1-packets in ALG′’s buffer at t. Since GR1 accepts 1-packets greedily and OPT1 accepts only

1-packets, fGR1(t)− fOPT1(t) ≥ 0 holds for any t. Let y (respectively y′) denote the number of 1-

packets transmitted by GR1 (respectively OPT1) during time [tp−, t2]. Since fGR1(t)−fOPT1(t) ≥ 0

for any t, GR1 transmits a 1-packet whenever OPT1 does so, and hence y ≥ y′. By an easy

calculation, fGR1(t2) = fGR1(tp−) + x+ x′′ − y and fOPT1(t2) = fOPT1(tp−) + x′ + x′′ − y′. By the

above equalities and inequalities,

0 ≤ fGR1(t2)− fOPT1(t2) = fGR1(tp−) + x+ x′′ − y − (fOPT1(tp−) + x′ + x′′ − y′)

= fGR1(tp−)− fOPT1(tp−) + x− x′ − y + y′ ≤ fGR1(tp−)− fOPT1(tp−) + x− x′.

That is, x′ ≤ fGR1(tp−) − fOPT1(tp−) + x. Hence, x′ + x′′ ≤ fGR1(tp−) − fOPT1(tp−) + x + x′′ =

fGR1(tp−)−fOPT1(tp−)+w holds. Furthermore, fGR1(tp−)−fOPT1(tp−) ≤ B−1 since GR1 accepts

p, namely, GR1’s buffer is not full just before the decision time of p. Thus, x′ + x′′ ≤ B − 1 + w.

Finally we consider the case where t1 is a time before the beginning of the input. Since

fGR1(tp−) = fOPT1(tp−) = 0, x′ + x′′ ≤ fGR1(tp−)− fOPT1(tp−) + w = w holds.

We are ready to give the proof of Lemma 3.2. The proof of (a) is almost the same as that of

Lemma 3.1. By the assumption that c = 0 or c ∈ [⌊A/2⌋, 3B − 1], MF accepts at least ⌊A/2⌋1-packets with block number M according to Lemma 3.5(b). If MF does not preempt any packet

10

with block number M , the statement is clearly true. Then, suppose that at an event time t, MF

preempts an x(∈ [2, k])-packet with block number M . By Case 2.2.2, MF stores A x-packets in

its buffer at t−. Moreover, all the x-packets in MF ’s buffer are queued in ascending order by

their block numbers by Lemma 3.7. Thus, for each x-packet p such that ℓ(t+, p) ∈ [⌊A/2⌋+ 1, A],

g(p) = M . As a result, hMF,M (t+) ≥ ⌊A/2⌋, which proves the part (a) of Lemma 3.2.

As for (b), since c ∈ [1, ⌊A/2⌋ − 1] by the assumption of (b), all the 1-packets with block

number M which are accepted by MF are the same as those of GR1. Then, let p′ (p′′) be the

first (hMF,M (τ)th) 1-packet accepted by MF whose block number is M . If we set t1 = tp′− and

t2 = tp′′+ in Lemma 3.8, then w = hMF,M (τ). Thus we have that hMF,M (τ)+B− 1 ≥ hOPT,M (τ).

Part (c) can be proved in a similar way to (b), by applying the latter part of Lemma 3.8.

3.3.4 Proof of Lemma 3.3

To prove Lemma 3.3, we first show the next three lemmas. We show in Lemma 3.9 that for

non-consecutive two good block numbers aj and aj+1, there must be a moment when an x(∈[2, k])-packet with block number aj and an x-packet with block number aj+1 exist in MF ’s buffer

simultaneously. This is a consequence of using middle-drop policy. We then show in Lemma 3.11

that in such a case, the number of packets accepted by OPT with block number aj , aj+1, . . . , aj+1−1 can be bounded.

Lemma 3.9 Suppose that aj+1 − aj ≥ 2 for an integer j(∈ [1,m − 1]). Then there exist two x-

packets q and q′ for some integer x ∈ [2, k] such that g(q) = aj, g(q′) = aj+1, and both q and q′ are

stored in MF ’s buffer at the same time.

Proof. For a non-event time t, we say that a block number u is good at t if u = M or at least ⌊A/2⌋frames with the block number u are valid at t, and bad at t otherwise. Note that the set of good

block numbers at the end of the input coincides the set G (see Sec. 3.2 for the definition of G).

Since aj+1 − aj ≥ 2, there must be at least one block number between aj and aj+1. Those block

numbers were initially good but turned bad at some event time, since aj and aj+1 are good block

numbers that are consecutive at the end of the input. Let u (aj < u < aj+1) be the block number

that turned bad lastly among them. The event time when block number u turns bad is the decision

time tp′ when some x(∈ [2, k])-packet p′ arrives. Specifically, MF accepts p′ at tp′ , and preempts

an x-packet p′′ with block number u(= g(p′′)) at Case 2.2.2 such that ℓ(tp′−, p′′) = ⌊A/2⌋ + 1.

Moreover, MF preempts all the packets with block number u in MF ’s buffer by executing Case

2.2.2.1.

Now we discuss the block numbers of packets inMF ’s buffer before or after tp′ . By the definition

of Case 2.2.2 in MF , the number of x-packets in MF ’s buffer at tp′− is A, and among them, exactly

⌊A/2⌋ ones are of block number g(p′′) (or ⌊A/2⌋−1 ones excluding p′′). In addition, all the x-packets

in MF ’s buffer are queued in ascending order by their block numbers by Lemma 3.7. Hence, (a)

g(p′′) > g(p) holds, where p is the x-packet such that ℓ(tp′−, p) = ℓ(tp′+, p) = 1. Also, MF accepts

p′, and preempts all the packets with block number g(p′′) at Case 2.2.2.1. Thus, g(p′) = g(p′′),

which means that (b) g(p′′) < g(p′) holds according to Lemma 3.7.

Now if aj < g(p), then aj < g(p) < g(p′′) by (a). This contradicts the definition of u since there

still remains a good block number g(p) between aj and u(= g(p′′)). Hence aj ≥ g(p). In the same

way, if aj+1 > g(p′), then g(p′′) < g(p′) < aj+1 by (b). We have the contradiction as well, which

means that (c) aj+1 ≤ g(p′).

11

In the following, we prove that q and q′ mentioned in this lemma exist in the buffer at time

tp′+. We first show the existence of q. Let us consider the case of aj = g(p). In this case, p is

clearly stored in MF ’s buffer at tp′+, and p satisfies the condition of q. Next, we consider the case

of aj > g(p). Since aj is a good block number by definition, there must be a packet p′′′ such that

aj = g(p′′′) and p′′′ is valid at tp′+. Then, g(p) < g(p′′′) = aj < aj+1 ≤ g(p′) by (c) and hence

arr(p) ≤ arr(p′′′) ≤ arr(p′) by Lemma 3.6. Note that MF stores both p′ and p in its buffer at tp′+,

and p′′′ is valid at tp′+ by the above definition. Therefore, p′′′ is stored in MF ’s buffer at tp′+,

and thus this p′′′ satisfies the condition of q. The case of q′ can be proven in the same way as q.

Namely, if aj+1 = g(p′), then let q′ = p′. Also, if aj+1 < g(p′), then there must be q′ satisfying

g(p) ≤ aj < aj+1 = g(q′) < g(p′). This completes the proof.

Lemma 3.10 For any non-event time t and x ∈ [2, k], let p be an x-packet valid for MF at t.

Then the number of x-packets q such that OPT accepts q, arr(p) < arr(q), and g(q) ∈ [1, g(p)− 1]

is at most B.

Proof. Let p1 be the 1-packet corresponding to p, q′ be an x-packet accepted by OPT , and q′1 be

the 1-packet corresponding to q′. As we assume that OPT never accepts a packet of an incompleted

frame, q′1 is accepted by OPT . Since the input is order-respecting, arr(p) ≥ arr(q′) if arr(p1) >

arr(q′1), that is, such q′ does not satisfy the second condition of q in the statement of this lemma.

Since the block numbers of 1-packets are monotonically non-decreasing in an arrival order, g(p1) ≤g(q′1) if arr(p1) < arr(q′1), namely, such q′ does not satisfy the third condition of q. Thus, only q′

such that arr(p1) = arr(q′1) can satisfy all the conditions of q. Since the buffer size is B, the number

of such q′1 accepted by OPT is at most B, which completes the proof.

Lemma 3.11 Let p and p′ be x(∈ [2, k])-packets stored in MF ’s buffer at the same time, and

suppose that g(p′) − g(p) ≥ 2. Then, if g(p) ≥ 2, the number of x-packets p such that g(p) ∈[g(p), g(p′)−1], and p is accepted by OPT is at most 5B+A−4. Moreover, if g(p) = 1, the number

of x-packets p such that g(p) ∈ [1, g(p′)− 1], and p is accepted by OPT is at most 4B +A− 3.

Proof. First, we consider the case of g(p) ≥ 2. Let q be an x-packet satisfying the conditions of

the lemma, i.e., an x-packet q such that g(q) ∈ [g(p), g(p′) − 1] and q is accepted by OPT . Note

that arr(p) ≤ arr(p′) by Lemma 3.6 (b) because g(p) < g(p′). We count the number of such q for

each of the cases (i) arr(q) < arr(p), (ii) arr(p) ≤ arr(q) ≤ arr(p′), and (iii) arr(p′) < arr(q).

(i) First, note that there is no q such that g(q) ∈ [g(p) + 1, g(p′) − 1] by Lemma 3.6, since

arr(q) < arr(p). Hence, we focus on q such that g(q) = g(p). Let p1 and q1 be the 1-packets

corresponding to p and q, respectively, and suppose that p1 (p′1) is the jth (first) 1-packet accepted

by MF with block number g(p). To count the number of q satisfying the condition, we count

the number of corresponding q1. Note that g(q1) = g(p1) since g(q) = g(p). By the definition of

MF , the j(∈ [1, A])th 1-packet accepted by MF is also accepted by GR1. If we set t1 = tp′1− and

t2 = tp1−, then w = j − 1 in Lemma 3.8, and Lemma 3.8 implies that the number of q1 such that

arr(q1) < arr(p1) is at most j− 1+B− 1. This is at most A+B− 2 since j ≤ A by Lemma 3.5(b).

The number of q1 such that arr(q1) = arr(p1) is at most B, since the buffer size is B. Finally,

the number of q1 such that arr(q1) > arr(p1) is zero by the order-respecting assumption because

arr(q) < arr(p). Hence, the number of q in Case (i) is at most (A+B − 2) +B = 2B +A− 2.

(ii) Let t be any non-event time when both p and p′ are stored in MF ’s buffer. Let w′ = arr(p)

and suppose that the delivery subphase just before t is in the w′′th phase. Then, the number

of delivery subphases during [w′, w′′] is w′′ − w′ + 1. Since p is still stored in MF ’s buffer at t,

12

w′′−w′+1 ≤ B−1 (as otherwise, MF must have transmitted p before t). The number of x-packets

which arrive during [w′, w′′] and are accepted by OPT is at most B+w′′−w′ ≤ 2B−2 by a similar

argument to the proof of Lemma 3.5(a). Thus, the number of x-packets q in this case is at most

2B − 2.

(iii) By Lemma 3.10, the number of x-packets q in this case is at most B.

Putting (i), (ii), and (iii) together, the number of x-packets q is at most (2B +A− 2) + (2B −2) +B = 5B +A− 4.

For g(p) = 1, the argument is the same as the case of g(p) ≥ 2, except that at an application of

Lemma 3.8 in Case (i), we let t1 be the time before the beginning of the input. Then, the number

of q1 such that q1 is accepted by OPT , g(q1) = g(p1), and arr(q1) < arr(p1) is at most A − 1,

instead of A+B− 2 in the case of g(p) ≥ 2. Then the number of x-packets q in question is at most

(B +A− 1) + (2B − 2) +B = 4B +A− 3.

Now we are ready to give the proof of Lemma 3.3. Fix the block number u(= M). We count the

number of 1-packets p accepted by OPT such that g(p) = u. Note that the number of 1-packets

with block number u accepted by GR1 is 3B. Let q (q′) be the first (last, i.e., 3Bth) 1-packet

accepted by GR1 with block number u. Also, let q′′ be the first 1-packet accepted by GR1 after

tq′+. Then q′′ has the block number u+1 by definition, and hence any packet with block number u

arrives during time [tq−, tq′′−]. By applying Lemma 3.8 with t1 = tq− and t2 = tq′′−, i.e., w = 3B,

the number of 1-packets p accepted by OPT such that g(p) = u is at most 3B + B − 1 = 4B − 1.

When u = M , the same upper bound can be obtained by almost the same argument as the above.

We use this fact several times in the following.

(a) By the above discussion, the number of 1-packets p accepted by OPT such that g(p) = amis at most 4B − 1, and hence the number of frames f completed by OPT such that g(f) = am is

at most 4B − 1.

(b) In the case of a2 = a1+1, by the same argument as (a) we can conclude that the number of

completed frames is at most 4B− 1 ≤ 4B+A− 3. If a2 ≥ a1+2, we know by Lemma 3.9 that two

x-packets p and p such that g(p) = a1 and g(p) = a2 are stored in MF ’s buffer at the same time.

Then by Lemma 3.11, the number of x-packets p accepted by OPT such that g(p) ∈ [a1, a2 − 1] is

at most 4B + A − 3 (recall that a1 = 1). By the same argument as above, we can conclude that

the number of frames completed by OPT such that g(f) ∈ [a1, a2 − 1] is also at most this number.

(c) The argument is almost the same as (b). The only difference is that here we use the fact

that for i ≥ 2, the number of x-packets p accepted by OPT such that g(p) ∈ [ai, ai+1 − 1] is at

most 5B +A− 4, which is due to Lemma 3.11.

4 Lower Bound for Deterministic Algorithms

In this section, we show a lower bound for deterministic algorithms.

Theorem 4.1 Suppose that k ≥ 2. The competitive ratio of any deterministic algorithm is at least2B

⌊B/(k−1)⌋ + 1 if B ≥ k − 1, and unbounded if B ≤ k − 2.

Proof. Fix an online algorithm ALG. Let us consider the following input σ. (See Figure 1.) At the

0th phase, 2B 1-packets arrive. ALG accepts at most B 1-packets, and OPT accepts B 1-packets

that are not accepted by ALG. Let C (D, respectively) be the set of the 1-packets accepted by

13

1,1c

2,1c

...

B,1c

1,1e

2,1e

...

B,1e

1,1f

2,1f

...

X,1f

B0 (k+2)B phase

1,1d

2,1d

...

B,1d

Optim

al Al

gorit

hmOn

line

Algo

rithm

x(B) y(B)Accept:

Accept: B X

at most B

1,2c

2,2c

...

B,2c

1,kc

2,kc

...

B,kc...

...

...

...

1,2e

2,2e

...

B,2e

1,ke

2,ke

...

B,ke...

...

...

...

1,2f

2,2f

...

B,2f

(k+2)B

B

(2k+1)B

1,kf

2,kf

...

B,kf

B

...

...

1,2d

2,2d

...

B,2d

3B

B

(k+1)B

1,kd

2,kd

...

B,kd

B

...

...

1,1g

2,1g

...

B,1g

1,1h

2,1h

...

B,1h

2B

z(B)

B

1,2f

2,2f

...

X,2f

X(k-1)B

1,kf

2,kf

...

X,kf...

...

...

...

1,2g

2,2g

...

B,2g

1,kg

2,kg

...

B,kg...

...

...

...

Figure 1: Lower Bound Instance. Each square denotes an arriving packet accepted by an onlinealgorithm or OPT . In the figure X = ⌊ B

k−1⌋.

ALG (OPT , respectively). At the ith phase (i ∈ [1, B − 1]), no packets arrive. Hence, just after

the (B− 1)st phase, both ALG’s and OPT ’s queues are empty (since B delivery subphases occur).

At the Bth phase, B + ⌊ Bk−1⌋ 1-packets arrive in the same manner as the first 2B 1-packets.

ALG can accept at most B 1-packets, and OPT accepts ⌊ Bk−1⌋ 1-packets that are not accepted by

ALG. Let E (F , respectively) be the set of the packets accepted by ALG (OPT , respectively).

At the ith phase (i ∈ [B + 1, 2B − 1]), no packets arrive, and both ALG’s and OPT ’s queues are

empty just after the (2B − 1)st phase.

Once again at the 2Bth phase, 2B 1-packets arrive. ALG accepts at most B 1-packets, and

OPT accepts B 1-packets that are not accepted by ALG. Let G (H, respectively) be the set of

the 1-packets accepted by ALG (OPT , respectively). This is the end of the arrivals and deliveries

of 1-packets. At the ith phase (i ∈ [2B + 1, 3B − 1]), no packets arrive, and hence just before the

3Bth phase, both ALG’s and OPT ’s queues are empty.

For each j = 2, ..., k, the B j-packets corresponding to 1-packets in D arrive at the (j + 1)Bth

phase. OPT accepts and transmits them. (There is no incentive for ALG to accept them.) Next, all

the packets corresponding to all the 1-packets in C∪E∪F ∪G arrive at the (k+2)Bth phase. Since

ALG needs to accept all the k− 1 packets of the same frame to complete it, the number of frames

ALG can complete is at most ⌊ Bk−1⌋. OPT accepts all the ⌊ B

k−1⌋(k − 1) packets corresponding to

all the 1-packets in F . Note that this is possible because ⌊ Bk−1⌋(k−1) ≤ B. Hence, OPT completes

all the ⌊ Bk−1⌋ frames of F .

After which all the packets corresponding to 1-packets in H arrive one after the other, and

OPT can accept and transmit them. Note that the input sequence is order-respecting.

By the above argument, we have VALG(σ) ≤ ⌊ Bk−1⌋ and VOPT (σ) = 2B + ⌊ B

k−1⌋. Therefore, if

B ≥ k − 1, VOPT (σ)VALG(σ) ≥

2B⌊ Bk−1

⌋ + 1. If B ≤ k − 2, the competitive ratio of ALG is unbounded.

14

5 Lower Bound for Randomized Algorithms

Theorem 5.1 When k ≥ 3, the competitive ratio of any randomized algorithm is at least k− 1− ϵ

for any constant ϵ against an oblivious adversary.

Proof. Fix an arbitrary randomized online algorithm ALG. Let y be a large integer that will be

fixed later. Our adversarial input σ consists of (k − 1)yB frames. These frames are divided into

k − 1 groups each with yB frames. Also, frames of each group are divided into y subgroups each

with B frames. For each i(∈ [1, k − 1]) and j(∈ [1, y]), let F (i, j) be the set of frames in the jth

subgroup of the ith group and let F (i) = ∪jF (i, j). For each x(∈ [1, k]), let P (i, j, x) be the set of

x-packets of the frames in F (i, j) and let P (i, x) = ∪jP (i, j, x).

We first give a very rough idea of how to construct the adversary. Among the k − 1 groups

defined above, one of them is a good group. In the first half of the input (from phase 0 to phase

(k−1)yB−1), the adversary gives packets to the online algorithm in such a way that the algorithm

cannot distinguish the good group. Also, since the buffer size is bounded, the algorithm must give

up many frames during the first half; only yB frames can survive at the end of the first half. In

the second half of the input, remaining packets are given in such a way that k-packets from the

bad groups arrive at a burst, while k-packets from the good group arrive one by one. Hence, if the

algorithm is lucky enough to keep many packets of the good group (say, Group 1) at the end of the

first half, then it can complete many frames eventually. However, such an algorithm behaves very

poorly for an input in which Group 1 is bad. Therefore, the best strategy of an online algorithm

(even randomized one) is to keep equal number of frames from each group during the first half.

Before showing our adversarial input, we define a subsequence of an input. For any t, suppose

that B packets of P (i, j, x) arrive at the tth phase and no packets arrive during t + 1 through

(t + B − 1)st phases. Let us call this subsequence a subround of P (i, j, x) starting at the tth

phase. Notice that if we focus on a single subround, an algorithm can accept and transmit all the

packets of P (i, j, x) by the end of the subround. A round of P (i, x) starting at the tth phase is a

concatenation of y subrounds of P (i, j, x) (j ∈ [1, y]), where each subround of P (i, j, x) starts at

the (t+ (j − 1)B)th phase. (See the left figure in Fig. 2.)

Our input consists of rounds of P (i, x) starting at the (i+ x− 2)yBth phase, for i ∈ [1, k − 1]

and x ∈ [1, k−1]. (See Fig. 3.) Note that any two rounds P (i, x) and P (i′, x′) start simultaneously

if i+x = i′+x′. Currently, the specification of the arrival of packets in P (i, x) for x = k is missing.

This is the key for the construction of our adversary and will be explained shortly.

Consider k − 1 rounds (of P (1, k − 1), P (2, k − 2), · · · , P (k − 1, 1)) starting at the (k − 2)yBth

phase, which occur simultaneously. Note that for each j, at the jth subround of these k−1 rounds,

ALG can accept at most B packets (out of (k − 1)B ones) because of the size constraint of the

buffer. For each j ∈ [1, y], let Ai,j denote the expected number of packets that ALG accepts from

P (i, j, k − i). By the above argument, we have that ΣiAi,j ≤ B and hence ΣiΣjAi,j ≤ yB. Let

Ai = ΣjAi,j and let Az be the minimum among A1, A2, · · · , Ak−1 (ties are broken arbitrarily).

Note that Az ≤ yBk−1 since ΣiAi = ΣiΣjAi,j ≤ yB. Also, note that since Ai is an expectation, z is

determined only by the description of ALG (and not by the actual behavior of A).

We now explain the arrival of packets in P (i, k) (i ∈ [1, k − 1]). (See the right figure in Fig. 2.)

For i = z, all the yB packets in P (i, k) arrive simultaneously at the (i+ k − 2)yBth phase. As for

i = z, packets are given as a usual round, i.e., we have a round of P (z, k) starting at (z+k− 2)yB.

It is not hard to verify that this input is order-respecting. Also, it can be easily verified that our

adversary is oblivious because the construction of the input does not depend on the actual behavior

15

t+Bt t+2B ... t+(y-1)B phase

subround

round

phaset

Pa,x

round

...

1,1,kp

1,2,kp

...

1,B,k

t phase

pa

a

a2,1,k

p

2,2,kp

...

2,B,kp a

a

a3,1,k

p

3,2,kp

...

3,B,kpa

a

a

burst round

phaset

,1,kp

,2,kp

...

,B,kpa

a

a

...

Pa,k

y

y

y1,1,xp

1,2,xp

...

1,B,xpa

a

a2,1,x

p

2,2,xp

...

2,B,xp a

a

a p

p

p

3,1,x

3,2,x

...

3,B,xa

a

a,1,x

p

,2,xp

...

,B,xpa

a

a

y

y

y

burst round

...

Figure 2: P (a, x) is written as Pa,x in this figure. The left figure shows a round of P (a, x) exceptfor the case where a = z and x = k. On the other hand, the right figure shows a round of P (a, k)for each a(∈ [1, k − 1]) such that a = z.

of ALG. Specifically, z depends on only the values of Ai,j (i ∈ [1, k − 1], j ∈ [1, y]), and σ can be

constructed not with time but in advance.

First, note that OPT can accept and transmit all the packets in P (z, x) for any x. Therefore,

OPT can complete all the yB frames in F (z) and hence VOPT (σ) ≥ yB. On the other hand,

since all the packets in P (i, k) (i = z) arrive simultaneously, ALG can accept at most B packets

of them and hence can complete at most B frames of F (i) for each i. As for F (z), ALG can

complete at most Az ≤ yBk−1 frames of them and hence E[VALG(σ)] ≤ yB

k−1 + (k − 2)B. If we take

y ≥ (k−1)2(k−2)ϵ − (k − 1)(k − 2), we have that

VOPT (σ)

E[VALG(σ)]≥ yB

(yB)/(k − 1) + (k − 2)B= k − 1− (k − 1)2(k − 2)

y + (k − 1)(k − 2)≥ k − 1− ϵ.

6 Conclusion

In this paper, we have improved an upper bound on the competitive ratio for k-OFTM, showing

the Θ(k)-competitiveness of the problem when B ≥ 2k. We also have presented lower bounds for

deterministic and randomized settings. When k − 1 ≤ B < 2k, our proof for the upper bound

does not work because there exists a j-subbuffer whose size is one and hence it is impossible for

two j-packets to exist in the buffer simultaneously. Developing competitive algorithms for this case

is one of interesting future work. Moreover, MF is a preemptive algorithm whereas the O(k2)-

competitive algorithm SP in [25] is non-preemptive. Therefore it is interesting to design (or prove

the non-existence of) a non-preemptive algorithm whose competitive ratio is O(k).

16

P1,1 P1,2 P1,3 P1,4 ... P1,k-1

P2,1 P2,2 P2,3

Pz,1

P2,k-2 P2,k-1

Pz,k-4 Pz,k-3 Pz,k-2 Pz,k-1

...

...

...

...

...

Pk-1,1

...

...

...

phase

...

...

...

...

...

...

Pk-1,2 Pk-1,3 Pk-1,4 Pk-1,5...

P1,k

P2,k

Pz,k

Pk-1,k

good rounds

bad rounds...

0 yB (i-1)yB (k-2)yB (k-1)yB kyB (k+1)yB (k+2)yB (2k-3)yB... ......

Figure 3: Lower bound instance for randomized algorithms

7 Acknowledgments

This work was supported by JSPS KAKENHI Grant Numbers 24500013 and 26730008.

References

[1] W. Aiello, Y. Mansour, S. Rajagopolan, and A. Rosen, “Competitive queue policies for differ-

entiated services,” Journal of Algorithms, Vol. 55, No. 2, pp. 113–141, 2005.

[2] S. Albers and M. Schmidt, “On the performance of greedy algorithms in packet buffering,”

SIAM Journal on Computing, Vol. 35, No. 2, pp. 278–304, 2005.

[3] N. Andelman, “Randomized queue management for DiffServ,” In Proc. of the 17th ACM

Symposium on Parallel Algorithms and Architectures, pp. 1–10, 2005.

[4] N. Andelman and Y. Mansour, “Competitive management of non-preemptive queues with

multiple values,” Distributed Computing, Vol. 2848, pp. 166–180, 2003.

[5] N. Andelman, Y. Mansour and A. Zhu, “Competitive queueing policies for QoS switches,” In

Proc. of the 14th ACM-SIAM Symposium on Discrete Algorithms, pp. 761–770, 2003.

[6] Y. Azar and A. Litichevskey, “Maximizing throughput in multi-queue switches,” Algorithmica,

Vol.45, No.1, pp, 69–90, 2006.

[7] Y. Azar and Y. Richter, “Management of multi-queue switches in QoS networks,” Algorithmica,

Vol.43, No.1-2, pp, 81–96, 2005.

[8] Y. Azar and Y. Richter, “An improved algorithm for CIOQ switches,” ACM Transactions on

Algorithms, Vol. 2, No. 2, pp. 282–295, 2006,

[9] M. Bienkowski, “An optimal lower bound for buffer management in multi-queue switches,”

Algorithmica, Vol.68, No.2, pp, 426–447, 2014.

[10] A. Borodin and R. El-Yaniv, “Online computation and competitive analysis,” Cambridge Uni-

versity Press, 1998.

17

[11] Y. Emek, M. Halldorsson, Y. Mansour, B. Patt-Shamir, J. Radhakrishnan and D. Rawitz,

“Online set packing and competitive scheduling of multi-part tasks,” In Proc. of the 29th

ACM Symposium on Principles of Distributed Computing, pp. 440–449, 2010.

[12] M. Englert and M. Westermann, “Lower and upper bounds on FIFO buffer management in

QoS switches,” Algorithmica, Vol.53, No.4, pp, 523–548, 2009.

[13] M. Goldwasser, “A survey of buffer management policies for packet switches,” ACM SIGACT

News, Vol.41, No. 1, pp.100–128, 2010.

[14] E. Hahne, A. Kesselman and Y. Mansour, “Competitive buffer management for shared-memory

switches,” In Proc. of the 13th ACM Symposium on Parallel Algorithms and Architectures, pp.

53–58, 2001.

[15] M. M. Halldorsson, B. Patt-Shamir and D. Rawitz, “Online Scheduling with Interval Con-

flicts,” Theory of Computing Systems, Vol.53, No.2, pp, 300–317, 2013.

[16] J. Kawahara, and K. M. Kobayashi, “Optimal Buffer Management for 2-Frame Throughput

Maximization,” Computer Networks, Vol. 91, pp. 804–820, 2015.

[17] A. Kesselman, Z. Lotker, Y. Mansour, B. Patt-Shamir, B. Schieber, and M. Sviridenko, “Buffer

overflow management in QoS switches,” SIAM Journal on Computing, Vol. 33, No. 3, pp. 563–

583, 2004.

[18] A. Kesselman and Y. Mansour, “Harmonic buffer management policy for shared memory

switches,” Theoretical Computer Science, Vol. 324, No.2-3, pp. 161–182, 2004.

[19] A. Kesselman, Y. Mansour and R. van Stee, “Improved competitive guarantees for QoS buffer-

ing,” Algorithmica, Vol.43, No.1-2, pp. 63–80, 2005.

[20] A. Kesselman and A. Rosen, “Scheduling policies for CIOQ switches,” Journal of Algorithms,

Vol. 60, No. 1, pp. 60–83, 2006.

[21] A. Kesselman and A. Rosen, “Controlling CIOQ switches with priority queuing and in mul-

tistage interconnection networks,” Journal of Interconnection Networks, Vol. 9, No. 1/2, pp.

53–72, 2008.

[22] A. Kesselman, K. Kogan and M. Segal, “Packet mode and QoS algorithms for buffered crossbar

switches with FIFO queuing,” Distributed Computing, Vol.23, No.3, pp. 163–175, 2010.

[23] A. Kesselman, K. Kogan and M. Segal, “Best effort and priority queuing policies for buffered

crossbar switches,” Chicago Journal of Theoretical Science, pp. 1–14, 2012.

[24] A. Kesselman, K. Kogan and M. Segal, “Improved competitive performance bounds for CIOQ

switches,” Algorithmica, Vol.63, No.1-2, pp, 411–424, 2012.

[25] A. Kesselman, B. Patt-Shamir and G. Scalosub, “Competitive buffer management with packet

dependencies,” Theoretical Computer Science, Vol.489–490, pp. 75–87, 2013.

[26] K. Kobayashi, S. Miyazaki and Y. Okabe, “A tight bound on online buffer management for two-

port shared-memory switches,” In Proc. of the 19th ACM Symposium on Parallel Algorithms

and Architectures, pp. 358–364, 2007.

18

[27] K. Kobayashi, S. Miyazaki and Y. Okabe, “Competitive buffer management for multi-queue

switches in QoS networks using packet buffering algorithms,” In Proc. of the 21st ACM Sym-

posium on Parallel Algorithms and Architectures, pp. 328–336, 2009.

[28] Y. Mansour, B. Patt-Shamir, and D. Rawitz, “Overflow management with multipart packets,”

In Proc. of the 31st IEEE Conference on Computer Communications, pp. 2606–2614, 2011.

[29] Y. Mansour, B. Patt-Shamir, and D. Rawitz, “Competitive router scheduling with structured

data,” Theoretical Computer Science, Vol. 530, pp. 12–22, 2014.

[30] G. Scalosub, P. Marbach and J. Liebeherr, “Buffer management for aggregated streaming data

with packet dependencies,” IEEE Transactions on Parallel and Distributed Systems, Vol. 24,

No. 3, pp. 439–449, 2013.

[31] D. D. Sleator, and R. E. Tarjan, “Amortized efficiency of list update and paging rules,”

Communications of the ACM, Vol. 28, No. 2, pp. 202–208, 1985.

[32] M. Sviridenko, “A lower bound for on-line algorithms in the FIFO model,” unpublished

manuscript, 2001.

A Lower bound for SP

We give an input σ for which SP ’s competitive ratio is as bad as Ω(k2). For ease of presentation,

let D = 3B and N = 3× 2k−1. σ consists of NB frames f1, . . . , fNB. For any i(∈ [1, NB]) and any

j(∈ [1, k]), let pi,j denote the j-packet of fi. Fig. 4 shows a pseudocode of generating σ. Note that

in σ, all the 1-packets arrive first. After that, all the 2-packets arrive, then all the 3-packets do,

and so on. An example of σ for k = 5 is depicted in Figs. 5 through 9, corresponding to 1- through

5-packets, respectively. Each figure consists of two graphs. An upper graph shows the arrival phase

of each packet, where the horizontal axis shows the packet index and vertical axis shows the phase.

For example, Fig. 5 shows that 1-packets pi,1 (i ∈ [1, B]) arrive at the 0th phase, indicated as (1),

1-packets pi,1 (i ∈ [B + 1, 2B]) arrive at the Bth phase, indicated as (2), and so on. (We assume

that Figs. 5 through 9 are printed in color. Please refer to the PDF version if necessary.)

First, consider SP ’s behavior. Without loss of generality, we assume that SP prioritizes frames

with smaller indices, e.g., if two packets pi,j and pi′,j with i < i′ arrive at the same time and

SP is able to accept only one packet, then SP accepts pi,j and rejects pi′,j . The lower graphs of

Figs. 5 through 9 show the behaviors of SP and OPT . For example, Fig. 5 shows that SP accepts

1-packets pi,1 (i ∈ [1, A]), indicated as (5’), pi,1 (i ∈ [B + 1, B + A]), indicated as (6’), and so on.

Now, for each w ∈ [1, N ], SP accepts A 1-packets p(w−1)B+1,1, p(w−1)B+2,1, . . . , p(w−1)B+A,1, hence

NA 1-packets in total, and rejects the rest. Next, for each integer j(∈ [2, k]) and each integer

y(∈ [0, 2k−j − 1]), SP accepts A j-packets py2j−1D+1,j , . . . , py2j−1D+A,j but rejects others. Note

that the number of j-packets accepted by SP is 2k−jA. In particular, the number of k-packets

accepted by SP is A. Therefore, VSP (σ) = A.

Next, consider OPT ’s behavior. Let b1 = 0 and bz =∑z−1

j=1 2k−j−1D for each integer z(∈

[2, k − 1]). OPT completes fbz+D+1, . . . , fbz+D+B for each integer z(∈ [1, k − 1]). Therefore,

VOPT (σ) = (k − 1)B and VOPT (σ)VSP (σ) = (k−1)B

A = Ω(k2) since A = ⌊B/k⌋.On the other hand, MF completes fbz+1, . . . , fbz+⌊A/2⌋ for each integer z(∈ [1, k − 1]) and

fbk+⌊A/2⌋+1, . . . , fbk+A. Therefore, VMF (σ) = (k−1)⌊A/2⌋+A−⌊A/2⌋ ≥ k⌊A/2⌋ and VOPT (σ)/VMF (σ) ≤(k − 1)B/(k⌊A/2⌋) ≤ B/⌊A/2⌋ hold.

19

t := 0.for w = 1, . . . , N do

1-packets p(w−1)B+1,1, . . . , pwB,1 arrive at the tth phase.

t := t+B.end forfor j = 2, . . . , k do

t := (j − 1)NB.for y = 0, . . . , 2k−j − 1 doj-packets py2j−1D+1,j , . . . , py2j−1D+2j−2D+D,j arrive at the tth phase.t := t+B.for x = 1, . . . , 2j−2 − 1 doj-packets py2j−1D+2j−2D+xD+1,j , . . . , py2j−1D+2j−2D+xD+D,j arrive at the tth phase.t := t+B.

end forend for

end for

Figure 4: Pseudocode of arriving packets in σ

B Execution Example of MF

In this section, we give an execution example of MF for a given input σ in Tables 1 and 2. We

suppose that k = 3 and B = 12, which means A = 12/3 = 4. σ includes 120 frames f1, . . . , f120.

For each i(∈ [1, 120]), pi, qi and ri denote the 1-packet, 2-packet and 3-packet in fi, respectively.

We suppose that arr(p1) ≤ arr(p2) ≤ · · · ≤ arr(p120). All the 1-packets (all the 2-packets and 3-

packets) arrive as shown in Table 1 (Table 2). Columns starting from the left in the tables present

the arrival times of packets, the names of arriving packets, actions by GR1 for arriving packets

(only in Table 1), actions by MF for arriving packets, the names of cases executed by MF and the

block numbers of arriving packets (only in Table 1).

For example, 1-packets p1, p2, p3 and p4 arrive at phase 0, MF executes Case 1.2.1, and accepts

these packets. (See Figure 10.) The block numbers of these 1-packets are 1. In particular, MF

accepts 2-packet q85 at phase 120, and preempts q51 that is stored in its buffer at tq85−. (That is,

MF discards q51 using a “middle-drop” policy.) Moreover, when MF accepts 3-packet r85 at the

120th phase, MF executes Case 2.2.2, and preempts r49. Hence, f49 becomes invalid for MF . At

this time, MF preempts 2-packet q49 as well. In addition, the frames f such that the 1-packets in

f are accepted by MF , and g(f) = 2 are f49, f50, f51 and f52. At event times tq85 and tq86 , q51 and

q52 are preempted, respectively. That is, the number of valid frames of MF with block number 2

decreases to less than ⌊A/2⌋ = 2 at event time tr85 . Thus, MF further executes Case 2.2.2.1, and

preempts all the packets whose block numbers are 2 in its buffer.

20

0 B 2D 16D

phase

frameD

B2B

5D 10D 15D

10B

20B

30B

40B

47B

0

...

0 B 2D 16D

phase

frameD

B2B

5D 10D 15D

10B

20B

30B

40B

47B

0

...

[1;B]

[B+1;B]

[2B+1;B]

[D+1;B]

[D+2B+1;B]

[D+B+1;B]

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

(9)(1)(2)(3)(4)(5)(6)

...

(1’)

(2’)

(3’)

(4’)

[2D+1;B]

[2D+2B+1;B]

[2D+B+1;B](7)(8)(9)

(5’)(6’)(7’)(8’)(9’)(10’)(11’)(12’)(13’)...

(14’)

(15’)

(16’)

[D+1;B]

[9D+1;B]

[13D+1;B]

[15D+1;B]

(1’)

(2’)

(3’)

(4’)

OPT

SP

[1;A]

[B+1;A]

[2B+1;A]

[D+1;A]

[D+2B+1;A]

[D+B+1;A]

(5’)

(6’)

(7’)

(8’)

(9’)

(10’)

(11’)

(12’)

(13’)

[2D+1;A]

[2D+2B+1;A]

[2D+B+1;A]

...

...

[1;A]

[D+1;A]

[2D+1;A]

(14’)

(15’)

(16’)MF

Figure 5: Arriving 1-packets in σ when k = 5. [i;x] in the figure denotes all the 1-packets infi, . . . , fi+x−1 for any integers i and x.

21

phase

frame2D 4D 6D0

t2

t2+ B

t2+2B

...

t2+7B

16D8D 10D 12D 14D

phase

frame2D 4D 6D0

t2

t2+ B

t2+2B

...

t2+7B

16D8D 10D 12D 14D

[D+1;B]

[9D+1;B]

[13D+1;B]

[15D+1;B]

(1’)

(2’)

(3’)

(4’)

[1; A/2 ] [8D+1; A/2 ]

[12D+1; A/2 ]

[14D+1; A/2 ]

[15D+ A/2 +1; A/2 ]

OPT

MF[4D+1; A/2 ]

[6D+1; A/2 ]

[7D+ A/2 +1; A/2 ]

(13’)

(14’)

(15’)

(16’)

(17’)

(18’)

(19’)

(20’)

[2D+1; A/2 ]

[3D+ A/2 +1; A/2 ]

[10D+1; A/2 ]

[11D+ A/2 +1; A/2 ]

(21’)

(22’)

(23’)

(24’)

(25’)

(26’)

(27’)

(28’)

[D+ A/2 +1; A/2 ]

[1;2D]

[2D+1;2D]

[4D+1;2D]

[6D+1;2D]

[10D+1;2D]

[12D+1;2D]

[14D+1;2D]

[8D+1;2D]

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

(13’)

(5’) (1’)

(2’)

(3’)

(4’)

(15’)

(25’)

(27’)(28’)

(6’)

(20’)(19’)

(21’)

(7’)

(8’)(16’)

(17’)

(23’)(24’)

(9’)

(10’)

(11’)

(12’)

(14’)

(18’)

(22’)

(26’)

[13D+ A/2 +1; A/2 ][5D+ A/2 +1; A/2 ]

[9D+ A/2 +1; A/2 ][1;A](5’)

(6’)

(7’)

(8’)

(9’)

(10’)

(11’)

(12’)

SP[8D+1;A]

[4D+1;A]

[12D+1;A]

[6D+1;A]

[2D+1;A]

[10D+1;A]

[14D+1;A]

Figure 6: Arriving 2-packets in σ when k = 5

22

3D

phase

frame2D 4D 6D0

t3

t3+ B

t3+2B

...

t3+7B

16D8D 10D 12D 14D

3D

phase

frame2D 4D 6D0

t3

t3+ B

t3+2B

...

t3+7B

16D8D 10D 12D 14D

[D+1;B]

[9D+1;B]

[13D+1;B]

[15D+1;B]

[1;A]

(1’)

(2’)

(3’)

(4’)

(5’)

(6’)

(7’)

(8’)

[1; A/2 ] [8D+1; A/2 ]

[12D+1; A/2 ]

[14D+1; A/2 ]

[15D+ A/2 +1; A/2 ]

OPT

SP

MF

[8D+1;A]

[4D+1; A/2 ]

[6D+1; A/2 ]

[7D+ A/2 +1; A/2 ]

(9’)

(10’)

(11’)

(12’)

(13’)

(14’)[4D+1;A]

[12D+1;A]

[2D+1; A/2 ]

[3D+ A/2 +1; A/2 ]

[10D+1; A/2 ]

[11D+ A/2 +1; A/2 ]

(15’)

(16’)

(17’)

(18’)

(19’)

(20’)

(9’)

(5’)

(1’)

(2’)

(3’)

(4’)

(10’)

(18’) (19’)

(20’)

(6’)

(14’)

(13’)

(15’)

(7’)

(8’)

(11’)

(12’)

(16’)

(17’)

[1;3D]

[3D+1;D]

[4D+1;3D]

[7D+1;D]

[11D+1;D]

[12D+1;3D]

[15D+1;D]

[8D+1;3D]

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

Figure 7: Arriving 3-packets in σ when k = 5

23

5D

phase

frame2D 4D 6D0

t4

t4+ B

t4+2B

...

t4+7B

16D8D 10D 12D 14D

5D

phase

frame2D 4D 6D0

t4

t4+ B

t4+2B

...

t4+7B

16D8D 10D 12D 14D

[D+1;B]

[9D+1;B]

[13D+1;B]

[15D+1;B]

[1;A]

[1;5D]

[5D+1;D]

[6D+1;D]

[7D+1;D]

[13D+1;D]

[14D+1;D]

[15D+1;D]

[8D+1;5D]

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

(1’)

(2’)

(3’)

(4’)

(5’)

(6’)

[1; A/2 ]

[8D+1; A/2 ]

[12D+1; A/2 ]

[14D+1; A/2 ]

[15D+ A/2 +1; A/2 ]

OPT

SP

MF

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

[8D+1;A]

[4D+1; A/2 ]

[6D+1; A/2 ]

[7D+ A/2 +1; A/2 ]

(7’)

(5’)

(1’)

(2’)

(3’)(4’)

(8’)

(12’)

(13’)

(14’)

(6’)(10’)

(9’)

(11’)

(7’)

(8’)

(9’)

(10’)

(11’)

(12’)

(13’)

(14’)

Figure 8: Arriving 4-packets in σ when k = 5

24

9D

phase

frame2D 4D 6D0

t5

t5+ B

t5+2B

...

t5+7B

16D8D 10D 12D 14D

[D+1;B]

[9D+1;B]

[13D+1;B]

[15D+1;B]

[1;A]

9D

phase

frame2D 4D 6D0

t5

t5+ B

t5+2B

...

t5+7B

16D8D 10D 12D 14D

[1;9D]

[9D+1;D]

[10D+1;D]

[11D+1;D]

[13D+1;D]

[14D+1;D]

[15D+1;D]

[12D+1;D]

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

(6’)

(7’)

(8’)

(9’)

(10’)

[1; A/2 ]

[8D+1; A/2 ]

[12D+1; A/2 ]

[14D+1; A/2 ]

[15D+ A/2 +1; A/2 ]

(6’)

(5’)

(1’)

(2’)

(3’)(4’)

(7’)

(8’)

(9’)

(10’)

OPT

SP

MF

(1’)

(2’)

(3’)

(4’)

(5’)

Figure 9: Arriving 5-packets in σ when k = 5

25

0

MF’ s buffer

p1 +

phase

1

t

-

1p

p2+ t

1p2p

... p24+ t

1p2p3p4p

d+ t

d+ t

pp 34

p pp4 23

... p4+ t

1p2p3p4p

...

p4

... t d+2

3

... t d+

p pp51 4950

t p+

p52

52

...

36

... ...

p pp87 8586

t p+

p88

88

...

72

... ...

...

phase

q qq51 4950

t q+

q52

52120

... ...

q qq51 4950

t q

q52

85

q85

q qq52 4950

t q+

q85

85

...

preempt

q qq85 4950

t r +

q86

4

...

r rr3 12r4

q qq85 4950

t q+

q86

86

...

q qq85 4950

t r +

q86

50

...

r rr49 12r50

...

...

t q+88

121

... ...

...

q qq85 4950

t r

q86

85

r85

qq 8586

t r +85

...

preempt

r rr49 12r50

rr 12r85

qq 8586

t r +86

...

rr 12r85r86

q86rr 12r85r86qq 8788

t r +87

q86rr 12r86qq 8788r87

... t r +88

rr 12qq 8788r87r88

p1

t

0

1

2

3

Figure 10: Execution example of MF . tdi denotes the ith delivery time.

26

Table 1: Arriving 1-packets in σ

Arrival GR1’s MF ’sTime Packets Action Action Case Block

0p1, . . . , p4 accept accept 1.2.1 1p5, . . . , p12 accept reject 1.2.2 1p13, . . . , p24 reject reject 1.1 1

12 p25, . . . , p36 accept reject 1.2.2 1

24p37, . . . , p47 accept reject 1.2.2 1

p48 accept reject 1.2.3 1

36p49, . . . , p52 accept accept 1.2.1 2p53, . . . , p60 accept reject 1.2.2 2

48 p61, . . . , p72 accept reject 1.2.2 2

60p73, . . . , p83 accept reject 1.2.2 2

p84 accept reject 1.2.3 2

72p85, . . . , p88 accept accept 1.2.1 3p89, . . . , p96 accept reject 1.2.2 3

84 p97, . . . , p108 accept reject 1.2.2 3

96p109, . . . , p119 accept reject 1.2.2 3

p120 accept reject 1.2.3 3

27

Table 2: Arriving 2-packets and 3-packets in σ

Arrival MF ’sTime Packets Action Case

108q1, . . . , q4 accept 2.2.1q5, . . . , q48 reject 2.1

120

q49, . . . , q52 accept 2.2.1q53, . . . , q84 reject 2.1

q85preempt q51 2.2.2accept q85

q86preempt q52 2.2.2accept q86

r1, . . . , r4 accept 2.2.1r5, . . . , r48 reject 2.1

r49preempt r3 2.2.2accept r49

r50preempt r4 2.2.2accept r50

r51, . . . , r84 reject 2.1

r85

preempt r49, q49 2.2.2accept r85

preempt r50, q50 2.2.2.1r86 accept 2.2.1

121

q87, q88 accept 2.2.1q89, . . . , q120 reject 2.1

r87preempt r85 2.2.2accept r87

r88preempt q86, r86 2.2.2

accept r88r89, . . . , r120 reject 2.1

28