Overflow management with multipart packets

doi:10.1016/j.comnet.2012.07.001

Computer Networks

Volume 56, Issue 15, 15 October 2012, Pages 3456-3467

https://doi.org/10.1016/j.comnet.2012.07.001 Get rights and content

Abstract

We study an abstract setting, where the basic information units (called “superpackets”) do not fit into a single packet, and are therefore spread over multiple packets. We assume that a superpacket is useful only if the number of its delivered packets is above a certain threshold. Our focus of attention is communication link ingresses, where large arrival bursts result in dropped packets. The algorithmic question we address is which packets to drop so as to maximize goodput. Specifically, suppose that each superpacket consists of k packets, and that a superpacket can be reconstructed if at most $β \cdot k$ of its packets are lost, for some given parameter $0 ⩽ β < 1$ . We present a simple online distributed randomized algorithm in this model, and prove that in any scenario, its expected goodput is $Ω (OPT /(k \sqrt{(1 - β) σ}))$ , where opt denotes the best possible goodput by any algorithm, and σ denotes the size of the largest burst (the bound can be improved as a function of burst-size variability). We also analyze the effect of buffers on goodput under the assumption of fixed burst size, and show that in this case, when the buffer is not too small, our algorithm can attain, with high probability, $(1 - ϵ)$ goodput utilization for any $ϵ > 0$ . Finally, we present some simulation results that demonstrate that the behavior of our algorithm in practice is far better than our worst-case analytical bounds.

Introduction

The following basic situation occurs on many levels in communication systems. There is a data unit that we want to send, but it’s too big for the available communication primitive. It is therefore broken into a number of packets, which are sent separately. Since communication may be unreliable, some packets may not arrive at the receiver. However, the data unit is useful at the receiver only if all its parts are delivered.

There are many variants of the basic problems, and a few solution approaches. For example, in the transport layer it is common to use automatic repeat request (ARQ); in the application layer, forward error correction (FEC) is sometimes used. In this paper we concentrate on the network layer. As a concrete example, the reader may think about an MPEG video stream transmitted over the Internet in UDP (see e.g., [2]). In this case, the basic data unit is a “frame slice”, whose size may be larger than the maximal transfer unit of the end-to-end connection, and thus it is common that each slice is broken into a few UDP packets. If any of its packets is lost, the slice becomes completely worthless. In the network layer, losses are primarily due to buffer overflows. This motivates our main basic research question in this paper, which can be informally described as follows. Suppose that the basic data units (which we call “superpackets”) consist of some $k ⩾ 1$ packets. Consider link ingresses. When the arrival rate of packets exceeds the link capacity, which packets should be dropped so as to maximize the number of completed superpackets?

We study this problem mainly from the theoretical perspective. Our basic model is the following (see Section 2 for more details). Each superpacket consists of k packets. Time is slotted, and in each time step t, an arbitrary set of $σ (t)$ packets, called the burst of step t, arrives at a server (the server models a link). The server can serve at most c packets at a step (c is the link speed). The task of the scheduling algorithm is to select, in an online fashion, which packets to serve and which to drop, due to buffer space constraints. A superpacket is said to be completed if at least $(1 - β) k$ of its constituent packets are served, for some given redundancy parameter $0 ⩽ β < 1$ . The goal of the scheduling algorithm is to maximize the number of completed packets.

Possibly the simplest algorithm to this problem is dropping packets at random. However, a second thought shows that this is not a good strategy: The probability that all k packets of a superpacket are delivered, under random discards, is exponential in k. We therefore consider the following slightly more structured randomization rule:

Aside from its obvious simplicity, Priority has some other important attractive features. From the implementation point of view, note that it is straightforward to implement in a distributed system, by using pseudo-random hash functions, mapping superpacket IDs to priorities (we only need to ensure that all algorithm sites use the same hash function and the same random seed). From the theoretical viewpoint, this rule (which is inspired by Luby’s maximal independent set algorithm [11]) was showed to be effective in the case of online set packing [3], i.e., without buffers or redundancy.

