Efficient Remote Data Access in a Mobile Computing Environment

Transcription

1 This paper appears in the ICPP 2000 Workshop on Pervasive Computing Efficient Remote Data Access in a Mobile Computing Environment Laura Bright Louiqa Raschid University of Maryland College Park, MD bright@cs.umd.edu, louiqa@umiacs.umd.edu Abstract We consider the problem of remote data access for multiple clients in mobile computing environments. In this environment, a base station provides a wireless communication link between mobile clients and remote servers that reside on a fixed network. Clients send requests to the base station for objects which reside on the remote servers. The base station downloads these objects from the remote servers and transmits them to the clients. A drawback in this environment is that remote data access across a fixed network is slow. When locally cached copies of data exist at the base station, accessing them reduces latency. However, the cached data becomes old as more recent data is made available at the remote servers. In this paper we consider a framework that allows mobile clients to specify their preferences about recency. The objective is to maximize the recency of the data for all clients while delivering data to clients as quickly as possible. We develop an on-demand strategy which determines when the base station should access data from remote servers and when it should return data copies from its cache. We present analytical results that show the benefits of the on-demand approach. Introduction The growing presence of mobile computing and wireless communication has increased the number of clients that access data remotely. In mobile computing environments, there is typically a set of servers on a fixed network that provide data to a set of mobile clients. The geographic area is divided into cells. Each cell has a base station, a fixed server with a wireless interface to communicate with mobile clients. The base station is connected to a fixed network and provides a wireless communication link between mobile clients in its cell and remote servers on the fixed network. This research has been partially supported by the Defense Advanced Research Project Agency undergrant , and the National Science Foundation under grant IRI Mobile clients send requests to the base station for objects which reside on the remote servers. The base station then downloads the objects from the remote servers and transmits them to the clients. The architecture is illustrated in Figure. Details of this architecture are described in [2]. A drawback in this environment is that remote data access is slow. This is because the base station must download objects from remote servers, and there may be delays due to network traffic and server workloads. Also, as the base station downloads more data over the fixed network, the overall latency may increase due to bandwidth contention. This may be unacceptable if clients require fast answers to their requests. In addition, a client may be connected to the base station in its cell for a short period of time, and then disconnect or move to a different cell, so the base station must serve client requests in a timely manner. Finally, in a mobile computing environment the wireless downlink from the base station to the clients typically has limited bandwidth. To deliver data to as many clients as possible, it is important to maximize utilization of this bandwidth. If there is too much delay in downloading data from remote sources, some of the available downlink bandwidth may be idle. Maintaining a cache at the base station can improve the above situation. The cache at the base station can store data obtained from remote servers. If the base station has a copy of an object in its cache, the cached copy can be used to answer client requests and therefore reduce the latency of downloading data across the fixed network. However, the cached data becomes stale as more recent data is made available at remote servers. Clients may have different preferences about the recency of the data. Some clients may prefer the most recent data even if it takes longer to access, while others may accept less recent data if it can be accessed quickly. In this environment, a challenge is determining how to maintain the appropriate level of recency in the cache while delivering data to clients as quickly as possible. Given a request for an object and a client s recency preference, the challenge is choosing which objects the base station should access remotely and which to access from the cache. One possible strategy is to refresh the cache in the background as in []. When an object is updated at a remote server, the base station can download a new copy of the ob-

