Allocating Objects in a Network of Caches ... - Semantic Scholar

Allocating Objects in a Network of Caches: Centralized and Decentralized Analyses* Mohit Tawarmalani Karthik Kannan Prabuddha De Krannert School of Management, Purdue University, West Lafayette, IN 47907 [email protected] [email protected] [email protected]

We analyze the allocation of objects in a network of caches which collaborate to service requests from customers. A thorough analysis of this problem in centralized and decentralized setups, both of which occur in practice, is essential for understanding the benefits of collaboration. A key insight of this paper is that an efficient implementation of cooperative cache management is possible since, in the centralized scenario, the object allocation resulting in the best social welfare can be found easily as a solution to a transportation problem. For the decentralized scenario involving selfish caches, it is shown that pure equilibria exist and that the cache network always reaches a pure equilibrium in a finite number of steps starting from any point in the strategy space. An auction mechanism is developed to derive prices that incentivize the caches to hold objects in a manner such that the optimal social welfare is attained. In the special case of symmetric caches, simple algorithms are devised to find the optimal social welfare allocation, the best pure equilibrium, and the prices for sharing objects. The results obtained in this paper should be valuable in developing and evaluating cache management policies. Resource-sharing problems with a similar cost structure exist in a variety of other domains, and the insights gained here are expected to extend to those scenarios as well. Key words : Collaborative Cache Management, Resource Sharing, Peer-to-Peer Network, Mathematical Programming, Game Theory History : Submitted July 2005; Revised April 2006; Revised April 2007; Revised October 2007.

* An earlier, abridged version of this paper, dealing only with symmetric caches, was presented at the Workshop on Information Technologies and Systems (WITS) in December 2005. 1

2

1.

Introduction

Caching is the process of replicating web contents in locations where they can be readily accessed by end users. The objective is to expedite the delivery of the content and to reduce network bandwidth usage by doing away with retrievals from the source for subsequent requests (Datta et al. 2003). Caching may be performed at various levels, namely, at the browser, proxy-server, and web-server (Mookerjee and Tan 2002, Podlipnig and B¨ osz¨ ormenyi 2003, Hosanagar et al. 2005). Dynamic replacement policies focus on minimizing the cost for the cache under consideration. This cost typically captures one or more of the following: the miss ratio, the byte hit rate, and the average latency experienced by the users of the cache. Most of these policies maintain a priority queue that orders the objects according to some measure of the cost reduction realized by caching those objects. This priority queue is then consulted to perform cache updates. Trace-driven simulation and analytical performance evaluations of these cache replacement strategies restricted to single cache frameworks have appeared in the literature (Cao and Irani 1997, Mookerjee and Tan 2002). Cooperative caching refers to the sharing of objects among a network of proxy caches (i.e., proxy servers serving as caches). The key motivation is that, in the event of a cache miss (i.e., when a requested object is not held by a cache), a “neighbor” cache that holds the object can deliver the content faster than the originating web server (referred to as the origin server henceforth). Thus, cooperative caches are designed to operate as follows: If an object is demanded from a cache that does not possess a local copy, the object is sought from the neighbor caches, failing which the request is forwarded to the origin server. Examples of cooperative caching include implementations in public domains such as IRCache, JANET, and w3cache,1 as well as in private organizations such as content delivery networks (CDN)–for example, Akamai2 and ChinaCache3 –and Internet service providers (ISP) such as Telstra.4 ISPs often connect to one another using Internet Business 1 2 3 4

http://www.ircache.net; http://wwwcache.ja.net; http://w3cache.icm.edu.pl/ http://www.akamai.com (Dilley et al. 2002, discuss the use of cooperative caching in Akamai) http://en.chinacache.com http://www.telstra.com

3

Exchanges (IBX) such as Equinix5 and purchase cache peering services from other IBX participants. The economic rationale for trading cache resources across ISPs has been made in the literature (see, for example, Geng et al. 2003). Cooperative caching is also becoming increasingly important with the introduction of IPTV for the delivery of television and video signals over the Internet.6 Protocols for cooperative caching–for example, ICP and CARP–are supported by most well-known proxy servers including Netscape Proxy Server, NetCache, and Squid.7 In the current cooperative caching frameworks, each object that results in a cache miss is replicated locally by acquiring it either from a neighbor or from the origin server. Any cache following this object replacement policy ignores the holdings at the other caches. Therefore, this allocation scheme is not able to minimize the total network access cost. Moreover, this ad-hoc strategy (Ramaswamy and Liu 2004) is suboptimal even for individual caches since it disregards the ease with which objects can be acquired from the neighbor caches. The current implementations of protocols such as ICP–which are used, for example, in ChinaCache and IRCache–do not optimally allocate objects and, therefore, do not fully realize the benefits of cooperative caching. Any attempt to design an alternative protocol to capture these untapped benefits must first answer the following question: What is the optimal allocation of objects, and can it be obtained efficiently? Further, is it possible to achieve this optimal allocation in an autonomous caching environment like IRCache? By answering these questions, this paper enables the design of effective cache management policies. Specifically, this paper develops analytical models that not only offer insights into the benefits of cooperative caching, but also help identify allocation mechanisms to realize these benefits. 1.1.

Literature Review and Problem Motivation

Caching has been studied extensively in the computer science literature. In recent years, interest in caching has also been growing in the information systems community. There is a sizable literature 5 6 7

https://ecc.equinix.com/peering/ See http://en.wikipedia.org/wiki/Iptv for a discussion on sharing data delivery workloads in IPTV. http://www.web-caching.com/proxy-caches.html

4

on caching in general, whereas cooperative caching, the subject of this paper, has received far less attention so far. Prior research has studied different aspects of caching and addressed questions such as the choice of objects to be stored, replacement policies, and frequency of replacements. Interested readers are referred to the surveys on caching by Podlipnig and B¨ osz¨ ormenyi (2003), Datta et al. (2003), and Wang (1999). While algorithms and protocols for implementing cache management policies have been extensively researched, analytical models to assess performance and their economic implications are still sparse. Information systems researchers have recently become interested in developing such models. For example, Mookerjee and Tan (2002) derive approximate analytical performance measures for the Least Recently Used (LRU) policy. In their model, the mean access rate of a document declines as the time after its last access increases. Hosanagar et al. (2005) develop a pricing model involving a single profit-maximizing proxy cache and various content publishers. In the cooperative caching context, prior studies have mostly been concerned with the development of protocols for searching and sharing objects among the caches. Examples of such protocols include ICP (Wessels and Claffy 1998), and CARP (Valloppillil and Ross 1998). In ICP, the protocol typically used in public domain caches, if a cache does not have a local copy of the requested object, it queries all other caches in the network to determine if any of them has a copy. Instead, in CARP, a universally known hashing function is used to allocate objects to the caches. The same hashing function then identifies the “neighbor” cache to query in the event of a cache miss. None of the existing cooperative caching protocols is designed to allocate objects optimally, and most use the ad-hoc mechanism described earlier (Ramaswamy and Liu 2004). The allocation mechanism differs depending on whether the caches are controlled centrally or operate in a decentralized environment. In the centralized framework, a central planner has complete information about object demands at all caches and optimizes the caching decisions from the perspective of the overall organization, thereby solving a social welfare problem. Such a scenario often exists in CDNs and ISPs. In the decentralized framework, on the other hand, the caches act selfishly in a strategic environment to minimize their own costs. However, this scenario is different

5

from the ad-hoc scheme mentioned above in that here the caches also take into consideration the contents in the other caches, interacting with one another in a strategic manner. The public domain caches as well as the ISPs involved in cache peering at an IBX fit the decentralized framework. Few studies have addressed the problem of optimal placement of objects. Chun et al. (2004) examine the optimal placement in the absence of capacity restrictions on the caches. Ramaswamy and Liu (2004) develop a scheme for allocating objects to the caches based on the expiration ages of the objects. This scheme does not, however, find an optimal allocation. Hosanagar and Tan (2004) analytically study the duplication of objects in the centralized case with two caches having equal capacities, each using the LRU policy, and where all objects exhibit identical demand patterns (at each cache and across caches). Their idea of duplication, however, does not extend to a network of more than two caches. In contrast, our paper analyzes the problem of allocating objects in a network of capacity-constrained caches, with varying object and cache characteristics, under both centralized and decentralized controls. Update policies for single caches were motivated from analyses involving same-sized objects (Young 1994, Cao and Irani 1997). In a similar spirit, we first consider same-sized objects in our study of collaborative caches, and later show that the results also hold for arbitrary-sized objects if the objects are allowed to be split across the caches. We formulate a mathematical program for the social welfare problem and show that it can be solved in polynomial time. The decentralized problem is addressed from a game-theoretic perspective. We show that every caching game has a pure-strategy Nash equilibrium. Further, independent of the initial holdings, a finite number of (best-response) moves by the caches always converge the network to a pure equilibrium. As expected, in the absence of prices, the decentralized solution may not always attain the optimal social welfare. On the other hand, if the caches charge prices to one another for sharing objects, the social optimum can be achieved even in a decentralized scenario. We provide an algorithm for determining such prices and show how the optimal allocation is achieved using an auction mechanism.

6

In the case of symmetric caches (i.e., when all cache capacities are the same and the demand for any object is the same at each cache), simple algorithms are developed to find the social optimal allocation, the best pure equilibrium from the social welfare perspective, and the object prices. We show that virtually all existing single-cache update policies, including the LRU scheme, are special cases of our policies. Although our analysis relates specifically to the cooperative caching problem, similar analyses may apply to other contexts as well. For example, in grid computing and various other peer-to-peer resource-sharing scenarios, a node may already have the required resource locally, or obtain it from a neighbor in the grid, or acquire it from outside in case the grid does not have it. Another example is that of accessing articles from libraries. One may get a copy from the local library, request it from a consortium of libraries (e.g., cooperating university libraries in a region), or purchase it from the publisher. Just as in the caching scenario, the costs for obtaining the resource in these examples are also three-tiered. The paper is organized as follows. In Section 2, the caching problem is formulated for both centralized and decentralized scenarios. Analyses of these two scenarios are carried out in Section 3 and Section 4, respectively. A pricing mechanism for the decentralized scenario is developed in Section 5. Generalizations pertaining to arbitrary object sizes and a dynamic caching environment are discussed in Section 6. Finally, concluding remarks are provided in Section 7.

2.

Basic Problem Statement

Let N = {1, . . . , n} denote a set of objects and M = {1, . . . , m} a set of caches. The objects are of unit size (we consider different object sizes later). The caches have fixed capacities which are denoted by K = {k1 , . . . , km }. Without the loss of generality, we assume kj ≤ n, ∀ kj ∈ K. Unlike in the setup of Chun et al. (2004), the cache capacities are fixed a priori in our analysis because the capacity expansion decisions are long-term and not as frequent as cache updates. Fixed cache capacities, however, link the allocation decisions across objects, thereby complicating the analysis significantly.

7