In this paper we extend the results of [3] as follows. First, we consider redundancy: we show that if superpackets are encoded so that they can be recovered even if a fraction β of their constituent packets are lost, then the Priority algorithm is very effective (in [3] β = 0). Second, we analyze systems with buffers, and derive a bound on the minimum size buffer that guarantees, for any given $ϵ > 0, (1 - ϵ) (1 - β)$ goodput utilization, when bursts are of roughly the same size. We also consider the case, where burst sizes may vary. The idea is that by adding a little redundancy to the superpackets, we may overcome the variability of the burst sizes.

Our results are stated mostly in terms of competitive analysis, comparing the goodput of the algorithm in any given scenario to the best possible goodput of any schedule. Specifically, for the case, where no buffer space is provided, namely the case in which an arriving packet is either served or dropped, we show that Priority guarantees expected goodput of $Ω (| OPT | / (k \sqrt{σ_{\max} (1 - β)}))$ , where opt is the best possible schedule and $σ_{\max}$ denotes the maximum burst size. In fact, it turns out that the competitive ratio (the worst-case ratio between the expected performance of the algorithm and opt), depends on the variability of the burst sizes. For example, if all bursts have the same size, then the competitive ratio improves to $O (k)$ . (We note that even offline, it is NP-hard to obtain an $O (k / \log k)$ -approximation for the case of β = 0.) For the case, where buffers are provided, and assuming that the burst size is fixed, we present an algorithm that for any given $ϵ > 0$ , if the buffer size is $Ω (ϵ^{- 2} k \log (k / ϵ))$ , guarantees expected goodput of $(1 - ϵ)^{3} | OPT |$ . We also define a notion of “relatively large burst” and provide an upper bound on the competitive ratio of Priority for the case, where such bursts are uncommon. Our theoretical study is augmented by some simulation results.

Overflow management was studied quite extensively in the last decade from the competitive analysis viewpoint (starting with [12], [9]: see [4] for a recent survey). However, only relatively little is known about the superpacket model we study. The model was first introduced in the competitive analysis context in [10]. In that work, no redundancy is considered, and burst size may be unbounded. They show that in this case, no finite upper bound on the competitive ratio exists; they proceeded to consider a certain restriction on packet arrival order.³ Under this assumption, [10] prove an upper bound of $O (k^{2})$ and a lower bound of $Ω (k)$ on the competitive ratio for deterministic online algorithms. A different, possibly more realistic, ordering restriction is studied in [14].⁴ In this model, [14] gives an exponential (in k) upper bound on the deterministic competitive ratio, and a linear lower bound. They also give simulation results in which they compared their algorithm to various versions of tail-drop. Both [10], [14] assume a push-out FIFO buffer architecture.

A different angle was taken in [3], where instead of restricting the packet ordering in the input, the results are expressed in terms of the maximal burst size. In [3], this model is studied under the simplifying assumption that no buffers are available (and again, without redundancy). For this model, Priority is introduced, and shown to have optimal competitive ratio of $O (k \sqrt{σ_{\max}})$ .

If β = 0 and there is no buffer, the offline version of the problem reduces to Set Packing, where each superpacket corresponds to a set and each burst correspond to an element. Set Packing is as hard as Maximum Independent Set even when all elements are contained in at most two sets (i.e., $σ (t) ⩽ 2$ , for every t), and therefore cannot be approximated to within $O (n^{1 - ϵ})$ -factor, for any $ϵ > 0$ [6]. In terms of the number of elements (time steps), Set Packing is $O (\sqrt{T})$ -approximable, and hard to approximate within $T^{1 / 2 - ϵ}$ [5]. When set sizes is at most k, it is approximable within $k / 2 + ϵ$ , for any $ϵ > 0$ [8] and within $(k + 1) / 2$ in the weighted case [1], but known to be hard to approximate to within $O (k / \log k)$ -factor [7].

The results of [3] and of this paper were recently extended in [13]. This work considers a router with multiple bounded-capacity outgoing links and a redundancy model which generalizes the one presented here.

We formally define our model in Section 2. In Section 3 we present upper bounds on the competitive ratio of Algorithm Priority for the case, where $β > 0$ and no buffer space. Our results for the case of large buffers are given in Section 4, and we consider the case, where most bursts are not large in Section 5. Section 6 contains our simulation results.

Section snippets

The model

In this section we formalize the model we study.

