SwiftCache: Model-Based Learning for Dynamic Content Caching in CDNs

We introduce SwiftCache, a "fresh" learning-based caching framework designed for content distribution networks (CDNs) featuring distributed front-end local caches and a dynamic back-end database. Users prefer the most recent version of the dynamically updated content, while the local caches lack knowledge of item popularity and refresh rates. We first explore scenarios with requests arriving at a local cache following a Poisson process, whereby we prove that the optimal policy features a threshold-based structure with updates occurring solely at request arrivals. Leveraging these findings, SwiftCache is proposed as a model-based learning framework for dynamic content caching. The simulation demonstrates near-optimal cost for Poisson process arrivals and strong performance with limited cache sizes. For more general environments, we present a model-free Reinforcement Learning (RL) based caching policy without prior statistical assumptions. The model-based policy performs well compared to the model-free policy when the variance of interarrival times remains moderate. However, as the variance increases, RL slightly outperforms model-based learning at the cost of longer training times, and higher computational resource consumption. Model-based learning's adaptability to environmental changes without retraining positions it as a practical choice for dynamic network environments. Distributed edge caches can utilize this approach in a decentralized manner to effectively meet the evolving behaviors of users.Comment: arXiv admin note: text overlap with arXiv:2401.0361

V-Cache: Towards Flexible Resource Provisioning for Multi-tier Applications in IaaS Clouds

Abstract—Although the resource elasticity offered by Infrastructure-as-a-Service (IaaS) clouds opens up opportunities for elastic application performance, it also poses challenges to application management. Cluster applications, such as multi-tier websites, further complicates the management requiring not only accurate capacity planning but also proper partitioning of the resources into a number of virtual machines. Instead of burdening cloud users with complex management, we move the task of determining the optimal resource configuration for cluster applications to cloud providers. We find that a structural reorganization of multi-tier websites, by adding a caching tier which runs on resources debited from the original resource budget, significantly boosts application performance and reduces resource usage. We propose V-Cache, a machine learning based approach to flexible provisioning of resources for multi-tier applications in clouds. V-Cache transparently places a caching proxy in front of the application. It uses a genetic algorithm to identify the incoming requests that benefit most from caching and dynamically resizes the cache space to accommodate these requests. We develop a reinforcement learning algorithm to optimally allocate the remaining capacity to other tiers. We have implemented V-Cache on a VMware-based cloud testbed. Exper-iment results with the RUBiS and WikiBench benchmarks show that V-Cache outperforms a representative capacity management scheme and a cloud-cache based resource provisioning approach by at least 15 % in performance, and achieves at least 11 % and 21 % savings on CPU and memory resources, respectively. I

Theory and Practice of Transactional Method Caching

Nowadays, tiered architectures are widely accepted for constructing large scale information systems. In this context application servers often form the bottleneck for a system's efficiency. An application server exposes an object oriented interface consisting of set of methods which are accessed by potentially remote clients. The idea of method caching is to store results of read-only method invocations with respect to the application server's interface on the client side. If the client invokes the same method with the same arguments again, the corresponding result can be taken from the cache without contacting the server. It has been shown that this approach can considerably improve a real world system's efficiency. This paper extends the concept of method caching by addressing the case where clients wrap related method invocations in ACID transactions. Demarcating sequences of method calls in this way is supported by many important application server standards. In this context the paper presents an architecture, a theory and an efficient protocol for maintaining full transactional consistency and in particular serializability when using a method cache on the client side. In order to create a protocol for scheduling cached method results, the paper extends a classical transaction formalism. Based on this extension, a recovery protocol and an optimistic serializability protocol are derived. The latter one differs from traditional transactional cache protocols in many essential ways. An efficiency experiment validates the approach: Using the cache a system's performance and scalability are considerably improved

Method-based caching in multi-tiered server applications

