21.5.1. Definition and Impact of Thrashing

When a process spends more time swapping pages in and out of memory than actual execution on the CPU, we say that the system is undergoing thrashing or the process is undergoing thrashing.

Thrashing occurs when a process is unable to keep its active pages in memory due to insufficient frames allocated to it. As a result, it continuously needs to swap pages in and out of memory, spending more time on this process than executing actual instructions. This situation arises particularly when many processes compete for limited memory resources, leading to high page-fault rates and decreased CPU utilization.

Imagine a chef trying to cook multiple dishes at once but only having one small pan. Every time they need to use a specific ingredient, they have to put down their current dish, open the refrigerator, and retrieve the ingredient, leading to constant interruptions. In this scenario, the chef ends up spending more time fetching ingredients than actually cooking, just like a process in thrashing spends more time managing pages than executing tasks.

Whenever the operating system sees low CPU utilization, it might incorrectly assume that there are not enough processes in memory and increase the degree of multiprogramming. When a new process is added, it may further reduce performance by competing for frames and causing more frequent page-faults.

Systems that experience thrashing often result in low CPU utilization as processes spend time handling page-faults instead of executing instructions. If the operating system misinterprets this low utilization as a need for more processes, it may increase the number of concurrent processes, leading to additional competition for limited memory resources. This exacerbates the thrashing scenario, as each process has even fewer frames available to keep their active pages in memory.

Think of a crowded restaurant where each waiter tries to serve too many tables at once. As more tables are added, the waitstaff becomes overwhelmed, leading to longer wait times for customers and poor service. In this analogy, the waitstaff represents the system resources which, when overtaxed, lead to a decline in service quality, much like how adding more processes to a system reduces its overall performance due to thrashing.

Each process requires a minimum number of active pages corresponding to the instructions it executes and the data it uses. If a process does not have enough active pages available in memory, it will result in a high page-fault rate.

Active pages refer to the specific pages of memory that a process is using at any given time. This includes pages that hold executable instructions and the data needed for computations. If not enough frames are allocated to a process to keep these active pages in memory, the process will frequently encounter page-faults, as it needs to retrieve the required pages from secondary storage. This increase in page-faults leads to inefficiencies and indicates that the process is effectively 'starving' for the memory it needs to function optimally.

Consider a student studying for a test with limited access to their textbooks. If they only have one book available at a time and frequently need to switch between several subjects, they'll lose valuable study time going back and forth rather than actually focusing on their studies. Similarly, a process needs sufficient active pages to efficiently execute without interruption from frequent page-faults.

If the total demand for frames exceeds the available number of frames in the main memory, the system is likely to experience thrashing, degrading its overall performance.

When the combined requirement for memory frames by all processes exceeds what is available in main memory, a scenario arises that can lead to thrashing. Each process struggles to maintain its necessary active pages in memory, causing continuous page-faults. As a result, the entire system suffers, with CPU resources being underutilized and processes waiting longer for needed data to be swapped in and out.

Imagine a library that has a limited number of reading tables but many patrons wanting to read at once. If there aren’t enough tables for everyone, patrons will have to wait longer to read, leading to frustration and inefficiency. In this analogy, the library’s reading tables symbolize memory frames; when demand exceeds supply, everyone’s experience suffers, just like processes in a system facing thrashing.

To manage thrashing, mechanisms like suspending or swapping out low-priority processes can be utilized to free up enough frames for higher-priority processes, facilitating optimal performance.

To mitigate the impacts of thrashing, operating systems can choose to suspend less critical processes to release memory resources for more critical workloads. By limiting the number of processes competing for limited frames, the operating system can ensure that essential processes have the adequate memory they need to perform optimally, thereby reducing the likelihood of thrashing and improving overall system performance.

Think of a busy kitchen at a restaurant where the chef can only manage a certain number of dishes at a time. If too many orders come in, the chef may set aside less important tasks to focus on completing high-priority orders. Similarly, in a computing environment, suspending less critical programs can help allocate resources to those that are crucial for system functionality, allowing for smoother operations.

--