Our basic concept is a superpacket, typically denoted S. Each superpacket consists of k unit size packets. The input to the system is a sequence of packets that arrive online. Each packet is associated with a superpacket, where a superpacket $S_{i}$ comprises the packets denoted $p_{i}^{1}, p_{i}^{2}, \dots, p_{i}^{k}$ . The set of superpackets is denoted by $I$ ( $I$ is unknown in advance). The system progresses in discrete time steps, where in each step an arbitrary set of packets

Admission control with redundancy

In this section we assume that no buffers are available. In some sense, in this case the algorithm acts as an admission control algorithm: at most c packets are delivered and the rest are dropped.

We show that Priority guarantees, for any packet arrival pattern, that its expected number of completed superpackets is $Ω (| OPT | / (k \sqrt{σ_{\max} (1 - β) / c}))$ , where $OPT$ denotes the schedule with maximum possible number of completed superpackets on that arrival pattern (recall that c is the link capacity). We also show

Buffer management

In this section we consider the case, where sufficient buffer space is available, assuming that all burst sizes are equal. We do it in two steps. First, we analyze Algorithm Priority for large capacity links. We show that if $c ⩾ \frac{3}{ϵ^{2} (1 - ϵ)} \ln \frac{(1 - β) k}{ϵ}$ , for some $ϵ > 0$ , then the link utilization is at least $(1 - ϵ)^{2} (1 - β)$ . Then, we reduce the model with large buffers and arbitrary link capacity to the model with no buffers and large link capacity by a simple “dual buffer” algorithm. This reduction allows us

Few large bursts

The analysis in Section 4 assumed that burst sizes are fixed, and now we extend it to the case, where burst sizes may vary. While arbitrary variability is hard to cope with, we believe that in many practical situations something can be done. The rationale is that in many practical situations, it appears reasonable to assume that overflow events occur infrequently, namely in most time steps $σ (t) ⩽ c$ . The idea is that by having a little redundancy, we can overcome the damage incurred by the few

Simulations

While most of our results are worst-case type of results with adversarial input, it seems also interesting to see how does the system perform when the input is generated by some stochastic process. We have implemented a simulation that allows us to observe the system behavior under a variety of conditions. In this section we present some of the simulation results. The buffer policy we employ here is a single buffer, rather than the dual buffer analyzed in Section 4, because we believe it is

Conclusion

In this paper we explored the effect of packet loss on multi-packet data units we called “superpackets.” We modeled superpackets as a set of k packets for some integer $k ⩾ 1$ , and assumed that a superpacket is useful if and only if at least $(1 - β) k$ of its packets are delivered, for some $0 ⩽ β < 1$ . The loss scenario is modeled first as bounded-capacity links without storage that lose arriving packets if their number is above its capacity, and then extended to the case of a bounded-size buffer drained by

References (14)

M.M. Halldórsson et al.
Independent sets with domination constraints
Discr. Appl. Math.
(2000)
P. Berman
A $d / 2$ approximation for maximum weight independent set in d-claw free graphs
Nord. J. Comput.
(2000)
J.M. Boyce, R.D. Gaglianello, Packet loss effects on MPEG video sent over the public internet, in: Proceedings of the...
Y. Emek, M. M. Halldórsson, Y. Mansour, B. Patt-Shamir, J. Radhakrishnan, D. Rawitz. Online set packing and competitive...
M.H. Goldwasser
A survey of buffer management policies for packet switches
SIGACT News
(2010)
J. Håstad
Clique is hard to approximate within $n^{1 - ϵ}$
Acta Math.
(1999)
E. Hazan, S. Safra, O. Schwartz, On the complexity of approximating k-dimensional matching, in: 6th International...

There are more references available in the full text version of this article.

Cited by (13)

