Efficient Allocation of Seed Serv ers in Peer-to-Peer
Streaming Systems with Scalable Videos
Kianoosh Mokhtarian and Mohamed Hefeeda
Schoo l of Computing Science
Simon Fraser Univ ersity
Surrey, BC, Canada
Abstract—Westudystreamingofscalablevideosoverpeer-to-
peer (P2P) networks. We focus on efficient management of seed
servers resources, which need to be deployed in the network to
make up for the limited upload capacity of peers in order to
deliver h igher quality video streams. These servers have finite
serving capacity and are often loaded with a volume of requests
larger than their capacity. We formulate the problem of allocating
this capacity for optimally serving scalable videos. We show that
this problem is NP-complete, and propose two approximation
algorithms to solve it. The first one allocates seeding resources
for serving peers based on dynamic programming, and is more
suitable for small seeding capacities (≤ 10 Mbps). The second al-
gorithm follows a greedy approach and is more efficient f or larger
capacities. We evaluate the proposed algorithms analytically and
in a simulated P2P streaming system. The results confirm the
efficiency and near-optimality of the proposed algorithms, and
show that higher-quality videos are delivered to peers if our
algorithms are employed for allocating seed servers.
I. INTRODUCTION
The demand for multimedia services has seen a rapid growth
in the past few years, which is even expected to accelerate
in the future [1], [2]. To meet portions of this demand, P2P
streaming systems hav e been designed and deplo yed for large-
scale user comm unities [3]–[6]. In current P2P streaming
systems, a video is encoded at a certain bitra te, typically
ranging from 300 kbps to 1 Mbps [7]. To support a wider
range of receivers, a lower-bitrate video is preferred, but this
provides low quality for everyone. This problem may be solved
by encoding and distributing multiple versions of the video,
which is called simulcasting.However,avideohastobe
encoded many times for different combinations of decoding
capabilities, bandwidths, and viewing resolutions. Moreover,
switching among versions is not easy, because (i) for every
switching, a client has to wait, possibly for a few seconds, for
the next intra-coded frame of the new version, and (ii) streams
of different versions could be asynchronous [8]. In addition,
P2P streaming with multiple video versions divides users to
separate networks which may result in reduced connectivity
and less efficient utilization of peers’ r esources. As an alterna-
ti ve, Multiple Description Coding (MDC) can encode a video
into multiple descriptions, where the quality of the video is
proportional to the number of descriptions received. However,
MDC techniques are well known for having considerable
bitrate overhead and being computationally complex [8].
In contrast, a scalable video has the advantage that it can
be encoded once and a wide range of heterogenous clients
can benefit from the video. In addition, heterogeneous clients
receiving different layers can still share common layers and
participate in the same overlay network, leading to a larger
pool of resources. Moreover, scalable coding has a lower
overhead and is simpler than MDC coding [8]. Recent scalable
video coding techniques, e.g., H.264/SVC [9], have further
improv e d this coding efficiency and significantly outperformed
previous ones [10]. Accordingly, they have received an in -
creasing adoption in practice [11], [12]. Our goal in this paper
is to leve rage scalable video streams to improve the quality
observ ed by di verse clients as well as to optimally utilize the
resources in P2P streaming systems.
There are a number of challenges traditionally faced by
P2P streaming systems. They include efficient overlay con-
struction and maintenance, asymmetry between peers’ down-
load and upload bandwidth, dynamics and unreliability of
peers and connections, and system considerations such as
NAT traversal—r ecent surveys on these issues can be found
in [13], [14]. These challenges become more serious in case of
employing scalable videos. As the data demanded/possessed
by peers gets more heterogen eous, seeding the data to the
network and having peers select their partners in arbitrary
ways, as in current P2P streaming systems [7], will result
in p oor management of resources and inefficient utilization
of data. Moreover , the flexibility offered by scalable video
streams should be appropriately taken advantage of to best
satisfy peers’ demands using the limited resources.
In this paper, we study streaming of scalable videos over
P2P networks. We co nsider both liv e streaming and video on-
demand scenarios. We focus on efficient management of the
resources of seed servers, which are needed in hig h-quality
P2P streaming systems to make up for the limited upload
capacity of peers. We formulate the problem of optimally
allocating the resources of seed servers when they serve scal-
able videos. We show that this problem is NP-complete. We
then propose two approximation algorithms for the problem,
and show that they produce near-optimal results, while being
computatio nally efficient and run in real-time. In addition, we
rigorously evaluate the propose d algorith ms in a simulated
P2P streaming system. Our simulation results confirm the
efficiency and near-optimality of the algorithms.
This paper is organized as follows. Related works are
summarized in Section II. In Section III, the considered archi-
tecture is presented and the seed serv er allocation problem is
978-1-4244-3876-1/09/$25.00 ©2009 IEEE
Authorized licensed use limited to: SIMON FRASER UNIVERSITY. Downloaded on November 15, 2009 at 14:36 from IEEE Xplore. Restrictions apply.
formulated and proven to be NP-complete. Two approximation
algorithms for the problem are presented in Section IV. We
e valuate the proposed system in Section V, and conclude the
paper in Section VI.
II. R
ELATED WORK
Cui et al. [15] and Rejaie et al. [16] study P2P streaming
systems with scalable videos, focusing on the tasks of peers.
An algorithm is presented in [15] to be run on each peer
independently that decides how to request video layers from a
given set of heterogeneous senders, assuming layers have equal
bitrate and provide equal video quality. Hefeeda et al. [17]
study this problem for Fine-Grained Scalable (FGS) videos,
taking into account the rate-distortion model of the video for
maximizing the perceived quality, which is more accurate than
assuming all layers have equal quality enhancemen ts as sup-
posed in [15]. We too consider video layers with heterogenous
rates and quality enhancements. In the framework presented
in [16], the problem of requesting from a set of senders is
studied from a practical perspective. A receiver periodically
sends an ord ered list of requested packets to each sender, and
the sender provides packets in the given order according to its
TCP-friendly congestion control mechanism.
Lan et al. [18] present a high level architecture for data-
driv en P2P streaming with scalable videos. The authors pro-
pose a scheduling algorithm for peers to req uest data f rom
senders. This algorithm, however, does not explicitly take the
scalable nature of the video into account. The packet sche dul-
ing problem for scalable video steams is more challenging than
nonscalable streams. Due to their adaptability to bandwidth
variations, naively fetching video data from other peers may
result in frequent variations in the number of video layers.
This causes fluctuations in the video quality, which may be
even worse than just watching a low quality video [19]. This
packet scheduling problem is studied in [20], [21].
All of these works do not consider the functionalities of
seed servers, which are critical to provide high-quality video
streaming services. This is because the upload bandwidths of
peers are often far less than their demanded download rates.
For example, an average -to-good quality video stream requires
about 1–2 Mbps, whereas the average upload capacity of home
users with DSL and cab le connections is often less than a
few hundred kilobytes. To make up for this asymmetry, a
number of seed servers need to be deployed in the network.
Xu et al. [22] study the functionality of seed servers for
P2P streaming. However, their work is only for nonscalable
video streams. The case for scalable video streams is more
challenging as various substreams need to be handled. In [15],
seed servers are assumed to always have enough capacity to
serve a ll requests, which is not realistic. In this paper, we
consider a more practical scenario in wh ich seed servers have
finite capacity, and this finite capacity needs to be optimally
allocated to requesting peers such that a higher-quality video
is delivered to all peers.
III. S
YSTEM MODEL AND PROBLEM STAT EMEN T
In this section, we describe the considered system model
and state the resource allocation problem ad dressed in this
paper.
A. System Overview
The considered P2P streaming architecture consists of track-
ers, seed servers, and peers. Peer s join the system by contact-
ing one of the track ers. The tracker receives periodic update
reports from peers, informing it about their available data and
capacity. A number of seed servers exist in the network to
serve requests when there is not enough capacity in the peer
population. Our problem is to decide which subset of requests
should be served by the seed servers to maximize a system-
wide utility function. This problem is important because the
volume of requests to be served often exceeds the seeding
capacity. Allocating seeding resources optimally will lead to
better utilization of seed servers, and higher video quality for
users, especially during periods with e xcessive loads which
are typically the most difficult to handle in real systems.
Peers are expected to use their limited upload bandwidth for
serving lower layers first, so as to avoid having some peers
starving while other peers are receiving highest rates. Peers
serve as man y layers as they can upload. For example, if all
layers have a rate of 100 kbps and a peer has 250 kbps upload
bandwidth , it will upload the two lowest layers at rate 100 kbps
and the third one at 50 kbps.
B. Problem Statement and Hardness
Peers’ requests are gathered in the tracker’s request queue.
The tracker decides every ∆ seconds, which is a few seconds,
and accepts some requ ests (to be served by a seed server)
and rejects others. Let V denote the set of video files in an
on-dem and session or the set of channels in a live streaming
scenario. We divide a video into short time intervals, called
video segments, the number of which is T
v
for each video
v ∈ V . A video segment is considered an atomic unit of
adaptatio n, meaning that the number of layers recei ved by
a peer is assumed constant during a media segment, but
may va ry between consecutive segmen ts. P
v
is the set of
peers currently participating in the streaming session of a
video v ∈ V . At each time the tracker solves the allocation
problem, there are K requ ests in the queue. Each request req
k
is in the form {req
k
.p, req
k
.t, req
k
.l
1
, req
k
.l
2
},meaning
that peer req
k
.p is requesting layers req
k
.l
1
through req
k
.l
2
(inclusive) of the stream, starting at segment req
k
.t; the peer
could be receiving layers 1 throug h req
k
.l
1
− 1 from other
peers. Since req
k
is for n
k
= req
k
.l
2
− req
k
.l
1
+1 layers
and may be admitted partially, we break it to n
k
sub-requests,
denoted by req
k,j
where 1 ≤ j ≤ n
k
. A sub-request req
k,j
represents a request for the j lowest requeste d layers, i.e.,
req
k,j
corresponds to layers req
k
.l
1
through req
k
.l
1
+ j − 1.
Let r
v,l
denote the bitrate (bps) of the l-th layer of the video
v,andu
p
be the upload capacity (bps) of peer p.
Serving each sub-request req
k,j
has a cost c
k,j
for seed
servers which is the sum of the bitrates of the j requested
Authorized licensed use limited to: SIMON FRASER UNIVERSITY. Downloaded on November 15, 2009 at 14:36 from IEEE Xplore. Restrictions apply.
layers. Letting ν denote the requ ested video ν = v
req
k
.p
in
req
k
,wedenotethecostsofreq
k
’s sub-requests by:
c
k,j
=
req
k
.l
1
+j−1
X
l=req
k
.l
1
r
ν,l
(1 ≤ k ≤ K, 1 ≤ j ≤ n
k
). (1)
Moreover, by admitting req
k,j
, a utility (benefit) b
k,j
is
gained by the system, which consists of the utility of serv-
ing the associated layers to the corr esponding peer, that
is,
P
req
k
.l
1
+j−1
l=req
k
.l
1
b
self
(req
k
.p, l), and the utility gained when
the peer shares those layers with the network, denoted by
P
req
k
.l
1
+j−1
l=req
k
.l
1
b
share
(req
k
.p, l). Our algorithms are not restricted
to a specific b
self
(p, l) function; we see in Section IV-C a
sample utility fu nction to provide max-min fairness among
quality received by peers according to their demands. For
calculating b
share
(p, l),weneedtoconsiderthepeerserving
those layers (or part of them) to its partners, those partners
serving (partially) to their partners, and so on. Taking these
neighborhood details into account requires knowledge of the
network topology, which is difficult to maintain for dynamic
P2P systems. We therefore compute b
share
(p, l) as the expected
utility that the system gains when a peer shares some video
layers with the network. In Section IV-C we see how to
calculate these expected utilities according to b
self
(p, l).
Problem 1: (Seed Server Allocation) Giv en the requests
req
1
,...,req
K
, their costs c
k,j
bps and utilities b
k,j
(1 ≤ k ≤
K, 1 ≤ j ≤ n
k
), and a seeding capacity C bps, find the
x
k
(0 ≤ x
k
≤ n
k
) value for each req
k
which indicates that
sub-requests req
k,1
, req
k,2
,...,req
k,x
k
should be served out
of req
k
in order to maximize the system-wide utility.
This problem is formulated as follows. Find x
k
in order to:
max
K
X
k=1
b
k,x
k
(2a)
s.t.
P
K
k=1
c
k,x
k
≤ C (2b)
x
k
∈ {0, 1,...,n
k
} (1 ≤ k ≤ K) (2c)
Theor em 1: The seed server allocation problem defined in
Eq. (2) is NP-complete.
Proof: We prove the NP-completeness by reducing the
Knapsack Problem [23 ] to a simplified version of the seed
server allocation problem. Suppose that all videos are single-
layer coded and thus all requests are for the first layer. In
this case, all x
i
values are either 0 or 1. This special case of
the problem is equivalent to the 0-1 Knapsack Problem. In
addition, a solution for the seed server allocation problem can
easily be verified in polynomial time. Hence, the seed server
allocation problem is NP-complete. ¤
IV. P
RO BL EM SOLUT IONS
In this section, we present two approximation algorithms
for the seed server allocation problem. The first algorithm
produces close-to-optimal results for small seeding capacity
C, but as the capacity increases, it has to get far from the
optimal in order to operate in real-time. The second algorithm
runs in a time independ e nt of the seeding capacity and can
always operate in real-time. It provides close-to-optimal results
for large seedin g capacities, but b ecomes far from the optimal
for small capacities.
A. SRA
DP Algorithm: Seed Resource Allocation using Dy-
namic Progr amming
Since our server allocation problem has some similarities
with the Knapsack problem, it is intuitiv e to check the appli-
cability of Knapsack solutions to our problem. The Knapsack
problem has an interesting optimal solution using dynamic
programming, and a consequent approximation solution [23].
Howe ver , if to be applied to the seed server allocation problem,
this algorithm can function only for the single-layer allocation
problem (see the proof of Theorem 1). We propose a dynamic
programming algorithm for the general case with multi-layer
videos. Unlike the approximation algorithm for the Knapsack
problem , our algorithm accounts for the consistency in serving
sub-requests of each request req
k
. That is, no higher layer must
be served unless all of its lower layers are already served. We
first transform all utility values b
k,j
, which are real numbers,
to integers b
0
k,j
= b
b
k,j
M
c where M is a constant real number
greater than zero, e.g., we set M =0.1 for neglecting the
second and further decimal points of b
k,j
values. We then
optimally solve the problem with b
0
k,j
values. The value M
determines the approximation factor and the running time of
the algorithm, as we analyze shortly.
The dynamic programming algorithm, denoted by SRA
DP,
operates as follows. Let B
0
max
denote the maximum b
0
k,j
for
all valid (k, j) values, C
min
the minimum c
k,j
, i.e., the bitrate
of the base layer, and K
0
=
P
K
k=1
n
k
the total number of sub-
requests. Thus, C/C
min
is an upperbound on the number of
sub-requests that can be served, and I =
C
C
min
B
0
max
is an
upperbound on the total utility that can be gained. We define
a[k,i](0≤ k ≤ K, 0 ≤ i ≤ I) as the minimum cost that a
subset of requests req
1
,...,req
k
can ha ve, whose total utility
exactly equals i; a[k, 0] for all 0 ≤ k ≤ K issetto0and
a[0,i] for all 1 ≤ i ≤ I is assigned ∞. If no subset of sub-
requests with a total utility of i can be formed, a[k, i] is set
to ∞. Having initialized a[k, 0] and a[0,i] values, the rest of
the matrix is calculated as in Eq. (3):
a[k, i]=min
⎧
⎪
⎪
⎪
⎪
⎪
⎪
⎪
⎨
⎪
⎪
⎪
⎪
⎪
⎪
⎪
⎩
a[k − 1,i],
a[k − 1,i− b
0
k,1
]+c
k,1
, if i ≥ b
0
k,1
a[k − 1,i− b
0
k,2
]+c
k,2
, if i ≥ b
0
k,2
.
.
.
a[k − 1,i− b
0
k,n
k
]+c
k,n
k
if i ≥ b
0
k,n
k
(3)
InEq.(3),thefirst option represents the case that no layer of
req
k
is served, the second option represents the case when one
layer is served, and so on. The min-cost value among these
options is chosen. Suppose x layers are to be served out of the
n
k
layers of req
k
in order to make a total utility of i,which
Authorized licensed use limited to: SIMON FRASER UNIVERSITY. Downloaded on November 15, 2009 at 14:36 from IEEE Xplore. Restrictions apply.
is only possible if b
0
k,x
≤ i. Then , the total cost will be that of
x layers from req
k
, i.e., c
k,x
, as well as the minimum cost for
obtaining a utility of i−b
0
k,x
using the previous k−1 requests,
which add up to b[k−1,i−b
0
k,x
]+c
k,x
as represented in Eq. (3).
The optimal utility that can be gained using the capacity C is
obtained by finding the maximum i such that a[K, i] does not
exceed C, and we denote this utility by i
∗
.
To keep track of how these optimal sub-solutions are built,
i.e.,toobtainx
k
values in Eq. (2), we keep another matrix
y[k,i](0≤ k ≤ K, 0 ≤ i ≤ I). Each y[k, i] for nonzero
k and i values holds the number of sub-requests served from
the request req
k
in the solution to subproblem (k, i). y[0,i]
and y[k, 0] are set to zero. In each iteration where an a[k, i] is
calculated accor ding to Eq. (3), y[k, i] is set to the number of
sub-requests, i.e., the row index (starting from 0) in Eq. (3),
that makes the minimum. Finally, we obtain the x[k] values
for Eq. (2) as follows. Let s be a pointer that is initially set
to i
∗
.First,x[K] is set as x[K]=y[K, s]. Then, s is reduced
by b
0
K,x[K]
, i.e., the utility of serving x[K] sub-requests out
of the K-th request. The new s value points to the best utility
we got using requests req
1
,...,req
K−1
.Thus,x[K − 1] is
obtained as x[K − 1] = y[K − 1,s]. Then, the pointer s is
updated accordingly, i.e., reduced by b
0
K−1,x[K−1]
, and so on.
The running time of the algorithm is analyzed shortly.
We now derive the approximation factor for the proposed
algorithm. The proof proceeds in a similar way to the proof of
the Fully Polynomial T ime Approximation Scheme (FPTAS)
for Knapsack [23]. We, however, pr ovide a tighter approxima-
tion factor by using the characteristics of our problem.
Theor em 2: The SRA
DP algorithm returns a solution for
the seed server allocation problem (Problem 1) w ith worst-
case approximation factor of 1 −
CM
C
min
B
max
,whereC (C ≥
c
k,j
), C
min
,andB
max
are the seeding capacity, the bitrate
of the base layer, and the maximum utility among all sub-
requests, respectively. Furthermore, the time complexity of the
SRA
DP algorithm is of O(K
0
b
CB
max
C
min
M
c),whereK
0
is the
total number of sub-requests.
Proof: Accordingtothedefinition and usage of x[k] values,
it is clear that the serving of sub-request is consistent. To
obtain the approximation factor, we first need to make sure that
the propose d dynamic programming algorithm is optimal with
rounded utility values b
0
k,j
. For this purpose, we only highlight
the point that the problem has optimal substructure property,
and skip the rest of the proof to save space as it easily follows
this property. The optimal substructure property means that
the optimal solution to the problem contains within it optimal
solutions to subproblem. This is true for our problem, because
if in the optimal solution (with utility a[K, i
∗
]) th e solution to
a subproblem (k, i) is not optimal —meaning that a utility of i
could have been achieved out of the first k requests at a lower
cost that a[k,i]— we can simply replace that part of the final
optimal solution and obtain a better utility than a[K, i
∗
],which
is contradiction. We now analyze the approximation factor .
Suppose the optimal solution to the original problem with b
k,j
values is the set O of sub-requests, and the solution to the
problem with b
0
k,j
values is O
0
. Let the function b(O) denote
the sum of the b
k,j
utilities of sub-requ e sts in O; like w ise for
b
0
(O) that su ms b
0
k,j
values. Thus, the obtained utility and the
optimal one are w = b(O
0
) and OPT = b(O), respectively.
Since we round down b
k,j
values by a factor of M,wehave:
b
k,j
≥ Mb
0
k,j
⇒ b(O
0
) ≥ Mb
0
(O
0
)
b
k,j
− Mb
0
k,j
≤ M ⇒ b(O) − Mb
0
(O) ≤ |O|M ≤
C
C
min
M
where the latter inequality is based on the observation that
any subset O of sub-requests that fits in a capacity of C has
at most C/C
min
elements. Because the subset O
0
is optimal
with b
0
k,j
values, we have:
b
0
(O
0
) ≥ b
0
(O) ⇒ w = b(O
0
) ≥ Mb
0
(O
0
) ≥ Mb
0
(O)
≥ b(O) −
C
C
min
M ⇒ w ≥ (1 −
CM
C
min
OPT
)OPT
⇒ w ≥ (1 −
CM
C
min
B
max
)OPT. (4)
For each row k of the matrices a[k, i] and y[k, i] together,
O(In
k
) comparisons are performed, where I =
C
C
min
B
0
max
is
an upperbound on the total utility that can be gained. Thus,
the running time of the algorithm is:
K
X
k=1
O(In
k
)=O(K
0
I)=O(K
0
b
CB
max
C
min
M
c). (5)
¤
We numerically analyze the running time of the algorithm
and its relation to the approximation factor γ =1−
CM
C
min
B
max
.
As Eq. (4) and Eq. (5) show, by decreasing the rounding factor
M, the approximation factor approaches 1, which, on the
other hand, increases the computational complexity. To have
an estimate of this relation, suppose the number of iterations
that the tracker can perform in ∆ seconds, i.e., till next turn
to run the seed serve r alloc ation algorithm, is given as Ω.
Each iteration of the algorithm consists of a few lookups, one
addition, two comparisons, and possibly one assignment. Also
suppose the number of iterations needed by the algorithm
is simp ly K
0
CB
max
C
min
M
, which must not exceed Ω. Therefore,
according to Eq. (4) and Eq. (5), the approximatio n factor γ
will be as follows:
M ≥
K
0
CB
max
ΩC
min
⇒ γ ≥ 1 −
K
0
Ω
(
C
C
min
)
2
. (6)
This is illustrated in Figure 1 where the g uaranteed approx-
imation factor γ is depicted versus the computational po wer,
assuming that the base layer of the videos is at 100 kbps,
there are K
0
= 1000 sub-requests in the queue, and that each
iteration roughly takes 100 machine instructions to execute.
According to Figure 1, a tracker with seed servers of total
capacity 10 Mbps whose allocation is decided every second,
can make sure that the approximation result is at least as good
as 90% of the optimal if it can perform 10 giga low-level
instructions per second.
Authorized licensed use limited to: SIMON FRASER UNIVERSITY. Downloaded on November 15, 2009 at 14:36 from IEEE Xplore. Restrictions apply.
0 5 10 15 20
0.2
0.4
0.6
0.8
1
Computational power (GIPS)
Approximation factor γ
5 Mbps seed
10 Mbps seed
15 Mbps seed
Fig. 1. T radeoff between approximation factor and computational complexity .
In sum, the SRA DP algorithm obtains answers very close
to the optimal for small seeding capacities, but it has to
sacrifice some non-negligible approximation factor for large
seeding capacities. We propose another approximation algo-
rithm for these cases in the next subsection.
B. SRA
GREEDY: Seed Resource Allocation using a Greedy
Algorithm
We present another approximation algorithm for the seed
server allocation problem, whose running time is independent
of the seeding capacity and only depends on the number
of requests in the queue. We show that the result of this
approximation gets very close to the optimal answer as the
seeding capacity increases, e.g., C =50Mbps, though is
worse than the algorithm SRA
DP if the seeding capacity is
small, e.g., C =10Mbps. Our approximation is based on
relaxing the Integer Programming (IP) problem in Eq. (2) to
its equivalent Linear Programming (LP) problem, in which the
constraint (2c) is relaxed to (7a) and (7b).
0 ≤ x
0
k
≤ n
k
(1 ≤ k ≤ K) (7a)
x
0
k
∈ R. (7b)
In other words, we now allo w a layer to be partially served ,
though it is not meaningful in practice . Having solved the LP
problem in Eq. (7) and obtained the x
0
k
values, we obtain a
valid solution to the original IP problem by rounding down all
x
0
k
values: x
k
= bx
0
k
c.Clearly,x
k
values form a valid answer
for the IP form in Eq. (2), since they satisfy both constraints
(2b) and (2c). We will see shortly that after th is relaxation
and down-rounding, how close the objective function (2a) will
be to the optimal solution. The proposed algorithm is called
SRA
GREEDAY and is shown in Fig ure 2. Sub-requests are
sorted in decreasing order of utility-to-cost ratio and are picked
one by one in each iteration. Since some sub-requests are
overlapping, i.e., each sub-request (k, j) is a subset of sub-
requests (k, j +1),...,(k,n
k
), in each iteration we take those
layers from sub-request (k, j) that are not already served by
another sub-request (k, j
0
<j). The algorithm consists of
sorting sub-requests, which runs in O(K
0
log K
0
) where K
0
is
SRA GREEDY
Gr eedyAllocatio n (K, C, n[], b[][], c[][])
1. // K:numberofrequests,C: seeding capacity
2. // n[k]: number of sub-requests in the k-th requests
(1 ≤ k ≤ K)
3. // b[k][j], c[k][j]: utility and cost of the j-th sub-request
of the k-th request (1 ≤ j ≤ n[k]); b[k][0]andc[k][0]are
assigned 0
4. // Output: x[]: number of sub-requests to serve from the
k-th request
5. K
0
=
P
K
k=1
n[k] // total number of sub-requests
6. S[] ←− the K
0
sub-requests sorted in decreasing order of
utility-to-cost ratio
7. z ←− 0 // will be the total obtained utility
8. x[] ←− CreateArray (K, 0)
9. for (k, j) ∈ S do
10. if x[k] >j then continue
11. cost ←− c[k][j]−c[k][x[k]]
12. utility ←− b[k][j]−b[k][x[k]]
13. if cost ≤ C then
14. C ←− C − cost
15. z ←− z + utility
16. x[k] ←− j
17. done
18. return z, x[]
Fig. 2. A greedy algorithm for the seed server allocation problem.
the total number of sub-requests, and performing K
0
iterations
of O(1), which makes the total running time O(K
0
log K
0
).
This is easily practical in real-time for reasonable K
0
values
(< 500K).
Theorem 3: If all costs c
k,j
are bounded as c
k,j
≤ c
max
<
C for all valid k, j values, the algorithm SRA
GREEDY is a
c
max
C − c
max
-factor approximation for the seed server allocation
problem, i.e., z ≥ (1 −
c
max
C − c
max
)OPT.
Proof: Consider the following two modifications to the
algorithm in Figure 2: (i) after line 16 in the code, if cost >C
then pick a portion θ (0 ≤ θ<1) of the current sub-request
(k, j) which can fill the capacity C, and quit the loop, (ii)
afterline16inthecode,ifcost >C then just quit the loop.
Case(i)referstothesolutiontotheLPprobleminEq.(7)
and provides the optimal answer for this problem; the proof
is skipped as it is easy and similar to that of the solution to
Knapsack’s LP-relaxation. Let z
∗
denote the utility obtained
by this solution, which is at least as good as OPT since it refers
to the LP-relaxation of the original problem. Case (ii) is only
for a comparison purpose. Since its solution is a subset of
the solution obtained by our algorithm in Figure 2, the utility
obtained by case (ii), denoted by z
0
, is a lower bound on our
obtained utility z, i.e., z
0
≤ z.
Authorized licensed use limited to: SIMON FRASER UNIVERSITY. Downloaded on November 15, 2009 at 14:36 from IEEE Xplore. Restrictions apply.
