-
Bounded Delay Scheduling with PacketDependencies
Michael Markovitch and Gabriel ScalosubDepartment of
Communication Systems Engineering
Ben-Gurion University of the NegevBeer-Sheva 84105, Israel
Email: [email protected], [email protected]
Abstract—A common situation occurring when dealing
withmultimedia traffic is having large data frames fragmented
intosmaller IP packets, and having these packets sent
independentlythrough the network. For real-time multimedia traffic,
droppingeven few packets of a frame may render the entire
frameuseless. Such traffic is usually modeled as having
inter-packetdependencies. We study the problem of scheduling
traffic withsuch dependencies, where each packet has a deadline by
whichit should arrive at its destination. Such deadlines are common
forreal-time multimedia applications, and are derived from
stringentdelay constraints posed by the application. The figure of
merit insuch environments is maximizing the system’s goodput,
namely,the number of frames successfully delivered.
We study online algorithms for the problem of maximizinggoodput
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 asmatching lower
bounds that are tight up to a constant factor. Wefurther present
the results of a simulation study which furthervalidates our
algorithmic approach and shows that insightsarising from our
analysis are indeed manifested in practice.
I. INTRODUCTION
A recent report studying the growth of real-time entertain-ment
traffic in the Internet predicts that by 2018 approximately66% of
Internet traffic in North America will consist ofreal-time
entertainment traffic, and most predominantly, videostreaming [1].
Such traffic, especially as video definitionincreases, is
characterized by having large application-leveldata frames being
fragmented into smaller IP packets whichare sent independently
throughout the network. For stored-video one can rely on mechanisms
built into various layersof the protocol stack (e.g., TCP) that
ensure reliable datatransfer. However, for real-time multimedia
applications suchas live IPTV and video conferencing, these
mechanisms arenot applicable due to the strict delay restrictions
posed by theapplication (such traffic is therefore usually
transmitted overUDP). These restrictions essentially imply that
retransmissionof lost packets is in most cases pointless, since
retransmittedpackets would arrive too late to be successfully
decoded andused at the receiving end. Furthermore, the inability to
decodean original dataframe once too many of its constituent
packetshave been dropped, essentially means that the resources
usedby the network to deliver those packets that did arrive
success-fully, have been wasted in vain. Since network elements
maketheir decisions on a packet-level basis, and are unaware of
such dependencies occurring between packets correspondingto the
same frame, such utilization inefficiencies can be quitecommon, as
also demonstrated in experimental studies [2].
Some of the most common methods employed to deal withthe
hazardous effect of packet loss in such scenarios focus ontrading
bandwidth for packet loss; The sender encodes the dataframes while
adding significant redundancy to the outgoingpacket stream, an
approach commonly known as forward errorcorrection (FEC). This
allows the user to circumvent the effectof packet loss, at the cost
of increasing the rate at whichtraffic is transmitted. This makes
it possible (in some cases)to decode the data frame even if some of
its constituentpackets are dropped. However, increasing the
bandwidth maybe prohibitively costly in various scenarios, such as
wirelessaccess networks, network transcoders, and CDN headends.
Insuch environments it is not recommended, nor even possiblein many
cases, to employ such solutions.
In this work we study mechanisms and algorithms that areto be
implemented within the network, targeted at optimizingthe usage of
network resources (namely, buffer space and linkbandwidth), when
dealing with such delay-sensitive traffic.Previous models
presenting solutions for packet dependenciesfocused on managing a
bounded-buffer FIFO queue, andmainly addressed the questions of
handling buffer overflows(see more details in Section I-C). We
consider a significantlydifferent model where each arriving packet
has a deadline(which may or may not be induced by a deadline
imposed onthe data frame to which it corresponds). We assume no
boundon the available buffer space, but are required to maximize
thesystem’s goodput, namely, the number of frames for which allof
their packets are delivered by their deadline.1 This modelbetter
captures the nature of real-time video streaming, wherea data frame
must be successfully decoded in real-time, basedon some permissible
deadline by which packets should arrive,that still renders the
stream usable.
We consider traffic as being burst-bounded, i.e., there is
anupper bound on the number of packets arriving in a time-slot.
This assumption does not restrict the applicability of
ouralgorithms, since it is common for traffic (and especially
trafficwith stringent Quality-of-Service requirements) to be
regulated
1It should be noted that the objective of maximizing goodput (on
the frame-level) is in most cases significantly different than the
common concept ofmaximizing throughput (on the packet-level).
arX
iv:1
402.
6973
v1 [
cs.N
I] 2
7 Fe
b 20
14
-
2
by some token-bucket envelope [3].We present several algorithms
for the problem and use
competitive analysis to show how close they are from anoptimal
solution. This approach makes our results globallyapplicable, and
independent of the specific process generatingthe traffic. We
further provide some lower bounds on theperformance of any
deterministic algorithm for the problem.Finally, we perform an
extensive simulation study whichfurther validates our results.
A. System ModelWe consider a time-slotted system where traffic
consists of a
sequence of unit-size packets, p1, p2, . . ., such that packets
arelogically partitioned into frames. Each frame f corresponds tok
of the packets, pf1 , . . . , p
fk ∈ {p1, p2, . . .}, where we refer
to packet pf` as the `-packet of frame f . For every packet pwe
denote its arrival time by a(p), and we assume that thearrival of
packets corresponding to frame f satisfies a(pf` ) ≤a(pf`+1) for
all ` = 1, . . . , k − 1. We make no assumptionon the relation
between arrival times of packets correspondingto different frames.
Each packet p is also characterized by adeadline, denoted e(p), by
which it should be scheduled fordelivery, or else the packet
expires. We assume e(p) ≥ a(p)for every packet p, and define the
slack of packet p to ber(p) = e(p)− a(p). For every time t and
packet p for whicht ∈ [a(p), e(p)], if p has not yet been delivered
by t, we sayp is pending at t. we further define its residual slack
at t tobe rt(p) = e(p)− t.2
We refer to an arrival sequence as being d-uniform if forevery
packet p in the sequence we have r(p) = d. Weassume that k ≤ d,
which implies that any arriving frame canpotentially be
successfully delivered (e.g., if all other framesare ignored). We
further let b denote the maximum burst size,i.e., for every time t,
the number of packets arriving at t is atmost b.
The packets arrive at a queue residing at the tail of alink with
unit capacity. The queue is assumed to be emptybefore the first
packet arrival. In each time-slot t we havethree substeps: (i) the
arrival substep, where the new packetswhose arrival time is t
arrive and are stored in the queue,(ii) the scheduling/delivery
substep, where at most one packetfrom the queue is scheduled for
delivery, and (iii) the cleanupsubstep, where every packet p
currently in the queue whichcan not be scheduled by its deadline is
discarded from thequeue, either because rt(p) = 0, or because it
belongs to aframe which has multiple pending packets at time t and
it isnot feasible to schedule at least one of them by its
deadline.Such packets are also said to expire at time t.
For every frame f and every time t, if f is not yetsuccessful,
but all of its packets that have arrived by t areeither pending or
have been delivered, then f is said to bealive at t. Otherwise it
is said to have expired. A frame issaid to be successful if each of
its packets is delivered (by itsdeadline).
2Note that this is a tad different from the model used in [4]
since we allowa packet to be scheduled also at time e(p) = a(p) +
r(p).
The Bounded-Delay Goodput problem (BDG) is defined asthe problem
of maximizing the number of successful frames.When traffic is
d-uniform, we refer to the problem as the d-uniform BDG problem
(d-UBDG).
The main focus of our work is designing online algorithmsfor
solving the BDG problem. An algorithm is said to beonline if at any
point in time t the algorithm knows only ofarrivals that have
occurred up to t, and has no informationabout future arrivals. We
employ competitive analysis [5], [6]to bound the performance of the
algorithms. We say an onlinealgorithm ALG is c-competitive (for c ≥
1) if for every finitearrival sequence it produces a solution who’s
goodput is atleast a 1/c fraction from the optimal goodput
possible. c is thensaid to be an upper bound on the competitive
ratio of ALG.As is customary in studies of competitive algorithms,
we willsometimes assume the algorithms works against an
adversary,which generates the input as well as an optimal solution
forthis input. This view is especially useful when showing
lowerbounds. For completeness, we also address the offline
problemwhere the entire arrival sequence is given in advance. In
suchoffline settings the goal is to study the approximation
ratioguaranteed by an algorithm, where an offline algorithm is
ansaid to be an α-approximation algorithm if for every
finitearrival sequence the goodput of the solution it produces
isalways at least a fraction 1/α of the optimal goodput
possible.
B. Our Contribution
In this paper we provide the initial study of
schedulingdelay-bounded traffic in the presence of packet
dependencies.We initially provide some initial observations on the
offlineversion of the problem, and then turn to conduct a
thoroughstudy of the problem with d-uniform traffic, i.e., where
allpackets have uniform delay d, burst sizes are bounded by b,and
each frame consists of k packets.
In the offline settings, we show that hardness results
derivedfor the bounded-size FIFO queue model are applicable toour
problem as well, which implies that it is NP-hard toapproximate the
problem to within a factor of o(k/ ln k), andthat a (k +
1)-approximation exists.
In the Online settings we provide a lower bound of Ω(bk−1)on the
competitive ratio of any deterministic online algorithmfor the
problem, as well as several other refined lower boundsfor specific
values of the system’s parameters. We also designonline
deterministic algorithms with competitive ratio thatasymptotically
matches our lower bounds. This means thatour algorithms are optimal
up to a (small) constant factor.
We complement our analytical study with a simulationstudy which
studied both our proposed algorithms, as well asadditional
heuristics for the problem, and also explores variousalgorithmic
considerations in implementing our solutions. Oursimulation results
show that our proposed solutions are close tooptimal, and also
provide strong evidence that the performanceexhibited by our
algorithms in simulation closely follow theexpected performance
implied by our analysis.
Due to space constraints, some of the proofs are omitted,and can
be found in [7].
-
3
C. Previous Work
The effect of packet-level decisions on the the
successfuldelivery of large data-frames has been studied
extensively inthe past decades. Most of these works considered FIFO
queueswith bounded buffers and focused on discard decisions
madeupon overflows [8], as well as more specific aspects relating
tovideo streams [9], [10]. This research thrust was accompaniedby
theoretical work trying to understand the performanceof buffer
management algorithms and scheduling paradigms,where the underlying
architecture of the systems employedFIFO queues with bounded
buffers. The main focus of theseworks was the design of competitive
algorithms in an attemptto optimize some figure of merit, usually
derived from Quality-of-Service objectives (see [11] for a survey).
However, most ofthe works within this domain assumed the underlying
packetsare independent of each other, and disregarded any
possiblestructure governing the generation of traffic, and the
effect thealgorithms’ decisions may have on such frame-induced
traffic.
Recently, a new model dealing with packet dependencieswas
suggested in [12]. They assumed arriving packets arepartitioned
into frames, and considered the problem of maxi-mizing the system’s
goodput. The main focus of this work wasbuffer management of a
single FIFO queue equipped with abuffer of size d, and the
algorithmic questions was how tohandle buffer overflows, and they
presented both competitivealgorithms as well as lower bounds for
this problem. In whatfollows we refer to this problem as the
d-bounded FIFOproblem (d-BFIFO). Following this work, a series of
worksstudied algorithms for various variants of the problem
[13],[14], [15], [16]. Our model differs significantly from this
bodyof work since in our model we assume no bounds on theavailable
buffer size (as is more common in queueing theorymodels), nor do we
assume the scheduler conforms with aFIFO discipline. More
generally, we focus our attention on thetask of deciding which
packet to schedule, where each arrivingpacket has a deadline by
which it should be delivered, asopposed to the question of how one
should deal with overflowsupon packet arrival when buffering
resources are scarce.
Another vast body of related work focuses on issues
ofscheduling, and scheduling in packet networks in particular,in
scenarios where packets have deadlines. Earliest-Deadline-First
schedulilng was studied in various contexts, includingOS process
scheduling [17], and more generally in the ORcommunity [18]. Our
framework is most closely related to [4]which considers a packet
stream where each packet has adeadline as well as a weight, and the
goal is to maximizingthe weight of packets delivered by their
deadline. They alsoconsider relations between this model and the
bounded-bufferFIFO queue model, and present competitive algorithms
inboth settings. These results are related to our discussionof the
offline settings in Section II. Additional works pro-vided improved
competitive online algorithms for this problem(e.g. [19], [20]).
However, none of these works considered thesettings of
packet-dependencies, which is the main focus ofour work.
II. THE OFFLINE SETTINGSIn order to study the d-UBDG problem in
the offline
settings, it is instructive to consider the d-BFIFO
problemstudied in [12]. We recall that in this problem traffic
arrivesat a FIFO queue with buffer capacity d, and the goal is
tomaximize the number of frames for which all of their packetsare
successfully delivered (and not dropped due to
bufferoverflows).
In what follows we first prove that these two problems
areequivalent in the offline settings (proof omitted).
Lemma 1. For any arrival sequence σ, a set of frames
Fconstitutes a feasible solution to the d-UBDG problem if andonly
if it is a solution to the d-BFIFO problem.
Proof: Assume a d-BFIFO algorithm A, and a d-UBDGalgorithm B,
and note the set of packets in the queue of A attime t as - PAF
(t), and the set of packets in the buffer of Bat time t as - PBU
(t).
At the time of arrival, every packet that a A can choose
toenqueue can be held in the buffer of B (since there are
nocapacity constraints). Every packet that A enqueues can notstay
in the queue more than d time slots, since after d timeslots the
packet must have been either sent or discarded (pre-empted) - the
packet can not be in the queue longer thanthe slack time d.
Therefore any algorithm B which neverschedules a packet before it
is scheduled by A can maintainthat PAF (t) ∈ PBU (t).
As at any time t an B can hold all the packets which A canhold,
any schedule which is feasible for A algorithm, is alsofeasible for
B (including the optimal schedule).
For the reverse direction, assume that B creates the scheduleSB
. At any time t, of all the packets in the buffer at that time,no
more than d packets can be part of the schedule SB - ifthere were
more than d packets than not all of them couldhave been sent,
rendering the schedule infeasible.
Therefore at any time t, all the buffered packets of theschedule
SB can fit a FIFO queue of size d. Since a packet cannot stay in a
FIFO queue and in the unbounded buffer morethan d time slots, there
must exist an offline FIFO scheduleSA, for which all the packets in
SB are in SA.
Note that in particular, Lemma 1 implies that a set of framesF
is optimal for d-UBDG if and only if it is optimal for d-BFIFO. By
using the results of [12] for the d-BFIFO problemwe obtain the
following corollaries:
Corollary 2. It is NP-hard to approximate the BDG problemto
within a factor of o( kln k ) for k ≥ 3, even for
0-uniforminstances.
Proof: Since any o( kln k ) approximation would imply
anapproximation of the same factor for the 1-BFIFO problem,the
result follows from [12, Corollary 2].
Corollary 3. There is a deterministic (k +
1)-approximationalgorithm for the d-UBDG problem.
Proof: One can apply the algorithm G-OFF specifiedin [12]. The
result follows from [12, Theorem 3].
-
4
III. THE ONLINE SETTINGS
The offline settings studied in section II, and the
relationbetween the d-UBDG problem and the d-BFIFO problem,give
rise to the question of whether one should expect a similarrelation
to be manifested in the online settings. In this sectionwe answer
this question in the negative.
A first fundamental difference is due to the fact that inthe
d-UBDG problem the scheduler is not forced to follow aFIFO
discipline. This means that the inherent delay of packetsstored in
the back of the queue which occurs in a FIFO buffer(unless packets
are discarded upfront) can be circumventedby the scheduler in the
d-UBDG problem, allowing it to takepriorities into account. Another
significant difference betweenthe two problems is that while in the
d-BFIFO problem discarddecisions in case of buffer overflow must be
made immediatelyupon overflow, in the d-UBDG problem such decisions
can besomewhat delayed. Intuitively, the online algorithm in the
d-UBDG problem has more time to study the arrivals in the
nearfuture, before making a scheduling decision, and thus enableit
to make somewhat better decisions, albeit myopic. We notethat this
view is also used in [20], [19] in the concepts ofprovisional
schedules and suppressed packets (we give moredetails of these
features in subsection IV-B).
A. Lower Bounds
In this section we provide several lower bounds for
variousranges of our systems parameters. The main theorem is
thefollowing:
Theorem 4. Any algorithm for the d-UBDG problem withburst size b
≥ 2d has competitive ratio Ω(bk−1).
Proof: Assume an arrival sequence with b > 1, for trafficwith
slack d comprised of three stages:
Stage 1 - at times 0, 1, 2, ..., (n − 1), b ’1’ packets
arrive.During this stage, out of nb ’1’ packets any online
algorithmcan only schedule up to n+ d ’1’ packets, and the
adversarycan schedule at least n (and at most n + d) other packets
-there are at most d time slots for which the online algorithmcan
schedule all arriving packets. We choose n so that n+ dis a
multiple of b in order to simplify the analysis.
Stage 2 - at times n, n + 1, ..., n + (n + d)/b − 1, b
’2’packets of frames whose ’1’ packets were scheduled by theonline
algorithm arrive. If we had not chosen n + d to be amultiple of b,
then there would also have been one more burstof size n+ d− b(n+
d)/bc.
Stage 3 - Stage 3 - at times n+ (n+ d)/b, n+ (n+ d)/b+1, ...,
n+(n+d)/b+n(d−1)−d−1, one ’2’ packet of frameswhose ’1’ packet were
not scheduled by the online algorithmarrive (including the
adversary’s packets).
This sequence is illustrated in Figure 1.For k > 2 stages 2
and 3 can be repeated with a slight
modification to stage 2 - packets of frames which werescheduled
by the online algorithm at the previous round arrivefirst (the
burst contains frames whose packets were scheduledby the online
algorithm in at least one stage).
By the end of stage 1, both the online and optimal algo-rithms
would have sent n+d ’1’ packets. Stage 2 is designedto hit the
goodput of the online algorithm as much as possible- only the
online algorithm schedules packets. Stage 3 isintended to maximize
the goodput of the optimal algorithm.
The goodput of the optimal schedule for this input is at leastn
(and at most n+ d). For k=2, the best possible goodput foran online
unbounded buffer algorithm can not be better thand+ n+db - the
algorithm can schedule up to d packets of thelast burst of stage 2,
and for all earlier bursts of stage 2 nomore than one packet each.
Since the at the end of the previousstage the number of frames
whose ’1’ packets were scheduledby the algorithm is n+ d, there are
n+db bursts in total.
If stages 2 and 3 are repeated, than the goodput of theoptimal
schedule for this input remains at least n.
In general, after stages 2 and 3 are performed j times,
thegoodput (GP ) of any online algorithm can not exceed GPj =d+
GPj−1b .
By induction: for j = 1 we have from the definition ofstage 1
that GPj−1 = n+ d and that GPj = d+
GPj−1b . For
the induction stage consider j + 1: during stage 2 there areGPjb
consecutive bursts (since packets scheduled during the
previous round arrive first), and therefore the online
algorithmcan not schedule more than GPjb + d packet, hence GPj+1
=d+
GPjb .
The best possible goodput of an online algorithm with kpackets
in a frame is then:
n+ d
bk−1+
k∑i=2
d
bi−2
Therefore, since we control n and can make it as large as
wedesire (nb is analogous to the number of streams), the lowerbound
for the competitive ratio of an online algorithm with amaximum
burst size of b is:
|ALG||OPT | ≤
n+ d
n · bk−1 +k∑
i=2
d
n · bi−2 −−−−→n→∞1
bk−1
Our lower bound can be adapted to token-bucket regulatedtraffic,
with maximum burst size b and average rate r. Suchrestrictions on
the traffic are quite common in SLAs. Of specialinterest is the
case where the average rate is r = 1, whichessentially means the
link is not oversubscribed. Even for suchhighly regulated traffic,
we have the following lower bound:
Theorem 5. For token-bucket regulated traffic with parame-ters
(b, r = 1), any algorithm for the d-UBDG problem whereb ≥ 2d has
competitive ratio Ω(
(bd
)k−1).
Proof: This proof is very similar to the proof of Theo-rem 4,
and therefore we only give the differences.
The arrival sequence is modified so in stage 1 the
intervalbetween consecutive bursts is of length 2d (in order to
buildup for the next burst), and in stage 2 the interval
betweenconsecutive bursts is of length b. Stage 3 remains
unchanged.
-
5
0 (n − 1) n n + n+db − 1 n + n+db n + n+db + 1 t
b
b·p
1
b·p
1
b
b·X
2
b·X
2
Y2 Y2
Y - AdversaryX - Algorithm
Fig. 1: Input for lower bound - The input is comprised of
threestages. During the first stage the algorithm schedules n +
d’1’ packets and the adversary schedules n + d different
’1’packets. During the second stage the algorithm’s ’2’
packetsdesignated X2j arrive as densely as possible. During stage
3the adversary’s ’2’ packets designated Y 2j arrive in a
patternthat allows the adversary not to drop a single packet
The goodput after repeating stages 2 and 3 j times can notexceed
GPj = d+
d·GPj−1b , since out of every burst in stage
2 the online algorithm can schedule up to d packets.The best
possible goodput for an online algorithm with k
packets in a frame is then:
ndk
bk−1+
k∑i=2
di−1
bi−2
Therefore, the lower bound for the competitive ratio of anonline
algorithm with a maximum burst size of b is:
|ALG||OPT | ≤
ndk
nd · bk−1 +k∑
i=2
di−1
nd · bi−2 −−−−→n→∞ (d
b)k−1
B. The Proactive Greedy Algorithm
In this section we present a simple greedy
algorithm,PROACTIVEGREEDY (PG), that essentially ignores the
dead-lines in making scheduling decisions, and proactively
dropspackets from the queue. Although one wouldn’t expect suchan
algorithm to perform well in practice, its simplicity allowsfor a
simple analysis which serves as the basis for the designand
analysis of the refined greedy algorithm for the d-UBDGproblem
presented in subsequent sections.
For every time t and frame f that has pending packetsat t, let
It(f) denote the index of the first pending packetof f . Recall
that by our assumption on the order of packetswithin a frame, this
is the minimal index of a pending packetcorresponding to f . We
consider at every time t all pendingframes as ordered in decreasing
order (It(f). For every packetf we let w(f) denote the number of
packets correspond-ing to f that were delivered by PROACTIVEGREEDY,
i.e.w(f) = |{p ∈ f | p is delivered by PG}|. In what follows
weslightly abuse notation and refer to a frame as alive as long
asnone of its packets has expired nor was dropped.
AlgorithmPROACTIVEGREEDY is described in Algorithm 1.
Algorithm 1 PROACTIVEGREEDY: at the scheduling substepof time
t
1: drop all pending packets of frames that are not alive2: Qt ←
all alive frames with pending packets at t3: f ← arg maxf ′∈Qt It(f
′) . Ties broken arbitrarily4: drop all pending packets of frames
in Qt \ {f}5: deliver the first pending packet of f
The following lemma shows no packet ever expires
inPROACTIVEGREEDY.
Lemma 6. No packet ever expires in PROACTIVEGREEDY.
Proof: Consider some packet p ∈ f for some frame f ,and assume p
is not delivered. It follows that there exists someminimal time
slot t where f ceases to be alive. Consider timea(p). If t <
a(p), then p is dropped upon arrival in line 1.If f is alive at
a(p) then Qa(p) 6= ∅. Let f ′ be the frameidentified in line 3. if
f 6= f ′, then p is dropped in line 4, attime a(p) and therefore
does not expire. Otherwise, we havef = f ′. Note that at the end of
every scheduling substep thequeue can only hold packets
corresponding to the single frameidentified in line 3 (if it is not
empty). It follows that p is inthe queue until time t, and since d
≥ k, if it weren’t dropped itcould have been delivered successfully
after all the precedingpackets of f residing in the queue with it
at time a(p), andwouldn’t expire. Since p is not delivered, it
follows that pmust be dropped at some time t ≤ a(p)+d due to some
otherframe f ′ identified in line 4.
The following corollary follows directly from Lemma 6.
Corollary 7. Every frame in the arrival sequence is
eithersuccessfully delivered by PROACTIVEGREEDY, or has one ofits
packets proactively dropped.
Let FPG be the set of frames successfully delivered by PG,and
let O denote the set of frames successfully delivered bysome
optimal solution.
Lemma 8. If f /∈ FPG, then there exists a time t = tf suchthat f
is alive at t, packet pIt(f) ∈ f is dropped in time t, anda packet
p′ ∈ f ′ is delivered at time t, for some frame f ′.
Proof: The proof follows directly from Lemma 6, and thedetails
in its proof applied to packet pIt(f) at the maximumtime t for
which f is alive at the beginning of time slot t.
We describe a mapping φ of frames in the arrival sequenceto
frames in FPG:
1) if f ∈ FPG then f is mapped to itself.2) if f /∈ FPG, then
let pf be the first packet of f dropped
by PG in line 4, and denote by tf the time slot where pfis
dropped. Let p′ = p ∈ f ′ be the packet scheduled intime slot tf in
line 5. We map f to f ′ directly, and re-map any frames that were
previously mapped to f ontof ′ indirectly. We say that these frames
are re-mapped tof ′ via packet p′. We also refer to tf as the drop
timeof f and to the set of frames mapped to f via p (eitherdirectly
or indirectly) as M(p).
-
6
The following lemma shows that frames are remapped ontoframes
that are (strictly) closer to completion.
Lemma 9. If f /∈ FPG is mapped to f ′ then w(f ′) >
w(f).Proof: Let t be the drop time of f and let f ′ be the
frame to which f is directly mapped. By the choice of f ′ inline
3 it follows that It(f ′) ≥ It(f). It follows that w(f) =It(f)− 1,
and since a packet of f ′ is delivered in time t wehave w(f ′) ≥
It(f ′). Combining these inequalities we obtain
w(f ′) ≥ It(f ′) ≥ It(f) > It(f)− 1 = w(f),as required.
The following corollary bounds the length of a
re-mappingsequence.
Corollary 10. A frame can be (re-)mapped at most k times,and all
frames are eventually mapped to frames in FPG.
Proof: By definition every f ∈ FPG is mapped to itself.For every
frame f /∈ FPG, consider the number of times `ffor which f is
mapped directly or indirectly to some otherframe. Denote by f` the
`-th packet to which f is mapped.We prove by induction on ` that in
the `-th such (re-)mapping,where f is mapped to f`, we have w(f)
< w(f)+ ` ≤ w(f`).This will imply that after at most k
remappings f is mappedto a frame f ′ for which w(f ′) = k, i.e., f
′ ∈ FPG. Forthe base case where ` = 1, this means f is directly
mappedto f1. By Lemma 9 we have w(f) < w(f1), and thereforew(f)
+ 1 ≤ w(f1). For the induction step, consider the `-thremapping for
` > 1. By the definition of the mapping, fwas mapped (directly
or indirectly) to f`−1 in the (` − 1)-th remapping, and we are
guaranteed to have w(f) + (` −1) ≤ w(f`−1). By Lemma 9 we have
w(f`−1) < w(f`), andtherefore w(f`−1)+1 ≤ w(f`). By combining
the inequalitieswe obtain
w(f) + ` = w(f) + (`− 1) + 1 ≤ w(f`−1) + 1 ≤ w(f`),thus
completing the proof.
The following corollary is an immediate consequence ofLemma 8
and Corollary 10.
Corollary 11. The mapping φ is well defined.
Lemma 12. For every frame f , the number of frames
directlymapped to f via packet p ∈ f is at most b.
Proof: As there can be at most b packets arriving at t,and all
carrying over from t− 1 correspond to a single frame,the number of
frames mapped via p(t) ∈ f is at most b.
By Lemma 12 it follows that the overall number of framesdirectly
mapped to any single frame f is at most kb. Com-bining this with
Corollary 10 implies a (k · b)-ary depth-ktree structure for the
mapping (direct or indirect) onto anysingle frame f ∈ FPG, which
shows that PROACTIVEGREEDYdelivers at least a fraction of 1
(k·b)k of the total arrivingtraffic. This clearly serves as a
bound on the competitive ratio.However, a significantly better
bound can be obtained by acloser examination of direct
mappings.
Lemma 13. For every frame f , the overall number of framesmapped
to f at time t via packets p` ∈ f is at mostb · (1 + b)`−1.
Proof: First we observe that if a a frame f ′ is directlymapped
to a frame f at time t, then It(f ′) ≤ It(f). Inparticular, if the
minimal-indexed packet of f ′ dropped at timet is the j-th packet
of f ′, then j ≤ It(f). Also notice that(1 + b)`−1 =
∑`−1i=0
(`−1i
)bi.
We now turn to prove the claim by induction on `. For thebase
case of ` = 1, assume f ′ is mapped to f via p` at timet. If f ′ is
mapped to f directly, by the above observation wehave that the
minimal-indexed packet of f ′ dropped at t is atmost ` = 1, and
therefore it must be the first packet of f ′.Since all these
packets must have arrived at time t, it followsthat none of these
frames have any frames mapped to them.By Lemma 12 it follows that
the overall number of framesdirectly mapped to f via p is at most
b. Note that this impliesthat for the base case there can be no
frames indirectly mappedto f . It follows that the overall number
of frames mapped to fvia p1 is at most |M(p1)| = b = b · (1 + b)0,
thus completingthe base case. For the induction step consider p`+1
∈ f for` + 1, and let f ′′ be a frame mapped to f via p`+1. Assumef
′′ is mapped to f directly. By the above observation we havethat
the minimal-indexed packet of f ′′ dropped at t is at most` + 1.
Again, the overall number of frames directly mappedto f via p`+1 is
at most b. It follows that the maximum indexof a packet p′′ ∈ f ′′
for which there were frames mapped tof ′′ via p′′ is at most `.
Hence for ` + 1, the overall numberof frames mapped to f at time t
via pf`+1 is at most:
|M(p`+1)| = b(
1 +∑̀i=1
|M(p′′i )|)
(1)
≤ b
(`0
)· b0 +
∑̀i=1
i−1∑j=0
b ·(i− 1j
)· bj (2)
= b
(`0
)· b0 + b
∑̀i=1
bi−1`−i∑j=0
(i− 1 + ji− 1
) (3)= b
((`
0
)· b0 + b
∑̀i=1
(`
i
)bi−1
)(4)
= b∑̀i=0
(`
i
)bi.
Equality (1) follows from the direct mappings via p`+1and
inequality (2) follows from the induction hypothesis.Equality (3)
follows from reversing the order of summationon j, and noticing
that only the topmost `− (i−1) sums overj contribute to the
coefficient of bi−1. Finally, equality (4) isa simple diagonal
binomial identity.
Since f ′′ itself is mapped to f in addition to all the
frameswhich were mapped to f ′′.
Recall O denotes the set of frames in an optimal solution.The
following corollary provides a bound on the number of
-
7
frames in O\FPG that are mapped by our mapping
procedure.Corollary 14. For every frame f , the overall number of
framesin O \ FPG mapped to f at time t via packets p` ∈ f is atmost
min {d, b} · (1 + b)`−1.
Proof: Assume a frame f which has a packet p ∈ fdelivered by
PROACTIVEGREEDY at time t. The number offrames in O \ FPG which can
be directly mapped to f viap ∈ f is at most min {d, b}, since the
optimal solution cannotdeliver more than d of the pending packets
at any time t.
If d ≥ b, then since the maximal number of packets whichcan
arrive at time t is b, the result of Lemma 13 applies inthis case
too, and b = min {d, b}.
If d < b, if frames f ′ ∈ O \ FPG were to be mapped toanother
frame f ′′ ∈ O \FPG via p
′′
` then at most d−1 frameswith weight w(f ′`−1) or d frames with
weight w(f
′`−2) can
be directly mapped via p′′
` . Therefore, the highest number offrames f ′ ∈ O \ FPG mapped
to a single frame f ∈ FPGis achieved when frames f ′ ∈ O \ FPG can
not be mappedto frames f ′′ ∈ O \ FPG (otherwise the resulting tree
likestructure contains less mapped frames) - the maximal numberof
frames f ′ ∈ O \FPG mapped to a single frame f ∈ FPG isachieved
when PROACTIVEGREEDY never schedules a packetof a frame f ′ ∈ O \
FPG. Hence by counting the maximalnumber of frames mapped to f ∈
FPG via packets withweight w ≥ 1 according to Lemma 13 (b (1 +
b)`−2 mappedframes), and mapping at most d frames f ′ ∈ O \ FPG
viaevery scheduled packet with ` = 1 (for every frame mappedto f
including itself), the result for the maximal number offrames f ′ ∈
O \ FPG mapped to a single frame f ∈ FPG is(b (1 + b)
`−2+ 1)d ≤ d (1 + b)`−1.
Theorem 15. Algorithm PROACTIVEGREEDY isO(min {d, b}
bk−1)-competitive.
Proof: By Corollary 14 the overall number of frames inO \ FPG
mapped to any f ∈ FPG is
k∑`=1
∣∣∣M(pf` )∣∣∣ ≤ min {d, b} k∑`=1
(1 + b)`−1
= min {d, b} bk−1(1 +O(kb
))
= O(min {d, b} bk−1),
which completes the proof.From this analysis of the
PROACTIVEGREEDY algorithm
we learn that choosing a preference based on how close is aframe
to completion guarantees not only that a frame will becompleted
(Corollary 10), but also that the algorithm will becompetitive.
Also, even though this algorithm is very simple(conceptually), the
competitiveness is close to the lower boundwe proved for the
general case (within a factor of d from thelower bound). This
competitive ratio does not depend if thetraffic is burst bound (r =
b the general case) or token bucketshaped (r < b), since an
arrival sequence achieving this bound
can be created regardless of the value of r (due to step 2 ofthe
algorithm).
C. The Greedy Algorithm
With the proactive greedy algorithm, we saw that choosinga
preference based on how close is a frame to completionresults in an
upper bound which is close to the lower bound forthe general case
(r = b). However, the PROACTIVEGREEDYalgorithm is not a natural
algorithm to suggest since framesare being dropped unnecessarily,
resulting both in inefficiencyand in implementation complexity.
We suggest a more intuitive algorithm, the GREEDY algo-rithm -
Algorithm 2. The only difference between the twoalgorithms is that
the GREEDY algorithm does not drop framesunnecessarily - a frame
expires only if it is not feasible toschedule one of it’s packets
by the packet’s deadline.
Algorithm 2 GREEDY: at the scheduling substep of time t1: drop
all pending packets of frames that are not alive2: Qt ← all alive
frames with pending packets at t3: f ← arg max {It(f ′) | f ′ ∈
Qt}4: deliver the first pending packet of f
We say a packet pf` is eligible if at a time t it is in
thebuffer of GREEDY and it’s index is ` = It(f) - it is the
firstpending packet of the live frame f at time t. The
followinglemma relates the number of packets of index at least `
thatwere dropped by GREEDY, to the number of packets of indexat
least ` that were delivered by t.
Lemma 16. For any time t during which a previously
eligiblepacket p` ∈ f is dropped, assume n`t is the total number
ofpackets with index at least ` which were eligible and droppedby
time t. It follows that at least dn`t/be packets with index ofat
least ` were delivered by GREEDYby time t.
Proof: At most b+ 1 packets can become eligible at thestart of
any time t - a burst of at most b packets, and onepacket p′′′i ∈ f
′′′ which was in buffer at time t − 1 if packetp′′′i−1 ∈ f ′′′ was
scheduled at time t-1.
When a packet p` ∈ f is eligible, only a packet whichbelongs to
a frame of at least the same weight can bescheduled. We note two
possible cases:
1) For the case that b + 1 packets belonging to frameswith
weight w(f ′) ≥ w(f) become eligible at time t(including p`), then
one of them will be scheduled sinceall eligible packets carrying
over from time t−1 p′′ ∈ f ′′belong to frames with w(f ′′) < w(f
′′′) - at least onepacket out of b+ 1 will be scheduled at time
t.
2) For the case that up to b packets belonging to frameswith
weight w(f ′) ≥ w(f) become eligible at time t(including p`), then
one packet pi≥` will be scheduled.The packet scheduled at time t
can be one of the up tob packets that became eligible, or it can be
a packet thatarrived at an earlier time (and is still eligible) -
at leastone packet out of b + 1 (in case the scheduled packet
-
8
was already eligible at t − 1) packets will be scheduledat time
t.
Note that if at time t − 1 there were eligible packets withw(f
′) ≥ w(f), all of them were already accounted for at timeof first
eligibility - either during a previous case 2, or duringa previous
case 1.
The combination of the two cases guarantees that at anytime t,
if the number of packets with index of at least ` whichwere
eligible and subsequently dropped by GREEDY by timet is n, than at
least dnb e packets with an index of at least `were scheduled by
time t.
In order to find the upper bound of the competitive ratio, weuse
the same approach used to analyze PROACTIVEGREEDY.Let FG be the set
of frames successfully delivered by GREEDYand let O denote the set
of frames successfully delivered bysome optimal solution. We define
mapping ψ of frames in thearrival sequence to packets in FG.
1) if f ∈ FG then f is mapped to itself.2) if f ∈ O \ FG, then
let pf` be the first packet of f
dropped by G in line 1, and denote by tf the time slotwhere pf`
was dropped. Let p
′i≥` = p(t ≤ tf ) ∈ f ′ be
a packet scheduled in time slot t ≤ tf in line 5. Wemap f to f ′
directly, and re-map any frames that werepreviously mapped to f
onto f ′ indirectly, if it is theearliest scheduled packet with the
lowest index i ≥ `which has less than 2 packets already directly
mappedto it. We say that these frames are re-mapped to f ′
viapacket p′ = p(t ≤ tf ). We also refer to the group of allframes
mapped to f via p as M(p).
3) if f /∈ FG ∪ O, then let pf` be the first packet of fdropped
by G in line 1, and denote by tf the time slotwhere pf` was
dropped. Let p
′i≥` = p(t ≤ tf ) ∈ f ′ be
a packet scheduled in time slot t ≤ tf in line 5. Wemap f to f ′
directly, and re-map any frames that werepreviously mapped to f
onto f ′ indirectly, if it is theearliest scheduled packet with the
lowest index i ≥ `which has less than b packets already directly
mappedto it. We say that these frames are re-mapped to f ′
viapacket p′ = p(t ≤ tf ). We also refer to the group of allframes
mapped to f via p as M(p).
The following lemma shows that the mapping is welldefined, and
that at most 2 packets of O are directly mappedto any single frame
f .
Lemma 17. At any time t when there is no eligible packetwith
index j ≥ `, at least 1 packet with index i ≥ ` have beenscheduled
by GREEDY for every 2 packets with indices j ≥ `which were eligible
and subsequently dropped by GREEDY.
Proof: Note that during every time slot that packet p` ∈f ∈ O is
eligible for GREEDY, if it is not scheduled it meansthere exist
some packet p′i≥` ∈ f ′ which is scheduled instead.Also note that
the schedule of the adversary must be feasible.
Consider the first time a packet with index ` becomeseligible
te: either all the packets with index i ≥ ` whichbecame eligible at
te (at least one of them with index i = `)
arrived at te, or one of the packets with an index i = `
whichbecame eligible was already in the buffer and became
eligiblebecause the `− 1 packet of the same stream was scheduled
attime slot te − 1.
We define tb as the first time after te where there are
noeligible packets with an index i ≥ ` in the buffer, by
definitiontb > te. We say call the interval [te, tb] an `-ary
busy period.
During an `-ary busy period, at most tb − te + 1 of
theadversary’s packets with index i ≥ ` can become eligible
forGREEDY:• at time te up to d+1 of the adversary’s packets with
indexi ≥ ` can become eligible for GREEDYdue to feasibilityof O, as
at most d such eligible packets can arrive at timete and one packet
was already in the buffer can becomeeligible.
• during the interval [te, tb] at most tb−te of the
adversary’spackets with index i ≥ ` could arrive and become
eligiblefor GREEDY, due to the combination of the feasibility ofO
and of the fact that at time tb there are no eligiblepackets with
index i ≥ ` in the buffer.
During the `-ary busy period [te, tb], tb − te packets withindex
i ≥ ` are scheduled by GREEDY.
Therefore during the `-ary busy period [te, tb], GREEDYschedules
tb − te packets with index i ≥ `, and drops at mosttb − te + 1 of
the adversary’s packets with index i ≥ ` whichbecame eligible
during the interval.
We extend the definition of te to be the first time slot apacket
with index ` becomes eligible after some time t < teduring which
there were no eligible packets with index i ≥ ` inthe buffer (this
definition applies also for te = 0 as at previoustimes the buffer
was empty). Then an `-ary busy period canbe followed by another
`-ary busy period after a it ends (therecan be no overlap between
the busy periods). Busy periods ofdifferent indices can and do
overlap one another.
As all packets of index ` become eligible during an `-arybusy
period the result follows, since during a single busyperiod tb − te
packets with index i ≥ ` are scheduled byGREEDY, and at most
tb−te+1 of eligible adversary’s packetswith index i ≥ ` are dropped
by GREEDY.
Lemma 16 and Lemma 17 ensure that mapping ψ is welldefined. The
definition of ψ together with Corollary 10 yields:
Corollary 18. A frame can be (re-)mapped at most k times,and all
frames are eventually mapped to frames in FPG.
By the definition of ψ, no more than b frames can be
directlymapped to a frame f ′ via packet p′ ∈ f ′. Furthermore, iff
/∈ FG is mapped to f ′ then w(f ′) > w(f). It followsthat the
proof of Lemma 13 also holds for GREEDY(sinceall requirements are
met):
Corollary 19. For every frame f , the overall number offrames
mapped to f at time t via packets p` ∈ f is at mostb · (1 +
b)`−1.
Therefore by applying Corollary 19 and the fact that accord-ing
to ψ the number of frames in O \ FPG directly mapped
-
9
to any f via p ∈ f is at most 2, using similar arguments asthe
ones used in Corollary 14 and Theorem 15 we obtain thefollowing
theorem.
Theorem 20. Algorithm GREEDY is O(bk−1)-competitive.
Proof: Applying the arguments from Corollary 14 on theresults of
Corollary 19 Lemma 17, yields that the overallnumber of frames in
O\FPG mapped to f at time t via packetsp` ∈ f is at most 2 · (1 +
b)`−1 (since min {2, b} ≤ 2). Thenas in Theorem 15 the overall
number of frames in O \ FPGmapped to any f ∈ FPG is
k∑`=1
∣∣∣M(pf` )∣∣∣ ≤ 2 k∑`=1
(1 + b)`−1
= 2bk−1(1 +O(k
b))
= O(bk−1)
We note that by our lower bounds algorithm GREEDYoptimal up to a
constant factor. Furthermore it should be notedthat this improved
bound, as well as expected performancein practice, comes at a cost
of significantly more compleximplementation. Specifically, while
PROACTIVEGREEDY canpotentially be implemented using a FIFO buffer,
GREEDY doesnot deliver packets in FIFO order. In other aspects
GREEDY isnot significantly more complex than the
PROACTIVEGREEDYe.g., by trading garbage collection with killing
live frames.
IV. FURTHER ALGORITHMIC CONSIDERATIONS
A. Tie-breaking
The results from the analysis of the two algorithms, showus that
an algorithm should prefer frames which are closerto completion
(since this characteristic guarantees competi-tiveness), and that
live frames should be kept in the bufferas long as possible (as
shown by the difference between thealgorithms). But the analysis
brings up the question how tobest tie-break between frames which
are the same distancefrom completion (the number of sent packets is
the same forboth frames).
A natural choice for a tie-breaker is the residual slack rt(pf
)of the smallest-index packet pf ∈ Qt ∩ f for each frame fthat has
the maximal It(f) value. The purpose of such a tiebreaker is of
course to improve performance by keeping asmany frames alive as
possible.
A less obvious choice for a tie-breaker is the number ofpending
packets corresponding to frame f , denoted nt(f). Theintuition
underlying this choice is that preferring frames withlower nt(f)
can more rapidly “clear” the effect of f on otherframes with
pending packets.
One should note that neither choice affects the
asymptoticcompetitiveness of GREEDY, which is tight up to a
constantfactor. However, this choice is expected to influence
theperformance of the algorithms in practice. In section V
wefurther address these design dilemmas.
B. Scheduling
For both of the greedy algorithms presented in Sec-tions III-B
and III-C, the first packet of the preferred framewas sent, where
the difference between the algorithms boileddown to the the way
other pending packets were treated.In particular, the residual
slack of the packets is essentiallyignored by these greedy
approaches (although it can be takeninto account in tie-breaking,
as discussed above).
One common approach to incorporate residual slack into
thescheduler is considering provisional schedules, which
essen-tially try pick the packet to be delivered using a local
offlinealgorithm, which takes into account all currently
availableinformation. Such an approach can be viewed as aiming
tomaximize the benefit to be accrued from the present
packets,assuming no future arrivals. Such an approach lays at the
coreof the solutions proposed by [4], [20], [19] which each used
analgorithm for computing an optimal offline local solution. Inour
case, as shown in Corollary 2, computing such an optimalprovisional
schedule is hard, but, as shown in Corollary 3,there exists a
(k+1)-approximation algorithm for the problem.
We adapt this algorithm into a procedure for computing
aprovisional schedule, which would allow a smaller I-indexedframe
to have one of its packets scheduled, only if non of theframes with
a higher I-index would become infeasible in thefollowing time slot.
Our proposed heuristic, OPPORTUNISTIC,is described in Algorithm 3.
OPPORTUNISTIC builds a provi-sional schedule Ft as follows:
1) Sort pending frames3 in decreasing lexicographical orderof
(It(f), d − rt(f)). I.e., preference is given to frameswith higher
I-index values. In case of ties, preference isgiven to frames for
which their smallest-index packet hasthe minimal residual
slack.
2) Initialize the provisional schedule Ft = ∅.3) For each frame
f in this order, test whether for all s =
0, . . . , d, the pending packets of f can be added to Ftsuch
that the overall number of packets in the provisionalschedule with
remaining slack at most s, does not exceeds. If f can be added,
update Ft = Ft ∪ {f}.
Figure 2 gives an illustration of construction of a
provisionalschedule at some time t. The first two frames have room
forall their packets in the provisional schedule, and all of
theirpackets can be accommodated for delivery by their
deadlines(note that the first frame tested will always be a part
ofthe provisional schedule, since otherwise it would not bealive).
The packet of the third frame causes an “overflow”for s = 5, and
therefore its frame cannot be accommodatedin the provisional
schedule. We note that in this example, thepacket picked for
delivery would be P 21 ∈ f2, which mightnot correspond to the
highest I-index pending frame (e.g., ifIt(f2) < It(f1)).
V. SIMULATIONS
In the previous sections we provided an analysis of thegreedy
online algorithm, and of discussed additional guidelines
3A frame is pending if it has pending packets.
-
10
1 2 3 4 5 S
P 12 P13
1 2 3 4 5 S
P 12
P 13
P 21 P22
1 2 3 4 5 S
P 12
P 13
P 21
P 22
P 31
”overflow”at S = 4
Fig. 2: Schematics of building a provisional schedule.
Algorithm 3 OPPORTUNISTIC: at the scheduling substep oftime
t
1: Build the provisional schedule Ft2: transmit the packet with
minimum residual slack in Ft
for effective algorithm design. We also presented
algorithmOPPORTUNISTIC. In this section we provide a
simulationstudy in which we test the performance of the algorithms,
theeffectiveness the guidelines, and the impact the parameters kand
d on the performance.
A. Traffic Generation and Setup
We recall that the problem of managing traffic with
packetdependencies captured by our model is most prevalent
inreal-time video streams. We therefore perform a simulationstudy
that aims to capture many of the characteristics of
suchstreams.
We will generate traffic which will be an interleaving
ofstreams, where each stream is targeted at a different
receiver,and all streams require service from a single queue at the
tailof a link.
In our simulation study, we focus on traffic with thefollowing
characteristics.
• We assume each stream has a random start time wherepackets are
generated. This corresponds to scenarios suchas VOD streams, where
each receiver may choose whichvideo to view and when to view it,
and these choices areindependent.
• We assume the average bandwidth demand of all streamsis
identical, which represents streams with comparablevideo
quality.
• Frames of a single stream are non-overlapping, and areproduced
by the source in evenly spaced intervals. E.g.,if we consider video
streams consisting of 30FPS, eachinterval is 33ms.
• The source transmits the packets of each frame in a burst,and
we assume each frame consists of the same number ofpackets. Such a
scenario occurs, e.g., in MPEG encodingmaking use of I-frames
alone. We assume all packet havethe same size, namely, the
network’s MTU.
• We assume a random delay variation between the arrivalof
consecutive packets corresponding to the same stream.Such delay
variation is produced, e.g., due to queueing
delay in previous nodes along the streams path. Specif-ically,
we assume a uniform delay variation of up to 5time slots.
• We assume each packet contains the frame number, andthe index
number of the packet within the frame. Suchinformation can be
encoded, e.g., in the RTP header.
For the setup we chose to simulate, the packet sizes areset such
that every time slot one packet can be scheduled,and the aggregate
bandwidth of all the streams is equal to theservice bandwidth. We
note that even in such cases, wheretraffic arrival rate does not
exceed the link capacity, no onlinealgorithm can obtain the optimal
goodput.
We simulate 2 minutes worth of traffic for 50 streams, wherefor
all the streams the frame rate is 30FPS (for a total of 3600frames
per stream). Since we fix the service rate as 1, in thesimulation
the interval between consecutive frames arrival ina stream is ∆F =
k · 50 time slots, where k is the number ofpackets per frame. As k
grows the “real” duration of a singletime slot decreases, as the
service rate effectively increases.
B. Simulated Algorithms
We performed the simulation study for four schedulingalgorithms,
where in all algorithms in case of ties in thepriorities, these are
broken according to the a random (butfixed) priority on the
streams:• The offline O(k + 1)-approximation algorithm of [12].
By Corollary 3 this algorithm has the same performanceguarantee
in our model as well. This algorithm serves asa benchmark for
evaluating the performance of the onlinealgorithms.
• Algorithm GREEDY, described and analysed in subsec-tion III-C.
This algorithm represents our baseline forstudying the the
performance of online algorithms for theproblem.
• Algorithm GREEDYSLACK, which implements GREEDYwith ties broken
according to minimum residual slack.
• Algorithm OPPORTUNISTIC, presented insubsection IV-B. This is
the most complex algorithm weevaluate, as in addition to the
enhanced tie-breaking, italso attempts to exploit opportunities to
schedule lowerranked packets according to the provisional
schedule.
C. Results
The simulation results confirm our hypothesis that
imple-mentation of the proposed algorithm design guideline
doesindeed impact the performance of online algorithms. We
depictthe performance of each online algorithm by its goodput
ratio,measured by the ratio between the goodput of the
onlinealgorithm and that of the offline algorithm.
Figure 3 presents the performance of the online algorithmsas a
function of the slack each packet has, for k = 6. Itcan be seen
that as the slack increases the tie-breaking rulein GREEDYSLACK
shows significant improved performance incomparison with the
vanilla greedy algorithm. The figure alsoshows that the
OPPORTUNISTIC exhibits a significantly betterperformance than
GREEDYSLACK (although this improvement
-
11
is paid for by significant additional complexity). We note
thatresults for greater values of 12 exhibit the same trends.
Alsoof note is that the GREEDYSLACK and OPPORTUNISTIC manageto
trace the performance of the offline algorithm (and
actuallycomplete all the frames of all the streams) for traffic
withsufficiently large slack.
0 20 40 60 80 100 120 140 160 180Slack
0.70
0.75
0.80
0.85
0.90
0.95
1.00
Goo
dput
ratio
Goodput of online algorithms - k=12
GREEDY
GREEDYSLACK
OPPORTUNISTIC
Fig. 3: Comparison of the goodput of online algorithms
In Figure 4 we presents the goodput ratio of OPPOR-TUNISTIC and
GREEDYSLACK as a function of d/k. The firstlesson learnt from this
data is that the performance of theopportunistic algorithm is
superior to that of the enhancedgreedy algorithm, in particular for
small d/k values where thedifference becomes more pronounced (these
results are alsohinted by Figure 3, but are not as pronounced).
Furthermore,the performance of both algorithms depends
exponentially onthe ratio between d and k (shown by the log scale),
as eventhough both graphs present results of many simulations
withdifferent inputs having different parameters, the plots show
alinear trend up to the point where they match the goodput
ofoffline algorithm. This exponential dependency can be viewedas
comparable to that of the analytic lower bound presentedin
subsection III-A, where d/k takes the role of 1/k.
Another important result is that the streams are not
treatedfairly. When there is no random delay variation for the
inputsequence, the algorithms synchronize with the input so
eitherall frames of a stream are completed, or none of them are
com-pleted. Raising the limits of the random delay variation
im-proves the fairness, although some degree of
synchronizationremains. When there exists a random delay variation
highervalues of k result in improved fairness. The impact of
thedelay variation can be seen in Figure 5, which shows that
forGREEDYSLACK maximal delay variation of 1 time slot (for
anaverage of 0.5 time slots) results in complete synchronization- a
stream either has all of it’s frames completed or it has noframe
completed. Raising the maximal delay variation evenby a small
amount reduces the synchronization significantly.
400 800 1200 1600 2000 2400 2800 3200 3600Completed frames per
stream
0.0
0.2
0.4
0.6
0.8
1.0
Cum
mul
ativ
epe
rcen
tage
ofst
ream
s
Cummulative goodput per stream , k=6, d=10
jit=1jit=3jit=5jit=7
Fig. 5: Cumulative completed frames per stream forGREEDYSLACK as
a function of maximal delay variation (jitter)between packets of a
stream.
VI. CONCLUSIONS AND FUTURE WORK
In this paper we address the problem of maximizing thegoodput of
delay sensitive traffic with inter-packet depen-dencies. We provide
lower bounds on the competitivenessof online algorithms for the
general case that the traffic isburst bounded, and present
competitive scheduling algorithmsfor the problem. Through the
analysis we show that thereexists an algorithmic guideline that
ensures competitiveness- preference for frames that are closer to
completion. Ourproposed solutions ensure the optimal performance
possible,up to a small constant factor.
Our analysis further provides insights into improving
theperformance of online algorithms for the problem. Theseinsights
are further verified by a simulation study whichshows that our
improved algorithms which are inspired byour analytic results, are
very close to the performance of thecurrently best known offline
algorithm for the problem. Morespecifically, the performance of our
algorithms approach theperformance of our benchmark algorithm with
an exponentialcorrelation to the increase in delay-slack.
Our work serves as an initial study of scheduling delay-bounded
traffic with inter-packet dependencies. Our workraises new
questions about the performance of algorithms forthis problem:
1) Our simulation results indicate that the ratio d/k bearssome
influence on the algorithm performance. Sheddinglight on this
effect is an interesting open question.
2) Are there other algorithmic guidelines which can fur-ther
improve the performance of online algorithms, andspecifically how
well can randomized algorithms per-form?
-
12
100 101
log d/k
0.70
0.75
0.80
0.85
0.90
0.95
1.00
Goo
dput
ratio
Goodput of OPPORTUNISTIC
k=6k=12k=18k=24k=30
(a) OPPORTUNISTIC
100 101
log d/k
0.70
0.75
0.80
0.85
0.90
0.95
1.00
Goo
dput
ratio
Goodput of GREEDYSLACK
k=6k=12k=18k=24k=30
(b) GREEDYSLACK
100 101
log d/k
0.70
0.75
0.80
0.85
0.90
0.95
1.00
Goo
dput
ratio
Goodput of GREEDY
k=6k=12k=18k=24k=30
(c) GREEDY
Fig. 4: Goodput of the online algorithms as a function of d/k on
a logarithmic scale
REFERENCES
[1] Sandvine, “Global Internet phenomena report – 1H 2013,”
http://www.sandvine.com/, July 2013.
[2] J. M. Boyce and R. D. Gaglianello, “Packet loss effects on
MPEGvideo sent over the public internet,” in Proceedings of the 6th
ACMInternational Conference on Multimedia, 1998, pp. 181–190.
[3] J. F. Kurose and K. W. Ross, Computer Networking: A
Top-DownApproach. Addison-Wesley, 2011.
[4] A. Kesselman, Z. Lotker, Y. Mansour, B. Patt-Shamir, B.
Schieber, andM. Sviridenko, “Buffer overflow management in QoS
switches,” SIAMJournal on Computing, vol. 33, no. 3, pp. 563–583,
2004.
[5] D. D. Sleator and R. E. Tarjan, “Amortized efficiency of
list update andpaging rules,” Communications of the ACM, vol. 28,
no. 2, pp. 202–208,1985.
[6] A. Borodin and R. El-Yaniv, Online Computation and
CompetitiveAnalysis. Cambridge University Press, 1998.
[7] M. Markovitch and G. Scalosub, “Bounded delay schedulingwith
packet dependencies,” December 2013. [Online].
Available:http://www.bgu.ac.il/∼sgabriel/MS-2013.pdf
[8] S. Ramanathan, P. V. Rangan, H. M. Vin, and S. S. Kumar,
“Enforcingapplication-level QoS by frame-induced packet discarding
in videocommunications,” Computer Communications, vol. 18, no. 10,
pp. 742–754, 1995.
[9] A. Awad, M. W. McKinnon, and R. Sivakumar, “Goodput
estimation foran access node buffer carrying correlated video
traffic,” in Proceedingsof the 7th IEEE Symposium on Computers and
Communications (ISCC),2002, pp. 120–125.
[10] E. Gürses, G. B. Akar, and N. Akar, “A simple and
effective mechanismfor stored video streaming with TCP transport
and server-side adaptiveframe discard,” Computer Networks, vol. 48,
no. 4, pp. 489–501, 2005.
[11] M. H. Goldwasser, “A survey of buffer management policies
for packetswitches,” ACM SIGACT News, vol. 41, no. 1, pp. 100–128,
2010.
[12] A. Kesselman, B. Patt-Shamir, and G. Scalosub, “Competitive
buffermanagement with packet dependencies,” Theoretical Computer
Science,vol. 489–490, pp. 75–87, 2013.
[13] Y. Emek, M. M. Halldórsson, Y. Mansour, B. Patt-Shamir, J.
Radhakrish-nan, and D. Rawitz, “Online set packing,” SIAM Journal
on Computing,vol. 41, no. 4, pp. 728–746, 2012.
[14] Y. Mansour, B. Patt-Shamir, and D. Rawitz, “Competitive
router schedul-ing with structured data,” in Proceedings of the 9th
Workshop onApproximation and Online Algorithms (WAOA), 2011.
[15] ——, “Overflow management with multipart packets,” Computer
Net-works, vol. 56, no. 15, pp. 3456–3467, 2012.
[16] G. Scalosub, P. Marbach, and J. Liebeherr, “Buffer
management for ag-gregated streaming data with packet
dependencies,” IEEE Transacationson Parallel and Distributed
Systems, vol. 24, no. 3, pp. 439–449, 2013.
[17] A. Silberschatz, P. B. Galvin, and G. Gagne, Operating
System Concepts.John Wiley & Sons, 2012.
[18] M. L. Pinedo, Scheduling: Theory, Algorithms, and Systems.
Springer,2012.
[19] M. Englert and M. Westermann, “Considering suppressed
packets im-proves buffer management in quality of service
switches,” SIAM Journalon Computing, vol. 41, no. 5, pp. 1166–1192,
2012.
[20] L. Jez, F. Li, J. Sethuraman, and C. Stein, “Online
scheduling of packetswith agreeable deadlines,” ACM Transactions on
Algorithms, vol. 9,no. 1, 2012.
http://www.sandvine.com/http://www.sandvine.com/http://www.bgu.ac.il/~sgabriel/MS-2013.pdf
I IntroductionI-A System ModelI-B Our ContributionI-C Previous
Work
II The Offline SettingsIII The Online SettingsIII-A Lower
BoundsIII-B The Proactive Greedy AlgorithmIII-C The Greedy
Algorithm
IV Further Algorithmic ConsiderationsIV-A Tie-breakingIV-B
Scheduling
V SimulationsV-A Traffic Generation and SetupV-B Simulated
AlgorithmsV-C Results
VI Conclusions and Future WorkReferences