Overflow management with self-eliminations
2023, Theoretical Computer Science
We study admission control with packet redundancy, where large data items, called superpackets, exceed some Maximum Transmission Unit (MTU) and therefore are broken into several smaller packets. It is assumed that each superpacket is comprised of k packets, and that a superpacket is considered useful if at least $(1 - β) k$ of its packets arrive at the receiving end, for some redundancy parameter $β \in [0, 1)$ . Our goal is to maximize the total profit of useful superpackets, under an overloaded network, where we are forced to drop packets.
Our starting point is an algorithm, called priority, which is based on assigning a random priority to each superpacket. This algorithm was shown to perform well when $β = 0$ , with and without a buffer. However, the performance of priority deteriorates with the increase of β, since it delivers too many packets for high priority superpackets. To tackle this issue, we propose an online algorithm which introduces randomized self-elimination of packets, called pse. When there is no buffer, we show that the competitive ratio of pse is better than the competitive ratio of priority, for the case where ${(1 - β)}^{3} \cdot ρ_{\max} \leq 1$ , where $ρ_{\max}$ is the maximal burst size-router capacity ratio. For real-world values ( $ρ_{\max} \leq 1.5$ ), pse outperforms priority for $β \geq 0.14$ . We also present simulation results, with a buffer, that demonstrate the behavior of pse in comparison with priority and tail-drop. It is shown that pse performs much better than priority when β is large. In fact, it is shown that pse behaves at least as good as both algorithms.
Bounded delay scheduling with packet dependencies
2022, Computer Communications
A common situation occurring when dealing with multimedia traffic is having large data frames fragmented into smaller IP packets, and having these packets sent independently through the network. For real-time multimedia traffic, dropping even few packets of a frame may render the entire frame useless. Such traffic is usually modeled as having inter-packet dependencies. We study the problem of scheduling traffic with such dependencies, where each packet has a deadline by which it should arrive at its destination. Such deadlines are common for real-time multimedia applications, and are derived from stringent delay constraints posed by the application. The figure of merit in such environments is maximizing the system’s goodput, namely, the number of frames successfully delivered.
We study online algorithms for the problem of maximizing goodput of delay-bounded traffic with inter-packet dependencies, and use competitive analysis to evaluate their performance. We present competitive algorithms for the problem, as well as matching lower bounds that are tight up to a constant factor. We further present the results of a simulation study which further validates our algorithmic approach and shows that insights arising from our analysis are indeed manifested in practice.
Queueing in the mist: Buffering and scheduling with limited knowledge
2018, Computer Networks
Citation Excerpt :
The problem was first introduced in the context of differentiated services, where packets have uniform size and processing requirements, but some of the packets have higher priorities, represented by a higher profit associated with them [10–12]. The numerous variants of this problem include models where packets have deadlines or maximum lifetime in the switch [11], environments involving multi-queues [13–16] and cases with packets dependencies [17,18], to name but a few. An extensive survey of these models and their analysis can be found in [19].
Scheduling and managing queues with bounded buffers are among the most fundamental problems in computer networking. Traditionally, it is often assumed that all the properties of each packet are known immediately upon arrival. However, as traffic becomes increasingly heterogeneous and complex, such assumptions are in many cases invalid. In particular, in various scenarios information about packet characteristics becomes available only after the packet has undergone some initial processing. In this work, we study the problem of managing queues with limited knowledge. We start by showing lower bounds on the competitive ratio of any algorithm in such settings. The techniques used in our proofs, which make use of a carefully crafted Markov process, may be of independent interest, and can potentially be used in other similar settings as well. Next, we use the insight obtained from these bounds to identify several algorithmic concepts appropriate for the problem, and use these guidelines to design a concrete algorithmic framework. We analyze the performance of our proposed algorithm, and further show how it can be implemented in various settings, which differ by the type and nature of the unknown information. We further validate our results and algorithmic approach by an extensive simulation study that provides further insights as to our algorithmic design principles in face of limited knowledge.
Towards optimal buffer management for streams with packet dependencies
2017, Computer Networks
We study the problem of managing a FIFO queue where traffic is an interleaving of multiple streams that have inter-packet dependencies. This situation is common when dealing with multimedia streaming traffic, where large data frames are fragmented into smaller IP packets sent independently through the network. The main difficulty in such systems is to decide which packets to discard in case of overflow, where the system’s goal is to maximize the goodput, namely, the number of frames that are successfully delivered. Previous results for this problem in the presence of bounded buffers obtained a competitive ratio which was exponential in the number of packets each data frame is decomposed into. We show both randomized and deterministic algorithms with polynomial competitive ratio in all system parameters thus exhibiting an exponential improvement over the best previously known algorithm for the problem.
Competitive router scheduling with structured data
2014, Theoretical Computer Science
Citation Excerpt :
In this paper we study, from the theoretical viewpoint, algorithms that decide which packets to drop so as to maximize the goodput of bounded-capacity links. Following [3,15], we study the fundamental Priority algorithm for link management, augmented with a simple randomized strategy that allocates superpackets to links based on the links capacities. Algorithm Priority assigns to each superpacket a random priority (based only on its weight, see below), and in case of overflows, low-priority packets are dropped.
We consider the task of transmitting structured information over bounded-capacity links. Our information model is a stream of basic units called superpackets that are broken into k packets each. To model the possible structure and redundancy of the superpackets, we assume that for each superpacket there is a collection of minimal subsets of packets whose delivery makes the superpacket useful. This very general model encompasses, for example, MPEG streams, where one can think of a group of pictures (GoP) as a superpacket. The fundamental difficulty is that networks can forward only the primitive packets, but applications can use only superpackets, and thus if no minimal subset is delivered, the whole superpacket becomes useless. Our aim is to maximize goodput (number of useful superpackets) in the face of overloaded communication links, where we are forced to drop some packets.
Specifically, we assume that an arbitrary stream of packets arrives at a router with multiple bounded-capacity outgoing links. An online algorithm needs to decide, for each superpacket, which outgoing link to use (all packets of the same superpacket must use the same link) and, in case of an overload at a link, which packets to drop and which to transmit so as to maximize goodput. We analyze a simple randomized competitive algorithm for the general case and provide a nearly matching lower bound on the competitive ratio of any randomized online algorithm.
Overflow Management with Self-eliminations
2021, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