2 ject without waiting for a client to request it. We refer to this as an asynchronous approach. While this strategy speeds up data delivery to clients by bringing the requested objects into the cache, it has two major drawbacks. First, asynchronous updates may waste bandwidth, since some objects may not be requested by clients between consecutive updates. This is especially true when there is a skew in the popularity of objects. Second, no matter how frequently the base station downloads objects from remote servers, the cache will never be completely up to date. This is because objects may be updated at any point in time. Even if the base station could request every object as soon as it was updated, there would still be some delay in downloading the object from the remote server, and during this time the cached object would be stale. This is studied in detail in []. In Section 3 we present analysis that explores these two drawbacks in greater detail, and motivates our proposed solution. In this paper we present a solution that provides more recent data and consumes less bandwidth than the asynchronous approach. We propose an on-demand approach, where we read some objects from the cache and access others remotely. Reading some data from the cache reduces the amount of time that the wireless downlink bandwidth may be idle while the base station waits for data to arrive from remote servers. It also consumes less bandwidth on the fixed network than accessing all requested objects remotely. We examine the problem of how to choose which objects the base station should access remotely when it receives requests from a large number of clients, and when copies of objects cached at the base station have varying degrees of recency. We map the problem to the knapsack problem [3] and use dynamic programming to solve it. We analyze how the relationships between object size, number of requests per object, and recency of cached objects affect the solution space. This analysis provides useful insights into the problem and presents areas for future work. We note that while we focus on a mobile computing environment in this paper, our results are applicable to any enviroment where time or bandwidth constraints make it impractical to access all requested data remotely. For example, our work could be applied to web proxy caching. This paper is organized as follows. Section 2 formally describes the problem. In Section 3 we present analysis that motivates an on-demand approach. In Section 4 we explore the solution space of the on-demand approach. Section 5 surveys related work, and Section 6 concludes. 2 Problem Definition We consider one or more mobile clients in a single cell that send requests to the same base station. The base station has cached copies of some objects which can be used to answer requests, but the cached copies may be less recent base station mobile clients wireless cell remote servers fixed network base station mobile clients wireless cell Figure. Architecture of a Mobile Computing Environment than the copies on the remote servers. The model is pullbased. Remote servers do not know the interests of the mobile clients, and only provide data when it is requested by the base station. All queries from the mobile clients are read-only, but data at the remote servers may be updated. Any object that the base station does not download will be read from the base station cache. Note that each object may have a different size. When a client requests an object, he can specify a target recency value C for the object. If the recency score x of the cached copy of the object meets or exceeds C, the object gets a score of.0. If the cached copy of the object is less recent than the target value, its score is computed using a scoring function. The score approaches 0 as x gets further from C. Example scoring functions are f C (x) = =(+abs(x=c? )) and f C (x) = exp(?abs(x=c? )). The score of any object accessed remotely is set to.0. We focus on two problems. The first problem is as follows. Given a set of requested objects (of varying sizes), a set of client recency requirements for each object, a cache containing a possibly less recent copy of each object, and a limit on the amount of data that can be downloaded, we need to decide which objects to access remotely, and which to read from the cache. The goal is to maximize the average client recency score over all objects. The second problem is to determine an upper bound on the amount of data that should be downloaded to answer a set of requests. Downloading too little data will result in delivering stale data to a large number of clients. However, downloading too much data will increase latency for all clients and may result in idle downlink bandwidth. In this paper we present analytical results that provide some insights into these two problems. We make a number of simplifying assumptions. We assume that each client requests only one object, but the same object may be requested by multiple clients. We do

