Page Cache Research Articles

A web page usage prediction scheme using sequence indexing and clustering techniques

In this paper we consider the problem of web page usage prediction in a web site by modeling users’ navigation history and web page content with weighted suffix trees. This user’s navigation prediction can be exploited either in an on-line recommendation system in a web site or in a web page cache system. The method proposed has the advantage that it demands a constant amount of computational effort per one user’s action and consumes a relatively small amount of extra memory space. These features make the method ideal for an on-line working environment. Finally, we have performed an evaluation of the proposed scheme with experiments on various web site log files and web pages and we have found that its quality performance is fairly well and in many cases an outperforming one.

Improving energy efficiency for flash memory based embedded applications

The JFFS2 file system for flash memory compresses files before actually writing them into flash memory. Because of this, multimedia files, for instance, which are already compressed in the application level go through an unnecessary and time-consuming compression stage and cause energy waste. Also, when reading such multimedia files, the default use of disk cache results in unnecessary main memory access, hence an energy waste, due to the low cache hit ratio. This paper presents two techniques to reduce the energy consumption of the JFFS2 flash file system for power-aware applications. One is to avoid data compression selectively when writing files, and the other is to bypass the page caching when reading sequential files. The modified file system is implemented on a PDA running Linux and the experiment results show that the proposed mechanism effectively reduces the overall energy consumption when accessing continuous and large files.

Controlling Control Flow in Web Applications

Control flow is often key problem in current web applications. For example, using the back button gives a POSTDATA error, using multiple windows books the wrong hotel, and sending a link to a friend does not work.Previous solutions used continuations as a model for user interaction. However continuations are insufficient as a model of all web interactions. We believe the protocol and browsers themselves are insufficiently powerful to represent the control flow desired in a web application.Our solution is to extend the protocol and browser sufficiently that these problems can be avoided. We seek to be agnostic about how web applications are written and instead recognise that many of the problems stem from underlying weaknesses in the protocol.As an example, the application ought to be able to inform the browser that pressing back on a payment confirmation page is not allowed. Instead, the cached page can be displayed in a read-only, archive fashion to the user, or a new page can be shown instead which is consistent with the global state.We discuss how some of these ideas may be implemented within the existing HTTP/1.1 protocol; and what modest extensions to the protocol would enable full implementation. We also discuss the interaction with Web 2.0 and the security and privacy implications of our extensions.

SWL

As mobile phones become increasingly multifunctional, the number and size of applications installed in phones are rapidly increasing. Consequently, mobile phones require more hardware resources such as NOR/NAND flash memory and DRAM, and their production cost is accordingly becoming higher. One candidate solution to reduce production cost is demand paging using MMU. However, demand paging causes unpredictably long page fault latency, and as such mobile phone manufacturers are reluctant to deploy this scheme. In this paper, we present a method that reduces the long latency of page faults by performing page fault handling in a parallelized manner, considering the characteristics of NAND-Type flash memory. We also discuss how to modify the existing page cache replacement policies so that they can exploit the benefits of the parallelized page fault handler. Experimental results show that the parallelized page fault handler improves the worst case latency of page faults significantly, by up to roughly 20%, and that the modified page cache replacement policies improve both the average and worst instruction fetch time.

Cooperative Client-Side File Caching for MPI Applications

Client-side file caching is one of many I/O strategies adopted by today's parallel file systems that were initially designed for distributed systems. Most of these implementations treat each client independently because clients' computations are seldom related to each other in a distributed environment. However, it is misguided to apply the same assumption directly to high-performance computers where many parallel I/O operations come from a group of processes working within the same parallel application. Thus, file caching could perform more effectively if the scope of processes sharing the same file is known. In this paper, we propose a client-side file caching system for MPI applications that perform parallel I/O operations on shared files. In our design, an I/O thread is created and runs concurrently with the main thread in each MPI process. The MPI processes that collectively open a shared file use the I/O threads to cooperate with each other to handle file requests, cache page access, and coherence control. By bringing the caching subsystem closer to the applications as a user space library, it can be incorporated into an MPI I/O implementation to increase its portability. Performance evaluations using three I/O benchmarks demonstrate a significant improvement over traditional methods that use either byte-range file locking or rely on coherent I/O provided by the file system.

User data persistence in physical memory

In this paper we present the results of experiments we conducted on Suse Linux and Windows XP systems to determine the age of user process data in physical memory. To be able to measure the age of pages we used an artificial load program which time-stamps data segment and block device cache pages. Our goal was to compare the behaviour of both systems and to determine whether the rate of decay for user data depends on the demand for physical memory. Our findings show that Windows and Linux systems preserve almost the same number of pages with user data, and the age distribution of these pages does not change significantly with the level of demand.

