1. Overview

In this tutorial, we’ll discuss Belady’s anomaly in computer memory. We’ll explore different reasons as well as an example demonstrating the evidence of Belady’s anomaly.

Finally, we’ll present several mitigation techniques to handle this anomaly.

2. Introduction to Anomaly

In computer storage, an anomaly refers to any irregular behavior that deviates from the normal pattern of data storage, retrieval, or processing. Additionally, anomalies may arise from various causes, including hardware malfunctions, software errors, deliberate attacks, and natural calamities.

Examples of anomalies in computer storage include data corruption, file system errors, unauthorized access, network interruptions, and system crashes. Furthermore, these anomalies can lead to serious consequences such as loss of important data, system downtime, and security breaches.

In order to mitigate the risks of anomalies, we can implement several measures such as data backup, redundancy, access control, and monitoring. These measures ensure the integrity, availability, and security of data stored in the systems.

3. Belady’s Anomaly

Belady’s anomaly refers to a phenomenon that can happen while using page replacement algorithms to manage memory. It refers to the unexpected result of increasing the number of page faults. Page faults are the instances where a required page isn’t present in physical memory. Therefore, we need to fetch those pages from the disk.

As the number of page frames increases, the page replacement algorithms evict pages that would have remained in memory. Evicting the pages from the memory results in more page faults as the system struggles to find the required pages from the disk.

Belady’s anomaly exists in various page replacement algorithms. It mainly occurs in the first in, first out (FIFO) algorithm, which prioritizes pages that have been in memory for the longest time. In the FIFO, page faults may increase by increasing the number of frames.

However, other page replacement algorithms, such as the least recently used (LRU) algorithm, don’t exhibit this behavior. Therefore, algorithms that don’t exhibit irregular behavior are preferred for managing memory in modern computer systems.

Belady’s anomaly is a helpful reminder that the behavior of complex systems can sometimes be counterintuitive. Therefore, we need careful experimentation and analysis to fully understand their behavior.

4. Reasons for Belady’s Anomaly

Let’s discuss some reasons for the occurrence of Belady’s anomaly:

Beladys anomaly

Belady’s anomaly mainly occurs in the first in, first out (FIFO) algorithm. We store the data in computer systems in the sequence in which it’s allocated. Each location in the memory is associated with an assigned time. Therefore, we place the newly allocated data at the end of the new sequence. However, we place the data released from the program at the beginning. This leads to an anomaly in the system.

The predetermined size of the memory is also responsible for the anomaly. We generally use computer systems with a fixed amount of memory. Due to memory limitations, we sometimes delete the essential pages. This increases page faults and leads to Belady’s anomaly.

Additionally, random allocation and shifting of memory sequence can also cause anomalies in the memory.

Generally, there’re no precise reasons for the occurrence of Belady’s anomaly. It depends on the specific page replacement algorithm being used. However, the behavior of the algorithm can be affected by the size and access patterns of the memory pages. It also depends on how an algorithm picks to remove pages when memory is full.

5. Example

Let’s take an example of the FIFO page replacement algorithm to demonstrate Belady’s anomaly. In this example, we assume that no pages are loaded in the memory when we apply the FIFO algorithm. Let’s take a reference string: 3, 2, 1, 0, 3, 2, 4, 3, 2, 1, 0, 4. Additionally, we set the frame size to 3:

FIFO 3 frame

As we can see, the number of page faults (PF) is 9 here. Now let’s try to repeat the FIFO with the same reference string but with a different frame size. Now, we set the frame size to 4:

FIFO 4 frame

With the frame size 4, the number of page faults is 10. Therefore, the number of page faults increases when we increase the frame size. This example shows Belady’s anomaly in the FIFO algorithm.

6. Impact

The impact of Belady’s anomaly can vary depending on the specific system and page replacement algorithm being used. In general, it decreases the performance of the systems.

If a system is experiencing Belady’s anomaly, page faults increase. The page replacement algorithm evicts pages that would have otherwise remained in memory if fewer page frames were available. This can result in the degradation of system performance. Additionally, it increases the response time for user requests.

In some cases, Belady’s anomaly may not significantly impact system performance, particularly if the system isn’t heavily loaded. Additionally, if we’re using an advanced page replacement algorithm, the chances of the occurrence of an anomaly are significantly less. However, the anomaly can lead to significant performance issues in systems with a high memory workload or complex memory access patterns.

7. Mitigation Strategies

Belady’s anomaly is a fundamental characteristic of certain page replacement algorithms and can’t be eliminated entirely. However, we can utilize several strategies that can help us to mitigate the impact of the anomaly and improve system performance:


We can use a more advanced page replacement algorithm, such as the least recently used (LRU) algorithm. It doesn’t exhibit Belady’s anomaly. Additionally, we can utilize it to manage memory in systems where the anomaly is causing performance issues.

By reducing the size of memory pages or optimizing memory access patterns, it may be possible to improve the efficiency of the page replacement algorithm. As a result, we can minimize the impact of Belady’s anomaly.

Furthermore, it may be possible to identify the specific causes of Belady’s anomaly by closely monitoring system performance and analyzing the behavior of the page replacement algorithm under different conditions.

Finally, we can implement memory caching to minimize the impact of anomalies. Caching frequently accessed data in memory. It can help reduce the number of page faults and improve system performance, particularly in systems where Belady’s anomaly is causing performance issues.

8. Conclusion

In this article, we discussed Belady’s anomaly and an example demonstrating its existence in computer memory.

Additionally, we presented different reasons for the occurrence of it. Finally, we highlighted several mitigation techniques to handle this kind of anomaly.

Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.