3 not consider the workload on servers from clients in other cells. We assume that the base station can cache a copy of every object that is requested. We consider only objects that are stored in the cache. Since any object that is not in the cache must be downloaded, this assumption allows us to focus on studying the tradeoffs between downloading data and using cached copies. Given a set of client requests and an upper bound on the amount of data that can be downloaded, the problem maps to the knapsack problem [3]. The knapsack problem considers a set of objects Ū, where each object u has size s(u) and profit p(u). Given a knapsack with capacity C, the problem is to choose a set of objects in Ū to maximize the total value P u2ū p(u) subject to P u2ū s(u) C. The mapping of our problem to the knapsack problem is as follows. Let each data object u have size s(u). The profit p(u) of each object u is computed as follows. Suppose that the set of clients who request an object u is requests(u). For each client i, we compute the client s recency score of the cached object using the client s target recency (C i ) and the recency (x) of the cached copy. Recall that the remote copy has a score of.0. We compute benefit(i), the difference between the score of the remote object (.0) and the score of the cached object for client i. This value is the benefit to client i of downloading object u. Note that the value of benefit(i) increases as C i is more recent and when the cached object is older. The profit p(u) of an object u is the sum of the benefit values of all clients that request u. This takes into account both the benefit to each client of downloading the object and popularity of an object, i.e. the number of clients that request the object. This mapping gives higher profit (i.e. a greater benefit of downloading) to remote objects that are requested by many clients or have older cached copies. Note that this mapping considers only the limit on the amount of bandwidth that can be used to answer a set of queries, and does not model network latency. The knapsack problem is known to be NP-complete but can be solved in pseudo-polynomial time using dynamic programming [3]. There are also polynomial time approximation algorithms. In this paper we use dynamic programming to explore the solution space. 3 Motivation In this section we present analysis that provides motivation for accessing some objects on demand, rather than updating the cache asynchronously in the background. Recall that there are two potential drawbacks to the asynchronous approach. First, asynchronously updating the cache may waste bandwidth if the base station downloads objects that are not requested by clients. Second, regardless of how often the base station downloads updated objects, the data in the cache may not be completely up-to-date. Below we present analysis that illustrates these two drawbacks. 3. Amount of Data Downloaded In our first analysis we measure how much data must be downloaded to deliver the most recent data to all users using an asynchronous approach and an on-demand approach. We compare the asynchronous approach, where every object in the cache is downloaded every time it is updated at the remote server, to an on-demand approach where an object is downloaded only if it is requested and its cached copy is stale with respect to the remote server. Note that in this first analysis, we do not use any stale cached objects to answer requests. We do not assume any limitations on the amount of data we can download. We illustrate the potential savings of the on-demand approach with some simple analysis. For simplicity, we consider a scenario where there are 500 objects of uniform size. All objects are updated simultaneously, and this occurs once every 5 time units. Thus, updates occur at time 0, 5, 0, etc. We note that our results were similar for varying object sizes, but we omit these results due to space considerations. In our analysis, we consider the effects of both the number of client requests and the skew in these requests on the amount of data that must be downloaded. We ran multiple simulations, each with a fixed number of requests per time unit. We varied the number of requests per time unit from 0 to 500. For each simulation, we started with an empty cache, and warmed up the cache for 00 time units. We then ran the simulation for an additional 500 time units and measured the total number of objects downloaded during this time. Recall that in the on-demand approach, an object is downloaded only when it is requested by at least one client and its cached copy is stale with respect to the server. In the asynchronous case, the amount of data that must be downloaded depends only on the rate that objects are updated and is independent of both the number of client requests and the skew in these requests. In our analysis, each object was updated once every 5 time units, and each simulation ran for 500 time units in the steady state. Therefore each object was updated exactly 00 times. Since there were 500 objects, a total 50,000 units of data needed to be downloaded to keep the cache completely up to date. This is an upper bound on the amount of data that must be downloaded to deliver the most recent data to all clients. The asynchronous approach and the on-demand approach are compared in Figure 2. The dotted line across the top of the graph indicates the amount of data that is downloaded in the asynchronous case, and this is compared with the on-demand approach for three different client access patterns. The solid curve in Figure 2 shows the case where all objects were requested with equal probability. For low re-

