Optimal Server Scheduling in Hybrid P2P Networks

Transcription

1 Performance Evaluation Performance Evaluation (21) 1 19 Optimal Server Scheduling in Hybrid P2P Networks Bo Zhang a, Sem C. Borst b,c, Martin I. Reiman b a School of Industrial and Systems Engineering, Georgia Tech, USA. bozhang@gatech.edu b Bell Laboratories, Alcatel-Lucent, USA. {sem,marty}@research.bell-labs.com c Department of Mathematics and Computer Science, Eindhoven University of Technology, The Netherlands Abstract We consider the server scheduling problem in hybrid P2P networks in the context of a fluid model. Specifically, we examine how to allocate the limited amount of server upload capacity among competing swarms over time in order to optimize the download performance experienced by users. For sufficiently high user churn rate, we prove that it is optimal to allocate the full server capacity at all times, and that it does not matter exactly how the capacity is distributed among competing swarms as long as no upload capacity is unnecessarily left unused. While it may seem obvious that it is optimal to allocate the full server capacity, we show that this is not always the case surprisingly enough when the user churn rate is not high. In that case, throttling the server capacity slows down downloads in the short run, but also boosts the future peer upload capacity, and may thus lead to higher download speeds in the long term. Keywords: content dissemination, download performance, file sharing, hybrid P2P networks, peer-assisted strategies, optimal server scheduling 1. Introduction Peer-to-peer (P2P) approaches have gained huge popularity as a highly scalable and costeffective mechanism for content dissemination. Measurement studies suggest that P2P applications such as BitTorrent account for the majority of the traffic in the Internet today. The very principle that makes P2P approaches scalable and cheap, however, also makes them vulnerable to user churn. It is difficult therefore to provide any performance guarantees in terms of download times, particularly for content that is recently released or of relatively rare interest. Long download delays may be acceptable to users for content that is available free of charge (possibly illegally), which has traditionally been the dominant source of P2P applications. However, poor download performance is far less acceptable for services offered by commercial content providers, which increasingly look for ways to adopt P2P approaches but at the same time maintain a guaranteed level of service as in a conventional client-server system. The achilles heel of a client-server architecture lies of course in the fact that it precisely lacks the scalability of P2P approaches, as it is either extremely costly or incapable of dealing

2 / Performance Evaluation (21) with highly variable demand patterns and flashcrowd effects. However, a hybrid or peer-assisted approach provides an attractive paradigm to achieve the best of both worlds by combining the predictable availability of provisioned server capacity with the inherent scalability and cost effectiveness of P2P strategies, see for instance [21] for a successful implementation of a peer-assisted online storage system. Such a hybrid approach is particularly attractive when the system offers a dynamic collection of content items whose popularities asynchronously vary over time. An important problem that then arises is how to allocate the limited amount of server upload capacity among competing swarms (torrents) over time in order to optimize the download performance experienced by users. In the present paper we will examine the above-described scheduling problem in the context of a fluid model describing the evolution of the number of leeches (peers who have obtained only part of a file) and seeds (peers who have obtained a complete copy). Specifically, we adopt a multi-dimensional extension of the fluid model originally proposed by Qiu & Srikant [15], where the various dimensions correspond to swarms for different files. We augment the fluid-model formulation to include the availability of additional server capacity and focus on the optimal allocation over time among competing swarms, explicitly allowing for arbitrary variations in the arrival rates of leeches for the various files. Other multi-dimensional versions of the fluid model (without any server assistance or time-varying arrival rates) were considered in [3, 24, 25, 33]. We refer to [6, 11, 13, 19, 31, 32] for several stochastic models of pure P2P systems (without any server assistance) which account for random features in more detail. Simulation results in [15] demonstrate that the fluid model adequately captures the key characteristics of the system, and provides accurate estimates for the number of leeches and seeds in a stationary regime. The accuracy of the fluid model requires the arrival rate of leeches to be relatively high compared to the download time, so that the peer population is sufficiently large for a continuous, deterministic representation to be applicable. In that sense, our model focuses on the relatively popular files, and does not include niche content, for which direct peer-to-peer approaches are not particularly effective anyway. An interesting approach for meeting the demand for less popular files is provided by so-called multi-torrent strategies, which promote contacts between peers belonging to different swarms, with users downloading in one swarm and concurrently uploading in another swarm [2, 12, 3]. Our results will indirectly provide an indication in what conditions such strategies provide scope for improving the download performance. As it turns out, the scheduling problem is complicated by the dual client-server role of users, with peers behaving as clients in downloading content, but at the same time acting as servers in uploading content to others. As a result, standard scheduling principles break down, and novel paradigms need to be established, which do not always seem to conform to intuition or conventional wisdom. For sufficiently high user churn rate, we prove that it is optimal to allocate the full server capacity at all times, and that it does not matter exactly how the capacity is distributed among competing swarms as long as no upload capacity is unnecessarily left unused. The case of a high churn rate is particularly relevant, since this is the scenario where server assistance is needed the most in order to ensure adequate download performance. While it may seem obvious that it is optimal to allocate the full server capacity, it turns out that this is not always the case surprisingly enough when the user churn rate is not high. In that case, throttling the server capacity slows down downloads in the short run, but also boosts the future peer upload capacity, and may thus lead to higher download speeds in the long term. Analytical models of hybrid P2P systems have received only limited attention so far. As one of the few exceptions, [4] studies an extension of the fluid model of [15] with an additional

