Page Replacement Policy Research Articles

Page Replacement with Multi-Size Pages and Applications to Web Caching

Abstract. We consider the paging problem where the pages have varying size. This problem has applications to page replacement policies for caches containing World Wide Web documents. We consider two models for the cost of an algorithm on a request sequence. In the first (the FAULT model) the goal is to minimize the number of page faults. In the second (the BIT model) the goal is to minimize the total number of bits that have to be read into the cache. We show offline algorithms for both cost models that obtain approximation factors of O(log k) , where k is the ratio of the size of the cache to the size of the smallest page. We show randomized online algorithms for both cost models that are O(log 2 k) -competitive. In addition, if the input sequence is generated by a known distribution, we show an algorithm for the FAULT model whose expected cost is within a factor of O(log k) of any other online algorithm.

A study of page replacement performance in garbage collection heap

Large number of page-faults can severely degrade the performance of any system. While much attention has been paid on the virtual memory space of an entire process, the paging behavior of one particular memory segment has not been reported. Unlike the static behavior in most of the memory segments, the heap segment has unique characteristics closely related to its memory management scheme. First, this paper presents a thorough study on the effect of heap page-faults on the performance of Kaffe JVM version 1.0.5 and the Kaffe Java virtual machine (JVM) with the modified buddy system. Second, a modified least recently used (mLRU) is proposed to improve the performance of the LRU page-replacement policy. Four different page-replacement policies, first-in-first-out (FIFO), Random, LRU and mLRU, are used to study the performance of each JVM. Third, the Java applications used in this study are SPECjvm98 benchmark suite. These programs represent real-world workload and are highly dynamic memory intensive. Fourth, an instrumented Kaffe JVM is used to generate memory traces. Then, a simulator is used to analyze and reconstruct the heap as the benchmark programs are executed. Finally, this study has shown that the modified buddy system has less page-fault occurrences in six out of eight applications. The improvement can be up to 74%. Moreover, the proposed mLRU can improve the performance up to 68.2%.

An optimality proof of the LRU- K page replacement algorithm

This paper analyzes a recently published algorithm for page replacement in hierarchical paged memory systems [O'Neil et al. 1993]. The algorithm is called the LRU- K method, and reduces to the well-known LRU (Least Recently Used) method for K = 1. Previous work [O'Neil et al. 1993; Weikum et al. 1994; Johnson and Shasha 1994] has shown the effectiveness for K > 1 by simulation, especially in the most common case of K = 2. The basic idea in LRU- K is to keep track of the times of the last K references to memory pages, and to use this statistical information to rank-order the pages as to their expected future behavior. Based on this the page replacement policy decision is made: which memory-resident page to replace when a newly accessed page must be read into memory. In the current paper, we prove, under the assumptions of the independent reference model, that LRU- K is optimal. Specifically we show: given the times of the (up to) K most recent references to each disk page, no other algorithm A making decisions to keep pages in a memory buffer holding n - 1 pages based on this infomation can improve on the expected number of I/Os to access pages over the LRU- K algorithm using a memory buffer holding n pages. The proof uses the Bayesian formula to relate the space of actual page probabilities of the model to the space of observable page numbers on which the replacement decision is acutally made.

Optimization of VLIW compatibility systems employing dynamic rescheduling

Lack of object code compatibility in VLIW architectures is a severe limit to their adoption as a general-purpose computing paradigm. Previous approaches include hardware and software techniques, both of which have drawbacks. Hardware techniques add to the complexity of the architecture, whereas software techniques require multiple executables. This paper presents a technique called Dynamic Rescheduling that applies software techniques dynamically, using intervention by the OS: at each first-time page fault, the page of code is rescheduled for the new generation, if required. Results are presented to demonstrate the viability of the technique using the Illinois IMPACT compiler and the TINKER architectural framework. For the machine models and the workloads used in this study, performance of the rescheduled code compares well with the native scheduled code for a machine. The behavior of a subset of programs in the workload is such that they face a large number of first-time page faults. Due to this, their rescheduling overhead is higher relative to their total execution time. Such programs are called high-overhead programs. Caching of translated pages across multiple invocations of the program to reduce the rescheduling overhead, using a persistent rescheduled-page cache (PRC) (1) discussed. It was found that for the workload used in this evaluation, a PRC of size between 512 to 1024 pages, and which uses an overhead-based page replacement policy would be effective in reducing the overhead.

System calls and interrupt vectors in an operating systems course

The introductory operating systems course has a tendency to appear to the student as a disparate collection of topics such as synchronization primitives, process scheduling algorithms, and page replacement policies. We describe a sequence of material to cover early in the operating systems course that prevents this tendency by clarifying the goal of the course and by providing a framework for understanding how the later course material is used in kernel design. The material centers around two concepts. First is the importance of the abstraction provided by the system call interface, that the kernel is the implementation of that interface, and the analogy with the instruction set interface the student has already encountered. Second is how the interrupt vector mechanism in a broad sense is central to how the kernel functions and underpins the actual implementation of many of the other topics in the course. Illustration through code from a real operating system kernel is a key feature of how this sequence makes clear the workings of an operating system.

Dismountable media management in tertiary storage systems

We describe an adaptive algorithm for tertiary storage media mount management. This predictive longest next reference mount management algorithm attempts to approximate the optimal page replacement policy, OPT.

Use Bit Scanning in Replacement Decisions

In paged storage systems, page replacement policies generally depend on a use bit for each page frame. The use bit is automatically turned on when the resident page is referenced. Typically, a page is considered eligible for replacement if its use bit has been scanned and found to be off on µ consecutive occasions, where µ is a parameter of the algorithm. This investigation focuses on the dependence of the number of bit-scanning operations on the value of µ and on properties of the string of page references. The number of such operations is a measure of the system overhead incurred while making replacement decisions. In particular, for several algorithms, the number of scans per reference is shown to be approximately proportional to µ However, empirical results from single-program traces show that the value of µ has little effect on the miss ratio. Although the miss ratios for the bit-scanning algorithms are close to those of least recently used (LRU), it is pointed out that increasing the value of µ need not bring the bit-scanning policies closer to LRU management.