The demands for objects are stochastic by nature. We denote the expected demand for object   i at cache j by αij and α1j , . . . , αnj by Aj . Clearly, αij ≥ 0, ∀ i ∈ N, j ∈ M . The demands are not assumed to be independent of each other. Since our analysis holds regardless of how frequently the future demands are estimated, all our results continue to hold even if αij s are the expected demand rates. As in the existing caching literature, we assume that a reasonable estimate of αij s is available. LRU, for example, addresses the cache allocation problem in a myopic fashion by storing objects in a priority order corresponding to the recency of object requests at the cache; a reallocation is performed whenever an object request arrives. As we show later, our policies reduce to LRU if αij corresponds to the demand rate experienced by cache j for object i and the demand rates are updated whenever an object request arrives at any of the caches. Our generalization of LRU to a network of caches exploits the magnitudes of object priorities (instead of just their order). This information is also implicitly used in the existing single-cache policies since priority-based orders are typically derived from magnitudes (for example, recency is used to define the mean access rate for analyzing LRU in Mookerjee and Tan 2002). The demand forecasts we use are, however, not restricted to depend only on recency; they may also depend on other factors found to be significant in earlier studies (such as 24-hour seasonalities discussed in Cao and Irani 1997). It can be argued that the magnitude requirement is, in fact, needed for multi-cache setups; simple examples show that a priority-based order does not suffice to identify the optimal allocation policy in this context. Continuing our description of the model, suppose the cost of serving an object locally from the cache where it is requested is cl , from the other caches in the network is cn , and from the origin server is co .8 Consistent with our earlier discussion on cooperative caching, we assume throughout that cl ≤ cn ≤ co . Our results carry through even if cl , cn , and co are dependent on i and j; however, for notational convenience, we assume them to be constants. 8

Overhead costs, such as the fixed cost of sharing information regarding the objects held, are omitted as they are independent of any particular allocation of objects and do not affect our analysis. Other potential costs, such as those incurred while changing a cache configuration, do not alter the insights offered by the paper. One must, however, realize that, in the presence of such costs, our policies would be myopic, just as those proposed in the prior literature (see, for example, Chun et al. 2004, for their treatment of placement costs).

8

We model the the expected total acquisition cost Cj incurred by cache j as follows: ⎛ ⎛ ⎞⎞ ⎛ ⎞ m n n n m  ⎜    ⎜ ⎟⎟ ⎜αij (1 − xij ) ⎜1 − ⎟ ⎝αij Cj = c l αij xij + cn (1 − xij )⎟ (1 − xij )⎠ , ⎝ ⎝ ⎠⎠ + co i=1

j  =1 j  =j

i=1

(1)

j  =1

i=1

where xij is 1 if object i is held in cache j and 0 otherwise. The first term in (1) accounts for the objects served locally, while the second and the third terms account for the ones retrieved from a neighbor cache and the origin server, respectively. Obviously, an object is obtained from a neighbor only when it is not held locally and at least one of the neighbors holds it. The object is obtained from the origin server only when it is not held by any of the neighbor caches. Equation (1) can be rewritten as follows: Cj = (cl − cn )

n 

αij xij + cn

n 

i=1

αij + (co − cn )

i=1

n  i=1

⎛ ⎝αij

m 

⎞

(1 − xij )⎠ .

(2)

j  =1

In the centralized scenario, the objective is to allocate the objects to the caches so as to minimize the network cost,

m

j=1 Cj ,

subject to the capacity constraints. In the decentralized scenario, on the

other hand, every cache j ∈ M decides on its holdings xij , ∀i ∈ N , with the objective of minimizing its individual cost Cj , subject to its capacity constraint.

3.

Analysis of Social Welfare

In this section, we analyze the social welfare problem in the centralized case to find the optimal holdings for the caches. In addition, we study the special case dealing with symmetric caches. Using (2), the social welfare problem can be expressed as a nonlinear 0−1 program as follows: ⎧ ⎛ ⎞⎫ m ⎨ n n n m ⎬      ⎝αij (S) min (cl − cn ) αij xij + cn αij + (co − cn ) (1 − xij )⎠ ⎭ ⎩  j=1 i=1 i=1 i=1 s.t.

n 

j =1

xij ≤ kj

j = 1, . . . , m

(3)

i = 1, . . . , n; j = 1, . . . , m.

(4)

i=1

xij ∈ {0, 1}

Problem (S) can be linearized using the techniques of Glover and Woolsey (1974), by introducing binary variables yi to represent

m

j=1 (1

− xij ) and adding linear constraints that impose the

nonlinear relationship when all xij s are binary valued (see Tawarmalani and Sahinidis 2002, for

9

a recent treatment). In our context, yi is 1 if object i is acquired from the origin server and 0 otherwise. So, (S) becomes:   m n n n     min (cl − cn ) αij xij + cn αij + (co − cn ) αij yi j=1

s.t.

yi ≥ 1 −

m 

i=1

xij

i=1

i=1

i = 1, . . . , n

(5)

yi ≥ 0

i = 1, . . . , n

(6)

yi ≤ 1 − xij

i = 1, . . . , n; j = 1, . . . , m

(7)

j=1

(3), (4). Although we have successfully linearized (S), finding an optimal solution to an integer program is, in general, hard. Further, not all extreme points feasible to the above constraints are integral. However, since max{0, 1 −

m

j=1

xij } ≤ 1 − xij for all j  ∈ {1, . . . , m} and co > cn , we can drop (7)

from the formulation. Consequently, the social welfare problem can be rewritten as:  m     (SL) min C  j  (5), (6), (3), (4) , j=1

where C  j =

m

j=1

{(cl − cn )

n

i=1 αij xij

+ cn

n

i=1

αij + (co − cn )

n

i=1 αij yi }.

The relaxation shown

here allows us to model (SL) as the well-known transportation problem. This fact is intriguing because, although linearization techniques are commonly used to convert nonlinear 0−1 problems into binary integer programs, seldom do they reduce the nonlinear problem to a network-flow structure. The proof of the following theorem illustrates the construction involved, which is also crucial in understanding the pricing mechanism for decentralized networks developed in Section 5. Theorem 3.1. (SL) can be modeled as a transportation problem. Proof.

Consider a bipartite graph G = (V, E) with vertices V = N ∪ M ∪ {D } and edges E =

N × M ∪ {(i, D) | i ∈ N }. The flow on arc (i, j) ∈ N × M corresponds to xij , whereas the flow on arc (i, D) is yi (see Figure 1). The objects and the caches are mapped to the demand locations and the suppliers, respectively, of the transportation problem. The dummy node D represents the origin server in the caching context. The cost associated with an arc xij is (cl − cn )αij . The cost

10 Objects: N 1

Caches: M x11

1

1

k1

j

kj

x1j y1 xi1 1

i

x1m xij

xnj

xim

m km

yi

xnm

xn1

1 Figure 1

associated with yi is (co − cn )

n

yn

D n

Transportation Formulation of Social Welfare

j∈M

αij . The flow out of each i ∈ N must be no less than one, and

the flow into each j ∈ M must be no more than kj . Since there are n objects, the maximum flow into D is at most n. Arguably, interpreting the social welfare problem as a transportation problem is one of the key insights of this paper. A transportation problem is solvable in strongly polynomial time (Ahuja et al. 1993), thus providing an efficient object allocation policy. The ability to solve the caching problem quickly is indeed necessary to perform frequent updates, which is the common practice in caching. 3.1.

Symmetric Caches

In this section, we study the allocation problem with symmetric caches (i.e., a setup where the cache capacities are identical and the demand for each object is the same across all caches). This setup serves as a bridge between single-cache scenarios studied extensively in the literature and a network of asymmetric caches studied in this paper. This is because priority-based greedy policies, such as LRU, that are commonly used for single caches, extend to symmetric setups, but not to asymmetric ones (see Proposition A.1 for a proof that the social welfare problem with an asymmetric setup is at least as hard as the assignment problem (for a description of the problem, see Ahuja et al.

11

1993)). We show in this section that the greedy scheme used to compute the minimum network cost for symmetric caches also provides an upper bound for the network cost when the cache capacities remain identical, but the demands vary from one cache to another. Later, in Section 5.1, we show that the greedy allocation mechanisms for symmetric caches are not only optimal, but also fair, if the caches are allowed to charge prices to one another. In addition, symmetric setups are easier to visualize and still capture many of the intuitions for a general network of caches. From a practical standpoint, there are scenarios where similar demands for a given object across the caches can be expected, especially when users are assigned to the caches at random or when the caches serve a large number of users. This is probably why the assumption of equality of demand patterns across the caches appears in the prior literature as well. Consider a simple example with two objects and two caches, each with capacity one. First, assume that cache 1 faces a demand of α for object 1 and no demand for object 2; similarly, cache 2 has a demand of α for object 2 and no demand for object 1. Then, it is clearly optimal for each cache to hold the object for which it has a demand. Next, suppose that some of the demand β ≤ α2 for object 1 is shifted to cache 2 and a demand of β for object 2 is shifted to cache 1. Clearly, the caches have to share the objects more as β increases, thereby leading to an increasing network cost with higher values of β. Indeed, the maximum network cost is incurred when β = α2 i.e., when each cache has the same demand for both objects. The following definition for symmetric cache setups provides a natural context in which the above observation can be generalized. Two caches j and j  are deemed symmetric when kj = kj = k and for each object i, αij = αij = αi . The symmetric caching problem is the one where all caches are symmetric. Theorem 3.2 formalizes our observation of the increasing optimal network cost in passing from asymmetric setups to symmetric ones. Theorem 3.2. If the cache capacities are identical and the total demand for each object is distributed equally among the caches, then the minimum network cost for the resulting symmetric setup is no less than the minimum network cost when the demand for an object varies from one cache to another. (See Appendix A.2 for a proof.)

12

We now develop a greedy algorithm that solves the social welfare problem optimally for symmetric setups. Without the loss of generality, for i < i , assume αi ≥ αi . Let xi be the number of copies of object i held in the network. Then, xi =

m

j=1

xij and (1 − yi ) = sgn(xi ), where sgn(x) is

1 if x > 0 and 0 if x = 0. After some algebraic simplification, the network cost reduces to: m  j=1

C  j = mco

n  i=1

αi −

n 

n          sgn(xi ) (m − 1) co − cn αi + co − cl αi − (xi − sgn(xi )) cn − cl αi .

i=1

i=1

When only one copy of i is cached, the cache holding i benefits (co − cl )αi , and each of the other   (m − 1) caches gains (co − cn )αi , yielding a total benefit of di1 = (m − 1) co − cn αi + (co − cl )αi . Any   subsequent copy (t > 1) of i provides a total benefit of dit = cn − cl αi . Let indx(x ∈ G) represent the index of an item x in an ordered set G, and let it denote the tth copy of i. Then, the algorithm in Figure 2 solves the symmetric caching problem. Figure 2

Algorithm Symmetric Cache Global Solution (SCGS)

Input: cl , cn , co , m, n, k, and {α1 , . . . , αn }. Output: xij Steps: 1. Construct G as a list of it s. 2. Sort G by dit in descending order, breaking ties by sorting with respect to i in ascending order and then with respect to t in ascending order. 3. for all i, where 1 ≤ i ≤ n, let xi ← max{t | indx(it ∈ G) ≤ mk }. 4. for all i and j, where 1 ≤ i ≤ n and 1 ≤ j ≤ m, let xij ← 0.  i−1  5. for all i, where 1 ≤ i ≤ n, and l ∈ [1, xi ], set xij ← 1, where j = 1 + l − 1 + t=1 xt mod m.