3 / Performance Evaluation (21) set of overlay nodes that provide dedicated upload capacity, and derives the mean download delays in both the transient and stationary regimes, but considers only a single-file scenario where no contention arises between swarms. Sun et al. [2] extend the basic fluid model to analyze two scheduling policies where the server capacity is either divided equally among all peers or distributed equally among all files, and compare their performance with an analytic lower bound. Rimac et al. [17, 18] also use an extension of the basic fluid model to determine the minimum amount of server capacity required to maintain the maximum download rate at all times, and exploit that to develop a method for server dimensioning. While the hybrid P2P approach is mainly aimed at improving the download performance experienced by users, it may yield an implicit benefit in the form of a higher routing efficiency and hence a reduction in the overall traffic load in the network, especially in case the server capacity is geographically dispersed. More direct approaches for mitigating the network load by localizing P2P traffic and making it ISP-friendly, also referred to as P4P schemes, are presented for example in [16, 29]. It is worth emphasizing that in the present paper we focus on peer-to-peer mechanisms for file sharing applications. We refer to [1, 8, 9, 1, 14, 23, 27, 28, 34] and further references therein for work on peer-to-peer streaming algorithms. The remainder of the paper is organized as follows. In Section 2 we provide a detailed model description along with a problem statement. In Section 3 we state the main results and demonstrate the relevance of a key assumption. The various proofs are presented in Section 4. In Section 5 we discuss the numerical experiments that we conducted. In Section 6 we make some concluding remarks. 2. Model description and problem statement In this section, we first provide a detailed description of the mathematical model that we use to study hybrid P2P networks, and formally state the optimal scheduling problem. Then, we discuss some key modeling elements and a conservation law of the model, and introduce the notion of upload- and download-constrained, which is particularly relevant to our main optimality result. Our analysis is based on a fluid model with N different classes (swarms) of users, with N <, and a server of capacity C >. The model is a multi-dimensional version of the fluid model proposed in [15], with additional components relating to the server capacity. Specifically, we consider a system in which there are N different files available for download and N classes of users (peers), with all class-i peers interested in downloading file i. Peers within each class are distinguished into leeches and seeds, depending on whether they have a complete copy of the file or not. The fluid model for each class is a system of two differential equations describing the number of peers of each type as a function of time. More specifically, we denote by x i (t) and y i (t) the number of class-i leeches and seeds at time t, respectively, and assume x i () = y i () = throughout the paper. At time t, class-i users arrive at rate λ i (t) (where t i := inf{t : λ i (t) > } may be interpreted as the release time of the i-th file), join the system as leeches, and in the meantime class-i leeches turn into class-i seeds at rate z i (t). We further denote by γ the seed churn rate, i.e., the rate at which seeds leave the system. Then the evolution of the number of class-i leeches and seeds is described by a set of differential equations x i (t) = λ i(t) z i (t), (1)

4 / Performance Evaluation (21) y i (t) = z i(t) γy i (t). (2) Throughout this paper, we assume λ i (t) s are integrable, and equations (1) and (2), with possibly discontinuous right-hand sides, are interpreted as integral equations (see [5]), yielding and x i (t) = A i (t) S i (t) (3) y i (t) = S i (t) γ t y i (s)ds, (4) with A i (t) := t λ i(s)ds and S i (t) := t z i(s)ds. Similar to the model in [18], we define the service rate z i (t) as the minimum of the upload and download capacities of class i: z i (t) := min{cηx i (t) + cy i (t) + C i (t), dx i (t)}, (5) where c and d denote the upload and download rate (or bandwidth) per peer, respectively, η (, 1] is a coefficient accounting for the reduced efficiency of a leech, compared to a seed, due to having only a partial copy of the file, and C i (t) is the amount of server (upload) capacity allocated to class i. For convenience, we define for a given policy the total amount of allocated server capacity C(t) := N C i(t) for the remainder of the paper. In this paper, we study optimal server scheduling in hybrid P2P networks, based on the N-dimensional fluid model. Under the model assumptions, a server scheduling policy is fully described by the amount of server capacity allocated to each class over time, namely, the N- dimensional nonnegative capacity allocation function {C i (t)} 1 i N. Because the fluid model abstracts away a significant amount of details in real system behavior, it makes sense to aim for the strongest possible notion of optimality. Therefore, our main objective is to find scheduling policies that minimize the total number of leeches, or x(t) := N x i(t), at every point in time. In other words, we want to choose {C i (t)} 1 i N so as to minimize x(t) for all t, subject to (1), (2), (5), and C(t) C, t, (6) C i (t), i = 1,..., N, t. (7) We choose to minimize the total number of leeches in the system mainly because it provides a good proxy for the delay performance. Denote by A(t) := N A i(t) the total number of leeches that have arrived by time t and by S (t) := N S i(t) the total number of leeches that have turned into seeds by time t. We may adopt W(t) := S 1 (A(t)) t = inf{u > : S (t + u) > A(t)} as a measure for the download delay of a fictitious user arriving at time t. Since (3) implies that minimizing x(t) for all t is equivalent to maximization of S (t) at every point in time, it then follows that W(t) is minimized for all t as well. The relation between the number of leeches in the system and the download delay is further illustrated by the identity x(t)dt = λ(t)w(t)dt, (8) which can be viewed as a version of Little s law from queueing theory (see [7]) in the context of the fluid model. We defer the proof of relation (8) until Section 4. We shall compare the candidate optimal policies only with those policies for which there exists a δ > such that for all i = 1,..., N, C i (t) is constant during each interval [kδ, (k + 1)δ),