4 quest rates, the on-demand approach provides considerable savings. This is because many objects that are stale in the cache are not requested before they are updated again at the remote server, so there is no need to download them. When the number of request per second is greater than 300, the on-demand approach downloads nearly as much data as the asynchronous approach. These results suggest that when all objects are requested equally, the on-demand approach provides the greatest benefit when there are few client requests. As the skew in client requests increases, the benefit to the on-demand approach increases. The dashed curve in Figure 2 shows the case when the requests were skewed uniformly (i.e. the ith most popular object was requested with probability proportional to i). The dotdash curve shows a higher degree of skew, where the requests had a zipf distribution (i.e. the ith most popular object was requested with probability proportional to =i). For higher degrees of skew in requests, the on-demand approach provides greater savings in terms of the amount of data that must be downloaded. This is because many more objects are not requested between updates. Number of Objects Downloaded x Objects updated every 5 time units asynchronous on demand uniform access on demand skewed(uniform) on demand skewed(zipf) Number of Requests per time unit Figure 2. Amount of data downloaded to provide the most recent data to all clients, for varying skew in requests 3.2 Recency of Data In the previous analysis, we showed that the on-demand approach requires downloading less data than the asynchronous approach to deliver the most recent data to clients. Next, we assume that there is a limit on how much data can be downloaded. We compare the recency of data delivered to clients using these two approaches under this constraint. For this analysis, we considered 500 objects of unit size and uniform access probability. 00 objects were requested per time unit. We ran multiple simulations and varied the Average recency low update frequency 0.2 on demand asynch Average recency high update frequency 0.2 Data Downloaded per time unit on demand asynch Figure 3. Average recency of data as amount of data downloaded increases number of objects downloaded per time unit from to 00. We began each simulation with an empty cache and warmed up the cache for 50 time units. We then ran each simulation for 00 time units and measured the average recency of all objects delivered to clients. We note that our results were similar for varying object sizes and skew in popularity. In the asynchronous approach, objects were downloaded in a fixed order in a round robin manner. At each time interval, if k was the upper bound on the number of objects to download, the next k objects in the fixed order were downloaded and updated in the cache. In the on-demand approach, at each time interval, the k requested objects with the lowest recency in the cache were selected to be downloaded. The remaining requested objects were read from the cache. Both simulations used the same set of randomly generated client requests. We measured the recency of cached objects as follows. Any object in the cache that was up-to-date had a value of. Each time an object in the cache was updated at the remote server, its recency score x decayed using the function x0 = C=(=x + ), where C is a constant. The results of these simulations are shown in Figure 3. The graphs show how the average recency changes when objects are updated with low frequency (once every 0 time units) and high frequency (once every time unit). Recall that 00 objects were requested in each time unit. In the ondemand case, as the amount of data downloaded per time unit approaches 00, most requested objects can be downloaded, so the recency approaches. In contrast, using the asynchronous approach, 00 arbitrary objects are downloaded at each time unit, and the remaining 400 objects become more stale. Since the 00 client requests are independent of which objects are downloaded, many requested objects are stale in the cache. When objects are updated with high frequency, the asynchronous approach performs poorly.