In this algorithm, G provides a list of object copies sorted by the benefits they add to the network, and xi is the number of copies of i which appear among the mk items with the highest valuations in G (recall that mk is the total cache capacity of the network). Step 5 allocates the objects, ensuring that no cache stores more than one copy of the same object. Since the ordered list G need not include any object with an index greater than mk, and αi s are assumed to be   pre-sorted, the complexity of the above algorithm is O min(mk, n) . Example 3.1. Consider 3 caches with a capacity of 2 each and 4 objects with demands [70, 36, 15, 5]. Suppose cl = 1, cn = 2, and co = 3. Then, G = {11 , 21 , 12 , 13 , 31 , 22 , 23 , 41 , 32 , 33 , 42 , 43 }.

13

Noting that mk = 6, the optimal solution is as follows: cache 1 holds {11 , 21 }, cache 2 holds {12 , 22 }, and cache 3 holds {13 , 31 }.

4.

Decentralized Setup

In this section, we consider the case when each cache is selfish. As before, the cache capacities and the demands for objects at each cache location are assumed to be known a priori. Let Oj be the set of objects held by cache j and O denote

m

j=1 Oj .

Cache j decides to hold Oj , which

must not have a cardinality of more than kj , such that its cost Cj is minimized, given the holding strategies Oj of all j  = j. This leads us to consider a simultaneous-move game among the caches. Of particular interest are the solutions where no cache benefits by unilaterally altering its holding strategy. These solutions are the pure-strategy Nash equilibria.9 The caching game described above is different from the one considered by Chun et al. (2004) because of the presence of capacity constraints in our setup. When there is no capacity constraint, each object can be examined separately, and this observation plays a central role in simplifying the analysis of Chun et al. (2004). Example 4.1. Suppose there is a symmetric case with two objects and two caches, where each cache can hold at most one object. Let α11 = α12 = α1 and α21 = α22 = α2 . Then, the payoff matrix for this game is the following: Object 1

Object 2

Object 1 −cl α1 − co α2 , −cl α1 − co α2 −cl α1 − cn α2 , −cn α1 − cl α2 Object 2 −cn α1 − cl α2 , −cl α1 − cn α2 −co α1 − cl α2 , −co α1 − cl α2 In this example, we assume that cl < cn < co . Without the loss of generality, we also assume that α1 ≥ α2 . If α1
bj , then it must be held by j in every optimal solution to (DL). Figure 3

Algorithm Local Solution

Input: cl , cn , co , j, kj , αij , and x ¯ij for all j  = j and i = 1, . . . , n. Output: xij for i = 1, . . . , n Steps:     1. Let Q = [b1j , . . . , bnj ], where bij = (cn − cl ) + (co − cn ) j =j 1 − x ¯ij αij . 2. Let bj be the kjth highest value in Q. 3. Let Oj ⊆ N be such that |Oj | = kj and for any i ∈ N \Oj , bij ≤ bj . 4. Let xij ← 1, if i ∈ Oj and 0 otherwise.

A pure equilibrium is a strategy that satisfies the above optimality conditions (see Lemma A.2) for each cache. Now, suppose that every cache j ∈ M holds the kj objects with the largest demands for itself, while ignoring the holding strategies of the other caches i.e., all the caches act as if cn = co . This non-sharing strategy is equivalent to the ad-hoc strategy of Ramaswamy and Liu (2004) discussed before. If the caches start from this strategy and sequentially move to their best responses,10 we show that a pure equilibrium is attained after each cache has had an opportunity to alter its holdings once. We assume that a cache does not replace an object with another object of the same value. Theorem 4.1. Every caching game has a pure strategy equilibrium. Further, if the system starts at the non-sharing caching strategy and the caches move to their best responses, no cache has an 10 Sequential moves considered here do not imply that this is a sequential game; rather sequential moves are used here as steps in an algorithm to identify equilibria in a simultaneous (normal-form) game.

16

incentive to move more than once. (See Appendix A.3 for a proof.) Theorem 4.1 proves the existence of a pure equilibrium following a sequence of moves starting from the non-sharing strategy. Next, we show in Theorem 4.2 that any sequence of best-response moves is finite in length. The proof of the theorem is relevant to networks cooperating using protocols such as ICP and elucidates the nature of moves by each cache in such a setup. The proof also clarifies the tradeoffs the caches face in holding unique objects versus objects already held by the other caches, and establishes that the caches which switch holding strategies based on bestresponse moves will not enter into a cycle of moves. The proof technique used here is reminiscent of rationalizability, a concept used to ascertain the rational behaviors of players (Fudenberg and Tirole 1991). We compute the fixed-point of best response moves, using reactions of one cache at a time. This is in contrast to the use of reactions of all players in the celebrated proof of the existence of mixed-strategy equilibria by Nash, as well as to the use of iterative dominance on similar sublattice structures in the proofs of existence of pure equilibria in supermodular games (Fudenberg and Tirole 1991). Theorem 4.2. Starting from any point in the strategy space, a pure equilibrium is always attained in a finite number of best response moves. Proof.

Since each cache is always filled to capacity, a move by cache j can be described using

a list of triples [(j, i1 , ¯i1 ), . . . , (j, ip , ¯ip )], where each triple (j, ir , ¯ir ) signifies that cache j relinquishes object ir in order to acquire ¯ir and p ≤ kj . Since the move is assumed to be a best response move, we may assume, without the loss of generality, that for any distinct r and s, is = ir and ¯ir is of strictly higher value to j than ir (i.e., b¯ir j > bir j ), given the holdings of the other caches at the time. We classify an object i as u or t according to whether it is held by one cache or more than one cache. A triple (j, ir , ¯ir ) is classified as t1 → t2 , where t1 ∈ {u, t} and t2 ∈ {u, t}, if ir is of classification t1 before the move and ¯ir is of classification t2 after the move. A triple of the form t → t and one of the form u → u keep the number of objects held in the network constant. A triple

17

of the form t → u increases, whereas a triple of the form u → t decreases, the number of objects held in the network. We first argue that a triple (j, ir , ¯ir ) of classification u → t exists only in the first move of cache j. Let (j, ir , ¯ir ) be one of the triples in the lth move of cache j. Then, in the (l − 1)st move of cache j, the value of ir was no more than what it is in the lth move (since no other cache holds it now) and the value of ¯ir was no less than what it is in the lth move (since some other cache holds it now). Therefore, considering best response moves, ¯ir should have been acquired in the (l − 1)st move. In other words, after each cache has moved at least once, the number of objects held in the cache never decreases. Now, create a global list of triples by placing the lists of triples from each move in their order of occurrence. Use the triples of classification t → u and u → t to split the list into sublists such that no sublist contains any triples with classification t → u or u → t. Assume that, at the beginning, the network holds a objects. Further, assume that there are b triples of classification t → u and c triples of classification u → t. Since the total number of objects in the network is no more than m

j=1

kj , it follows that a + b − c ≤

first move, it follows that c ≤

m

j=1

m

j=1

kj . Since each cache can have at most kj triples in the

kj . Since a ≥ 0, it also follows that b ≤ 2

the number of sublists created is bounded from above by 3

m

j=1

m

j=1

kj . As a result,

kj + 1. To show finiteness, now we

only need to show that each sublist is of finite length. Pick an arbitrary sublist created in the preceding step. All the triples in the sublist are either of the type t → t or u → u. As such, the number of objects held in the network remains constant and is bounded from above by

m

j=1 kj .

We show that the number of triples in the sublist corresponding

to an arbitrary cache j is finite. We assume, without the loss of generality, that j moves at least twice in the sublist. Otherwise, the number of triples for cache j would be bounded by kj . Consider any triple (j, ir , ¯ir ) in this sublist which is not from the first (partial) move by cache j. Clearly, αir j < α¯ir j . Otherwise, j would not relinquish ir in favor of ¯ir . Let i be one of the least preferred items held by j before the second move of j in this sublist. Define I = {i | αij > αi j } ∪ {i | αij =

18

αi j and j held i before the second move of j in this sublist}. We claim that |I | ≤ tradiction to |I | > is bounded by

m

m

j=1 kj

j=1 kj

m

j=1 kj .

A con-

is derived by simply noting that the number of objects in the network

and, therefore, after the previous move of j, there was an object i ∈ I that

was not held in the network and that has a higher demand than i , which is not possible for the best response moves. Therefore, |I | ≤

m

j=1

kj . The strategies of j are now limited to the objects

in I and form a finite sublattice11 of Rkj . With each triple, j moves to a strategy that dominates the previous one. As a result, there are a finite number of triples of the form (j, ·, ·). The sublist must, therefore, be of finite size since j is arbitrarily chosen. Since the starting strategy in Theorem 4.2 is arbitrary, if a new cache enters the network and the current caches in the network are already in a pure equilibrium, a sequence of best response moves will lead the network to a pure equilibrium once again. The same argument works even when a cache leaves the network. 4.1.2.

Set of Pure Equilibria As we have already observed, the caching game is guaranteed

to have a pure equilibrium. The equilibrium may not, however, be unique. Moreover, different pure equilibria often yield different social benefits. Since in the non-sharing strategy discussed before, every cache holds its most demanded objects, it may seem that the equilibrium attained via the best-response sequential moves starting from this strategy yields the maximum social benefit. In reality, however, this is not the case even for symmetric caches, as illustrated below. Example 4.3. Suppose there are 3 caches, each with a capacity of 4, and 9 objects, with demands [34, 33, 27, 18, 17, 15, 14, 13, 10]. Let cl = 1, cn = 2, and co = 3. The network incurs the minimum cost if cache 1, cache 2, and cache 3 hold objects {1, 2, 4, 7}, {1, 2, 5, 8}, and {1, 3, 6, 9}, respectively. The total cost is then 804. This is not a pure equilibrium since cache 2 would rather hold object 3 (even if it is held by cache 3 already) than hold object 8. The equilibrium attained following the best-response sequential moves – without the loss of generality, in the order of their indices – starting from the non-sharing strategy is as follows: cache 1 holds {1, 2, 5, 6}, cache 2 holds   11 of Rn if, whenever (a , b ) ∈ Z and (a , b ) ∈ Z, then cmax(a , a ), cmax(b , b ) ∈ Z and  Z is a sublattice    cmin(a , a ), cmin(b , b ) ∈ Z. Here, cmin and cmax are the component-wise minimum and maximum, respectively.

19

{1, 2, 3, 7}, and cache 3 holds {1, 2, 3, 4}. The corresponding network cost is 836.12 Among all pure

equilibria, the one that yields the minimum network cost is as follows: cache 1 holds {1, 2, 4, 5}, cache 2 holds {1, 2, 6, 7}, and cache 3 holds {1, 2, 3, 8}. The network cost here is 811. Interestingly, not only do these three solutions incur different network costs, but the number of objects held in the network is also different in each case. The above example shows that there may be multiple pure equilibria and that one pure equilibrium may be better than another in terms of social welfare. This leads us to the problem of finding the equilibrium that results in the minimum network cost. The pure equilibrium that minimizes the network cost will be henceforth referred to as the best pure equilibrium. An integer-programming formulation, which yields the best pure equilibrium as its optimal solution, is developed in Appendix A.4 and the correctness of the formulation is proved in Proposition A.2 therein. The key ingredient in this proof is that the optimality conditions of Lemma A.2 can be modeled using logical constraints. Interestingly, the size of our integer-programming formulation is polynomial in kj , n, and m, even though the strategy space of each player is exponential. Following arguments similar to those in Appendix A.4, the problem of finding the best/worst pure equilibrium from a particular cache’s perspective can also be formulated as an integer program. 4.2.