5 / Performance Evaluation (21) for all k Z + ; that is, a policy is said to be optimal if it is better than all policies in this class. This notion of optimality avoids unnecessary technicalities and yet is adequate for our purposes because δ can be arbitrarily small. In general, an optimal policy may not exist. The main result of this study is to establish the optimality of a class of simple scheduling policies in the presence of a high seed churn rate. We also extend the optimality result to a weighted multi-file problem, i.e., minimizing N a ix i (t) for all t, in which a positive constant weight a i is assigned to each class to represent its relative importance. To facilitate the understanding of our model and the optimality results, we briefly discuss the choice of system parameters and a conservation law for the fluid model, as well as their relation to real system characteristics. First, in practice, the download bandwidth of a home broadband user is typically a few times greater than her upload bandwidth, and therefore we assume d > c > for the remainder of this paper. Also, since the file size is implicitly assumed to be 1 in the fluid model, the unit for c and d can be considered as files per time unit. We interpret the reciprocal of the churn rate γ as the average amount of time that a user spends as a seed in the system. This parameter measures the altruism level of users and, as we shall see in the following sections, it plays a most important role in system behavior. For the leech arrival rate function λ i (t) s, some reasonable choices include the Bass diffusion model (see [26]) and a triangular function, both of which consist of a phase with increasing popularity and another one with decreasing popularity, or an exponential decay function (as considered in [18]) and a linearly decreasing function, which do not have the initial increasing period. Note that, even if the simplest one among these functions, a linearly decreasing function, is chosen to model the leech arrival rate for each class, the aggregate leech arrival rate λ(t) := N λ i(t) exhibits a sawtooth behavior due to the difference in the release times of different files. This poses challenges in solving the optimal control problem, where the objective function is the aggregate number of leeches in the system; yet, we shall show that, under the assumption of a high churn rate, the optimality of our proposed policies is robust to the variation in λ i (t) s. Next, by adding up the earlier integral expressions (3) and (4), we obtain a conservation law for the fluid model, which holds under any scheduling policy. Specifically, we have t λ i (s)ds = x i (t) + y i (t) + γ t y i (s)ds, (9) for all t, which states that those users who arrive during [, t) are either leeches or seeds remaining in the system at time t, or have left as a seed by t. By letting t, we further have λ i (s)ds = γ y i (s)ds, which says that the total number of users that arrive to download a file throughout all time equals the total number of seeds that eventually leave the system. Finally, we define R i (t) := (d cη)x i (t) cy i (t), which measures the difference between the download capacity dx i (t) and the upload capacity cηx i (t) + cy i (t) of class i due to peers themselves. We say that class i is upload-constrained at time t if R i (t) and downloadconstrained otherwise. From (5) and the definition of R i (t), it is easy to deduce that if class i is upload-constrained at time t, it can use server assistance for up to R i (t); any portion of the server capacity allocated to class i beyond R i (t) is wasted, or does not improve z i (t). When a swarm is download-constrained, leeches are turning into seeds at the maximum possible rate dx i (t) and any server assistance is wasted. Therefore, an alternative representation of the service rate function is z i (t) = cηx i (t) + cy i (t) + min{c i (t), R i (t)}. (1)

6 / Performance Evaluation (21) Depending on the system state R i (t) and the decision variable C i (t), the service rate z i (t) can take on the value of either term in the minimum expression (5) at different time points, which makes the system of differential equations (1) and (2) a switched linear system (see [22]). Also, the functions R i (t) and the upload- or download-constrained status of each swarm stand out as important characteristics for the system, especially when it comes to formulating and proving our optimality results. This will become evident in the next section. 3. Main results In this section, we first present our results for the single-file problem and show how single-file systems relate to multi-file problems. Then we state and prove our main optimality results Single-file In this subsection, we present our results for the special case of N = 1, upon which our multifile analysis will hinge. With N = 1, a scheduling policy is simply identified with the function C(t), and the objective is to find a C(t) that minimizes x(t) for all t subject to (1), (2), (5), with all the subscripts removed, and C(t) C. We define the greedy policy as the policy of always providing the full server capacity, i.e., C(t) = C for all t. Our first result is the optimality of the greedy policy under a sufficiently high churn rate. Theorem 1. If γ > γ := max{2c(η + 1), 2d}, then the greedy policy is optimal. One may argue that the optimality of the greedy policy should be obvious, because there seems to be no incentive to idle any server capacity. However, this is not really the case due to the dual client-server role of users. If the churn rate is not high and consequently P2P swarms behave differently from traditional systems with a clear-cut distinction between uploaders and downloaders, the non-idling intuition drawn from those systems also breaks down and the greedy policy could be suboptimal, as seen in a following numerical example. We first describe the main idea in the construction of our example. Many more such examples can be found by following this idea. In short, a competing scheduling policy can beat the greedy policy, or result in a smaller x(t), at some time t, by first holding back the server capacity for, say, T time units, which enables the swarm to develop an advantage in its peer upload capacity (i.e., a greater cηx(t) + cy(t)), and then providing the full server assistance after T just like the greedy policy. After time T, a crossing of the x(t) curves under the two policies will occur if (i) the competing system maintains its advantage in the peer upload capacity and (ii) R(t) C > or equivalently z(t) = cηx(t) + cy(t) + C in both systems for a long enough period after T. Note that condition (ii) is essential here, because otherwise an advantage in cηx(t) + cy(t) does not imply an advantage in z(t). Also, as d is typically a few times greater than c, condition (ii) tends to hold when x(t) is very large, which can be a response to a large λ(t). In the example that we show below, we shall let λ(t) jump up at some point after T and this ensures that condition (ii) is satisfied. A sudden increase in λ(t) is not necessary for the construction (as shown in our numerical example, where the x(t) crossing occurs before λ(t) jumps up) and yet it is a practically relevant scenario, because we shall apply the single-file results to analyzing multi-file systems, where we define λ(t) as the sum of leech arrival rates over all N classes; in that context, an abrupt rise in λ(t) exactly models the release of a new file or the initiation of a new swarm.

