APPROXIMATE EQUILIBRIA IN LARGE GAMES
A DISSERTATION SUBMITTED TO THE DEPARTMENT OF MANAGEMENT SCIENCE AND ENGINEERING AND THE COMMITTEE ON GRADUATE STUDIES OF STANFORD UNIVERSITY IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHILOSOPHY
Yu Wu August 2012
© 2012 by Yu Wu. All Rights Reserved. Re-distributed by Stanford University under license with the author.
This work is licensed under a Creative Commons Attribution- Noncommercial 3.0 United States License. http://creativecommons.org/licenses/by-nc/3.0/us/
This dissertation is online at: http://purl.stanford.edu/jv163hr1839
ii I certify that I have read this dissertation and that, in my opinion, it is fully adequate in scope and quality as a dissertation for the degree of Doctor of Philosophy.
Ramesh Johari, Primary Adviser
I certify that I have read this dissertation and that, in my opinion, it is fully adequate in scope and quality as a dissertation for the degree of Doctor of Philosophy.
Nicholas Bambos
I certify that I have read this dissertation and that, in my opinion, it is fully adequate in scope and quality as a dissertation for the degree of Doctor of Philosophy.
Christina Aperjis
Approved for the Stanford University Committee on Graduate Studies. Patricia J. Gumport, Vice Provost Graduate Education
This signature page was generated electronically upon submission of this dissertation in electronic format. An original signed hard copy of the signature page is on file in University Archives.
iii Abstract
The complexity of studying Nash equilibrium in large games often scales with the size of the system: as it increases, computing the exact Nash equilibrium can soon become intractable. However, when the number of players in the system approaches infinity and no individual player has a significant impact on the system, we can approximate the system by considering each single player no longer playing against other individual players but a single aggregation of all other players. In this paper, we apply this idea to study and approximate Nash equilibria in two large scale games. In part I, we consider a model of priced resource sharing that combines both queueing behavior and strategic behavior. We study a priority service model where a single server allocates its capacity to agents in proportion to their payment to the system, and users from different classes act to minimize the sum of their cost for processing delay and payment. As the exact processing time of this system is hard to compute and cannot be characterized in closed form, we introduce the concept of aggregate equilibrium to approximate the exact Nash equilibrium, by assuming each individual player plays against a common aggregate priority that characterizes the large system. We then introduce the notion of heavy traffic equilibrium as an alter- native approximation of the Nash equilibrium, derived by considering the asymptotic regime where the system load approaches capacity. We show that both aggregate equilibrium and heavy traffic equilibrium are asymptotically exact in heavy traffic. We present some numerical results for both approximate equilibria, and discuss effi- ciency and revenue, and in particular provide a bound for the price of anarchy of the heavy traffic equilibrium. In part II, we study the reputation system of large scale online marketplace. We
iv develop a large market model to study reputation mechanisms in online marketplaces. We consider two types of sellers: commitment sellers, who are intrinsically honest but may be unable to accurately describe items because of limited expertise; and strategic sellers, who are driven by a profit maximization motive. We focus on stationary equi- libria for this dynamic market, in particular, on separating equilibria where strategic sellers are incentivized to describe the items they have for sale truthfully, and char- acterize the conditions under which such equilibria exist. We then complement our theoretical results with computational analysis and provide insights on the features of markets that may incentivize truthfulness in equilibrium.
v Acknowledgements
First, I would like to give my deepest gratitude to my advisor Ramesh Johari for his endless support and constant encouragement in my education at Stanford. His passion, optimism, attitude towards work and life has inspired and will continue to inspire me. I am very grateful to Christina Aperjis and Loc Bui for their insightful suggestions in collaborating in several areas of this thesis. I would like to thank Nick Bambos, Ashish Goel and Balaji Prabhakar for serving my dissertation committee and provid- ing great advice to the development of this work. I want to thank all the faculty and staff in the Department of Management Science and Engineering, for their generous help that makes my stay at Stanford a very enjoyable one. I would like to gratefully acknowledge support from a Larry Yung Stanford Grad- uate Fellowship, and the National Science Foundation under grant CMMI-0948434. In these five years at Stanford, I benefited tremendously from fruitful discus- sions with fellow students, especially Krishnamurthy Iyer, Xiangrui Meng and Zizhuo Wang. I enjoyed very much my life at Stanford, which has been filled with joyful memories with my friends here: Ming Chen, Hao Chen, Pei He, Yi Liu, Zhen Qian, Xu Tan and many others. I would also like to express my gratitude to Shanshan Xu, Weipeng Zhang and Yali Zhang for giving me constant emotional support despite the geographical distance between us. I have a special thank you to Beichen Wang, who embraces me with heartfelt friendship and influences me with his kindness and integrity. Finally, I would like to thank my parents Qingping Wu and Yuan Wang for their unconditional love, support and encouragement. I owe the most thanks to them.
vi Contents
Abstract iv
Acknowledgements vi
1 Part I: Resource Sharing Game 1 1.1 Introduction ...... 1 1.2 Resource Sharing Game ...... 4 1.2.1 Characterizing Processing Times ...... 6 1.2.2 Nash Equilibrium ...... 8 1.3 Job Level Game: Aggregate Approximation ...... 10 1.3.1 Aggregate Priority ...... 11 1.3.2 Aggregate Processing Time ...... 12 1.3.3 Aggregate Equilibrium ...... 16 1.4 Job Level Game: Heavy Traffic Approximation ...... 20 1.4.1 Heavy Traffic Processing Time ...... 20 1.4.2 Heavy Traffic Equilibrium ...... 21 1.4.3 Sensitivity ...... 24 1.4.4 Efficiency ...... 25 1.4.5 Revenue ...... 28 1.5 Class Level Game ...... 30 1.5.1 Aggregate Equilibrium ...... 33 1.5.2 Heavy Traffic Equilibrium ...... 36 1.6 Numerics ...... 37
vii 1.6.1 Approximation Errors: AE vs. HTE ...... 38 1.6.2 Approximation Sensitivity ...... 38 1.6.3 Price of Anarchy ...... 41 1.7 Extensions ...... 41 1.7.1 A Multi-server Model ...... 44 1.8 Conclusion ...... 47
2 Part II: Reputation System 49 2.1 Introduction ...... 49 2.2 Model ...... 53 2.2.1 Preliminaries ...... 53 2.2.2 Market Dynamics and Stationary Equilibrium ...... 56 2.2.3 Separating Equilibrium ...... 58 2.3 Existence of Separating Equilibria ...... 60 2.4 Approximating Separating Equilibria ...... 65 2.5 Computational Analysis ...... 68 2.6 Conclusion ...... 72
Bibliography 73
viii List of Tables
1.1 Fairness-efficiency tradeoff on α...... 26
ix List of Figures
1.1 Relative error of AE and HTE with different system loads...... 39 1.2 Relative error of HTE under different parameters...... 40 1.3 Price of anarchy of HTE under different parameters...... 42
2.1 Density functions and their logarithmic ratio...... 71 2.2 The function B(r) with different class weights...... 72
x Chapter 1
Part I: Resource Sharing Game
1.1 Introduction
A range of resource sharing systems, such as computing or communication services, exhibit two distinct characteristics: queueing behavior and strategic behavior. Queue- ing behavior arises because jobs or flows are served with the limited capacity of system resources. Strategic behavior arises because these jobs or flows are typically generated by self-interested, payoff-maximizing users. Analysis of strategic behavior in queueing systems has a long history, dating to the seminal work of Naor [47]; see the book by Hassin and Haviv [22] for a comprehensive survey. The interaction of queueing and strategic behaviors has become especially important recently, with the rise of paid re- source sharing systems such as cloud computing platforms. For example, [2] and [12] discussed systems with multiple service providers, modeled as first-come-first-serve queues, that compete in both price and response time for potential buyers. In this chapter we consider a particular queueing model where a single server is shared among multiple jobs, and the service capacity allocated to each job depends on its priority level. The particular scheduling policy we consider is known in the liter- ature as the discriminatory processor sharing (DPS) policy, introduced by Kleinrock [38]. In the DPS model, the server shares its capacity in proportion to the priority level of all jobs currently in the system. This service allocation rule is a special case of a more general scheduling policy for queueing networks known as proportionally
1 CHAPTER 1. PART I: RESOURCE SHARING GAME 2
fair resource sharing [34, 42]; such scheduling policies have been studied extensively in the context of networked resource sharing (see [32, 54] and references therein). A survey of the DPS literature can also be found in [3]. We consider a DPS system in steady state, and study a job level game where every individual job is a single strategic user. Each user chooses a payment β, which corresponds to the priority level of that user. The user also incurs a cost proportional to total processing time. The users’ goal is to choose priority levels to minimize the sum of expected processing cost and payment. (We also briefly discuss a class level game, where every class is a single user.) This game is inspired by resource sharing in real services. For example, in the Amazon EC2 Spot Instances, a user can bid her own price (priority) and enjoy the service as long as the dynamic benchmark price computed by the system is lower than the bid. The service is terminated either upon completion of task or when the system price rises above the bid price. In many file hosting websites, users can purchase premium packages which increase upload/download bandwidth and speed, and allow parallel tasks among other benefits. Note that in these services, the resource is shared among all users that currently request service, and a higher payment leads to higher performance. A central difficulty in analysis of equilibria arises because exact computation of the steady state processing time of a single job, given the priority choices of other jobs, is not possible in closed form. Since the queueing behavior computation itself involves numerical complexity, equilibrium characterization in closed form for the strategic behavior is essentially impossible. Thus obtaining structural insight into the games is a significant challenge. To tackle this problem, we propose an approximate approach to equilibrium char- acterization that is amenable to analysis, computable in closed form, and provably exact in an appropriate asymptotic regime where the load on the system increases, known as the heavy traffic regime [37, 49]. The heavy traffic asymptotic regime is widely used in analysis of queueing systems and is especially valuable to study systems with many users. Asymptotics yield two benefits. First, they significantly simplify stochastic analysis. The second key benefit of asymptotics is that we are also able to CHAPTER 1. PART I: RESOURCE SHARING GAME 3
simplify our game theoretic analysis. Informally, an important reason is that when the number of users grows large, no single user has a large impact on the whole system; this effect allows us to simplify calculation of equilibria. (Note that this is similar to the “large market” approximation used to justify competitive price equilibria in economics.) We conclude with a brief survey of related work. Priority pricing problems in queueing systems with disciplines other than DPS have been investigated, such as de- sign of efficient, incentive compatible pricing for nonpreemptive priority FIFO queues [43, 36]. Besides the service discipline, our work also differs from this work because in our model users choose their own priority levels, while in previous models the service provider fixes the priority levels available. Other studies focus on optimal arrival strategy of users, including the work by Glazer and Hassin [20] and Jain et al. [28]. In our paper, although we briefly discuss the case where arrivals are endogenously generated, in the main discussion we assume that arrival rates exogenously given. In a recent work, Yolken and Bambos [58] studied a proportional priority game similar to our class level game, but each class of users form a separated queue . This difference leads to quite different structures and results of their and our models. Turning our attention to DPS specifically, we note that most prior work on DPS considers only analysis of the queueing system without any strategic choice of priori- ties. Haviv and van der Wal [23] consider a DPS system in which users choose their own priority levels to minimize their costs, but only study a model with one class of users. This is essentially different from the multiple-class game studied in this paper because in the one-class game processing time can be computed in closed form, while that is not the case in the multiple-class game. To the best of our knowledge, there is no previous work that considers priority pricing in the multiple class DPS system, because expected processing time cannot be characterized in closed form. The remainder of part I is organized as follows. In Section 1.2, we describe the queueing game setup. In Section 1.3 and 1.4, we introduce the notion of aggregate equilibrium and heavy traffic equilibrium for the job level games, and present the results on parameter sensitivity, efficiency, and revenue under the heavy traffic equi- librium. Then we apply similar approximation techniques to class level games in CHAPTER 1. PART I: RESOURCE SHARING GAME 4
Section 1.5. Numerical results of the approximate equilibria are presented in Section 1.6. Some extensions of the model are discussed in Section 1.7. Substantial portions of the content in this chapter appear in the papers by Wu et al. [56, 57].
1.2 Resource Sharing Game
We consider a queueing game in which K classes of jobs share a single server of unit capacity. Class i (i = 1, ··· ,K) jobs arrive according to a Poisson process with arrival rate λi and have i.i.d. exponentially distributed service requirements
(measured in units of service, e.g., processing cycles) with mean 1/µi. We assume P for simplicity that µi = µ for all classes. Let λ = k λk denote the total arrival rate to the system. Also, let ρi = λi/µ be the load of class i, and define the system load P P as ρ = k ρk = k λk/µ. To ensure stability, we assume ρ < 1. It is well known that under this condition, the resulting queueing system is ergodic and possesses a unique steady state distribution [39]. Waiting and being served in the system induces a cost ci per unit time for users of class i. Without loss of generality we assume c1 > c2 > ··· > cK : if two classes i and j have the same cost ci = cj, then they can be merged into one class with arrival rate λi + λj. We assume that the server allocates its capacity according to the discriminatory processor sharing (DPS) policy. Under this policy, each job is associated with a priority level. If there are currently N jobs in the system and job ` has chosen priority PN level β`, then the fraction of service capacity allocated to job ` is β`/ m=1 βm. Upon arrival, without observing the state of the system, each job chooses a priority level β > 0. We consider a family of pricing rules for priority that we refer to as α-fair pricing rules, where α > 0. Formally, we assume that if a job chooses priority level β, then the system manager charges that job a price βα, where α > 0. Varying α allows us to study a range of pricing schemes. In particular, as α → 0, jobs face a strongly diminishing marginal cost to higher choices of β; while as α → ∞, jobs face a strongly increasing marginal cost with higher choices of β. The pricing rules we consider are closely related to α-fair allocation rules studied in the networking literature [35] [45]. In an α-fair allocation system, one unit of resource CHAPTER 1. PART I: RESOURCE SHARING GAME 5
is allocated to N users, whose utility functions are characterized by α: U (α)(x) = x1−α/(1 − α) if α 6= 1, and U (α)(x) = log(x) if α = 1. Users make payments for use of the system. Let w` be the payment of user `; the payments determine users’ weights in the system. Formally, suppose the payment vector of users is w and the allocation vector is x; then the resource manager solves the following optimization problem:
N N X (α) X max w`U (x`) s.t. x` ≤ 1. x `=1 `=1
1/α P 1/α The solution of this problem is x` = w` /( wm ). A well-known example of an α- fair allocation rule is the proportionally fair allocation rule, obtained when α = 1 [34]: resource is allocated proportional to payment. Now, suppose that the α-fair pricing α rule is used in our model, so that w` = β` . Then the α-fair allocation rule reduces to the discriminatory processor sharing policy described above—i.e., allocation of server capacity in proportion to the priority levels β`. In this paper we will generally be interested in scenarios where all jobs of the same class i choose the same priority level. In an abuse of notation we denote by
βi the priority level chosen by all class i jobs, and in this case we succinctly denote
(β1, ··· , βK ) by β. We refer to β as the class priority vector. Let V (β; β) be the expected processing time for a job with priority β that arrives to the system in steady state, with the class priority vector given by β. Observe that with this notation, a class i job with priority level βi has expected processing time V (βi; β). For conve- α nience we define Wi(β) = V (βi; β). The total cost of a user is cV (β; β) + β , where c is the user’s unit time cost and β is its priority level. We frequently make use of Little’s law, which provides a relationship between steady state expected processing times and steady state expected queue lengths [39].
In particular, let Ni denote the steady state number of class i jobs in the system. In a system consisting of K classes (λi, βi), i = 1,...,K, Little’s law establishes that in steady state, for every class i we have
E[Ni] = λiWi(β). (1.1) CHAPTER 1. PART I: RESOURCE SHARING GAME 6
1.2.1 Characterizing Processing Times
First we characterize the processing times V (β; β) and Wi(β). For the K class DPS model, Fayolle et al. [19] show that the expected steady state processing time Wi for each class i can be determined by solving a linear system.
Theorem 1. [19] In a K-class DPS model with class priority vector β, (W1(β), ···
,WK (β)) is the unique solution of the following system of equations:
K X λiβi µW (β) − [W (β) + W (β)] = 1, k = 1, ··· ,K. (1.2) k β + β k i i=1 i k
On the other hand, computing the processing time V (β; β) for general β can be reduced to computing the processing time Wi(β), i = 1, ··· ,K as stated by the following theorem.
Proposition 2. Let Ni be the steady state number of class i jobs in a K-class DPS system with class priority vector β. Then the steady state processing time of a job with priority β is
K X V (β; β) = U0(β; β) + Ui(β; β)E[Ni], (1.3) i=1 where
" K #−1 βi X λiβi U (β; β) = U (β; β), i = 1, ··· ,K; and U (β; β) = µ − (1.4) i β + β 0 0 β + β i i=1 i
Proof. We follow the same approach as in [23] (see also Theorem 4.8 in [22]) by decomposing the problem into two parts. Fix a job with priority β > 0, and fix β =
(β1, ··· , βK ) > 0 where βi is the priority level of class i jobs. Let U(β; β, n1, ··· , nK ) be the expected time in the system if this job has priority β, and is currently being processed with ni class i jobs in the system. Then conditional on the first transition, CHAPTER 1. PART I: RESOURCE SHARING GAME 7
we have the following recursion:
K 1 X λi U(β; β, n , ··· , n ) = + U(β; β, n , ··· , n + 1, ··· , n ) 1 K λ + µ λ + µ 1 i K i=1 K X µ niβi + U(β; β, n , ··· , n − 1, ··· , n ). λ + µ PK 1 i K i=1 k=1 nkβk + β (1.5)
Following the same argument as in [22], we can show that U(β, n1, ··· , nK ) is linear in each ni. That is, there are functions Ui(β; β)(i = 0, ··· ,K) such that:
K X U(β; β, n1, ··· , nK ) = U0(β; β) + Ui(β; β)ni. (1.6) i=1
Substituting (1.6) into (1.5) yields that
" K #" K # " K # K X X X X niβi + β 1 + λiUi(β; β) = βµ U0(β; β) + Ui(β; β)ni +µ βiUi(β; β)ni. i=1 i=1 i=1 i=1
Then compare the coefficients of each ni as well as the constant term, we obtain:
" K # X βk 1 + λiUi(β; β) = µ(β + βk)Uk(β; β), k = 1, ··· ,K; i=1 K X 1 + λiUi(β; β) = µU0(β; β). i=1
Hence the solution to (1.5) is
" K #−1 βi X λiβi U (β; β) = U (β; β), i = 1, ··· ,K; U (β; β) = µ − . i β + β 0 0 β + β i i=1 i
The above equation, along with (1.6) gives the expression for V (β; β) in terms of the expected queue lengths.
The values of E[Ni] can be obtained by applying Little’s law to the solution of CHAPTER 1. PART I: RESOURCE SHARING GAME 8
the system of linear equations (1.2). We conclude, therefore, that solving for V (β; β) in (1.3) can be reduced to computing Wi(β). In general, explicitly solving (1.2) requires the inversion of a K × K matrix with 3 complexity O(K ), and hence, there is no closed form expression for Wi(β) or V (β; β).
Nevertheless, when K = 1 or K = 2, we are able to solve for Wi(β) and V (β; β) in closed form. The solution of (1.3) with K = 1 is first established in [23, 22] as follows
1 β(1 − ρ) + βˆ V (β; βˆ) = · . (1.7) µ(1 − ρ) βˆ(1 − ρ) + β
When K = 2, the solution for Wi(β) is given by [19], and the solution for V directly follows. Both solutions are lengthy and omitted for brevity.
1.2.2 Nash Equilibrium
In this DPS system with jobs generated by strategic users, we consider two types of games for this system: the job level game and the class level game. In the job level game, each job is an individual user, aiming to minimize its expected total cost by choosing its own priority level β. Although jobs from the same class are allowed to choose different priority levels, because jobs of the same class share the same parameters ex ante, we restrict our attention only to symmetric equilibria of the resource sharing game; these are equilibria where jobs from the same class choose the same priority levels. Such an equilibrium can be characterized by a class priority vector (β1, ··· , βK ).
Definition 1. A job level Nash equilibrium consists of a class priority vector
β = (β1, ··· , βK ) such that for all i = 1, ··· ,K,
α βi = arg min [ciV (β; β) + β ] , ∀ i = 1, ··· ,K. (1.8) β>0
In the class level game, each class is regarded as a single user and chooses a priority level for all of its jobs; therefore the equilibrium is again characterized by a class priority vector. CHAPTER 1. PART I: RESOURCE SHARING GAME 9
Definition 2. A class level Nash equilibrium consists of a class priority vector
β = (β1, ··· , βK ) such that for all i = 1, ··· ,K,
α βi = arg min [ciWi(β1, ··· , βi−1, β, βi+1, ··· , βK ) + β ], ∀ i = 1, ··· ,K. β>0
We emphasize that, although jobs from the same class choose the same priority in both the symmetric job level equilibrium and the class level equilibrium, these two equilibria are not identical. The difference is that in the class level game, changing the priority level of a whole class i causes an externality within the class itself, while by contrast, in the job level game, a single job alters its priority level in isolation. We mainly study the job level game, then we discuss how our study can be adapted to the class level game in the Section 1.5. Existence of Nash equilibrium can be guaranteed when α ≥ 1, by exploiting con- vexity of the job cost function in (1.8). When α < 1, the payment term βα is strictly concave, therefore the convexity of the objective function is not guaranteed. Al- though analytically establishing existence of Nash equilibrium in this regime remains an open question, our numerical computation with best response dynamics converges to a Nash equilibrium even when α < 1.
Proposition 3. There exists a Nash equilibrium for the job level game when α ≥ 1.
Proof. It is straightforward to show that V (β; β) ≤ 1/(µ(1 − ρ)): the expected pro- cessing time of any job, regardless of priority, cannot be longer than the expected length of a busy period in an M/M/1 queue with arrival rate λ and service rate µ [39]. (This follows because the discriminatory processor sharing policy is work- conserving, so the length of a busy period will be identical to that in an M/M/1 queue.) It then follows that there exists an upper bound β such that no job ever has β > β as an optimal strategy. Next we show that V (β; β) is convex in β. Combining (1.3) and (1.4) gives V (β; β) = f(β)/g(β), where f(β) = 1 + PK λiWiβi and g(β) = µ − PK λiβi . It is i=1 βi+β i=1 βi+β easy to check that f(β) > 0, f 0(β) < 0, f 00(β) > 0; and g(β) > 0, g0(β) > 0, g00(β) < 0, CHAPTER 1. PART I: RESOURCE SHARING GAME 10
thus
f(β)00 [f 00(β)g(β) − f(β)g00(β)] 2 [f 0(β)g(β) − f(β)g0(β)] g(β)g0(β) = − > 0. g(β) [g(β)]2 [g(β)]4
α α Moreover, β is convex in β since α ≥ 1, so ciV (β; β) + β is convex in β. It follows by Rosen’s existence theorem [52] that a pure Nash equilibrium exists for the game in this case.
As usual, this existence result is nonconstructive, since it uses a fixed point theo- rem. In general, given the implicit equations that define the processing times in Wi(β) and V (β; β), there is no closed form characterization of the Nash equilibrium, and no tractable approach for computation is available. Although we could resort to some heuristics (e.g., best response dynamics) to approach NE, each step of such an algo- rithm requires computing a range of processing times with fixed parameters, and as established above each such computation has complexity O(K3). Further, there is no theoretical guarantee that such dynamics will converge. (Though we note, numerical computation suggests that the best response dynamics does converge.) Equilibrium computation is therefore not possible in closed form in general; as a result, we are left with essentially no structural insight into the behavior of players in the game.
1.3 Job Level Game: Aggregate Approximation
One of the most crucial complexity of computing Nash equilibria lies in the intractabil- ity of computing processing time V (β; β). In the next two sections, we consider an alternate approach to the equilibrium analysis, by approximating the processing time. If we can find a closed form approximation of V (β; β), we may also approximate Nash equilibrium in closed form and analytically study the equilibrium. Our first attempt of approximation is inspired by the closed form expression (1.7). Although V (β; β) does not admit an explicit form in general, it has a simply expression if there is only one class of jobs in the system (i.e., K = 1). Note that in the DPS system, the service rate of any individual job depends on the priorities of other jobs only through the CHAPTER 1. PART I: RESOURCE SHARING GAME 11
sum of those priorities, therefore the idea of aggregating the priorities of the whole system into a single class is promising.
1.3.1 Aggregate Priority
Formally, suppose the system consists of K classes (λi, βi), i = 1, ··· ,K with β > 0. We seek an aggregate priority βˆ such that the K classes of jobs in the system are PK ˆ approximately equivalent to a single class with arrival rate λ = i=1 λK , priority β. To find a suitable value of βˆ, consider two parallel systems for an additional job with priority β. In the original DPS system with K classes (λi, βi), i = 1, ··· K, the PK service capacity our chosen job enjoys at time t is β/( i=1 Ni(t)βi + β) if it is in the system at time t, and 0 otherwise. We then consider a second system where we imagine that there is only one class (λ, βˆ). If we denote by random variable Nˆ(t) the number of other jobs at time t in this system, the service capacity allocated to our chosen job is β/(Nˆ(t)βˆ + β) if this job is in the system at time t, and 0 otherwise. We hope these two systems are identical from the point of view of our single job, which would be ensured if the service allocated to each job, as well as the number of jobs in two systems, were the same. In other words, we require the two systems to ˆ PK satisfy N(t) = i=1 Ni(t) almost surely, and
K K X ˆ ˆ X ˆ Ni(t)βi = N(t)β = Ni(t)β a.s. (1.9) i=1 i=1
However, this is impossible on a sample path basis, since βˆ cannot be equal to every
βi (except in the degenerate case where all βi’s are equal). Nevertheless, we can develop a choice for βˆ by taking expectations on both sides of (1.9). Applying Little’s Law (1.1), and replacing the class level expected processing time Wi(β) by the equivalent job level expected processing time, we have:
h K i P K K E i=1 Niβi P λ W (β)β P λ V (β ; β)β βˆ = = i=1 i i i = i=1 i i i . h K i PK PK P λiWi(β) λiV (βi; β) E i=1 Ni i=1 i=1 CHAPTER 1. PART I: RESOURCE SHARING GAME 12
The preceding approximation suggests a reasonable approach to choosing the ag- gregate priority βˆ; however, it still requires computation of the full K-class expected job level processing time. But recall that our intention is that the system with all K classes (λi, βi), i = 1, ··· ,K, should be well approximated by a system with a single ˆ ˆ class (λ, β). Therefore we hope that V (βi; β) ≈ V (βi; β), where the latter is the job level processing time in a system with only one class. Using this approximation, we arrive at the following definition.
ˆ Definition 3. β is the aggregate priority of the system with K classes (λi, βi), i = 1, ··· ,K if PK λ V (β ; βˆ)β βˆ = i=1 i i i . (1.10) PK ˆ i=1 λiV (βi; β) Lemma 4. For any system with β > 0, aggregate priority exists and is unique.
Proof. Define K X fβ(x) = (x − βi)λiV (βi; x). i=1 ˆ ˆ It follows that any β satisfying (1.10) is a solution to fβ(β) = 0. It is straightforward to check by differentiating that for any β > 0, fβ is a convex function, with fβ(0) < 0 and fβ(x) → ∞ as x → ∞. Hence for any β > 0, there exists a unique solution ˆ ˆ to fβ(β) = 0 in (0, ∞), and that unique solution is the aggregate priority β we are looking for.
We note aggregate priority βˆ is a function of system priorities β. Although there is no general closed form expression for aggregate priority βˆ, the above proof shows it can be obtained by a simple bisection method numerically.
1.3.2 Aggregate Processing Time
With the aggregate priority and equation (1.7), we define the aggregate processing time as follows. CHAPTER 1. PART I: RESOURCE SHARING GAME 13
Definition 4. The aggregate processing time for a job with priority level β > 0 in the system with K classes (λi, βi), i = 1, ··· ,K, with β > 0, is defined as
V AG(β; β) = V (β; βˆ(β)) (1.11) where βˆ(β) is the aggregate priority of the system, and V is the one-job-one-class processing time given by (1.7).
Once again, βˆ(β) is dependent on ρ but we do not parameterize this dependence for simplicity. Based on the preceding heuristic derivation, our conjecture is that V AG is a po- tentially good proxy for the true processing time. In the remainder of this subsection, we verify that our calculation is correct in an asymptotic regime when the system is heavily loaded. We have the following theorem that the (scaled) aggregate processing time converges to the (scaled) exact p time in heavy traffic.
Theorem 5. Let β > 0. As ρ → 1,
(1 − ρ)[V AG(β; β) − V (β; β)] → 0.
To show this theorem, we first study the heavy traffic regime. That is, the system arrival rate λ approaches total service capacity µ, or equivalently, system load ρ approaches 1. In heavy traffic, a phenomenon known as state space collapse gives us a simplified solution for the steady state distribution of the system [49]; informally, state space collapse refers to the fact that the numbers of jobs of each class in the system become perfectly correlated when the system is heavily loaded. In a slight abuse, whenever we write ρ → 1, we mean that we consider a sequence PK of systems such that (ρ1, ··· , ρK ) converges to some (ρ1, ··· , ρK ) with i=1 ρi =
1. Moreover, we emphasize that both V (β; β) and Wi(β) depend on ρ, though we suppress this dependence for notational brevity. Let Ni denote the steady state number of type i jobs in the system. Then we have the following result on the joint steady state distribution of (N1, ··· ,NK ) for a DPS system in heavy traffic. CHAPTER 1. PART I: RESOURCE SHARING GAME 14
Theorem 6. [48] Let Ni be the steady state number of class i jobs in a K-class DPS system with class priority vector β. Then as ρ → 1, we have
d. ρ1 ρK (1 − ρ)(N1, ··· ,NK ) → Z · , ··· , , β1 βK where “→d. ” denotes convergence in distribution, and Z is an exponentially distributed PK random variable with mean 1/γ(β) where γ(β) = i=1(ρi/βi).
With this state space collapse result, we are able to approximate V (β; β) in heavy traffic.
Lemma 7. In a K-class DPS system with class priority vector β,
1 lim(1 − ρ)V (β; β) = , ρ→1 λγβ
PK where γ = i=1(ρi/βi) and ρi = ρi/ρ does not change as ρ → 1.
Proof. Convergence of the joint distribution implies convergence of marginal distri- d. butions, so (1 − ρ)Ni → Zρi/βi for each i. Moreover, the second moment of (1 − ρ)Ni is shown to be uniformly bounded [48], so the Ni’s are uniformly integrable. It follows from [9] that in this case convergence in distribution implies convergence in the mean, and hence, ρi ρi lim(1 − ρ)E[Ni] = E[Z] = . (1.12) ρ→1 βi βiγ
Taking advantage of this approximation of E[Ni], we are now able to approximate V (β; β). Note that
" K !#−1 K !−1 X ρiβi X ρi lim U0(β; β) = λ 1 − = λβ ρ→1 β + β β + β i=1 i i=1 i CHAPTER 1. PART I: RESOURCE SHARING GAME 15
is finite, so substituting (1.4) and (1.12) into (1.3) yields
lim(1 − ρ)V (β; β) ρ→1 " K # X ρi = lim U0(β; β) + (1 − ρ) ρ→1 γ(β)(β + β) i=1 i QK PK Q (1 − ρ)γ(β) (βi + β) + ρ (βj + β) = lim i=1 i=1 i j6=i ρ→1 QK PK Q µγ(β)[(1 − ρ) i=1(βi + β) + β i=1 ρi j6=i(βj + β)] K ! X βi = lim U0(β; β) lim(1 − ρ)E[Ni] ρ→1 β + β ρ→1 i=1 i 1 = . λγβ
Now we prove Theorem 5.
Proof. Let βˆ = βˆ(β); then βˆ is the unique solution of the following equation:
PK λ V (β ; βˆ)β βˆ = i=1 i i i . (1.13) PK ˆ i=1 λiV (βi; β)
From (1.7) we have
βˆ β(1 − ρ) + βˆ βˆ ≤ µ(1 − ρ)V (β; βˆ) = ≤ (1 − ρ) + . (1.14) βˆ(1 − ρ) + β βˆ(1 − ρ) + β β
ˆ It is clear from the definition that β/βi ≤ maxj βj/ minj βj , M, for all i. Then it follows from (1.14) that
µ(1 − ρ)V (β ; βˆ)β lim i i = 1, ∀ i = 1, ··· ,K. ρ→1 βˆ
Substituting this limit into (1.13), we immediately get
λ 1 lim βˆ = = . (1.15) ρ→1 PK γ i=1 λi/βi CHAPTER 1. PART I: RESOURCE SHARING GAME 16
Since βˆ has a finite limit when ρ → 1, (1.14) implies that
λ(1 − ρ)V (β; βˆ)β lim = 1, ∀ β > 0. (1.16) ρ→1 βˆ
Then (1.15) and (1.16) yield
1 lim(1 − ρ)V (β; βˆ) = . ρ→1 λγβ
It follows from Lemma 7 that the proof is complete.
Therefore, the aggregate processing time is a good approximation for the exact processing time in heavy traffic.
1.3.3 Aggregate Equilibrium
Recall from Definition 1 that β = (β1, ··· , βK ) is a job-level Nash equilibrium if (1.8) holds, i.e., α βi = arg min ciV (β; β) + β , i = 1, ··· ,K. β>0 For general K it is quite hard to solve for the preceding equilibrium because: i) computing V (β; β) requires matrix inversion to solve the linear system (1.2), which can only be done numerically; and ii) even if we are able to solve V (β; β) numerically and obtain optimality conditions for each player (which cannot be done in closed form), we would still need to solve a possibly nonlinear system with K equations and K unknowns to compute the Nash equilibrium. In this section, we propose a novel concept of equilibrium which can be used to approximate the Nash equilibrium, yet can be computed in closed form. We approxi- mate V (β; β) by V AG(β; β) in the objective function, and based on this approximation we define a concept of equilibrium that we call aggregate equilibrium (AE), as follows.
Definition 5. An aggregate equilibrium of the game consists of a set of priorities CHAPTER 1. PART I: RESOURCE SHARING GAME 17
β = (β1, ··· , βK ) such that