Symmetric Caches

We now analyze the best pure equilibrium for the symmetric setup. We assume, without the loss of generality, that objects are sorted in the order of non-increasing demand. If an object is held   by only one cache, this cache benefits co − cl αi since it does not need to acquire the object   from the origin server. Otherwise, the benefit is cn − cl αi . For each object i, define wi = max{i | (cn − cl )αi > (co − cl )αi }. Therefore, wi is the least demanded object that a cache will prefer to hold jointly before it holds i uniquely. Algorithm SCBE is the key subroutine in identifying the best pure equilibrium. Theorem 4.3. A pure equilibrium that holds ri copies of object i, where ri is what Algorithm SCBE returns, generates the best social welfare among all pure equilibria that hold objects {1, . . . , a}. 12

Without the loss of generality, here we assume that cache 1 moves first, followed by 2, and then 3.

20 Figure 4

Algorithm Symmetric Cache Best Equilibrium (SCBE)

Input: cl , cn , co , k, αi for i ∈ N , and a ∈ N . Output: fi for i = 1, . . . , a, ri for i = 1, . . . , a Steps: 1. wi ← max{i | (cn − cl )αi > (co − cl )αi }. 2. a1 ← a, j ← 1 and fi ← 0, ∀i. 3. if k < wa + 1 return infeasible 4. while aj > wa : 5. if j = m + 1 return infeasible 6. if waj > 0 then fw  ← fw  + 1 a

7. 8. 9. 10. 11. 12. 13. 14. 15. 16.

j

a

j

aj+1 ← aj − (k − waj ) j ←j +1 end while fi ← i≤¯i≤wa f¯i for i = 1, . . . , wa fi ← 1 for wa < i ≤ a h ← k(m − j) + wa − aj   ! Empty spaces i l ← max{i | i =1 (m − fi ) < h} + 1 if (cn − cl )αl ≥ (co − cl )αa+1 return l−1 infeasible ri ← m for i < l, rl = h + fl − i =1 (m − fi ) and ri = fi for l < i ≤ a. return r

The proof of Theorem 4.3 in Appendix A.5 uses the outputs of Algorithm SCBE to construct the best pure equilibrium among those that hold objects {1, . . . , a}. Therefore, running Algorithm SCBE for a = 1, . . . , min(n, mk) and comparing the associated social welfares generated, one can   determine the best pure equilibrium and the corresponding social welfare in O mk min(mk, n)

time. It is surprising that finding the best pure equilibrium requires polynomially many steps in n, m and k, even though the strategy space for each cache is exponential in those parameters and there are

n

Ck

m

strategy profiles. Finding the best social welfare symmetric equilibrium is

NP-hard in general, even for two-player symmetric games (McLennan and Tourky 2006). While this result does not apply directly to our scenario, it demonstrates the computational difficulty of related problems. Is it always bad to store redundant copies beyond the minimum number of copies required? Although the decentralized solution is generally believed to be inefficient because it holds redundant copies (Ramaswamy and Liu 2004), the following example shows that this is not always the case.

21

Example 4.4. Consider 4 symmetric caches, each with capacity 2, and 6 objects, with demands [60, 14, 13, 11, 10, 3]. Let cl = 1, cn = 2 and co = 6. There is a pure equilibrium as follows: 1 holds {1, 4}, 2 holds {1, 5}, 3 holds {1, 6}, and 4 holds {2, 3}. The optimal social welfare solution, which

is also the best pure equilibrium, is, however, the following: 1 holds {1, 2}, 2 holds {1, 3}, 3 holds {1, 4}, and 4 holds {1, 5}. So, we see that a pure equilibrium may hold fewer copies (equivalently,

more unique objects) than does the optimal social welfare solution.

5.

Pricing Mechanism

We have seen in Section 4 that, in the decentralized setup with no monetary transactions among caches, the optimal social welfare is not always attained. One might feel that the introduction of prices would automatically lead to social optimality. However, that is not the case, as shown in the following example. Example 5.1. Consider three unit-sized objects and three caches, each with a capacity of one. Let A1 = (9, 0, 0), A2 = (9, 2, 0) and A3 = (9, 0, M ), where M is large enough to ensure that cache 3 always prefers object 3 to object 1. Let cl = 1, cn = 2, and co = 10. The social optimal solution is for cache 1 to hold object 1, cache 2 to hold object 2, and cache 3 to hold object 3, yielding a cost of M + 47. We assume sharing of revenues if two or more caches hold the same object. By construction, in a decentralized framework with pricing, there is no incentive for cache 3 to hold any object other than 3. If cache 1 does not hold object 1, the optimal social welfare cannot be attained. Therefore, assuming that cache 1 holds object 1, cache 2 will prefer object 2 to object 1 if and only if the price of object 1 is less than 23 . Cache 1, on the other hand, prefers the price of 8 over the price of

2 3

for object 1 in spite of sharing the revenue with cache 2. Therefore, cache

1 charges a price of 8 and holds object 1. Also, cache 2 holds object 1, yielding a social cost of M + 56, which is clearly suboptimal. Therefore, it follows that, even when the caches charge prices, a pure equilibrium may not lead to social optimality. In this section, we devise a scheme that will avoid the above predicament that the equilibrium prices do not necessarily result in socially optimal holdings. The caches following this scheme

22

will charge prices for sharing objects with the other caches in such a manner that the optimal social welfare is indeed attained. We also propose an auction mechanism to arrive at the optimal allocation. To achieve the optimal social welfare, we first investigate some properties of the centralized object placement problem and its linear programming (LP) dual, which we can construct since the constraint matrix of (SL) is totally unimodular (Ahuja et al. 1993). Define gij = (cn − cl )αij and βi = (co − cn ) (DS)

m

j=1

αij . The LP dual of (SL) is as follows: max

n 

ui −

i=1

s.t.

m 

kj vj −

m n  

j=1

zij

i=1 j=1

ui − vj − zij ≤ −gij

i = 1, . . . , n; j = 1, . . . , m

0 ≤ ui ≤ βi

i = 1, . . . , n

(12)

vj ≥ 0

j = 1, . . . , m

(13)

zij ≥ 0

i = 1, . . . , n; j = 1, . . . , m.

Since the coefficients of zij in the objective function of (DS) are negative, zij equals max{0, gij + ui − vj } at the optimal solution. In other words, (DS) can be rewritten as:  n   m m n      (DD) max ui − kj vj − max{0, gij + ui − vj }  (12), (13) . i=1

j=1

i=1 j=1

Lemma A.5 in Appendix A.6 allows us to assume that vj ≤ maxi {gij + ui | i = 1, . . . , n}. Since ui ≤ βi , we can, in fact, relax the above condition to: vj ≤ max{gij + βi | i = 1, . . . , n}. i

As a result, we can rewrite (DD) as:  n   m m n      (DN) max ui − kj vj − max{0, gij + ui − vj }  (12), (13), (14) . i=1

j=1

i=1 j=1

(14)

23

Proposition A.3 in Appendix A.6 establishes that the capacities of caches are substitutes with respect to social welfare. This implies that the cost decrease due to a capacity increase at a cache reduces with the capacity increases at the other caches. Next, assume that (x∗ , y ∗ ) is a binary-valued optimal solution to (SL). Then, any optimal solution (u, v) satisfies the following conditions (Dantzig 1963): (F)

vj ≥ gij + ui

if x∗ij = 0

(15)

vj ≤ gij + ui

if x∗ij = 1

(16)

ui ≤ βi

if yi∗ = 0

(17)

ui = βi

if yi∗ = 1 m  if x∗ij > 1.

(18)

ui = 0

(19)

j=1

Further, any solution in (F) is optimal to (DN ). The maximum (coordinate-wise) element in (F) exists by Proposition A.3 and is the unique optimal solution to:  n   m    ui + vj  (15), (16), (17), (18), (19) (M) max i=1

j=1

Here, ui can be interpreted as the potential revenue that any object i offers to a cache willing to hold it. Then, cache j that holds i obtains a revenue of ui , in addition to the cost saving gij realized from local availability. Hence, ui + gij is the value for j from holding i. In the above, vj provides a threshold of these valuations: objects with lower valuations are not held in j, as seen in (15), while objects held have higher valuations, as seen in (16). If a cache holds i uniquely, the revenue generated is at most βi (see (17)), whereas the potential revenue lost by a cache when it does not hold an object i that is held nowhere in the network is βi (see (18)). As shown in Example 5.1, in the absence of (19), two caches may hold the same object and charge a price for sharing it, forcing the network to deviate away from the socially optimal holdings. Interestingly, (19) provides the additional condition needed to attain social optimality. This constraint is equivalent to forcing a competition among the caches for the right to hold any object and charge a (non-zero) price for it.

24

Propositions A.4 and A.5 in Appendix A.7 show that, if the revenue earned from object i is ui , then cache j’s optimal holding corresponds to an optimal social welfare allocation. In Appendix A.7, we also argue that a cache has no reason to prefer one optimal allocation over another. We do not, however, imply that the caches have incentives to truthfully reveal their demands; in fact, the following example clearly shows that they may have incentives to do otherwise. Instead, we assume that the demands are common knowledge. Example 5.2. Consider two objects and two caches, the first with a capacity of two and the second with a capacity of one. Let cl = 1, cn = 2 and co = 3. Suppose the first cache has a demand of one for each object. Consider the case where the demand for cache 2 is A2 = (1 + a, 1), where a > 0.   The optimal dual solution is u = (0, min(a, 2)). The cost to cache 2 is then (1 + a) + 2 + min(a,2) . 2 However, if the cache fakes its demand to be (1, 1), the price for object 2 will be reduced to 0 and the cost incurred would be reduced by min

a 2

 , 1 . Therefore, it is not in the interest of cache 2 to

truthfully reveal its demand. It turns out that an auction mechanism derived using myopic decisions for each cache results in an optimal allocation for the network. Auction processes in assignment problems are discussed by Demange et al. (1986) and, on a different version of the transportation problem from the one discussed here, by Bertsekas and Castanon (1989). Our treatment here is heavily inspired by these works. However, unlike the auction of Bertsekas and Castanon (1989), the caches here do not bid for objects held by them. We assume that, even if the value of the best available object is 0 for a cache (which is quite unlikely), the cache holds it rather than leaving the spot empty. Our setup is also different from typical setups found in the auction literature (see Day 2004). First, unlike in a two-sided market, the transactions here are among the caches themselves and each cache may pay, as well as receive, payments for objects. Second, the price for an object is an agreement about the amount that a cache can charge for each access of that object by a neighbor. Third, we require that multiple copies of an object be allowed in the network only when the price for sharing that object drops to zero. At that time, no further competition is required to cache that object.

25