7 / Performance Evaluation (21) Our specific numerical example is as follows. Consider a file of moderate popularity. Its demand rate starts with 1 requests per hour, decreases at a fairly slow exponential rate for the first 4.6 hours, then jumps up to 2 requests per hour at t = 4.6 hours, and afterwards decays exponentially. Specifically, λ(t) = 1 e t 1 requests per hour for t < 4.6 and λ(t) = 2 e t requests per hour for t 4.6. We take c = 1 file per hour, d = 6 files per hour, and η =.6. This set of parameters is suitable for home broadband users, say, interested in downloading a file of size 6 MB and having a download bandwidth of 8 Mbps and an upload bandwidth of approximately 1.34 Mbps. We assume γ = 1.2 hour 1 and C = 3, which means that on average a seed stays in the system for 5 minutes and the available server upload capacity is 3 times that generated by one seed. 5 4 δ x(t) δ u(t) t Figure 1: Numerical example for suboptimality of greedy policy. In the figure, δ x (t) := x(t) in system II x(t) in system I and δ u (t) := (cηx(t) + cy(t) in system II) (cηx(t) + cy(t) in system I). Now consider two systems with the same set of parameters as specified above: system I operates under the greedy policy, that is, C(t) = 3 for all t, and system II operates under the policy of C(t) = for t < T 1 and C(t) = 3 for all t T, with T = 2. By solving the differential equations (1), (2), and (5) for both systems, we calculate the peer upload capacity at time T = 2: cηx(2) + cy(2) is in system I vs in system II. So system II has an advantage of in the peer upload capacity at this moment, although our computation also shows that its number of leeches is greater by 54.28: x(2) is in system I vs in system II. Figure 1 shows the differences in x(t) and cηx(t) + cy(t), respectively, between the two systems from time 2 to 8.6. Condition (i) obviously holds for the interval [2, 5.81]. Also, under the specified λ(t) function, we find that throughout the interval [2, ) condition (ii) is satisfied except for a very short period of time [ ), which accounts for the non-smoothness of the curves during that interval in Figure 1. Therefore, with C(t) = 3 in both systems during the interval [2, 5.81], system II s advantage in cηx(t) + cy(t) leads to a greater rate of turning leeches into seeds almost all the time, which continuously reduces its excess of x(t) and eventually leads 1 In real P2P systems, the interaction among peers cannot start without some initial server assistance to disseminate the file chunks into the swarm. Therefore, C(t) = for the first T time units in system II may correspond to the practice of allocating a very small amount of server capacity and primarily relying on peer upload capacity during that time interval.

8 / Performance Evaluation (21) to a crossing at around t = As mentioned above, the crossing occurs before λ(t) jumps up at time 4.6. Our next result on the single-file problem is a sufficient condition on the churn rate for a swarm to be upload-constrained at all times under any scheduling policy. Theorem 2. If γ γ := d(c + d cη)/(d cη), then a swarm described by (1), (2), and (5) is upload-constrained at all times under any scheduling policy. Because 1/γ is the average amount of time that a user spends as a seed in the system and 1/d can be viewed as the user download time in an ideal situation, the condition γ γ can be rewritten as average seeding time r(c, d, η) := d cη minimal download time c + d cη = d/c η. (11) A reasonable range for d/c is 2 to 1. The choice of η is a matter of debate and varies from.3 to 1. Then plugging these values into (11) shows that the critical ratio r(c, d, η) takes on values from.5 to.9 or so. This implies that, even with fairly altruistic users (say, willing to seed for up to 5% or even a greater percentage of their minimal download time), a P2P system still can use some server assistance most of the time. Also, we note that, due to the non-linearity of the system, it is difficult to obtain a closed-form symbolic expression for x(t) under any given scheduling policy even in the single-file setting. Deriving explicit and tight performance bounds is also difficult in general. One lower bound for x(t) can be obtained by solving x (t) = λ(t) dx(t), which describes an idealized system with all peers receiving the maximum download speed at all times. Proposition 1. Let x LB (t) := t λ(s)e d(t s) ds. Then under any policy, x(t) x LB (t) for all t. Finally, we emphasize that in this subsection (and also in later sections) the peer arrival rate function λ(t) is an arbitrary non-negative integrable function, and this is the key reason for the usefulness of the single-file results to our analysis of multi-file systems From single-file to multi-file In this subsection, we discuss the connection between the multi-file scheduling problem and its corresponding single-file problem with the same aggregate leech arrival rate, first in general and then under one assumption. For the N-file problem, consider an arbitrary policy {C i (t)} 1 i N. At any instant t, the total rate at which leeches are turning into seeds is given by the summation of (5) over all N classes: z i (t) = min{cηx i (t) + cy i (t) + C i (t), dx i (t)} (12) min cη x i (t) + c y i (t) + C i (t), d x i (t) (13) = min cηx(t) + cy(t) + C i (t), dx(t), (14) where x(t) := N x i(t), y(t) := N y i(t), and (13) follows from the elementary property that sum of minimums minimum of sums. Because the minimum expression (14) is exactly that