5 Parameter range distribution Object Size [-20] uniform N um Requests [-20] uniform or constant Cache Recency Score [0.-.0] uniform Table. Parameter values for each object and their distributions These graphs show that when objects are updated more frequently and there is a limit on how much data can be downloaded, the on-demand approach provides a greater benefit. This is because the asynchronous approach may download objects at a lower rate than they are updated. In contrast, the on-demand approach always accesses the most recent copies of some objects, and therefore provides more recent data to clients. 4 Analysis of Solution Space In this section we present analytical results using the dynamic programming solution to the knapsack problem. Recall our problem: given a set of requested objects, a set of client recency requirements for each object, a cache containing a possibly less recent copy of each object, and a limit on how much data can be downloaded, we must determine which objects to access remotely, and which to read from the cache. The goal is to maximize the average client recency score over all objects. Our results show how the average recency score for all clients improves as we increase the upper bound on the amount of data downloaded. We note that as more data is downloaded, the average recency score for a set of requests will improve. However, downloading large amounts of data may increase the delay in delivering data to clients. The dynamic programming algorithm works by finding the optimal solution for downloading a single unit of data, and then finds the solution for larger amounts of data until the upper bound is reached. The algorithm is well-suited to our analysis because it allows us to observe how the quality of the solution changes as the upper bound increases. We first describe the parameter values we used in the analysis. We then discuss our results. 4. Setup The name, distribution, and range of values for the three parameters that were varied in this study are summarized in Table. The first parameter is the sizes of the objects, Object Size. We used a uniform distribution in the range from [-20]. The second parameter is the number of clients who request each object, N um Requests. In the first analysis, N um Requests was set to a constant of. In the remaining analysis, N um Requests was uniformly distributed in the range from [-20]. The third parameter we consider is Cache Recency Score. This is the recency score of a cached object averaged over the clients who request the object. A uniform distribution in the range from 0. to.0 was used. The number of clients in our study was 5000, and the number of distinct objects requested by these clients was 500. The sum of the sizes of these objects was 5000 units. Therefore, the maximum number of units of data downloaded in this analysis is All analysis was performed using synthetic data that was generated to conform to Table. In each set of results, we measure the value of Average Score as a function of the upper bound on the number of data units downloaded. Average Score is the average recency score of a solution for all clients. It is computed as follows. Recall that a solution is a set of objects to access remotely, and the remaining objects are read from the cache. If an object is downloaded, the score for every client that requested it is.0. If an object is read from the cache, the score for each client that requested it is computed as a function of the client s target recency C i as described in Section 2. Average Score is the average of the scores of all of the clients. Since our objective is to provide the most recent data to the largest number of clients, Average Score is a good way to measure the quality of the solution. We note that Average Score can be understood in the context of the knapsack problem as follows. In our mapping to the knapsack problem, the profit of an object is equal to the number of clients requesting the object, N um Requests, times the average benefit to these clients of downloading the object, avg benefit. Recall that benefit(i) is the amount by which the score will increase for client i if an object is downloaded. In this mapping, choosing a set of objects with the maximum profit will maximize the average value of benefit over all clients. It is straightforward to verify that maximizing the benefit will also maximize the average client score, i.e. Average Score. 4.2 Analysis We study the effects of the parameters Object Size, N um Requests, and Cache Recency Score on the Average Score. We consider the effects of both positive and negative correlations between each of these three parameters. We show when there is a benefit to downloading a large amount of data, and when downloadinga small amount of data will provide an answer that is almost as good. Our analysis indicates that the distribution of these parameters and the way they are correlated play a significant role in the rate at which Average Score increases as more data is

6 downloaded. These results identify workloads and cache states for which downloading a relatively small amount of data provides nearly as good an answer as downloading a larger amount of data. This information is useful in determining how to use the available bandwidth most effectively Uniform Access We first consider the case where all objects were requested by the same number of clients. Figure 4 plots the Average Score versus the upper bound on the number of data units downloaded. The solid line shows the case where larger objects had higher Cache Recency Score values in the cache, i.e. there is a positive correlation between Object Size and Cache Recency Score. The dashed line shows the case where larger objects had lower values of Cache Recency Score, i.e. a negative correlation. The dashdot line shows a case where Cache Recency Score and Object Size were uncorrelated. Figure 4 shows that Average Score increases rapidly and then levels off when the large objects have the highest Cache Recency Score values (solid line). In contrast, when the largest objects have the lowest Cache Recency Score (dashed line) values, Average Score increases gradually. The uncorrelated case (dashdot line) lies in between these two. When the upper bound on the number of data units downloaded is low, only smaller objects will be downloaded. As the upper bound increases, it is possible to download an increasing number of large objects. Thus, when the large objects are the ones with the highest Cache Recency Score values, the Average Score will increase dramatically when small objects are downloaded, and it will level off as larger objects are downloaded. In contrast, when the larger objects have lower Cache Recency Score values (dashed line), there is less benefit to downloading small objects. However, there is an increasing benefit to downloading the larger objects with the lower Cache Recency Score values. Thus, the Average Score continues to increase as the number of units of data downloaded is increased Skewed Access Next, we study the effect of skew in the number of users requesting each object. A hot object is one that is requested by many users, i.e. its value for N um Requests is high. We control skew by varying the correlation between N um Requests and Object Size. Figure 5 plots the Average Score versus number of units of data downloaded when there is a correlation between Object Size and N um Requests. In both Figure 5(a) and Figure 5(b), when no data is downloaded, the scores vary due the differences in correlations between Cache Recency Score and Object Size. All objects accessed equally large objs high scores large objs low scores no correlation Figure 4. Effect of correlations between Object Size and Cache Recency Score when all objects are requested equally Figure 5(a) shows the case when the smaller objects are the hottest, i.e. there is a negative correlation between N um Requests and Object Size. For the solid line, large objects have the highest Cache Recency Score values. Since the small objects are the hottest, when no data was downloaded the Average Score was lowest. The Average Score values converge very quickly. The corner of the dotted rectangle indicates the point where the scores of all three cases are greater than. There is not a significant increase in the score once 2000 units of data are downloaded. This analysis suggests that when small objects are the hottest, there may not be a significant benefit to downloading a large amount of data. Figure 5(b) shows the case when the large objects were hottest. As the number of units of data downloaded increases, the Average Score increases steadily in all cases. The scores do not approach until about 3500 units of data are downloaded, as shown by the corner of the dotted rectangle in the figure. This suggests that when large objects are hottest, there is an increasing benefit to downloading a large amount of data. The next set of analytical results studies the effect of a positive or negative correlation between Object Size and Cache Recency Score. Figure 6(a) plots Average Score versus the upper bound on number of units of data downloaded when small objects have the highest Cache Recency Score values, and large objects have the lowest. In this case, Average Score increases steadily independent of the positive or negative correlation between Object Size and N um Requests. Thus, there is a significant benefit to downloading a larger number of units of data, especially when the large objects are hotter (solid line). The scores of all three do not reach until a