The proposed auction mechanism is a descending-price auction, similar to the wireless spectrum auctions of Milgrom (2000). An object i is initially priced at co − cn . There are rounds of the auction and, in each round, the caches bid for the objects that they would like to hold and share with the network at the bid price. The objects are assigned to prospective caches at the prices they have already committed to. Sharing an object at the bid price generates a revenue for the cache, which includes the amount collected from the other caches and also the amount the cache saves by not having to pay for it. Therefore, we may refer to revenues instead of prices as the bid parameter. Formally, at the beginning of round r, Ojr is the set of objects allocated to a prospective cache j and uri denotes the revenue from object i. The valuation of object i by cache j at the beginning r of round r is vij = gij + uri if i ∈ Ojr . For a valid bid, the discount offered by a cache for acquiring

object i must be at least min{uri , }. In other words, the caches can either offer an object for free or offer a discount of at least  in each bid. Therefore, the valuation of i ∈ Ojr for cache j can be r calculated to be vij = max{gij , gij + uri − }. At the end of each round of the auction, the object

is assigned to the cache offering the maximum discount. If the price of the object reduces to 0, it is assigned to all the caches that are willing to share the object for free. The rounds of auction terminate when there is no uncommitted spot left in any cache. We assume that each cache’s behavior is myopic. Let Tjr ⊆ N \Ojr be a set of objects, of cardinality kj − |Ojr |, with the highest valuations for j at the beginning of round r. Let i (r, j) be the next best object after Tjr in N \Ojr . If N \(Ojr ∪ Tjr ) = ∅, let vir (r,j)j = 0. It follows that cache j is willing to acquire an object i ∈ Tjr as long as the revenue it generates (after accounting for the discount that must be offered to acquire it) is not less than max{0, vir (r,j)j − gij }. Theorem 5.1. The above auction allocates objects in a manner that generates the optimal social welfare as long as  ≤

m1

j=1 kj

. (See Appendix A.8 for a proof.)

The proof of this theorem relies on the gross substitutability (see, for example, Kelso and Crawford 1982) of objects for the individual optimal allocation at each cache. The gross substitutability in our case also follows from Theorem 3.1 of Day (2004). However, Theorem 5.1 departs from the

26

results of Day (2004) in that the structure of our game is different and that our theorem also provides an upper bound on . 5.1.

Symmetric Caches

The prices in the symmetric cache setup can be interpreted using the benefits dit of holding the tth copy of object i. Such an interpretation leads to an alternate (dual) proof of the optimality of Algorithm SCGS of Section 3.1 (see Appendix A.9 for details). In the context of symmetric caches, it is natural to ask if the resulting pricing and allocation decision is fair for each cache. In Appendix A.9, we show that the threshold valuations for a spot are identical across all caches i.e., vj = vj and that the resulting pricing and allocation decision is indeed fair. The following example illustrates the valuations, prices, and optimal allocation in a symmetric setup. Example 5.3. Consider Example 4.3, where the social optimal allocation is not a pureequilibrium. Let the revenue vector for the objects be u = {0, 0, 6, 15, 16, 18, 19, 20, 23} and let every cache j have a threshold valuation of vj = 33 for each of its spots. Object 1 is the only one with g1j > vj ; so, all the caches hold this object. The other objects are all valued at vj . At least one copy of objects 2, . . . , 9 must be held since the revenue ui is below βi , where βi is the revenue required to bring the cost of acquiring the object down from co to cn (see (F) on Page 23). The remaining spot is filled by another copy of object 2. This allocation exactly corresponds to the social optimal one mentioned earlier for Example 4.3.

6.

Generalization and Future Directions

In this section, we consider the generalization of our results to objects with arbitrary sizes. We also discuss the application of our policies in a dynamic context, relating them to the existing dynamic update strategies in the literature. 6.1.

Arbitrary Object Sizes

The formulation of the social welfare problem can be generalized to handle the case where each object has a different size si by simply replacing (3) with

n

i=1 si xij

≤ kj for each j ∈ M . Here, αij is

measured in the number of bytes, or the number of packets for transmission, or any other common

27

size unit. In terms of complexity, however, the problem now becomes much harder. Clearly, even with just one cache, it is equivalent to the knapsack problem and is, therefore, NP-Hard. Actually, the social welfare caching problem is strongly NP-hard even when all the caches have the same capacity (see Appendix A.10 for a proof). When cl = cn , there is no benefit from holding an object at two caches simultaneously. Therefore, m

j=1

xij ≤ 1. Here, yi = 1 −

m

j=1

xij , and the social welfare caching problem reduces to the multi-

dimensional knapsack problem. When cn = co , the problem decomposes into m knapsack problems. The NP-Hardness of the social welfare problem with different object sizes stems from the fact that we are not allowed to split an object and store the individual parts in different caches. Assuming that we can indeed split the objects13 and prorate the cost of acquiring portions of an object, the optimal social welfare is obtained by solving the following transportation problem:   m n n n     αij αij (SS) min (cl − cn ) χij + cn αij + (co − cn ) γi si si j=1 i=1 i=1 i=1 n  s.t. χij ≤ kj j = 1, . . . , m i=1

γi ≥ si −

m 

χij

i = 1, . . . , n

(20) (21)

j=1

γi ≥ 0

i = 1, . . . , n

γi ≤ si − χij

i = 1, . . . , n; j = 1, . . . , m

(22)

χij ∈ {0, 1, . . . , si }

i = 1, . . . , n; j = 1, . . . , m.

(23)

Here, χij is integer because we do not allow splitting below the common size unit in which αij is expressed. Also,

χij si

is the fraction of object i held by cache j and

acquired from the origin server. Clearly, γi = max{0, si −

m

j=1

γi si

is the fraction of the object

χij } ≤ si − χij . Therefore, (22) can