9 / Performance Evaluation (21) for the service rate in a single-file system consisting of x(t) leeches and y(t) seeds and receiving N C i(t) units of server assistance, inequality (13) implies that at any instant the scheduler s capacity allocation decision cannot lead to a higher total service rate in the N-file system than in the single-file scenario with the same aggregate user arrival rate, same total number of peers of each type in the system, and same total amount of server assistance. On the other hand, if the N C i(t) units of capacity is suitably allocated, the scheduler may do as well as in the single-file scenario, or inequality (13) may hold with equality. By elementary analysis, the equality holds if the N minimums in (12) either all equal the first term cηx i (t) + cy i (t) + C i (t) or all equal the second term dx i (t). This is exactly what our proposed {C i (t)} 1 i N will induce at every instant, which we discuss in detail in the next section. However, it is worth noting that inequality (13) alone in general does not imply that the optimum for the single-file problem, say x (t), serves as a pointwise lower bound for every achievable N x i(t) for the multi-file problem 2, and thus achieving (13) with equality for all t (if at all possible) does not necessarily lead to optimality either. But these are indeed true under one assumption. Theorem 3. Suppose that all N classes are upload-constrained at all times under any policy and that an optimal policy exists for the single-file problem with the same system parameters and aggregate leech arrival rate function. Let x (t) be the number of leeches at time t under an optimal policy for the single-file problem. Under any policy for the N-file problem, the resulting N x i(t) x (t), t. Theorem 3 implies that under the assumption of upload-constrained at all times under any policy, a policy must be optimal for the N-file problem if the resulting N x i(t) = x (t) for all t. Furthermore, it suggests, under this assumption, a sufficient condition for optimality with respect to the aggregate service rate function: if a policy is such that the resulting {z i (t)} 1 i N satisfies z i (t) = z (t) := min {cηx(t) + cy(t) + C (t), dx(t)}, for all t, (15) where C (t) corresponds to an optimal policy for the single-file problem, then it must be optimal. We shall see in Subsection 3.3 that a large class of simple policies satisfy (15) under the uploadconstrained assumption Optimality results for multi-file problem In this subsection, we present and prove our main optimality results. We start by defining a class of scheduling policies. A policy for the multi-file problem is called efficient if min{c i (t), R i (t)} = min C, R i (t), for all t. (16) Or equivalently, under an efficient policy, if C j (t) < R j (t) for some j, then N C i(t) = C and C i (t) R i (t) for all i = 1,..., N. Due to the representation (1), the characterization (16) is 2 This is essentially the main insight from the counterexample given in Subsection 3.1: when leeches in one system are turning into seeds at a slower rate than those in another system, an advantage in peer upload capacity is potentially being developed in the former system, which may lead to a crossing of x(t) in the future.

10 / Performance Evaluation (21) equivalent to (13) holding with equality, where N C i(t) in (13) is replaced by C. As discussed in the previous subsection, such a policy may not exist in general. But in systems with a sufficiently high churn rate, efficient policies not only exist but also are optimal. Let γ and γ be defined as in Theorems 1 and 2. Theorem 4. If γ > max{γ, γ }, then an efficient policy exists and is optimal for the multi-file problem. Proof. In order to establish the existence of an efficient policy, first recall from Theorem 2 that γ > γ implies that R i (t) at all times under any policy, for all i = 1,..., N. At any time t, we distinguish two cases: (i) N R i(t) C, and (ii) N R i(t) > C. In case (i), we can set C i (t) = R i (t) for all i = 1,..., N, so that condition (16) is satisfied. In case (ii), it is easy to find a server capacity allocation such that C i (t) R i (t) for all i = 1,..., N, N C i(t) = C, and again condition (16) is satisfied. We next turn to proving optimality. By Theorem 1, the assumption γ > γ implies that the greedy policy is optimal. In addition, due to Theorem 2, γ > γ ensures that all N classes are upload-constrained at all times under any policy, which makes Theorem 3 applicable. As discussed in the previous subsection, it then suffices to prove (15), where C (t) is replaced by the greedy allocation C. Applying (1) and (16), we establish this sufficient condition z i (t) = [cηx i (t) + cy i (t) + min{c i (t), R i (t)}] = cηx(t) + cy(t) + min C, R i (t) = z (t). The proof of Theorem 4 is illuminating. The proof of existence shows that an efficient policy is just to allocate as much server capacity as needed subject to availability, and to distribute the capacity among different swarms in a rational manner; that is, a swarm does not receive sufficient server assistance at some point in time, only if the server is being fully utilized and no other swarm is being provided with excessive capacity at that time. Note that our definition of an efficient policy does allow excessive server assistance to some swarm or some capacity wastage (i.e., C j (t) > R j (t) for some j) when all N classes are receiving their maximum service rate (i.e., z i (t) = dx i (t) for all i = 1,..., N). Therefore, it is efficient, and optimal under the assumption of a high churn rate, to allocate the full server capacity at all times as long as none of it is unnecessarily left unused. In addition, the constructive proof shows that efficient policies are highly non-unique, under the assumption of the theorem. Specifically, when N R i(t) < C (which falls into case (i) in the proof), an efficient policy can prescribe any allocation such that C i (t) R i (t) for all i = 1,..., N. When N R i(t) > C, or in case (ii) of the proof, any allocation that is greedy and incurs no wastage, i.e., N C i(t) = C and C i (t) R i (t) for all i = 1,..., N, is efficient. Only at those rare moments when N R i(t) = C is the efficient allocation unique, that is, C i (t) = R i (t) for all i = 1,..., N. The proof of optimality is closely related to our discussion in Subsection 3.2. An efficient policy satisfies (15) and (13) with equality at every instant by making sure that the N minimums in (12) either all equal the first term cηx i (t) + cy i (t) +C i (t) or all equal the second term dx i (t). If the churn rate is not sufficiently high, efficient policies need not exist or be optimal. If γ γ < γ, efficient policies still exist and the resulting N x i(t) still equals the x(t) under the greedy policy in the corresponding single-file system. However, because the greedy policy

