21.4.2. Global Frame Allocation

Now, we need to do a page-fault to get this page; now for that because we have to replace this an existing page so we need to do a page-fault to get this page; then we need to replace an existing frame, because it does not have enough frames in memory_all its frames all its pages that are there in its frames are in active use, it needs to replace an existing frame, but because all these pages are in active use; it quickly needs to replace the frame back.

In a computer system that uses paging, each process has a limited number of frames allocated in memory. If a process needs to access a page that is not currently in memory, it results in a 'page-fault'. This situation necessitates replacing an existing page in memory. However, if all the pages in memory are in active use, the process cannot afford to lose those pages and will repeatedly require replacements.

Imagine you are a librarian managing a set number of books (frames) in a small library. If a patron (process) requests a book that isn't currently on the shelf, you need to replace one book with another. But what if every book currently on the shelf is being read? Just like the librarian can't let go of a book that's being read, a computer can't replace an actively used page, leading to a situation where the process is always trying to access new pages, effectively causing a backlog.

Now, allocation schemes are typically of two types fixed allocation and priority based allocation and there are many variations of this.

Allocation schemes determine how memory frames are distributed to processes. The two primary types are fixed allocation, where a set number of frames are allocated equally among all processes, and priority-based allocation, where frames are distributed according to the importance of the process. This prioritization allows higher-priority processes to access more resources, enhancing overall system performance.

Think of a classroom of students (processes) needing computers (frames) for a project. If the teacher assigns each student an equal share of time on the computer (fixed allocation), some high-need students may struggle. Instead, if the teacher allows students who need it more time on the computer (priority-based allocation), those students will likely perform better, just as high-priority processes benefit from getting more memory.

In a fixed allocation scheme what happens? Suppose this is basically equal allocation for example, if you are given 100 page frames, if you are given 100 page frames and we have 5 processes, we give 20 frames to each process.

In fixed allocation, the total number of frames is divided equally among all processes. For example, if there are 100 frames available and 5 processes, each process receives 20 frames. This method fails when processes have different memory requirements, as larger processes may need more frames than smaller ones and could suffer from low performance as a result.

Envision a pizza party where each person (process) is given an equal slice of pizza (frames). If one person is very hungry (a large process), they will not get enough pizza to satisfy their needs, while someone who is not hungry (a small process) may waste their slice, just as a larger computing task may struggle with insufficient memory.

Now we come to the next issue which is thrashing; now we are saying that as we have discussed each process requires a minimum number of active pages, when it is executing at a given time. This is required for the instructions so the pages that it requires for the instruction that it is executing the data it requires for these instructions and the data it requires to write to.

Thrashing occurs when a process spends more time loading and unloading pages from memory than executing actual instructions. This situation typically arises when a process doesn't have enough frames allocated to hold all the active pages it needs, leading to frequent page-faults and significantly reduced CPU efficiency.

Consider a college student conducting research (process) that requires a stack of books (pages) to work effectively. If the student only has a tiny desk (limited memory), they might waste more time continually moving books in and out from their shelves (paging from secondary memory) instead of studying, similar to how a computer suffers from thrashing when memory resources are insufficient.

--