7 (a) Small objects hot (a) Small objects have highest recency scores large objs high scores large objs low scores no correlation large objects hot small objects hot uniform access (b) Large objects hot (b) Large objects have highest recency scores large objs high scores large objs low scores no correlation Figure 5. Effect of correlations between Object Size and Num Requests large objects hot small objects hot uniform access Figure 6. Effect of correlations between Object Size and Cache Recency Score large amount of data is downloaded, as shown by the dotted rectangle. There is a significant benefit to downloading as much as 4000 units of data. Figure 6(b) shows the case where large objects have a higher Cache Recency Score. The Average Score values for all three cases (correlations between Object Size and N um Requests) converge very quickly. Note that all three curves are similar to those shown in Figure 5(a). The corner of the dotted rectangle indicates the point where the scores for all three exceed, which occurs when about 2000 units of data are downloaded. This suggests that when large objects have the highest Cache Recency Score values, there may not be a significant benefit to downloading large amounts of data. 5 Related Work There has been much work on data dissemination that addresses the issue of which pages to broadcast to a set of clients in a limited bandwidth environment [4, 5, 6, 7, 8]. This work is similar to ours in that multiple clients share limited downlink bandwidth. However, this work assumes that data cached at the base station is up-to-date. In contrast, we consider the problem of providing the most recent data to clients when data cached at the base station may be stale. The work in Broadcast Disks [4, 5, 6] that is most similar to ours is [6]. This introduces a pull-based backchannel which allows clients to explicitly request data that will not be broadcast for a long period of time. As in our work, a client must choose whether or not to access data remotely. In our work, if data is not accessed remotely, the cached copy will be used instead. Similarly, in [6], if data is not requested via the backchannel, clients must wait for it to be broadcast. Another similarity is that there is contention among all clients for the available pull bandwidth. When a client sends a request via the backchannel, it is queued with other requests. In our work, a similar problem arises due to contention among clients for the fixed network bandwidth. Another focus of work in data dissemination is cache consistency. Work in [5, 7, 8] addresses the issue of how to maintain consistent data in client caches when there are updates at the server. All of these works assume that servers can push information to clients, while our environment is pull-based. Work in [5] extends broadcast disks to handle