Protect your users against the latest web-based threat: malicious code on caching servers [Your Internet Connection

Internet security threats are continually evolving as hackers try to stay ahead of countermeasures. In the last two years, a growing number of hackers have shifted their focus from straight-on firewall assaults and virus-laden emails - although these threats are not entirely things of the past - to Web-based attacks that expose Web site visitors to spyware, phishing scams, viruses, trojans, and other malicious code. An especially insidious new threat to Web users is the existence of malicious content residing in cached Web pages on storage and caching servers, such as those used by leading search engine providers, Web 2.0 sites, and Internet service providers (ISPs). This paper discusses the step-by-step process describing the infection method using search engine caching servers. The three examples of the type of Web threat, based on a recent analysis of Web pages on public storage and caching servers of three popular search engine providers are presented

Caching and prefetching algorithms for programs with looping reference patterns

We present a thorough analysis of the memory behaviour of page caching and prefetching algorithms. The analysis is restricted to programs whose execution consists of iteration of a sequence of page accesses. Program activity is characterized in terms of utilization of system resources. A graphical model of program execution is used to describe both page placement in the primary memory and the actions of page fetch and replacement. The algorithms are compared from the point of view of a number of performance indexes that include program response time and utilization of the secondary memory system. Special attention is paid to transient program behaviour and the effects of the time necessary for the processor to control the disk activities of page fetch. The results of a large set of measurement experiments are used to validate the analytical model and acquire significant indications concerning the extent of the simplifying assumptions made in the theoretical analysis. The discussion of the relation to previous work makes special reference to two classes of algorithms that received much attention in the past, aggressive prefetching and informed prefetching.

Bridging the generation gap

The demand for mobile service increase many service providers which they start finding solutions for integrating third and fourth generation networks and to develop mobility protocols. This article introduces the macromobility, micromobility, and ad hoc routing protocols the Internet Engineering Task Force (IETF) has discussed. The aim is to familiarize readers with various mobility protocols, point out differences, and generate interest to pursue research. Cellular IP can perform handoffs in a number of ways, and it uses an efficient paging technique. To achieve this, it uses two mappings: paging cache (PC) and routing cache (RC). PCs are used only to search for (mobile node) MNs while RCs are used to route data to the MNs. Micromobility protocols complement MIP by reducing signaling overheads and enabling faster handoffs for seamless connectivity. These protocols handle local movements of MN without any interaction with MIP. It reduces the bandwidth consumption and another advantage of reducing signaling overheads is that it helps to conserve the power reserves of MNs.

Multitiered Cache Management and Acceleration for Database-Driven Websites

Response time is a key differentiation point among electronic commerce (e-commerce) applications. For many e-commerce applications, web pages are created dynamically based on the current state of a business stored in database systems. To improve the response time, many e-commerce websites deploy caching solutions for acceleration of content delivery. There are multiple tiers in the content delivery infrastructure where cache servers can be deployed, including (1) data caching (in data centers), (2) content page caching (in edge or front end caches), and (3) database query result set caching (between application servers and DBMS). The architecture of database-driven e-commerce websites is more complex than that of typical websites. It requires the integration of web servers, application servers, and back end database systems as well as dynamic content caching solutions. In this paper, the issues associated with the management of content page caching and database query result set caching tiers are studied. It is observed that caching management for these two tiers have their unique characteristics. It is because cached object types and information available for the caching management in the two tiers are different. Solutions are proposed for effective caching management for each tier and extensive evaluations are conducted. The experimental results show the usefulness of the technology in improving overall system performance.

Mining interesting knowledge from Web-log

Web-log contains a lot of information related with user activities on the Internet. How to mine user browsing interest patterns effectively is an important and challengeable research topic. On the analysis of the present algorithm’s advantages and disadvantages we propose a new concept: support-interest. Its key insight is that visitor will backtrack if they do not find the information where they expect. And the point from where they backtrack is the expected location for the page. We present User Access Matrix and the corresponding algorithm for discovering such expected locations that can handle page caching by the browser. Since the URL-URL matrix is a sparse matrix which can be represented by List of 3-tuples, we can mine user preferred sub-paths from the computation of this matrix. Accordingly, all the sub-paths are merged, and user preferred paths are formed. Experiments showed that it was accurate and scalable. It’s suitable for website based application, such as to optimize website’s topological structure or to design personalized services.

The influence of caching on web usage mining

Most web servers collect lots of data during their daily operation. Information, such as which pages are requested and who is responsible for these requests, is stored in log files. The analysis of these log files may yield worthwhile information on how to adapt the site to improve the user experience. However, the data in the log files is usually not stored in a format suited to perform analyses. Many operations are needed to transform the logs in a format that is convenient for the chosen type of analysis. After an overview of these operations, we will discuss how caching of pages can skew the results of studies. We will show how caching can be detected and how one can deal with it. Afterwards, the techniques are applied to the data of a European online wine shop.

On Staleness and the Delivery of Web Pages

A popular technique to improve the scalability of a web based system is caching at proxy servers. Caching has the drawback that a cached page becomes stale when the page is updated at the web server. In some cases, staleness may not be completely avoided because the server may not wish to expend the processing and communication resources required to transmit all the updates immediately. In general, if updates are transmitted less frequently, the staleness will tend to increase, but the amount of resources consumed will be reduced. The tradeoff between resource consumption and staleness is investigated. A measure of staleness is defined and optimization problems are formulated. The solutions to these problems allow one to come up with an optimal strategy for transmitting page updates. Numerical examples showing the resource consumption/staleness tradeoff are presented.

Optimizing Traffic in DSM Clusters: Fine-Grain Memory Caching versus Page Migration/ Replication

In this paper we compare and contrast two techniques to improve capacity/conflict miss traffic in CC-NUMA DSM clusters. Page migration/replication optimizes read-write accesses to a page used by a single processor by migrating the page to that processor and replicates all read-shared pages in the sharers' local memories. R-NUMA optimizes read-write accesses to any page by allowing a processor to cache that page in its main memory. Page migration/replication requires less hardware complexity compared with R-NUMA, but has limited applicability and incurs much higher overheads even with tuned hardware/software support. In this paper we compare and contrast page migration/replication and R-NUMA on simulated clusters of symmetric multiprocessors executing shared-memory applications. Our results show that: (1) both page migration/replication and R-NUMA significantly improve the system performance over first-touch migration in many applications, (2) page migration/replication has limited opportunity and cannot eliminate all the capacity/conflict misses even with fast hardware support and unlimited amount of memory, (3) R-NUMA always performs best given a page cache large enough to fit an application's primary working set and subsumes page migration/replication, (4) R-NUMA benefits more from hardware support to accelerate page operations than page migration/replication, and (5) integrating page migration/replication into R-NUMA to help reduce the hardware cost requires sophisticated mechanisms and policies to select candidates for page migration/replication

The bigwig Project

We present the results of the <tt><bigwig></tt> project, which aims to design and implement a high-level domain-specific language for programming interactive Web services.<br /> <br />A fundamental aspect of the development of the World Wide Web during the last decade is the gradual change from static to dynamic generation of Web pages. Generating Web pages dynamically in dialogue with the client has the advantage of providing up-to-date and tailor-made information. The development of systems for constructing such dynamic Web services has emerged as a whole new research area.<br /> <br />The <tt><bigwig></tt> language is designed by analyzing its application domain and identifying fundamental aspects of Web services inspired by problems and solutions in existing Web service development languages. The core of the design consists of a session-centered service model together with a flexible template-based mechanism for dynamic Web page construction. Using specialized program analyses, certain Web specific properties are verified at compile-time, for instance that only valid HTML 4.01 is ever shown to the clients. In addition, the design provides high-level solutions to form field validation, caching of dynamic pages, and temporal-logic based concurrency control, and it proposes syntax macros for making highly domain-specific languages. The language is implemented via widely available Web technologies, such as Apache on the server-side and JavaScript and Java Applets on the client-side. We conclude with experience and evaluation of the project.

Dynamic location problems with limited look-ahead

The following problem arose in connection with studies of Internet web page caching. The general setting is as follows: In some fixed metric space M , k “servers” S1, . . . , Sk are given with some arbitrary initial locations in M . Requests for service at certain points σ1, σ2, σ3, . . . , σN , in M arrive over time. Immediately after request σt is received, exactly one of several mutually exclusive actions must be taken: (i) Some server is moved to σt, with a resulting cost of c(σt), the “cost” of the point σt. (ii) No server moves. In this case, the cost for “no service” is defined to be mink d(Sk, σt), where d(x, y) denotes the distance between x and y in M . A further feature of our model is that two parameters u,w ≥ 0 are specified, which are used as follows. Before having to decide how to service request σt, the servers have at their disposal the knowledge of the u+ w requests σi with t− u ≤ i ≤ t+ w − 1. Thus, the servers can only ”remember” or store the past u requests σt−u, σt−u+1, . . . , σt−1 but are allowed to know the w future requests σt, σt+1, . . . , σt+w−1 before having to service σt. The rules which govern the choices made for servicing all the σt define some algorithm A. In this model, A is deterministic and can only depend on the values of the σi which it currently knows, and nothing else. In particular, A is not allowed to make probabilistic choices based on some source of randomness. We denote by A(σ), the cost of servicing the request sequence σ = (σ1, . . . , σN ). Of course, if we are allowed to know all the σt before having to act, it is very likely the cost of servicing σ can be decreased. Let us denote by OFF(σ) the minimum possible cost of ∗University of California, San Diego †Research supported in part by NSF Grant No. DMS 98-01446 ‡Research supported in part by Bell Communications Research, Morristown, New Jersey §University of California, San Diego ¶AT&T Labs, Florham Park, New Jersey

Dynamic data prefetching in home-based software DSMs

A major overhead in software DSM (Distributed Shared Memory) is the cost of remote memory accesses necessitated by the protocol as well as induced by false sharing. This paper introduces a dynamic prefetching method implemented in the JIAJIA software DSM to reduce system overhead caused by remote accesses. The prefetching method records the interleaving string of INV (invalidation) and GETP (getting a remote page) operations for each cached page and analyzes the periodicity of the string when a page is invalidated on a lock or barrier. A prefetching request is issued after the lock or barrier if the periodicity analysis indicates that GETP will be the next operation in the string. Multiple prefetching requests are merged into the same message if they are to the same host. Performance evaluation with eight well-accepted benchmarks in a cluster of sixteen Power PC workstations shows that the prefetching scheme can significantly reduce the page fault overhead and as a result achieves a performance increase of 15%–20% in three benchmarks and around 8%–10% in another three. The average extra traffic caused by useless prefetches is only 7%–13% in the evaluation.

Implementation and comparison of distributed caching schemes

Shared Web Caches allow multiple clients to quickly access a pool of popular web pages. An organization that provides shared caching to its web clients will typically have a collection of shared caches rather than a single cache. If a collection of shared caches is used, it is required to coordinate the caches so that all cached pages in the collection are shared among the clients of the organization. In this paper, two protocol schemes for coordinating the collection of shared caches are investigated. The first scheme is based on Internet Caching Protocol (ICP) (D. Wessels, K. Claffy, ICP and the Squid WebCache, National Laboratory for Applied Network Research, http://www.nlanr.net/(wessels/papers/icp-squid.ps.gz). In the ICP scheme, the web caches query other caches for the web pages and fetch the web pages from the neighbors if they have cached the requested page. The second scheme is the hash routing scheme in which the client (browser) has to find the hash value for the URL of the requested page and send the request to the corresponding cache server (D. Wessels, K. Claffy, IEEE Network magazine, November–December (1997); G. Thalur, C.V. Ravishankar, IEEE/ACM Trans. Networking (1997); V. Valloppillil, J. Cohen, Hierarchical HTTP Routing Protocol, Internet Draft, http://ww.nlanr.net/Cache/ICP/draft-vinod-icp-traffic-dist00.txt; Super proxy script, How to make Distributed Proxy Servers by URL Hashing, White Paper, http://naragw.sharp.co.jp/sps, August (1996)). These two schemes have been implemented, and compared with respect to the page retrieval latency and the adaptability of the cache servers when a peer cache server fails. Our analysis shows that the hash routing schemes have significant performance advantages over ICP with respect to the average latency under normal conditions but when failure rate of the cache server is significant the ICP provides good adaptability. Also, we observe that the hashing function used in the hash routing scheme must have certain features such as quick calculation of the hash value and uniform distribution of the web pages (among cache servers).

Improving performance of large physically indexed caches by decoupling memory addresses from cache addresses

Modern CPUs often use large physically indexed caches that are direct-mapped or have low associativities. Such caches do not interact well with virtual memory systems. An improperly placed physical page will end up in a wrong place in the cache, causing excessive conflicts with other cached pages. Page coloring has been proposed to reduce the conflict misses by carefully placing pages in the physical memory. While page coloring works well for some applications, many factors limit its performance. Page coloring limits the freedom of the page placement system and may increase swapping traffic. In this paper, we propose a novel and simple architecture, called color-indexed, physically tagged caches, which can significantly reduce the conflict misses. With some simple modifications to the TLB (translation look-aside buffer), the new architecture decouples the addresses of the cache from the addresses of the main memory. Since the cache addresses do not depend on the the physical memory addresses anymore, the system can freely place data in any cache page to minimize the conflict misses, without affecting the paging system. Extensive trace-driven simulation results show that our design performs much better than traditional page coloring techniques. The new scheme enables a direct-mapped cache to achieve hit ratios very close to or better than those of a two-way set associative cache. Moreover, the architecture does not increase cache access latency, which is a drawback of set associative caches. The hardware overhead is minimal. We show that our scheme can reduce the cache size by 50 percent without sacrificing performance. A two-way set associative cache that uses this strategy can perform very close to a fully associative cache.

Lookahead scheduling requests for multisize page caching

This paper studies the effects of reordering page requests for multisize page caching. First, we consider a model, where an input queue keeps requests which will be processed in the future. It is assumed that they arrive during the processing time of miss requests. We develop an efficient page replacement algorithm which shifts some page requests in the queue. Second, we analyze the miss ratios of two methods, the nonshifting method and our shifting method, under the semi-online model. The analysis assumes that the input/output ratio of the queue is in equilibrium. Third, we compare our method with the other algorithms by simulation.