11 / Performance Evaluation (21) may be suboptimal for the single-file problem in this case, efficient policies are not necessarily optimal for the multi-file problem either. Counterexamples may readily be found, by following the same main idea as in the construction for the N = 1 case in Subsection 2.1. The case of a high churn rate is particularly relevant, because this is the scenario where server assistance is needed the most. Also our assumption γ > max{γ, γ } is not too restrictive. In fact, as we discussed in Subsection 2.1, γ = d/r(c, d, η) ranges from approximately d to 2d, and γ often takes the value of 2d. This suggests that the optimality result and the main insight are useful for a variety of hybrid P2P networks where the altruism level of users is not high, with the rule of thumb for high altruism level being users seeding for more than half their (average) minimal download time. Also, we note that the single-file scenario provides a characterization of the achievable performance of multi-torrent strategies, where users can download in one swarm and concurrently upload in another swarm. The proof of Theorem 4 shows that for a sufficiently high churn rate such strategies will not be able to reduce the overall number of leeches, since the same number can be attained in the multi-file problem. However, multi-torrent strategies do provide the capability to trade a slight increase in the download delay for popular files for a huge decrease in the download delay for a niche content. We next extend the optimality result to a weighted multi-file problem, in which the objective is to minimize N a ix i (t) for all t. Without loss of generality, we assume that the various classes are indexed such that a 1 a 2 a N >. This is a reasonable objective when customers with lower class indices are more important. A policy for the multi-file problem is called smart if m m min{c i (t), R i (t)} = min C, R i (t), for all m = 1,..., N, t. (17) Our last analytical result is the existence and optimality of smart policies for the weighted multifile problem under the assumption of a high churn rate. Theorem 5. If γ > max{γ, γ }, then a smart policy exists and is optimal for the weighted multifile problem. Proof. The proof of existence is the same as that for Theorem 4, except that in case (ii) the allocation is unique: R i (t), i = 1,..., m (t) 1 C i (t) = C m (t) 1 R i (t), i = m (t), (18), i = m (t) + 1,..., N where m (t) = min{m N : m R i (t) > C}. In order to prove optimality, first note that a i = a N + N 1 j=i (a j a j+1 ), and thus the weighted objective function can be rewritten as N 1 N 1 j a i x i (t) = a N + (a j a j+1 ) x i(t) = a N x i (t) + (a j a j+1 ) x i (t). (19) j=i Because a smart policy is efficient in a system with only the first m classes, for any m = 1,..., N, Theorem 4 implies that it is optimal for the m-file problem, i.e., for any m = 1,..., N, m x i (t) is minimized at every point in time by a smart policy, under the assumption on the churn rate. Applying this result to the representation of the objective function (19) then yields the desired result. j=1

12 / Performance Evaluation (21) The optimality of smart policies for the weighted multi-file problem is very intuitive because, as the above constructive proof suggests, every smart policy is just an efficient policy that gives higher priority to lower-indexed (or more important) classes in capacity allocation. 4. Proofs This section is devoted to various proofs. We start with the proof of the Little s-law-like identity (8). Proof of Relation (8). From (3) we know that x(t) = A(t) S (t) = t λ(s)1 {S (t)<a(s)}ds, where 1 {S (t)<a(s)} = 1 if S (t) < A(s) and 1 {S (t)<a(s)} = otherwise. It then follows that x(t)dt = = t λ(s) λ(s)1 {S (t)<a(s)} dsdt = S 1 (A(s)) s dtds = λ(s) s 1 {S (t)<a(s)} dtds λ(s)w(s)ds. (2) We now establish a lemma that will be used several times. Lemma 1. Consider an interval [a, b), with b. Suppose that for i = 1, 2, f i (t) is an integrable function on [a, b) and g i (t) satisfies the differential equation where q is a positive constant. If then g 1 (t) g 2 (t), for all t [a, b). g i (t) = f i(t) q g i (t), with initial value g i (a), (21) g 1 (a) g 2 (a) and f 1 (t) f 2 (t), for all t [a, b), (22) Proof. First, as the solution to the differential equation (21), g i (t) is continuous on [a, b), for i = 1, 2. Consider g(t) := g 2 (t) g 1 (t), which is therefore also continuous in t. Suppose there exists a t 1 (a, b) such that g(t 1 ) >. Let ɛ := g(t 1 )/2. Because g(a) and g(t 1 ) = 2ɛ >, by the continuity of g(t), there must exist a t (a, t 1 ) such that g(t ) = ɛ and g(t) ɛ, for all t [t, t 1 ]. In addition, because (21) and (22) imply that g (t) := g 2 (t) g 1 (t) q g(t), we must have g (t) q ɛ <, for all t [t, t 1 ]. This contradicts the fact that g(t 1 ) g(t ) = ɛ >. Therefore, g(t 1 ) > is impossible, or g 1 (t) g 2 (t), for all t [a, b). The next lemma is a preliminary result for the proof of our single-file optimality result, Theorem 1. Recall that we dropped the subscript i in the notation in all our single-file analysis, since there is only one file. In the following two proofs, we shall use subscript π i (or sometimes π) to denote all quantities associated with policy π i (or π); in particular, the greedy policy is denoted by π 1. Lemma 2. Consider any policy π 2 such that C π2 (t) is constant for each interval [kδ, (k + 1)δ), for all k Z + and some δ >. Suppose s := inf{s : (x π1 (s), y π1 (s)) (x π2 (s), y π2 (s))} <. Then there exists a t s and τ > such that x π1 (t) x π2 (t) for all t [s, t ] and x π1 (t) < x π2 (t) for all t (t, t + τ ).

