20.2.2. Explanation of LRU

Now we will try to see in more detail why this happens? Now the reason for Belady’s anomaly has been found to be this; pages in memory at any given time for the stipulated number of frames is not always a subset of the pages when the number of frames become higher.

Belady’s anomaly occurs when increasing the number of memory frames results in an unexpected increase in the number of page faults. The core reason is that the pages present in memory with fewer frames may not be a subset of the pages present when more frames are available. This means that sometimes, having fewer frames can actually lead to fewer faults, contradicting our assumptions about the benefits of more memory.

Imagine you have a small basket that can hold three items (frames). If you try to pick items (pages) randomly and you can only keep three, sometimes you may end up with items that fit perfectly, causing no issues. Now, if you increase your basket’s capacity to four but end up picking items that require five spaces to fit comfortably, you could end up excluding an item you really need, thereby creating confusion – this is similar to what happens with Belady's anomaly.

We will take an example; we will take the example of this reference string and see why and how this happens.... the references shown here, 1 2 3 4 1 2 5 1 2 3 4 5.

We analyze a reference string of pages (1, 2, 3, 4, 1, 2, 5, etc.) over time. Each reference can result in a page fault (when the requested page is not in memory) or a hit (when it is in memory). Using a FIFO policy, we observe how pages are replaced in memory. This example illustrates how, under certain conditions, increasing the number of frames leads to more page faults.

Think of a library where students can borrow books (pages) to read. With three study tables (frames), they can share and use the space efficiently. But if you add a fourth table but still try to read the same number of books, you might end up creating more clutter in your study area, losing track of important books, leading to confusion – akin to having more frames causing more page faults.

We see that when you have 3 frames in memory, the number of page faults are 9; you have 3 hits. And when you have 4 frames in memory, you have only 2 hits. So, therefore, you have 10 page faults; here you have 9 faults and here you have 10 faults.

In our example, we calculated the number of page faults for configurations with 3 and 4 memory frames. With 3 frames, there were 9 faults, while with 4 frames, there were 10 faults. This indicates that although we have more memory available, the actual performance can worsen due to how pages are replaced based on algorithms and policies.

If you go to a buffet with the same number of courses each time (3 frame configuration) and can serve yourself perfectly, it's seamless. However, if an additional course is added but not enough serving spoons (frames), you end up in more confusion and run back and forth, making the experience clumsier – mirroring increasing faults with a wrong configuration.

The pages in physical memory at any given time.... For example, here 5 2 3 4 is not a superset of 5 1 2...

In memory management, at any given time, the set of pages present in physical memory may not always align perfectly when the number of frames increases. This illustrates how, when accessing pages like '1' or '2', their availability depends on the current state of memory, leading to hits or misses based on the configuration. Hence, the structure of memory usage affects page fault occurrence.

Imagine you're participating in a game that requires the use of tokens (pages) to play. If you hold onto a set of tokens (5 1 2) but need different ones (5 2 3 4) when more friends join in, you might not have the right token at hand – thus leading to a loss or fault in the game. Your ability to play efficiently depends on having the right tools available.

The optimal algorithm and LRU both do not exhibit Belady’s anomaly. The optimal algorithm always maintains the most frequently used pages to be accessed in future.

Both the least recently used (LRU) and optimal algorithms are designed to optimize page replacement effectively without experiencing Belady’s anomaly. They maintain the most recently or frequently accessed pages to enhance memory management and minimize page faults, proving efficiency regardless of frame count.

Picture a closet with storage boxes where you store your most-used items at the front. If you always keep the items you need most regularly (like LRU) or anticipate what you will need next (like the optimal algorithm), your storage stays organized, and you avoid searching endlessly for things – similar to reducing faults in memory management.

--