21.2. Concept of Paging

Paging is a memory management scheme that eliminates the need for contiguous allocation of physical memory and thus eliminates the problems of fitting varying sized memory chunks onto the backing store.

Paging divides the process's memory address space into small fixed-size blocks called 'pages'. These pages can be placed anywhere in the physical memory, allowing more flexible memory usage because there is no need for continuous blocks of memory. When a process requests a page that is not currently in physical memory, a page fault occurs, prompting the operating system to fetch the required page from secondary storage, like a hard drive.

You can think of paging like having a library where books (pages) can be stored anywhere on the shelves, instead of being kept in a linear order. When someone wants a book, they may not have to worry about where it is, as the librarian will fetch it from wherever it's stored. This allows for a more spacious and organized way of storing books.

In paging, physical memory is divided into fixed-size units called page frames. The size of a page frame is usually the same as that of a page, making the transfer of pages between disk and memory efficient.

The main memory is divided into equal-sized units known as page frames. When a process is executed, its pages are loaded into these frames. Because pages and frames are of the same size, it simplifies the process of loading and swapping pages between the disk (where pages reside when not in use) and the RAM. This helps in quicker and more efficient memory management.

Consider each page frame as a parking spot in a parking lot. Each car (page) can be parked in any available spot without needing the spots to be in sequence. This flexibility helps in efficiently using the parking lot space and allows for quick entry and exit of cars.

When a page fault occurs and there are no free page frames available, the operating system must select a page to evict from memory to make space for the new page.

If a process accesses a page that is not in memory, the operating system checks if there are available page frames. If all frames are occupied and a new page needs to be loaded, a page replacement algorithm kicks in to decide which page to evict. This process is crucial because it helps maintain efficient memory usage while ensuring that necessary data remains accessible.

Imagine a suitcase filled with clothes (pages) and you want to add a new shirt (new page) but there's no room. You'd have to decide which item to remove to make space for the new shirt. Just like prioritizing which clothes to keep based on usage, the computer has to decide which pages to keep or remove based on their frequency of use.

When a page that has been modified (dirty page) needs to be replaced, it must be written back to disk before the new page can be loaded into its frame.

When a page in memory is modified, it is marked as dirty. Before replacing this dirty page with a new one, the operating system needs to write the dirty page back to its location on the disk. This ensures that any changes made to the data in memory are not lost. To optimize performance, techniques such as buffering are used to manage these writes efficiently to reduce waiting time.

Think of it like a chef who needs to swap out an ingredient (page) but first needs to bottle up the remaining sauce (dirty page) in the jar (disk) before putting in a new ingredient. If they don’t bottle it up first, the sauce's recipe will be ruined, just as data would be lost if the page isn't updated on disk.

Frame allocation can be fixed or proportional. Fixed allocation divides frames equally among processes, while proportional allocation assigns frames based on the size or requirement of each process.

Fixed allocation means that each running process gets an equal number of frames, regardless of how much memory they actually need. Proportional allocation, on the other hand, assigns memory based on the individual memory requirements of each process. For larger processes requiring more memory, this allocation method can prevent poor performance and frequent page faults.

Imagine a group of friends ordering pizzas (processes). If you split the pizzas equally among them (fixed allocation), smaller friends may be hungry while one bigger friend might end up with too little food to satisfy them. Instead, if you give each friend pizza slices according to their appetite (proportional allocation), everyone will leave the party satisfied.

Thrashing occurs when a process spends more time swapping pages in and out of memory than executing instructions due to insufficient memory allocation.

When a process does not have enough frames allocated for its active pages, it leads to a high rate of page faults. Continuously swapping pages in and out can result in thrashing, where the CPU is overloaded with page-fault handling instead of executing instructions. This inefficient use of resources results in low system performance.

Think of thrashing like a student who has too many subjects to study for their exams, but only a small desk to work on. The student spends so much time flipping through books and moving papers around that they hardly have time to actually study anything. Just like the student, a system that is thrashing cannot effectively utilize its CPU for operations.

--