13 / Performance Evaluation (21) Proof. Define x(t) := x π2 (t) x π1 (t) and y(t) := y π2 (t) y π1 (t). First, by the definition of s and the continuity of x π (t) and y π (t) for any policy π, we have (x π1 (t), y π1 (t)) = (x π2 (t), y π2 (t)), for all t s. (23) Let C L := C π2 (s ). By right continuity of C π2 (t), there exists a σ > such that C π2 (t) = C L for all t [s, s + σ ]. Also, by the definition of s, we must have C L < C. Next, we consider two cases. Case I: R π2 (s ) > C L. Therefore, z π2 (s ) = cηx π2 (s ) + cy π2 (s ) + C L, and z π1 (s ) = min{cηx π2 (s )+cy π2 (s )+C, dx π2 (s )} > min{cηx π2 (s )+cy π2 (s )+C L, dx π2 (s )} = z π2 (s ), where the first equality follows from (23), and the inequality follows from R π2 (s ) > C L and C L < C. Therefore, x (s ) = z π1 (s ) z π2 (s ) >. Note that the right continuity of C π2 (t), together with the continuity of x π2 (t) and y π2 (t), implies the right continuity of z π2 (t); similarly, z π1 (t) is right-continuous (in fact, z π1 (t) is also left-continuous since C π1 (t) = C is continuous). Therefore, x (t) = z π1 (t) z π2 (t) is right-continuous. This, combined with x (s ) >, yields that there exists an ɛ > such that x (t) > for all t [s, s + ɛ ]. Therefore, the lemma holds with t = s and τ = ɛ. Case II: R π2 (s ) C L. By (23), R π1 (s ) = R π2 (s ) < C. By continuity, there exists an ɛ 1 > such that, for all t [s, s + ɛ 1 ], R π1 (t) C and thus z π1 (t) = dx π1 (t), for all t [s, s + ɛ 1 ]. (24) Then combining z π2 (t) dx π2 (t), x π1 (s ) = x π2 (s ), and (24), we apply Lemma 1 and obtain that x π1 (t) x π2 (t), for all t [s, s + ɛ 1 ]. Now let us define m := max t [s,s +ɛ 1 ] x(t) and further distinguish between two sub-cases. Case II.1: m =, or x π1 (t) = x π2 (t), for all t [s, s + ɛ 1 ]. This, together with (24), implies that and t z π1 (t) = dx π1 (t) = dx π2 (t) z π2 (t), for all t [s, s + ɛ 1 ], (25) s x (s)ds = t s (z π1 (s) z π2 (s))ds =, for all t [s, s + ɛ 1 ]. (26) From (2), we have that, for any policy π and t s, y π (t) = y π (s )e γ(t s) + t z s π (s)e γ(t s) ds. This then implies that y π1 (t) = y π2 (t) for all t [s, s + ɛ 1 ], because y π1 (t) y π2 (t) t [z s π1 (s) z π2 (s)]ds = due to (25) and (26). Therefore, (x π1 (t), y π1 (t)) = (x π2 (t), y π2 (t)) for all t [s, s + ɛ 1 ], which contradicts the definition of s, or in other words, Case II.1 (m = ) is impossible. Case II.2: m >, or there exists a t [s, s + ɛ 1 ] such that x π1 (t) x π2 (t) for all t [s, t ) and x π1 (t ) < x π2 (t ). By continuity, there exists a τ > such that x π1 (t) < x π2 (t) for all t [t, t +τ ), which shows the statement of the lemma. Loosely speaking, Lemma 2 states that at the first time that x π2 (t) differs from x π1 (t) we must have x π2 (t) > x π1 (t) but never x π2 (t) < x π1 (t). We next prove Theorem 1. For convenience, we define the amount of effectively used server capacity at time t as u πi (t) := min{c πi (t), max{r πi (t), }}. Proof of Theorem 1. Consider an arbitrary policy π 2 such that C π2 (t) is constant for each interval [kδ, (k + 1)δ), for all k Z +. Define x(t) := x π2 (t) x π1 (t) and y(t) := y π2 (t) y π1 (t). At any time t, either Case A or Case B holds:

14 Case A: u π1 (t) < C. In this case, we have that / Performance Evaluation (21) x π 1 (t) = λ(t) dx π1 (t), x π 2 (t) λ(t) dx π2 (t), x (t) d x(t), (27) y π 1 (t) = dx π1 (t) γy π1 (t), y π 2 (t) dx π2 (t) γy π2 (t), y (t) d x(t) γ y(t). (28) Case B: u π1 (t) = C. We have that x π 1 (t) = λ(t) (cηx π1 (t) + cy π1 (t) + C), x π 2 (t) λ(t) (cηx π2 (t) + cy π2 (t) + u π2 (t)), (29) y π 1 (t) = (cηx π1 (t) + cy π1 (t) + C) γy π1 (t), y π 2 (t) (cηx π2 (t) + cy π2 (t) + u π2 (t)) γy π2 (t), (3) where u π2 (t) C. Thus x (t) c(η x(t) + y(t)) and y (t) cη x(t) + (c γ) y(t). (31) Now suppose that t 1 := inf{t : x(t) < } <. We know that, for all t [, t 1 ], x(t). In addition, if x max := max t [,t1 ] x(t) and t max arg max t [,t1 ] x(t), then it follows from Lemma 2 that x max > must hold. Also, from (28), (31), and our assumption of d > cη, we know that, for any t [, t 1 ], whenever y(t) >, y (t) d x(t) + (c γ) y(t). (32) Note that y() = and c γ < due to γ > γ. Then by Lemma 1, y(t max ) w(t max ), where w(t) satisfies the differential equation w (t) = d x max + (c γ)w(t), for t, with the initial condition w() =, i.e., w(t) = d x max γ c [1 e (γ c)t ]. Thus, y(t max ) d x max γ c < x max. We proceed to show y(t) x(t), for all t (t max, t 2 ], (33) where t 2 := inf{t > t max : x(t) = } t 1. Supposing (33) does not hold, then If t falls into Case A, then x (t ) y (t ) and y(t ) = x(t ) > for some t [t max, t 2 ). (34) x (t ) d x(t ) and y (t ) d x(t ) γ y(t ) = (d γ) x(t ), (35) due to (28) and (34). The first inequality in (34), together with (35), thus requires γ 2d, which contradicts γ > γ. Similarly, if t falls into Case B, then it would imply γ 2c(η+1), which also contradicts γ > γ. This proves (33), which, combined with (27) and (31), yields that x (t) max{c(η + 1), d} x(t), for any t [t max, t 2 ). If t 2 <, x(t 2 ) e max{c(η+1),d}(t 2 t max ) x max >, which contradicts the definition of t 2. Thus t 2 =. Since t 2 t 1, then we must also have t 1 =, which contradicts our initial supposition. In conclusion, t 1 =, or x(t), for all t. Next, we prove Theorem 2. We shall not use the π subscript any more. We start with a useful lemma. Lemma 3. For any policy and a [, ), x(t) x(a)e d(t a), for all t > a. Proof. Let g 1 (t) := x(t) and g 2 (t) := x(a)e d(t a). Applying Lemma 1 then yields the desired result.

