22.1. Summary of Memory Sub-system Organization

Here we will summarize our discussion with Virtual Memory. Virtual memory may be described as the level of memory hierarchy that manages caching between the main memory and disk. Therefore, it allows main memory to act as a cache for the disk.

Virtual memory is a technique that helps manage the relationship between the fast main memory (RAM) and slower storage (like a hard disk). It allows the computer to treat both as levels of memory, where the main memory can temporarily store data that is also located on disk. This way, programs can access more memory than what is physically available in RAM by using disk space as an overflow.

Imagine a library where the main reading area can only hold a limited number of books. To manage this, some extra books are stored in a warehouse (the disk). When you need a book that is in the warehouse, the librarian fetches it and puts it on the reading table (the main memory) for you. This setup allows readers to have access to tons of books (data) without needing a huge reading area.

It provides; virtual memories provide address translation from virtual address, used by a program to the physical address space used to access memory. It allows a single program to expand its address space beyond the limits of the main memory.

Address translation is a crucial function of virtual memory. When a program needs to access data, it uses a virtual address, which is then translated to a physical address in the RAM. This translation allows the program to access more memory than is actually available, preventing it from crashing when it tries to use more memory than the physical RAM can hold.

Think of virtual addresses like room numbers in a hotel. Guests (programs) have a room number (virtual address), which can be different from the actual building number (physical address) where the hotel rooms are located. The hotel staff (the operating system) knows how to map room numbers to building numbers, allowing guests to find their rooms easily, even if some rooms are located far away.

It allows main memory to be shared among multiple active processes in a protected manner. How do you give this protection? It prevents this protection is given by preventing user programs from tampering with page tables so that only the OS can change virtual to physical address translations.

Memory protection is a security feature of virtual memory that ensures that one program does not interfere with another program’s memory. The operating system controls access to the memory and only it can modify the mappings between virtual addresses and physical addresses. This prevents one program from accessing or changing the data of another program.

Consider how a school keeps classroom doors locked (the page tables). Only authorized staff (the OS) have the keys to these doors, preventing students (user programs) from entering other classrooms and potentially causing chaos.

However, it also allows controlled sharing of pages between different programs. How? Controlled sharing is implemented with the help of OS and access bits in the page table that indicate whether a program has read or write access to a page.

Controlled sharing of memory is used in environments where multiple processes need to share data safely. The operating system uses access bits to specify whether a program can read from or write to specific memory pages. This capability ensures that data integrity is maintained while still allowing for collaboration between programs.

Think of controlled memory sharing like a communal kitchen in a shared apartment. Each roommate can use the kitchen, but certain shelves (pages) might be labeled 'no touch' for ingredients that belong to a specific roommate, ensuring everyone respects each other’s food while still sharing the space.

this caching mechanism between main memory and disk is challenging because the cost of page faults is very high. If you have a miss in the main memory you have to go to physical memory.

A page fault occurs when a program tries to access a page that is not currently in physical memory. This triggers the operating system to fetch the required page from the disk, which is significantly slower than accessing RAM. As a result, page faults can drastically reduce program performance. This emphasizes the importance of keeping frequently accessed pages in main memory.

Imagine you are in a store and you need a specific item that is out of stock. Instead of being able to get it quickly from the back room (main memory), you must wait for someone to fetch it from a warehouse far away (disk). The longer you wait, the less efficient your shopping trip becomes.

So, we need techniques towards reducing the miss penalty. We use large page tables to take advantage of the spatial locality.

To reduce the frequency and cost of page faults, operating systems employ several strategies. For instance, using larger page sizes can help because it makes it more likely that data requested by programs is kept together in memory, thereby improving access speed (spatial locality).

This is akin to packing for a trip. If you pack items that you will need together (like putting your toiletries in the same bag), it’s more efficient than scattering them across several bags. Similarly, keeping related data together in memory can minimize the need to fetch from the disk.

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

When physical memory becomes full, the system must decide which pages to remove to make space for new ones. Efficient algorithms like the second chance algorithm help in making these decisions based on which pages have been used recently. This is crucial to minimize page faults and maintain performance.

Think of a library where there's limited shelf space. When a new book arrives, the librarian must decide which book to take off the shelf. They might choose to take down books that haven't been checked out in a while, ensuring that popular books remain accessible to patrons.

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

In virtual memory systems, writing changes back to the disk is costly in terms of time. The write-back mechanism allows the computer to only write modified pages (dirty pages) back to disk when they are replaced in memory. This helps reduce the number of writes to the disk, thus improving performance.

Imagine a student working on a project. Instead of printing every small change they make, they save all their changes on their computer and only print it once when they finish. This way, they save time and resources by not running back and forth to the printer.

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

Thrashing happens when a program needs to access so many pages that the operating system spends more time swapping pages in and out of memory than executing the program. This leads to significant performance degradation and inefficient use of resources. Addressing thrashing involves understanding the program's working set and either providing more memory or optimizing the program.

Imagine a restaurant that becomes so popular that there's not enough seating for all the customers. If new patrons keep arriving, the staff spends all their time seating people rather than serving food. To solve this, the restaurant might need to expand its seating or create a waiting list.

--