be dropped. Since (SS) is a transportation problem with integral right-hand sides, (23) can be 13 Typically, an object is divided into packets for transmission. So, assembly is required irrespective of whether the entire object is brought from one source or from a number of sources. Indeed, splitting the object and assembling it later is used in practice (http://www.atzio.com/technology.htm) and known to have a very low overhead. Therefore, our assumption of proportionality of costs for split objects is reasonable in a caching context. On the contrary, in a grid computing environment in which we allocate jobs to processors, the cost of combining the split segments may be too large to be ignored.

28

relaxed to 0 ≤ χij ≤ si (Ahuja et al. 1993). Also, since the total number of constraints in (20) and (21) is m + n, any extreme point optimal solution to the transportation problem has at most m + n variables that are not at their bounds. For the caching problem, where typically m n, this implies that objects are not split heavily. When cl = cn , (SS) reduces to ⎧ ⎫ ⎛ ⎞  m m n m n ⎨ ⎬      α ij ⎝ max χij ⎠  χij ≤ si ∀i, χij ≤ ki ∀j . ⎩ ⎭ si  i=1 j=1 j=1 i=1 j =1

The optimal allocation here is for the objects to be ordered by

m

αij j=1 si

and allocated in a greedy

manner. When cn = co , (SS) decomposes into m problems, each of which can be solved greedily. Clearly, the results presented in the previous sections, except for the algorithmic complexity of computing the best pure equilibrium, continue to hold for objects with arbitrary sizes as long as they are allowed to be split. 6.2.

Dynamic Policies

In the literature, dynamic cache update policies are typically implemented using priority queues where the priority of an object is determined by a cost metric that may be cache and/or object dependent and may evolve with time (see Cao and Irani 1997, Mookerjee and Tan 2002). Thus far, we have used αij to signify the demand (or demand rate) for object i experienced by cache j. Such an interpretation is, however, not needed in our analysis. In fact, αij may as well be any priority-order cost parameter consistent with the policies used in the literature. Here, we have absorbed in αij any cost that is dependent on the object-cache pair in consideration. The only role played by cl , cn and co is to proportionately scale the cost metrics depending on the location from which the object is accessed. In the single-cache framework, the distinction among cl , cn and co is unnecessary. If m = 1, the cost expression in (2) simplifies to co

n

i=1 αi1

− (co − cl )

n

i=1

αi1 xi1 . The first part of the above

expression is constant, and (co − cl ) may be scaled to one. Therefore, (SL) becomes:   n  n   (PO) max αi1 xi1  xi1 ≤ k1 , xi1 ∈ {0, 1} . i=1

i=1

29

The optimal solution to (PO) is trivially obtained by retaining the objects with the highest priorities. The algorithm for optimally solving (PO) is, therefore, greedy in nature. Interestingly, as shown earlier, a greedy algorithm is optimal even for a network of caches with a symmetric setup, whereas such algorithms cannot be devised for asymmetric setups. Cache update policies for objects with different sizes have been proposed in the literature by replacing the object priority measures with priority-to-size ratios. We show next that these policies are optimal in the setup for arbitrary object sizes. If m = 1, (SS) reduces to   n n n    αi1 (PS) min co αi1 − (co − cl ) χi1 | χi1 ≤ k1 , χi1 ∈ {0, 1, . . . , si } . si i=1 i=1 i=1 Assume, without the loss of generality, that

αi1 si

>

αi 1 si

whenever i < i (i.e., the objects are ordered

based on priority-to-size ratios). Let r be the largest index such that

r

i=1 si

< k1 . The optimal

solution to (PS) is the following: ⎧s if i ≤ r, i ⎪ r ⎨  si if i = r + 1, χi1 = k1 − ⎪ ⎩ i=1 0 otherwise.

The above allocation matches the dynamic policies proposed in the literature for all objects except the (r + 1)th one, which is not held in the dynamic policies but is partially held in this allocation. The above solution can also be obtained by viewing (PS) as a continuous knapsack problem. When m = 1, any cn between cl and co yields the same solution. To our knowledge, Mookerjee and Tan (2002) and Hosanagar and Tan (2004) are the only studies that analytically evaluate the performance of the popular LRU strategy using metrics such as the expected waiting time and the hit ratio. Mookerjee and Tan (2002) consider a single-cache, single-user framework. Their results critically depend on two tacit assumptions: object accesses are independent of one another; and for every object and a given time duration, the unconditional probability that the object has not been requested during that time interval is the same (i.e., all objects have similar access patterns that are just temporally shifted with respect to one another). Our analysis, on the other hand, does not make these simplifying assumptions. In fact, even for

30

single-cache frameworks, an analytical calculation of the expected waiting time is still an open question if one relaxes these assumptions. Hosanagar and Tan (2004) consider a two-cache, cooperative caching, centralized scenario. In addition to the assumptions of Mookerjee and Tan (2002), they assume that the object requests are independent across caches. The similarity and the independence assumptions of the object demands (at each cache and across caches) are restrictive, but necessary for their analysis. These assumptions imply that, given a set of objects, any ordering of objects is equally likely in terms of temporal locality. Incidentally, the intuitions gained from their analysis can also be derived quite easily in our framework (which does not make similar assumptions). In particular, the intuitions regarding the latency effects on schemes like CARP and ICP can be found by setting cn = cl and cn = co , as discussed in Section 6.1. In order to implement dynamic cache update policies for cooperative caches in the centralized framework, we propose to update αij and solve the transportation problem at certain points (which can be determined by the time since the last update). As we have already argued, this policy reduces to the existing cache update policies in a single-cache environment. One need not solve a single transportation problem over all the caches in the network, and may instead partition the network heuristically and solve a separate problem for each partition.14 Thus, generalizations of the existing cache update policies can be easily derived from our work; we leave their specific analyses for future investigation. Currently, cooperative caches employ protocols such as ICP where each cache has its own priority queue according to which its allocation decisions are made (Cao and Irani 1997, Ramaswamy and Liu 2004). Such a setup can be modeled as the decentralized setup of Section 4. In fact, as long as the individual priority queues are such that local access is preferred to access from the neighborhood, which in turn is preferred to access from the origin server, Theorems 4.1 and 4.2 will hold. This is because the proofs of these results only make use of the stated property for object 14 One may not have to create many partitions since transportation problems can be solved relatively quickly anyway (see http://plato.asu.edu/ftp/network.html for recent benchmarks for network-flow problems).

31

access preferences and not the particular structure of the cost expressions. Without substantial changes, the integer program for locating the best pure equilibrium, alluded to in Section 4.1.2 and described in Appendix A.4, can also be adapted to account for cache-specific priority queues. Therefore, the decentralized analysis presented in the paper is applicable to the current cooperative caching contexts.

7.

Conclusions

We have analyzed object allocation mechanisms for web caching in both centralized and decentralized scenarios. The comprehensive analysis presented here draws tools from operations research and game theory. The social welfare problem is shown to reduce to the well-known transportation problem, which can be solved efficiently. When the caches act selfishly, it is shown that pure equilibria always exist and can be characterized by an integer program. More interestingly, starting with arbitrary holdings, myopic reactions by the caches always lead to a pure equilibrium in a finite number of steps. Unfortunately, for many instances, there are no equilibria that achieve the optimal social welfare. However, when the caches charge prices for sharing objects, the auction mechanism presented here results in an allocation that yields the optimal social welfare. The paper addresses the two key questions motivating this study and raised in the introductory section: The allocation that yields the optimal social welfare can be found using efficient and wellknown algorithms; and if the caches charge prices for sharing objects, the optimal social welfare can indeed be attained in an autonomous environment. Our work provides a number of other useful managerial insights as well: First, using the fact that the social welfare problem can be expressed as a transportation problem, we show that cache capacities are substitutes, i.e., increasing the capacity at one cache has a lesser effect on social welfare if the capacities at the other caches are also increased. This should be helpful in allocating capacities to caches. Second, if the cache capacities are identical and the overall demand for each object is given, then the symmetric setup, as defined in the paper, incurs the highest social network cost. Since the symmetric setups are solved very easily, they may be used to quickly determine a bound on the optimal social cost.

32

Third, interesting responses by the caches operating under autonomous control are observed. For example, contrary to popular belief, the caches in a pure equilibrium may hold more objects in the network than in the socially optimal allocation; and when the equilibrium is not unique, which is often the case, the network cost and the number of objects held in the network may both be different in different equilibria. Fourth, for a symmetric setup, in the absence of prices for sharing objects, a necessary condition for a strategy to be a pure equilibrium is that the network holds at least a certain number of copies of an object. If this criterion is not met by the optimal social welfare allocation, none of the pure equilibria will produce as good an allocation. Fifth, prices are simultaneously maximized for all objects, yielding the maximum revenue to each cache, and these prices can be easily obtained. We believe that the ideas presented in this paper will help develop effective cache management policies. Future work would benefit from our results in deciding how to allocate capacities to the caches, whether to invest in extra capacities, how demand changes will affect the overall network cost, and whether or not to share objects in a given scenario. If sharing is found profitable, our work would help design protocols geared toward achieving the maximum profit and also aid in developing policies that would incentivize the caches to participate in a collaborative manner. The directions provided in Section 6 show promise in addressing problems involving objects with different sizes and in developing dynamic cache update policies for a network of caches. The design of online mechanisms and the development of allocation schemes where the underlying network is not a complete graph would be interesting future extensions. The insights gained in this paper may also benefit research on other resource-sharing problems that have a similar three-tiered cost structure.

Acknowledgments We thank Dan Kovenock, Rabee Tourky, and the seminar participants at CMU, Indiana University, Michigan State University, University of Alberta, University of Texas, Dallas, and University of Washington for their comments. We also thank Chetan Kumar for his involvement in the initial stage of this project. In addition, we thank one anonymous reviewer, in particular, for his/her careful reading and suggestions.

33

References Ahuja, R. K., T. L. Magnanti, J. B. Orlin. 1993. Network Flows. Theory, Algorithms and Applications. Prentice Hall, Englewood Cliffs, NJ. Bertsekas, D. P., D. A. Castanon. 1989. The Auction Algorithm for the Transportation Problem. Annals of Operations Research 20 67–96. Cao, C., S. Irani. 1997. Cost-aware www proxy caching algorithms. Proceedings of the 1997 Usenix Symposium on Internet Technologies and Systems. 193–206. Chun, B.-G., K. Chaudhuri, H. Wee, M. Barreno, C. H. Papadimitriou, J. Kubiatowicz. 2004. Selfish Caching in Distributed Systems: A Game-Theoretic Analysis. Proceedings of the Twenty-Third Annual ACM Symposium on Principles of Distributed Computing. 21–30. Dantzig, G. B. 1963. Linear Programming and Extensions. Princeton University Press, Princeton, NJ. Datta, A., K. Dutta, H. Thomas, D. VanderMeer. 2003. World Wide Wait: A Study of Internet Scalability and Cache-Based Approaches to Alleviate It. Management Science 49 1425–1444. Day, R. 2004. Expressing preferebces with price-vector agents in combinatorial auctions. Ph.D. thesis, University of Maryland, College Park. Demange, G., D. Gale, M. Sotormayor. 1986. Multi-item auctions. Journal of Political Economy 94 863–872. Dilley, J., B. Maggs, J. Parikh, H. Prokop, R. Sitaraman, B. Weihl. 2002. Globally distributed content delivery. IEEE Internet Computing 6 50–58. Fudenberg, D., J. Tirole. 1991. Game Theory. MIT Press, Boston. Garey, M. R., D. S. Johnson. 1979. Computers and intractability. A guide to the theory of NP-completeness.. A Series of Books in the mathematical Sciences. San Francisco: W. H. Freeman and Company. Geng, X., R. Gopal, R. Ramesh, A. Whinston. 2003. Trading capacities: Capacity provision networks. IT Professional 5 30–36. Glover, F., E. Woolsey. 1974. Converting a 0−1 polynomial programming problem to a 0−1 linear program. Operations Research 22 180–182. Horn, R. A., C. R. Johnson. 1990. Matrix Analysis. Cambridge University Press, Cambridge, UK. Hosanagar, K., R. Krishnan, J. Chuang, V. Choudhary. 2005. Pricing and Resource Allocation in Caching Networks with Multiple Levels of QoS. Management Science 51(12).

34 Hosanagar, K., Y. Tan. 2004. Optimal Duplication in Cooperative Web Caching. Proceedings of the Fourteenth Annual Workshop on Information Technologies and Systems. 92–97. Kelso, A. S., V. P. Crawford. 1982. Job matching, coalition formation and gross substitutes. Econometrica 50 1483–1504. McLennan, A., R. Tourky. 2006. Simple complexity from imitation games. Games and Economic Behavior Forthcoming. Milgrom, P. 2000. Putting auction theory to work: The simultaneous ascending auction. Journal of Political Economy 108 246–272. Mookerjee, V. S., Y. Tan. 2002. Analysis of a Least Recently Used Cache Management Policy for Web Browsers. Operations Research 50 345–357. Podlipnig, S., L. B¨ osz¨ormenyi. 2003. Survey of Web Cache Replacement Strategies. ACM Computing Surveys 35 374–398. Ramaswamy, L., L. Liu. 2004. An expiration age-based document placement scheme for cooperative web caching. IEEE Transactions on Knowledge and Data Engineering 16 585–600. Tawarmalani, M., N. V. Sahinidis. 2002. Convexification and Global Optimization in Continuous and MixedInteger Nonlinear Programming: Theory, Algorithms, Software and Applications. Kluwer Academic Publishers, Dordrecht. Topkis, D. M. 1998. Supermodularity and Complementarity. Princeton University Press, Princeton, NJ. Valloppillil, V., K. W. Ross. 1998. Cache Array Routing Protocol v 1.0 Internet Draft. http://www.globcom. net/ietf/draft/draft-vinod-carp-v1-03.html. Wang, J. 1999. A survey of web caching schemes for the internet. ACM Computer Communication Review 29 36–46. Wessels, D., K. Claffy. 1998. ICP and Squid Web Cache. IEEE Journal on Selected Areas in Communications 16 345–357. Young, N. 1994. The k server dual and loose competitiveness for paging. Algorithmica 11 525–41.

1

Appendix/Online Supplement A.1.

Minimum Network Costs with Identical Cache Capacities

Proposition A.1. An assignment problem can be reduced to (SL), where each cache capacity is one. Proof.

Consider an assignment problem with m jobs and m workers where the profit from assigning job

i to worker j is pij . It is sufficient to consider instances of assignment problems where, for each job i, there is at least one worker j such that pij > 0. The instance of (SL) is created by mapping jobs to objects and workers to caches. Set cl = 0, cn = 1, co =

maxi,j (αij ) mini m j=1 αij

+ 1 +  for an arbitrarily chosen  > 0. Further, set

αij = pij . We prove by contradiction that for all objects, yi = 0 in any optimal solution to the constructed instance of the (SL) problem. Each cache holds an object. If not, placing any unassigned object in the vacant cache improves the objective function value. Now, consider an i such that yi = 1 in an optimal solution to (SL). Then, by the pigeon hole principle, there exists an object i which is held by at least two caches, say, j and j  . Consider an alternative solution to (SL) where yi = 0, xij = 1, and xi j = 0. The constructed solution is m clearly feasible, and the objective function decreases by (co − 1) j  =1 αij + αij − αi j , a quantity larger than zero. m m m m From (5), it follows that i=1 j =1 xij ≥ m. Also, from (3), it follows that i=1 j =1 xij ≤ m. Therefore, m m m m x = m and, consequently, i=1 xij = 1 and j =1 xij = 1. Furthermore, any assignment solution i=1 j =1 ij can be translated to a feasible solution of (SL) with the same objective function value.

A.2.

Technical Results Concerning Cost Sensitivity to Demand Changes

Let A = [A1 , . . . , Am ] ∈ Rn×m be the demand matrix and E be an m × m matrix of all ones. Further, let OptCost(A) denote the minimum cost experienced by the network facing a demand of A. We show that   λ OptCost (1 − λ)A + m AE is an increasing function of λ for λ ∈ [0, 1]. Lemma A.1. If the cache capacities are identical, then OptCost(A) ≤ OptCost(U AV ), where U ∈ Rn×n and V ∈ Rm×m are doubly stochastic matrices.1 Proof.

By linear programming sensitivity analysis, OptCost(A) is concave in A. Clearly, permuting the

objects does not alter the cost. Since the caches have the same capacity (i.e., kj = kj  = k for all j and j  ), OptCost(A) remains the same when the caches are permuted. 1

A matrix is doubly stochastic if each of the elements is non-negative and each row and each column sums to one.

2 There exist I and J, which are each finitely sized; non-negative λij for i ∈ I and j ∈ J such that λ = 1; and Si ∈ Rn×n for i ∈ I and Tj ∈ Rm×m for j ∈ J which are permutation matrices so that: i∈I,j∈J ij OptCost(U AV ) =

i∈I,j∈J

OptCost(λij Si ATj ) ≥

i∈I,j∈J

λij OptCost(Si ATj ) =

i∈I,j∈J

λij OptCost(A) =

OptCost(A). The first equality follows from Birkhoff’s Theorem (Horn and Johnson 1990), the first inequality follows from the concavity of OptCost(A), and the second equality follows from permutation invariance with respect to caches and objects. Proof of Theorem 3.2 Since

E m

and the identity are both doubly stochastic matrices, it follows directly 1  from Lemma A.1 that OptCost(A) ≤ OptCost m AE .

A.3.

Local Optimality Condition for Each Cache and Existence of Pure Equilibria

Lemma A.2. A pure strategy Oj corresponds to the optimal solution in (DL) if and only if it satisfies the condition in Step 3 of Algorithm Local Solution. Proof.

First note that (11) is linear in xij . Further, the coefficient of xij is non-negative since cn ≥ cl ,

co ≥ cn , and 0 ≤ x ¯ij ≤ 1. Consider an arbitrary set Oj of cardinality kj . Since the cardinality of the set {i | bi j > bj } is less than or equal to kj − 1 (by Step 2 of Algorithm Local Solution), there exists an i ∈ Oj such that bi j ≤ bj . We prove the result by contradiction. If there is an i ∈ N \Oj with bij > bj , then Oj \{i } ∪ {i} yields a higher objective function value than Oj . Therefore, Oj cannot be the optimal solution of (DL). Proof of Theorem 4.1 A cache is said to acquire an object if it did not hold this object prior to the move and holds it subsequently. Consider an arbitrary cache j. We first argue that, in its first move, j does not acquire an object which is held by another cache. An object i already held by another cache yields a benefit of (cn − cl )αij to j. The objects held by j in the non-sharing strategy have demands larger than or equal to αij , and all these objects yield at least a benefit of (cn − cl )αij . A cache is said to relinquish an object if it held this object prior to the move and does not hold it subsequently. We argue that a cache j does not relinquish an object i that is held uniquely by it before its first move. An object i with lesser demand αi j cannot provide more value to j (i.e., bi j ≤ bj ) irrespective of whether it is available for unique holding or is being held by another cache. Since i is among the top kj demanded objects, j does not relinquish it in its first move. We prove by contradiction that no cache moves a second time. Assume that cache j is the first cache to have an incentive to move a second time. Meanwhile, no cache has acquired an object held by j. This implies

3 that the values of the objects held by cache j have not reduced since it made the first move. Since j is the first cache wanting to move again, no cache has relinquished a uniquely held object in the meantime. It follows that an object i, that was not available for unique holding during the first move of j, is not available before its second move either. In short, the value of the objects regarded inferior by cache j during its first move has not increased since then. Thus, the values of inferior objects have not increased and the values of preferred objects have not reduced. Consequently, j has no incentive to move again, yielding a contradiction.

A.4.

Integer-Programming Formulation for the Set of Pure Equilibria

To develop this formulation, we use variables xij and yi as defined in the paper. In addition, we introduce  variables oij to linearize 1 − j  =j (1 − xij ). In our context, oij is 1 if some cache j  = j holds i and 0 otherwise. Using these variables, the problem of finding the best social equilibrium can be formulated as:   n m n n     (BP) min αij xij + cn αij + (co − cn ) αij yi (cl − cn ) j =1

s.t.

i=1



i=1

i=1

∀i; ∀j; ∀j  ; j  = j

(24)

1 − yi ≥ xi j

∀i; ∀j; ∀i ; αij > αi j

(25)

xij ≥ xi j + oi j + yi − 1

∀i; ∀j; ∀i ; αij > αi j

(26)

1 − yi ≥ xi j + oi j + yi − 1

∀i; ∀j; ∀i ; (co − cl )αij > (cn − cl )αi j

(27)

xij ≥ xi j

∀i; ∀i ; ∀j; (cn − cl )αij > (co − cl )αi j

(28)

1 − xij ≤ yi + oij ≤ 1 n  xij = kj

∀i; ∀j

(29)

∀j

(30)

xij ≤ oij ≤

xij

j  =j

i=1

xij , oij , yi ∈ {0, 1}

∀i; ∀j.

It is interesting to note that the size of (BP) is polynomial in kj , n, and m, whereas the strategy space of each player is exponential. Proposition A.2. The set of pure equilibria is identical to the set of feasible solutions to (BP). Proof.

First, note that yi = (1 − oij )(1 − xij ). In other words: xij oij = xij + oij + yi − 1

∀i; ∀j.

4 In order that a feasible solution to (BP) corresponds to a pure equilibrium, it is necessary and sufficient by Lemma A.2 that it satisfies: #

$

(cn − cl )(αi j − αij ) + (co − cn ) αi j

    1 − xi j  − αij 1 − xij j  =j

%& xi j (1 − xij ) ≥ 0

j  =j

for any j which holds i instead of i. By substituting oij and oi j for the nonlinear products, the above constraint can be simplified to: '  ( (cn − cl )(αi j − αij ) + (co − cn ) αi j (1 − oi j ) − αij (1 − oij ) xi j (1 − xij ) ≥ 0.

(31)

A solution violates (31) if and only if xi j = 1, xij = 0, and the expression in the brackets is negative. We now obtain the conditions when this expression is negative. Clearly, it is so if (co − cl )αi j < (cn − cl )αij , which yields (28). Now, assume that (co − cl )αi j ≥ (cn − cl )αij . If αij > αi j then the expression is negative if either oij = 0 (equivalently, yi = 1), which yields (25); or if oi j = 1 (equivalently, xi j oi j = 1), which yields (26). If αij ≤ αi j and (co − cl )αij > (cn − cl )αi j , then the expression is negative if oi j = 1 (equivalently, xi j oi j = 1)  and oij = 0 (equivalently, yi = 1), which yields (27). Constraints (24) linearize oij = j  =j (1 − xij ), whereas constraints (29) linearize yi = (1 − oij )(1 − xij ). Constraint (30) models the capacity of cache j. This proves that all constraints of (BP) are satisfied by a pure equilibrium, and vice versa. Proposition A.2 allows us to find equilibria with the minimum social welfare by maximizing the objective function of (BP). We can also find the best/worst pure equilibrium from a particular cache’s perspective by minimizing/maximizing (cl − cn ) ni=1 αij xij + cn ni=1 αij + (co − cn ) ni=1 αij yi . A.5.

Technical Results for Pure Equilibria of Symmetric Caches

Lemma A.3. There exists a pure equilibrium that attains the maximum social welfare, where the set of objects held in the network is {1, . . . , a} and each cache that holds an object i ∈ {1, . . . , wa } also holds all objects in {1, . . . , i}. Proof.

Consider a pure equilibrium such that a cache j holds a. We prove by contradiction. Let i =

max{i | i < a; i ∈ ∪m j =1 Oj }. Since this is a pure equilibrium, αi ≤ αa . But i < a implies that αi ≥ αa . Therefore, αi = αa . Consider the pure equilibrium where j caches i instead of a. Clearly, the social welfare remains the same. This proves the first condition. If j caches a, it must also cache {1, . . . , wa }. Now, consider a cache j  that holds i ∈ {1, . . . , wa }, but not i < i. Clearly, j  does not hold any object a such that wa ≥ i or else i must be held. Therefore, j  can relinquish i in favor of i without reducing social welfare while keeping the caches in equilibrium.

5 In the following, we only consider pure equilibria that satisfy the conditions of Lemma A.3. Lemma A.4. Any pure equilibrium that satisfies the conditions of Lemma A.3 holds at least fi copies of object i, where i ∈ {1, . . . , wa } and fi is as generated by Algorithm SCBE in Figure 4. Proof.

Consider a pure equilibrium E, with ri copies of object i. Let tj = max{i | i ≤ wa , i ∈ Oj }. We

order the caches such that for any j  < j, tj  ≥ tj . By Lemma A.3, for any i ≤ wa , i is held by caches in {1, . . . , ri }. We prove by contradiction. Let i = max{i | i ≤ wa , ri < fi }. Now, consider the caches in {1, . . . , ri }. Each of them holds objects {1, . . . , i }. Also, these caches hold ri copies of objects in {i | i < i ≤ wa }. Furthermore, since no other cache holds object i , caches in {1, . . . , ri } hold objects in I = {i | i ≤ wi }. Since fi = i≤¯i≤wa f¯i , kri ≥ i ri +



ri + |I| ≥ i ri +

i a − aj = ri k −





i ≤¯ i≤wa

1≤i≤¯ i

f¯i = ri k − ri i −





f¯i = ri k − ri i −

i fi , then ri = m. Consider the case with l > wa . For i ∈ {1, . . . , l}, allocate i to the caches in {1, . . . , rl }. Then, allocate the remaining objects arbitrarily. Now, let l ≤ wa . Fill each cache in j  ≤ fl with objects in {1, . . . , waj } ∪ {aj +1 + 1, . . . , aj }. For j  ∈ {fl + 1, . . . , rl }, allocate all objects in {1, . . . , l} and, for j  ∈ {rl + 1, . . . , m}, allocate all objects in {1, . . . , l − 1}. It can be verified that each object in {1, . . . , wa } is allocated to ri caches. By (34), there is enough space to allocate the remaining objects once; allocate them arbitrarily. Clearly, the caches in {1, . . . , fl } are in equilibrium. The caches in {fl + 1, . . . , rl } are also in equilibrium since waf +1 < l. l

A.6.

Sensitivity of Social Welfare with Cache Capacities

Lemma A.5. There exists an optimal solution to (DD) where vj ≤ maxi {gij + ui | i = 1, . . . , n}. In fact, if kj > 0, then vj ≤ maxi {gij + ui | i = 1, . . . , n} in every optimal solution. Proof.

The objective function of (DD) increases with vj only if max{0, gij + ui − vj } increases for some

i. This is possible only if vj ≤ gij + ui . If kj > 0, then any increase beyond maxi {gij + ui } decreases the objective function value because of the presence of −kj vj in the objective. Proposition A.3. The optimal social cost is supermodular2 in K = (k1 , . . . , km ). Further, the set of optimal solutions to (DN) is decreasing as a function of K. The set of optimal solutions to (DN) is a sublattice, whose minimum/maximum element is decreasing3 in K. Proof.

Since

n

i=1

ui is linear, it is supermodular in (u1 , . . . , un ). Clearly, −kj vj is supermodular in

(vj , −kj ) (see Example 2.6.2(c) in Topkis 1998). Further, − max{0, gij + ui − vj } is a concave function of ui − vj . Therefore, by part (b) of Lemma 2.6.2 in Topkis (1998), − max{0, gij + ui − vj } is supermodular in (ui , vj ). Also, by part (b) of Lemma 2.6.1 in Topkis (1998), the objective function of (DD) is supermodular in (u1 , . . . , un , v1 , . . . , vm , −K). Whenever (u , v  ) and (u , v  ) are feasible to (DN), (cmax{u , u }, cmax{v  , v  }) 2

A function f (x) is said to be supermodular over Rn if for any x ∈ Rn and x ∈ Rn : f (x ) + f (x ) ≤ f (cmax(x , x )) + f (cmin(x , x )), where cmax{x , x } and cmin{x , x } denote, respectively, the component-wise maximum and minimum of x and x (see, for example Topkis 1998). 3

A set X  is set to be smaller than X  if for each x ∈ X  and x ∈ X  , cmax{x , x } ∈ X  and cmin{x , x } ∈ X  .

7 and (cmin{u , u }, cmin{v  , v  }) are also feasible to (DN). Therefore, the feasible set of (DN) is a sublattice of Rn+m . By Theorem 2.7.6 in Topkis (1998) and strong duality of linear programming (see Dantzig 1963), the optimal value of (SL) is supermodular in −K. If we denote the optimal value of (SL) for a given K by f (K), then for any K  and K  in Rm , f (K  ) + f (K  ) = f (−(−K  )) + f (−(−K  )) ≤ f (− cmax{−K  , −K  }) + f (− cmin{−K  , −K  }) = f (cmin{K  , K  }) + f (cmax{K  , K  }), where the equalities are trivial and the inequality follows from the supermodularity of the optimal value with respect to −K. Therefore, f (K) is supermodular. By Theorem 2.7.1 of Topkis (1998), the set of optimal solutions is a sublattice, and by Theorem 2.8.2 of Topkis (1998), the set of optimal solutions to (DN) is decreasing. Because the dual variables are non-negative, the set of optimal solutions is bounded. Since the set of optimal solutions is decreasing as a function of K, by Lemma 2.4.2 in Topkis (1998), the minimum/maximum element also decreases. Even though the warehouse capacities have already been shown to be substitutes in a transportation problem (see Theorem 3.4.1 in Topkis 1998), Proposition A.3 does not directly follow. In particular, it still needs to be verified whether the substitutability property continues to hold even with upper bound constraints on the arc costs (since (4) constrains xij to be less than or equal to 1).

A.7.

Prices and Optimal Social Welfare Allocation

In an optimal allocation, let o∗ij be 1 if i is held by some cache j  = j and 0 otherwise. Further, any object held by the other caches is available to j at the price of qi . Assume that cache j offers an object at the price pi . For analytical convenience, let ti be 1 if pi < qi and 0 otherwise. Then, the objective of cache j is to maximize: n  i=1

$ pi xij (1 − o∗ij )



αij + pi ti xij o∗ij

j  =j



αij %

j  =j ∗ ij

∗ ij

− cl αij xij − (cn + qi )(1 − xij )o αij − co (1 − xij )(1 − o )αij

,

which can be simplified to: $ % $ % n    (cn + qi − cl )αij o∗ij + pi ti o∗ij αij + (co − cl )αij + pi αij (1 − o∗ij ) xij i=1

j  =j

n    co (1 − o∗ij ) − (cn + qi )o∗ij αij . − i=1

j  =j

8 Since the caches can always acquire an object from the origin server, it should be clear that p i ≤ co − cn .

(35) u

Proposition A.4. Let (u , v  ) be a feasible solution to (F). Assume that qi = m i α  . Then, vj ≤ (cn + j  =1 ij   ∗ ∗ ∗ ∗ qi − cl )αij oij + pi ti oij j  =j αij + (co − cl )αij + pi j  =j αij (1 − oij ), if xij = 1 and pi ≥ m

ui

j  =1

αij

.

(36)

First, consider x∗ij o∗ij = 1. By (19), ui = 0. Therefore, qi = 0 and ti = 0. So, by (16), vj ≤ gij = m (cn − cl + qi )αij + pi ti j  =1 αij . Second, consider x∗ij (1 − o∗ij ) = 1. Then, Proof.

vj ≤ gij + ui ≤ gij + pi

m 

αij = (cn − cl )αij + pi

j  =1

m 



αij ≤ (co − cl )αij + pi

j  =1

αij ,

j  =j

where the first inequality follows from (16), the second from (36), and the last from (35). Proposition A.5. Let (u , v  ) be a feasible solution to (F). Assume that qi =   vj ≥ (cn + qi − cl )αij o∗ij + pi ti o∗ij j  =j αij + (co − cl )αij + pi j  =j αij (1 − o∗ij ). Proof.

m

ui

j  =1

αij 

. If x∗ij = 0, then

First, consider (1 − x∗ij )o∗ij = 1. Since pi ti ≤ qi , then by (15), vj ≥ gij + ui = (cn − cl + qi )αij + qi



αij ≥ (cn − cl + qi )αij + pi ti

j  =j



αij .

j  =j

Second, consider (1 − x∗ij )(1 − o∗ij ) = 1. Then, vj ≥ gij + ui = (cn − cl )αij + (co − cn )

m 

αij ≥ (co − cl )αij + pi

j  =1



αij ,

j  =j

where the first inequality follows from (15) and the last from (35). We now argue that a cache has no reason to prefer one optimal allocation over another. It is well known that an optimal flow can be obtained from another by flow augmentation along paths/cycles with zero reduced cost on each arc. The augmenting paths (and obviously cycles) do not start/end at any caches (assuming that they are completely full in both solutions). Therefore, each cache trades an object for another. Let (u, v) be optimal to (M). Cache j incurs a loss of gij + ui when it relinquishes i. If i is also held by another cache, then ui = 0. On the other hand, if i is left to be served by the origin server, then ui = βi . Otherwise, j loses revenues from the other caches and pays to the cache which acquires the object. Similarly, the object that j acquires yields a benefit of gij + ui . If the object has already been held by another cache and is not relinquished by it, then ui = 0. Otherwise, the cache earns revenues from the other caches and does not pay itself. Therefore, in each augmentation, every cache has the same welfare as before.

9 A.8.

Proof of Theorem 5.1

We say that a solution satisfies  − CS ( − complementary slackness) conditions before round r if for each r i and j such that i ∈ Ojr , vij ≥ vir (r,j)j and for each object i ∈

m

j =1

Ojr , uri = βi . Further, uri ≥ 0, ∀i, and

if i ∈ Ojr ∩ Ojr for some j = j  , then uri = 0. In particular, the starting solution of u1i = βi and Oj1 = ∅, ∀j, satisfies  − CS conditions.4 We show by induction that  − CS conditions are satisfied after each round if the initial solution satisfies the conditions. By the rules of the auction, an assigned object always remains assigned and the prices do not go up. Assume that a solution satisfies  − CS conditions before round r. Let I1 ⊆ Ojr be the set of objects that j loses and I2 be the set of objects j acquires in the rth round. Since I2 ⊆ Tjr , it follows that for r +1 r +1 ≥ vir (r,j)j . Further, by our induction hypothesis, for each i ∈ Ojr , vij ≥ vir (r,j)j . Now, there any i ∈ I2 , vij

must be kj − |Ojr+1 | objects in N \Ojr+1 with a valuation of at least vir+1 (r +1,j )j . Since objects with a valuation more than vir (r,j)j at the end of rth round must be in I1 ∪ Tjr \I2 , there are at most kj − |Ojr+1 | such objects. r +1 r Therefore, for any i ∈ Ojr+1 , vir+1 (r +1,j )j ≤ vi (r,j )j ≤ vij . Further, the object is not allocated to more than one

location unless uri +1 = 0. In other words,  − CS conditions are satisfied at the end of round r. r − gij } = max{0, uri − }. There are three For i ∈ Tjr , the bid by cache j is max{0, vir (r,j)j − gij } ≤ max{0, vij

possibilities. First, the price of an object is bid down by . Since prices cannot reduce forever, the number of such rounds is finite. Second, there is a possibility that the price of at least one of the objects is reduced to zero. Since there are finitely many objects, the number of such rounds is also finite. The third case is where all the objects in Tjr for all caches j have a price of 0. In this case, the auction terminates since no uncommitted spots remain. We have shown that the final allocation obeys  − CS conditions and has no uncommitted spots. If the final allocation is not optimal, there exists a path/cycle that only uses arcs with a non-zero residual capacity and is such that the resulting change in the objective is negative (see Theorem 3.5 in Ahuja et al. 1993). This is because the difference between any two solutions can be expressed as a sum of the flows on such paths/cycles. It can be easily verified that ui = uri for i = 1, . . . , n and vj = vir (r,j)j for j = 1, . . . , m is a dual feasible solution (see DD). Then, each arc (i, j) where i is not held by j has a reduced cost of at least − since r for i ∈ Ojr , vir (r,j)j − crij − uri ≥ vir (r,j)j − vij −  ≥ −. Each arc with i ∈ Ojr has a non-negative reduced cost r since gij + ui − vir (r,j)j ≥ vij − vir (r,j) ≥ 0. Any arc of the form (i, D) has a non-negative reduced cost. If the 4

Other starting prices are possible as long as they satisfy the  − CS conditions described later.

10 path ends at an object node i, then ui = 0. If the path ends at the dummy node, vD = 0. If the starting node is an object or the dummy node, the corresponding dual is non-negative or zero, respectively. Therefore, the change in the objective (see Property 9.2 in Ahuja et al. 1993) is greater than or equal to − and βi are integer (or appropriately scaled, if rational) and 
1, gi is dit . Also, dit ≥ q if indx{it ∈ G} < mk and, in particular, q is the valuation of the mk th element in G. Then, u∗i = q − gi   if i ∈ A1 and u∗i = 0 otherwise. The prices and valuations can be computed in O min(mk, n) time. Since the

11 constructed (u∗ , v ∗ ) and the solution from Algorithm SCGS obey complementary slackness, this provides an alternate proof that the allocation of Section 3.1 is a socially optimal one. What prices generate the above revenues? If p∗i =

u∗ i mαi

is the price for i, then, for the cache that holds i,

the revenue from the other caches and the savings from not having to pay for object i, adds up to u∗i . As a result, the cost to every cache can be calculated as:

n

i=1

(cn + p∗i )αi −

i∈A3

gi − (k − |A3 |)q. Since the cost

is the same for every cache, this pricing arrangement is fair.

A.10.

Arbitrary Object Sizes and NP-Hardness.

Consider an instance of the Bin Packing Problem (BPP), which is known to be strongly NP-Complete (Garey and Johnson 1979) and is defined as follows: Let M be a set of m bins and N a set of n items. Each bin has a capacity k and each item has a size si . Is it possible to pack all the items in the bins? Proposition A.6. The social welfare caching problem is strongly NP-Hard even if all the caches have the same capacity and αij , ∀ i ∈ N, j ∈ M , is a fixed constant greater than zero. Proof.

We prove the claim by reducing an instance of BPP to an instance of the social welfare problem,

where all caches have the same capacity and the demands are positive. For each bin, we create a cache, and for each item, we create an object. The capacity of each cache is k, and the size of object i is si . We define cl = 0, cn = 0, and co = 1. If O is the set of objects cached by at least one cache in a solution of the social welfare problem, then the total cost incurred is due only to the objects brought from the origin server, which is



m i∈N\O

j =1

αij . Therefore, the optimal solution to the social welfare caching problem has a value of 0 if

and only if BPP has a solution.

References Garey, M. R., D. S. Johnson. 1979. Computers and intractability. A guide to the theory of NP-completeness.. A Series of Books in the mathematical Sciences. San Francisco: W. H. Freeman and Company. Horn, R. A., C. R. Johnson. 1990. Matrix Analysis. Cambridge University Press, Cambridge, UK.