Comparative Analysis of Page Replacement Algorithms

for Calculating Page Faults

 Introduction

Page replacement algorithms are essential in managing memory in operating systems,

especially when a process requires more pages than there are frames available in the
physical memory. When a process requests a page not currently in memory (causing a
"page fault"), the system must decide which page to replace. This choice significantly
impacts the system’s performance, as each page replacement can slow down processing.

In this report, we analyze three common page replacement algorithms—First-In-First-

Out (FIFO), Least Recently Used (LRU), and Optimal Page Replacement—and
discuss their characteristics, advantages, and limitations. By applying a sample page
reference string, we can observe how each algorithm performs in terms of page faults,
providing insight into their practical suitability for different workloads.

 Page Reference String Example

We use the following page reference string for this analysis: 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2,

with a frame size of 3.
1. First-In-First-Out (FIFO) Algorithm
 Methodology: The FIFO algorithm replaces the oldest page in memory, meaning the
page that has been in the system the longest, without considering how often or
recently it was accessed. This simplicity makes FIFO easy to implement, as it only
requires a queue to keep track of the pages in the order they entered.
 Explanation: FIFO’s simplicity is both its strength and its limitation. It’s
straightforward to implement and doesn’t require additional data structures or
complex tracking, making it suitable for systems where simplicity is a priority.
However, FIFO does not account for page usage frequency or recency, which can lead
to inefficient replacements. For instance, a page that will be needed soon might get
removed just because it has been in memory the longest.

Advantages:

 Easy to Implement: FIFO is one of the simplest algorithms, with minimal

computational and memory overhead.
 Low Resource Requirement: It doesn’t need to track recent usage, making it suitable
for low-power or embedded systems.

Disadvantages:

 Inefficient in Real-World Patterns: The lack of awareness about page usage

patterns can lead to frequent page faults in scenarios where some pages are accessed
repeatedly.
 Belady’s Anomaly: In some cases, adding more memory frames can actually increase
page faults, which is counterintuitive and shows FIFO’s limitations in handling real-
world memory access patterns.

Page Fault Count (for the example): 9 page faults

2. Least Recently Used (LRU) Algorithm

 Methodology: The LRU algorithm replaces the page that has not been accessed for
the longest period of time. This approach is based on the principle of temporal
locality, which assumes that pages used recently are likely to be used again soon. To
implement LRU, the system must track each page's last access time, typically
requiring a stack or linked list to efficiently manage this information.
 Explanation: LRU is a more sophisticated algorithm compared to FIFO, as it actively
adapts to access patterns by retaining recently used pages. It performs well in
applications where recent page access is a good predictor of future access, such as
web browsers and caching systems. However, LRU has a higher implementation
complexity and requires additional resources to maintain accurate tracking of page
usage history. This tracking can introduce extra computational overhead, especially if
there are many frames and frequent page accesses.

Advantages:

 Better Performance in Real-World Usage: By leveraging temporal locality, LRU

reduces page faults effectively in most practical scenarios.
 Avoids Belady’s Anomaly: LRU does not suffer from the counterintuitive increase in
page faults when adding more frames, providing more predictable performance.

Disadvantages:

 Increased Overhead: The need for data structures to track page usage makes LRU
more resource-intensive than FIFO, potentially impacting performance in systems
with limited processing power.

Page Fault Count (for the example): 7 page faults

3. Optimal Page Replacement Algorithm
 Methodology: The Optimal algorithm replaces the page that will not be used for the
longest period in the future. This approach provides the minimum possible number of
page faults for any page reference string, serving as a benchmark for evaluating other
algorithms. However, Optimal requires perfect knowledge of future page requests,
making it impractical in real-world systems.
 Explanation: Optimal is primarily used as a theoretical baseline rather than a
practical solution, as it requires future knowledge that’s not available in real-time
operating systems. In controlled or simulated environments where page access
patterns are predefined, Optimal can be used to establish the minimum achievable
page faults. This algorithm highlights the potential performance gap between
theoretically perfect replacements and practical, implementable strategies.

Advantages:

 Minimal Page Faults: By design, Optimal provides the fewest possible page faults
for a given reference string, making it the ideal benchmark for comparison.

Disadvantages:

 Impractical for Real-World Systems: Since it requires future knowledge, Optimal

cannot be implemented directly in dynamic, real-time environments.

Page Fault Count (for the example): 6 page faults (the minimum possible)
  Comparative Report Summary

Page
Algorithm Fault Advantages Disadvantages
Count

Simple and easy to

High page faults, especially in
implement; low
FIFO 9 bursty access patterns; suffers from
computational
Belady’s anomaly.
requirements.

Effective in real-world Higher resource demand for

LRU 7 scenarios due to temporal tracking usage history; complex
locality usage. implementation.

Provides the minimum page Impractical to implement, as it

Optimal 6 faults; serves as an ideal requires knowledge of future
benchmark. accesses.
Solved Example: consider the following page reference string
1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6
Compare the number of page faults for FIFO, LRU and optimal page replacement. Assume
number of frame is 4.

Sol. FIFO page replacement

4 4 4 4 4 4 1 1 1 1 1 1 2 2 2 2 2

3 3 3 3 3 3 2 2 2 2 2 6 6 6 6 6 6 6

2 2 2 2 2 2 6 6 6 6 6 7 7 7 7 7 7 3 3

1 1 1 1 1 1 5 5 5 5 5 3 3 3 3 3 1 1 1 1

H H H H H H

Total Page Fault = 14

LRU page replacement

4 4 4 4 6 6 6 6 6 7 7 7 7 1 1 1 1

3 3 3 3 5 5 5 5 5 3 3 3 3 3 3 3 3 3

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

1 1 1 1 1 1 1 1 1 1 1 1 1 6 6 6 6 6 6 6

H H H H H H H H H H

Total Page Fault = 10

Optimal page replacement

4 4 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6

3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

1 1 1 1 1 1 1 1 1 1 1 1 7 7 7 7 1 1 1 1

H H H H H H H H H H H H

Total Page Fault = 8

 Conclusion
This comparison highlights the trade-offs between simplicity, efficiency, and practical
feasibility among the three algorithms:

 FIFO is the simplest of the three and requires minimal resources, making it suitable for
environments where ease of implementation and low resource usage are primary
concerns. However, its lack of adaptability to access patterns can lead to high page fault
rates, especially in applications where some pages are frequently reused.
 LRU offers better performance in practical systems by accounting for recent usage
history, which aligns well with common access patterns in applications like caching and
file systems. However, this comes at the cost of additional memory and processing power,
as LRU requires data structures to track and update page usage. Despite this, LRU is
widely favored in operating systems because it effectively balances performance and
feasibility for most workloads.
 Optimal Page Replacement is a theoretical ideal, achieving the fewest page faults
possible for any sequence of requests. It provides a valuable baseline for evaluating other
algorithms, but it cannot be applied in real-world scenarios because it requires future
knowledge of page references. It remains useful for simulation and theoretical analysis,
helping to demonstrate the potential limitations of practical algorithms.

In summary, LRU is often the best practical choice for systems requiring efficient memory
management, while FIFO may be used in simpler systems where minimal overhead is
essential. Optimal serves as a benchmark, illustrating the maximum possible efficiency
gains. Understanding the characteristics of each algorithm allows system designers to select
the most appropriate page replacement strategy based on workload patterns, available
resources, and pesrformance requirements.

 References

https://chatgpt.com/
https://www.vbspu.ac.in/e-content/Page-Replacement-Algorithms.pdf
https://www.geeksforgeeks.org/page-replacement-algorithms-in-operating-systems