22.1.3. Cost of Page Faults

The cost of page faults is very high. If you have a miss in the main memory you have to go to physical memory. And we saw that this could be very high up to 100s of times slower, 1000s of times slower than accessing the main memory.

A page fault occurs when a program attempts to access a page that is not currently in physical memory, prompting the system to fetch the required page from disk storage. This operation is slow, as accessing the disk can be hundreds to thousands of times slower than accessing RAM. Therefore, the cost associated with page faults can significantly affect system performance.

Think of a page fault as if you were searching for a book in a library, but instead of just walking to a nearby shelf, you have to leave the library and go to an off-site warehouse to retrieve it. This process takes much longer compared to simply grabbing it from the shelf, illustrating how much more time-consuming it is to handle page faults.

So, we need techniques towards reducing the miss penalty. So, we don’t want to go into the disk. So, we have techniques, we have to have techniques that reduce chances of going to the disk. We use large page tables to take advantage of the spatial locality.

To mitigate the high cost of page faults, several strategies can be implemented. One such strategy is the use of large page tables that leverage spatial locality. Spatial locality refers to the tendency of a program to access data that is located close together in memory. By using large pages, the system can reduce the number of page accesses and thus minimize the likelihood of page faults.

Imagine a news article that references multiple images. Instead of fetching each image separately, it’s more efficient to access an entire section of images at once. This way, you're optimizing the process by reducing the number of times you need to retrieve items, similar to how large page sizes optimize memory access.

Mapping between virtual addresses to physical addresses is made fully associative so that a page can potentially be mapped to any page frame.

The concept of fully associative mapping allows a page to be placed into any available frame in the physical memory. This flexibility helps improve the chances of finding a space for a page in memory. Since the mapping isn’t restricted, it increases the chances of utilizing available memory effectively, thereby reducing misses.

Consider a box that can hold toys of various shapes and sizes. Instead of having designated spots for specific toys, you can place any toy into any empty space within the box. This adaptability allows you to maximize the space used efficiently, just as fully associative mapping enhances memory utilization.

Use of efficient page replacement algorithms must be used, such as the second chance page replacement which approximates LRU by using FIFO along with the reference bit.

Page replacement algorithms are critical for managing which pages stay in memory and which are evicted. The Second Chance algorithm, for example, checks the usage of pages and grants them a 'second chance' if they've been accessed recently. This helps ensure that frequently used pages remain in memory while less frequently used pages are replaced, which optimizes memory performance.

Imagine a queue at a coffee shop where regular customers get a 'second chance' to order their favorite drink if they didn't get a chance on their last visit. This way, the staff can prioritize loyal customers while still serving new ones efficiently.

Writes into the disk are very expensive. So, we use a write back mechanism instead of write through.

The write-back mechanism allows the system to delay writing data back to the disk until the page is replaced. This minimizes expensive disk writes and helps maintain better performance. Instead of continuously writing every change to disk (which is called write-through), updates are held in memory until it's necessary to write them back.

Consider a student taking notes in a notebook. The student may write quickly without worrying about transferring those notes to a digital device immediately. Once the notes are finalized, the student can then upload them all at once, saving time and effort, akin to how write-back saves on disk writes.

If a process routinely accesses more virtual memory than it has physical memory due to insufficient physical memory it suffers thrashing as we saw.

Thrashing occurs when a system spends more time swapping pages in and out of memory than executing the program itself. This typically happens when the physical memory is insufficient to hold the working set of the program, which leads to excessive paging. Solutions include increasing the physical memory allocated to a process or using better algorithms to improve the program's locality.

Imagine a busy restaurant where the kitchen is always sending plates back to the dishwashing station, only to find that they haven’t cleaned enough dishes to serve the next round of customers. The restaurant ends up wasting time and effort rather than serving food. In this analogy, the overflowing dishwashing process represents thrashing, while having extra clean dishes ready would reduce the issue.

--