Abstract In recent years, application server technology has become very popular for building complex but mission-critical systems such as Web-based E-Commerce applications. However, the resulting solutions tend to suffer from serious performance and scalability bottlenecks, because of their distributed nature and their various software layers. This paper deals with the problem by presenting an approach about transparently caching results of a service interface\u27s read-only methods on the client side. Cache consistency is provided by a descriptive cache invalidation model which may be specified by an application programmer. As the cache layer is transparent to the server as well as to the client code, it can be integrated with relatively low effort even in systems that have already been implemented. Experimental results show that the approach is very effective in improving a server\u27s response times and its transactional throughput. Roughly speaking, the overhead for cache maintenance is small when compared to the cost for method invocations on the server side. The cache\u27s performance improvements are dominated by the fraction of read method invocations and the cache hit rate. Our experiments are based on a realistic E-commerce Web site scenario and site user behaviour is emulated in an authentic way. By inserting our cache, the maximum user request throughput of the web application could be more than doubled while its response time (such as perceived by a web client) was kept at a very low level. Moreover, the cache can be smoothly integrated with traditional caching strategies acting on other system tiers (e.g. caching of dynamic Web pages on a Web server). The presented approach as well as the related implementation are not restricted to application server scenarios but may be applied to any kind of interface-based software layers

DESIGN AND IMPLEMENTATION OF A HIGHLY MODIFIABLE RETAIL E-COMMERCE WEBSITE

The availability, modifiability, and performance of retail e-commerce websites(RECWEB) is greatly impacted by seasonal constraints. For many RECWEB, half of the calendar year is comprised of holidays and seasons. Spikes in website traffic and transactions can lower availability, modifiability, and performance of a RECWEB. This can result in downtime, customer abandonment, and ultimately lost revenue. This research focuses the modifiability aspects of the problem. During holiday and seasonal periods, enhancements to a RECWEB are generally not feasible. Enhancements put availability and performance at risk. In addition, most human resources are dedicated managing content changes. RECWEB are less modifiable then other systems because enhancements are only feasible for half of the calendar year. Furthermore, the scope of an enhancement must fit within a six month time box. This research provides pilot project for testing, designing, and implementing a highly modifiable RECWEB. The approach is to automate seasonal content changes. The cost savings on human resources can be reallocated to enhancements work. In addition, enhancements can simulate holiday seasons further in advance. The result is enhancement deployment is more feasible throughout the calendar year

AOP-Based Caching of Dynamic Web Content: Experience with J2EE Applications

Caching dynamic web content is an appealing approach to reduce Internet latency and server load. In aspect-oriented programming, caching is usually presented as an orthogonal aspect that could be automatically integrated to an application. A classical AOP motivating example is adding caching of static data with no underlying consistency. But what about caching dynamic data? In this paper, we explore the feasibility of aspectizing consistent caching of dynamically generated web documents. We use two J2EE web applications to validate our experiments: the TPC-W on-line bookstore and the RUBiS auction site. To the question "Can we consider consistent caching of dynamic web content as a separate aspect that could be transparently and efficiently integrated to a dynamic web application?", our conclusions are the following: (a) Just as in the classic AOP caching example having no consistency management, AOP provides a modular way to add caching having a strong consistency policy. (b) However, maintaining strong consistency on web pages results in prohibitively expensive run-time processing and, thus, any straightforward implementation in AOP is too slow. We propose an optimization that essentially eliminates all the run-time overhead in practice. (c) Furthermore, we identify in-stances where consistent web caching may not be orthogonal to J2EE applications, especially for those applications that rely on sophisticated web techniques (e.g., cookies). In summary, adding caching supporting strong consistency using AOP turned out to be an unexpected chal-lenge

Website Architecture and Web Programming Co-Design for Accelerating Highly Personalized Dynamic Web Pages Generation

Department of Computer Scienc

Managing Cache Consistency to Scale Dynamic Web Systems

Data caching is a technique that can be used by web servers to speed up the response time of client requests. Dynamic websites are becoming more popular, but they pose a problem –- it is difficult to cache dynamic content, as each user may receive a different version of a webpage. Caching fragments of content in a distributed way solves this problem, but poses a maintainability challenge: cached fragments may depend on other cached fragments, or on underlying information in a database. When the underlying information is updated, care must be taken to ensure cached information is also invalidated. If new code is added that updates the database, the cache can very easily become inconsistent with the underlying data. The deploy-time dependency analysis method solves this maintainability problem by analyzing web application source code at deploy-time, and statically writing cache dependency information into the deployed application. This allows for the significant performance gains distributed object caching can allow, without any of the maintainability problems that such caching creates