Home Blog Python Java JavaScript XML C Embedded System SQL HTML

What is Thrash?
In computer science, thrash is the poor performance of a virtual memory (or paging) system when
the same pages are being loaded repeatedly due to a lack of main memory to keep them in
memory. Depending on the configuration and algorithm, the actual throughput of a system can
degrade by multiple orders of magnitude.

In computer science, thrashing occurs when a computer's virtual memory resources are overused,
leading to a constant state of paging and page faults, inhibiting most application-level processing.
It causes the performance of the computer to degrade or collapse. The situation can continue
indefinitely until the user closes some running applications or the active processes free up
additional virtual memory resources.

To know more clearly about thrashing, first, we need to know about page fault and swapping.

Page fault: We know every program is divided into some pages. A page fault occurs when
a program attempts to access data or code in its address space but is not currently located
in the system RAM.

Swapping: Whenever a page fault happens, the operating system will try to fetch that page
from secondary memory and try to swap it with one of the pages in RAM. This process is
called swapping.

Thrashing is when the page fault and swapping happens very frequently at a higher rate, and
then the operating system has to spend more time swapping these pages. This state in the
operating system is known as thrashing. Because of thrashing, the CPU utilization is going to be
reduced or negligible.
The basic concept involved is that if a process is allocated too few frames, then there will be too
many and too frequent page faults. As a result, no valuable work would be done by the CPU, and
the CPU utilization would fall drastically.

The long-term scheduler would then try to improve the CPU utilization by loading some more
processes into the memory, thereby increasing the degree of multiprogramming. Unfortunately,
this would result in a further decrease in the CPU utilization, triggering a chained reaction of
higher page faults followed by an increase in the degree of multiprogramming, called thrashing.

Algorithms during Thrashing

Whenever thrashing starts, the operating system tries to apply either the Global page replacement
Algorithm or the Local page replacement algorithm.

1. Global Page Replacement

Since global page replacement can bring any page, it tries to bring more pages whenever
thrashing is found. But what actually will happen is that no process gets enough frames, and as a
result, the thrashing will increase more and more. Therefore, the global page replacement
algorithm is not suitable when thrashing happens.

2. Local Page Replacement

Unlike the global page replacement algorithm, local page replacement will select pages which
only belong to that process. So there is a chance to reduce the thrashing. But it is proven that
there are many disadvantages if we use local page replacement. Therefore, local page
replacement is just an alternative to global page replacement in a thrashing scenario.

Causes of Thrashing

Programs or workloads may cause thrashing, and it results in severe performance problems, such
as:

If CPU utilization is too low, we increase the degree of multiprogramming by introducing a

new system. A global page replacement algorithm is used. The CPU scheduler sees the
decreasing CPU utilization and increases the degree of multiprogramming.

CPU utilization is plotted against the degree of multiprogramming.

As the degree of multiprogramming increases, CPU utilization also increases.

If the degree of multiprogramming is increased further, thrashing sets in, and CPU
utilization drops sharply.

So, at this point, to increase CPU utilization and to stop thrashing, we must decrease the
degree of multiprogramming.

How to Eliminate Thrashing

Thrashing has some negative impacts on hard drive health and system performance. Therefore, it
is necessary to take some actions to avoid it. To resolve the problem of thrashing, here are the
following methods, such as:

Adjust the swap file size:If the system swap file is not configured correctly, disk thrashing
can also happen to you.

Increase the amount of RAM: As insufficient memory can cause disk thrashing, one
solution is to add more RAM to the laptop. With more memory, your computer can handle
tasks easily and don't have to work excessively. Generally, it is the best long-term solution.

Decrease the number of applications running on the computer: If there are too many
applications running in the background, your system resource will consume a lot. And the
remaining system resource is slow that can result in thrashing. So while closing, some
applications will release some resources so that you can avoid thrashing to some extent.
 Replace programs: Replace those programs that are heavy memory occupied with
equivalents that use less memory.

Techniques to Prevent Thrashing

The Local Page replacement is better than the Global Page replacement, but local page
replacement has many disadvantages, so it is sometimes not helpful. Therefore below are some
other techniques that are used to handle thrashing:

1. Locality Model

A locality is a set of pages that are actively used together. The locality model states that as a
process executes, it moves from one locality to another. Thus, a program is generally composed of
several different localities which may overlap.

For example, when a function is called, it defines a new locality where memory references are
made to the function call instructions, local and global variables, etc. Similarly, when the function
is exited, the process leaves this locality.

2. Working-Set Model

This model is based on the above-stated concept of the Locality Model.

The basic principle states that if we allocate enough frames to a process to accommodate its
current locality, it will only fault whenever it moves to some new locality. But if the allocated
frames are lesser than the size of the current locality, the process is bound to thrash.

According to this model, based on parameter A, the working set is defined as the set of pages in
the most recent 'A' page references. Hence, all the actively used pages would always end up being
a part of the working set.

The accuracy of the working set is dependent on the value of parameter A. If A is too large, then
working sets may overlap. On the other hand, for smaller values of A, the locality might not be
covered entirely.

If D is the total demand for frames and WSSi is the working set size for process i,

D = ⅀ WSSi

Now, if 'm' is the number of frames available in the memory, there are two possibilities:
 D>m, i.e., total demand exceeds the number of frames, then thrashing will occur as some
processes would not get enough frames.

D<=m, then there would be no thrashing.

If there are enough extra frames, then some more processes can be loaded into the memory. On
the other hand, if the summation of working set sizes exceeds the frames' availability, some of the
processes have to be suspended (swapped out of memory).

This technique prevents thrashing along with ensuring the highest degree of multiprogramming
possible. Thus, it optimizes CPU utilization.

3. Page Fault Frequency

A more direct approach to handle thrashing is the one that uses the Page-Fault Frequency
concept.

The problem associated with thrashing is the high page fault rate, and thus, the concept here is to
control the page fault rate.

If the page fault rate is too high, it indicates that the process has too few frames allocated to it. On
the contrary, a low page fault rate indicates that the process has too many frames.

Upper and lower limits can be established on the desired page fault rate, as shown in the diagram.
If the page fault rate falls below the lower limit, frames can be removed from the process.
Similarly, if the page faults rate exceeds the upper limit, more frames can be allocated to the
process.

In other words, the graphical state of the system should be kept limited to the rectangular region
formed in the given diagram.

If the page fault rate is high with no free frames, some of the processes can be suspended and
allocated to them can be reallocated to other processes. The suspended processes can restart
later.

← Prev Next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk SPSS Swagger Transact-SQL