View all citing articles on Scopus

Prof. Yishay Mansour got his PhD from MIT in 1990, following it he was a postdoctoral fellow in Harvard and a Research Staff Member in IBM T.J. Watson Research Center. Since 1992 he is at Tel-Aviv University, where he is currently a Professor of Computer Science and has serves as the head of the School of Computer Science during 2000–2002. Prof. Mansour has held visiting positions with Bell Labs, AT&T research Labs, IBM Research, and Google Research. Prof. Mansour has published over 50 journal papers and over 100 proceeding paper in various areas of computer science with special emphasis on communication networks, machine learning, and algorithmic game theory. Prof. Mansour is currently an associate editor in a number of distinguished journals and has been on numerous conference program committees. He was both the program chair of COLT (1998) and served on the COLT steering committee. He has supervised over a dozen graduate students in various areas including communication networks, machine learning and algorithmic game theory and algorithm design.

Boaz Patt-Shamir is a Professor of Electrical Engineering in Tel Aviv University since 1997, where he directs the laboratory for distributed algorithms. He received his B.Sc. degrees in Mathematics and Computer Science from Tel Aviv University, his M.Sc. degree from Weizmann Institute, and his Ph.D. degree from MIT. His interests include distributed network algorithms and algorithms for communication networks.

Dror Rawitz got a B.Sc. degree in Computer Engineering (summa cum laude) from the Technion-Israel Institute of Technology (1996). He received an M.Sc. degree (1999) and a Ph.D. degree (2003) in Computer Science also from the Technion. He is now a research associate at the School of Electrical Engineering of Tel Aviv University. His main research areas are algorithmic aspects of communication networks and designing approximation and online algorithms.

^☆: A preliminary version was presented at the 30th IEEE INFOCOM 2011. Research supported in part by the Next Generation Video (NeGeV) Consortium, Israel (http://www.negev-initiative.org).

¹: Supported in part by the IST Programme of the European Community, under the PASCAL2 Network of Excellence, IST-2007-216886, by a grant from the Israel Science Foundation (Grant No. 709/09) and Grant No. 2008-321 from the United States-Israel Binational Science Foundation (BSF) and by the Israel Ministry of Science and Technology. This publication reflects the authors’ views only.

²: Supported in part by the Israel Science Foundation (Grant 1372/09) and by Israel Ministry of Science and Technology.

View full text

Overflow management with multipart packets☆

Abstract

Introduction

Section snippets

The model

Admission control with redundancy

Buffer management

Few large bursts

Simulations

Conclusion

Discr. Appl. Math.

A d/2 approximation for maximum weight independent set in d-claw free graphs

Nord. J. Comput.

A survey of buffer management policies for packet switches

SIGACT News

Clique is hard to approximate within n1-ϵ

Acta Math.

A $d / 2$ approximation for maximum weight independent set in d-claw free graphs

Clique is hard to approximate within $n^{1 - ϵ}$