15 / Performance Evaluation (21) y(t) Proof of Theorem 2. We first prove that, under any policy, sup t> x(t) d γ d if γ > d. Fix an arbitrary policy and s (, ). Let x s := x(s), y s := y(s), and x(t) := x s e d(s t), for all t [, s]. First, it must be true that x(t) x(t), for all t [, s], because x(s) = x(s) and if there exists t [, s), such that x(t ) > x(t ) = x s e d(s t), we would have the following contradiction x(s) x(t )e d(s t) > x s e d(s t) e d(s t) = x s, where the first inequality holds by Lemma 3. Second, we have that y(t) y(t) := Ke dt Ke γt, with K = dx s e ds /(γ d), for all t [, s], (36) where y(t) is the solution to y() =, y (t) = dx(t) γy(t), for all t [, s]. Relation (36) follows from Lemma 1 by comparing the characterization of y(t) with the fact that y() = and y (t) dx(t) γy(t) dx(t) γy(t), for all t [, s], (37) where the second inequality in (37) is due to x(t) x(t), for all t [, s]. It then follows from (36) that y(t) < Ke dt, for all t [, s]. In particular, y(s) < Ke ds = dx s y(s) γ d, or x(s) < d γ d. Since y(t) the choice of the policy and s is arbitrary, we have sup t> x(t) d γ d. This, together with γ γ, y(t) implies that sup t> x(t) d cη c, or the system is upload-constrained at any time t >. Also since R() =, this completes the proof. Proof of Proposition 1. The result follows immediately by applying Lemma 1 and noting that z(t) dx(t) and x LB (t) is the solution to x (t) = λ(t) dx(t). Finally, we prove Theorem 3, connecting multi-file problems with the single-file scenario. Proof of Theorem 3. Fix an arbitrary policy for the multi-file problem {C i (t)} 1 i N and let {x i (t)} 1 i N and {y i (t)} 1 i N be the resulting peer evolution functions. For the corresponding single-file problem, we define a policy, namely ψ, by letting C(t) = C ψ (t) := N min{c i(t), R i (t)} and use subscript ψ to denote all quantities in the single-file system under policy ψ. First, since R i (t) for all t due to the upload-constrained assumption, policy ψ is feasible or C ψ (t) for all t. Now observe that if N x i(t) = x ψ (t) and N y i(t) = y ψ (t), then C ψ (t) N R i(t) = N [(d cη)x i(t) + cy i (t)] = (d cη)x ψ (t) + cy ψ (t) = R ψ (t). Therefore, N z i(t) = N [cηx i(t)+cy i (t)+min{c i (t), R i (t)}] = cηx ψ (t)+cy ψ (t)+c ψ (t) = cηx ψ (t)+cy ψ (t)+ min{c ψ (t), R ψ (t)} = z ψ (t). Since all peer evolution functions start with at time, we conclude that N x i(t) = x ψ (t) x (t) for all t. 5. Numerical results We next present some numerical experiments assuming a relatively low churn rate. We will show that in this case, even using the possibly non-optimal greedy policy (and a simple variant in the multi-file scenario), the hybrid P2P strategy can achieve substantial gains over both the pure P2P system and the conventional client-server model. Consider a single-file scenario, with c = 1, η =.6, d = 6, γ = 1.25, and λ(t) = 2 e t 3. We compare the number of downloaders in the system function x(t) under three different strategies: system I operates under a conventional client-server strategy with 8 units of server capacity, i.e., x (t) = λ(t) 8; system II is a pure P2P model, i.e., (1), (2), and (5) with C(t) = for all t ; system III is a hybrid P2P system with 8 units of server capacity and operating under the greedy policy for the first 2 time units, i.e., (1), (2), and (5) with C(t) = 8 for all t 2, and a pure P2P system after time 2. Figure 2 shows that

16 / Performance Evaluation (21) the hybrid P2P paradigm, keeping its x(t) at a much lower level almost all the time, outperforms considerably the other two. This advantage is further illustrated by Figure 3, in which we plot the cumulative arrival function A(t) = t λ(s)ds and the cumulative service function S (t) = A(t) x(t) for each system, and by Figure 4, where we plot W(t) = S 1 (A(t)) t = inf{u > : S (t + u) > A(t)}, as a measure for the download delay of a hypothetical user arriving at time t in each system. As can be seen in both figures, system III shows consistently better and much more stable performance I A(t) 8 x(t) 6 II 2 S III(t) S I(t) 4 2 III 1 S II(t) t t Figure 2: I: pure client-server, II: pure P2P, III: hybrid P2P. Figure 3: A(t) and S (t) for systems I, II, and III. 1.6 I W (t) II III t 5 4 x(t) I II III t Figure 4: W(t) for systems I, II, and III. Figure 5: Multi-file. I: pure client-server, II: pure P2P, III: hybrid P2P. Also note that in system I the server is needed throughout all time, while in system III it is only used until time 2 and can be allocated to other swarms thereafter. This observation in fact shows that, in the multi-file scenario where a new file with a similar λ(t) profile is made available about every 2 time units, the simple policy of always allocating the full server capacity to the most recently released file would maintain the aggregate number of leeches at a much lower level than the other two types of models; this is demonstrated in Figure 5, where in system I with