8 updates to pages. In [8] a server periodically broadcasts invalidation reports to clients to tell them which data has been updated. Work in [7] describes a weaker type of consistency which is similar to what we propose. It introduces the term quasi-copy, a cached value that is allowed to deviate from a server value in a controlled way. For example, a client querying stock prices may be satisfied with cached stock prices that are within 5 percent of actual prices. This is similar to our work which allows users to specify the desired degree of recency of cached data. Work in [] describes strategies to maintain the recency of cached data in the presence of updates at the remote servers. This work assumes that all requested objects will be read from the cache, and the goal is to maximize the overall recency of the data in the cache at any point in time. This is similar to the asynchronous strategy we describe. The authors provide techniques to keep the cached data as up-todate as possible. In our analysis of the on-demand approach, we have shown that it is possible to provide more recent data by downloading some requested objects. The benefit is greater with higher update frequency and bandwidth limitations. Further, [] does not consider the popularity of objects, and therefore may waste bandwidth by downloading objects that will not be requested by any clients. There is relevant work on Web caching and replication that aims to reduce latency and bandwidth usage in Web environments. Research reported in Harvest [0] and in [9], as well as several commercial products, for example Akamai s FreeFlow [], Inktomi s TrafficServer [3], and CacheFlow [2] aim to reduce latency and bandwidth consumption on the internet by replicating web content in multiple locations. These products offer a solution when the Internet itself is a bottleneck, i.e. the cause of latency is network congestion. 6 Conclusions and Future Work We have identified a challenge that arises in mobile computing environments when multiple clients in a cell connect to a single base server. To access objects from remote servers, clients send requests to the base station and the base station downloads the objects from the remote servers. In such an environment, it may be inefficient for a base station to download all data from remote servers. Mobile clients must rely on less recent data cached at the base station to answer some requests. We have shown that asynchronously updating a cache may waste bandwidth and may not provide the most recent data to clients. We have proposed an ondemand approach to determine which objects to download and which to read from a cache to answer a given set of requests. We have shown that our approach maps to the knapsack problem, and we have studied how the quality of the solution changes for varying client access patterns and recency of cached data. In future work, we will develop techniques to determine how much data the base station should download to satisfy a set of requests. The techniques will use knowledge of the current workload and recency of cached data to determine an upper bound on the amount of data to download. Our analysis shows that under some circumstances there is not a great benefit to downloading large amounts of data. In these cases the techniques will choose a smaller upper bound. Another area of future work is developing caching policies when cache space at the base station is limited. In this case, the problem is not only what data to download, but also what data to cache. We will consider cache replacement policies based on client requests and knowledge of server updates. Our analysis has shown the effect of the cache state on the recency score of a set of requests, and may provide some insights into effective caching policies. 7 Acknowledgements We thank Bobby Bhattacharjee, Selcuk Candan, Mike Franklin, and Samir Khuller for their feedback. References [] [2] [3] [4] S. Acharya, R. Alonso, M. Franklin, and S. Zdonik. Broadcast disks: Data management for asymmetric communication environments. Proc. ACM SIGMOD Conf., 995. [5] S. Acharya, M. Franklin, and S. Zdonik. Disseminating updates on broadcast disks. Proc. VLDB Conf., 996. [6] S. Acharya, M. Franklin, and S. Zdonik. Balancing push and pull for data broadcast. Proc. ACM SIGMOD Conf., 997. [7] R. Alonso, D. Barbara, and H. Garcia-Molina. Data caching issues in an information retrieval system. ACM. TODS Vol. 5, no. 3, 990. [8] D. Barbara and T. Imielinski. Sleepers and workaholics: Caching strategies in mobile environments (extended version). VLDB Journal Special Issue of the best of SIGMOD System-Oriented Papers, 995. [9] A. Bestavros, R. Carter, M. Crovella, C. Cunha, A. Heddaya, and S. Mirdad. Application-level document caching in the internet. Proc. 2nd Workshop on Services in Distributed and Networked Environments, 995. [0] A. Chankhunthod, P. Danzig, C. Neerdaels, M. F. Schwarz, and K. Worrell. A hierarchical internet object cache. Proc. USENIX Technical Conference, 996. [] J. Cho and H. Garcia-Molina. Synchronizing a database to improve freshness. Proc. ACM SIGMOD Conf., [2] T. Imielinski and B. Badrinath. Mobile wireless computing. Communications of the ACM, October 994. [3] S. Martello and P. Toth. Knapsack Problems: Algorithms and Computer Implementations. John Wiley and Sons, Chichester England, 990.