Skip to content

Techniques to handle Thrashing

Program for Least Recently Used (LRU) Page Replacement algorithm

Last Updated : 15 Sep, 2023

Prerequisite: Page Replacement Algorithms
In operating systems that use paging for memory management, page replacement algorithm are needed to decide which page needed to be replaced when new page comes in. Whenever a new page is referred and not present in memory, page fault occurs and Operating System replaces one of the existing pages with newly needed page. Different page replacement algorithms suggest different ways to decide which page to replace. The target for all algorithms is to reduce number of page faults.
In Least Recently Used (LRU) algorithm is a Greedy algorithm where the page to be replaced is least recently used. The idea is based on locality of reference, the least recently used page is not likely
Let say the page reference string 7 0 1 2 0 3 0 4 2 3 0 3 2 . Initially we have 4 page slots empty.
Initially all slots are empty, so when 7 0 1 2 are allocated to the empty slots —> 4 Page faults
0 is already there so —> 0 Page fault.
when 3 came it will take the place of 7 because it is least recently used —>1 Page fault
0 is already in memory so —> 0 Page fault.
4 will takes place of 1 —> 1 Page Fault
Now for the further page reference string —> 0 Page fault because they are already available in the memory.

LRU

Given memory capacity (as number of pages it can hold) and a string representing pages to be referred, write a function to find number of page faults.

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Let capacity be the number of pages that  memory can hold.  Let set be the current  set of pages in memory.    1- Start traversing the pages.   i) If set holds less pages than capacity.     a) Insert page into the set one by one until         the size  of set reaches capacity or all        page requests are processed.     b) Simultaneously maintain the recent occurred        index of each page in a map called indexes.     c) Increment page fault   ii) Else      If current page is present in set, do nothing.     Else        a) Find the page in the set that was least        recently used. We find it using index array.       We basically need to replace the page with       minimum index.       b) Replace the found page with current page.       c) Increment page faults.       d) Update index of current page.    2. Return page faults.

Below is implementation of above steps.

C++

   //C++ implementation of above algorithm 
#include<bits/stdc++.h> 
using namespace std; 
  
// Function to find page faults using indexes 
int pageFaults(int pages[], int n, int capacity) 
{ 
    // To represent set of current pages. We use 
    // an unordered_set so that we quickly check 
    // if a page is present in set or not 
    unordered_set<int> s; 
  
    // To store least recently used indexes 
    // of pages. 
    unordered_map<int, int> indexes; 
  
    // Start from initial page 
    int page_faults = 0; 
    for (int i=0; i<n; i++) 
    { 
        // Check if the set can hold more pages 
        if (s.size() < capacity) 
        { 
            // Insert it into set if not present 
            // already which represents page fault 
            if (s.find(pages[i])==s.end()) 
            { 
                s.insert(pages[i]); 
  
                // increment page fault 
                page_faults++; 
            } 
  
            // Store the recently used index of 
            // each page 
            indexes[pages[i]] = i; 
        } 
  
        // If the set is full then need to perform lru 
        // i.e. remove the least recently used page 
        // and insert the current page 
        else
        { 
            // Check if current page is not already 
            // present in the set 
            if (s.find(pages[i]) == s.end()) 
            { 
                // Find the least recently used pages 
                // that is present in the set 
                int lru = INT_MAX, val; 
                for (auto it=s.begin(); it!=s.end(); it++) 
                { 
                    if (indexes[*it] < lru) 
                    { 
                        lru = indexes[*it]; 
                        val = *it; 
                    } 
                } 
  
                // Remove the indexes page 
                s.erase(val); 
  
                // insert the current page 
                s.insert(pages[i]); 
  
                // Increment page faults 
                page_faults++; 
            } 
  
            // Update the current page index 
            indexes[pages[i]] = i; 
        } 
    } 
  
    return page_faults; 
} 
  
// Driver code 
int main() 
{ 
    int pages[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; 
    int n = sizeof(pages)/sizeof(pages[0]); 
    int capacity = 4; 
    cout << pageFaults(pages, n, capacity); 
    return 0; 
} 
 
  

Java

   // Java implementation of above algorithm 
  
import java.util.HashMap; 
import java.util.HashSet; 
import java.util.Iterator; 
  
class Test 
{ 
    // Method to find page faults using indexes 
    static int pageFaults(int pages[], int n, int capacity) 
    { 
        // To represent set of current pages. We use 
        // an unordered_set so that we quickly check 
        // if a page is present in set or not 
        HashSet<Integer> s = new HashSet<>(capacity); 
       
        // To store least recently used indexes 
        // of pages. 
        HashMap<Integer, Integer> indexes = new HashMap<>(); 
       
        // Start from initial page 
        int page_faults = 0; 
        for (int i=0; i<n; i++) 
        { 
            // Check if the set can hold more pages 
            if (s.size() < capacity) 
            { 
                // Insert it into set if not present 
                // already which represents page fault 
                if (!s.contains(pages[i])) 
                { 
                    s.add(pages[i]); 
       
                    // increment page fault 
                    page_faults++; 
                } 
       
                // Store the recently used index of 
                // each page 
                indexes.put(pages[i], i); 
            } 
       
            // If the set is full then need to perform lru 
            // i.e. remove the least recently used page 
            // and insert the current page 
            else
            { 
                // Check if current page is not already 
                // present in the set 
                if (!s.contains(pages[i])) 
                { 
                    // Find the least recently used pages 
                    // that is present in the set 
                    int lru = Integer.MAX_VALUE, val=Integer.MIN_VALUE; 
                      
                    Iterator<Integer> itr = s.iterator(); 
                      
                    while (itr.hasNext()) { 
                        int temp = itr.next(); 
                        if (indexes.get(temp) < lru) 
                        { 
                            lru = indexes.get(temp); 
                            val = temp; 
                        } 
                    } 
                  
                    // Remove the indexes page 
                    s.remove(val); 
                   //remove lru from hashmap 
                   indexes.remove(val); 
                    // insert the current page 
                    s.add(pages[i]); 
       
                    // Increment page faults 
                    page_faults++; 
                } 
       
                // Update the current page index 
                indexes.put(pages[i], i); 
            } 
        } 
       
        return page_faults; 
    } 
      
    // Driver method 
    public static void main(String args[]) 
    { 
        int pages[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; 
         
        int capacity = 4; 
          
        System.out.println(pageFaults(pages, pages.length, capacity)); 
    } 
} 
// This code is contributed by Gaurav Miglani 
 
  

Python3

   # Python implementation of above algorithm 
def pageFaults(pages, n, capacity): 
  
    # To represent set of current pages. We use 
    # an unordered_set so that we quickly check 
    # if a page is present in set or not 
    s = set() 
  
    # To store least recently used indexes 
    # of pages. 
    indexes = {} 
  
    # Start from initial page 
    page_faults = 0
    for i in range(n): 
  
        # Check if the set can hold more pages 
        if len(s) < capacity: 
  
            # Insert it into set if not present 
            # already which represents page fault 
            if pages[i] not in s: 
                s.add(pages[i]) 
  
                # increment page fault 
                page_faults += 1
  
            # Store the recently used index of 
            # each page 
            indexes[pages[i]] = i 
  
        # If the set is full then need to perform lru 
        # i.e. remove the least recently used page 
        # and insert the current page 
        else: 
  
            # Check if current page is not already 
            # present in the set 
            if pages[i] not in s: 
  
                # Find the least recently used pages 
                # that is present in the set 
                lru = float('inf') 
                for page in s: 
                    if indexes[page] < lru: 
                        lru = indexes[page] 
                        val = page 
  
                # Remove the indexes page 
                s.remove(val) 
  
                # insert the current page 
                s.add(pages[i]) 
  
                # increment page fault 
                page_faults += 1
  
            # Update the current page index 
            indexes[pages[i]] = i 
  
    return page_faults 
  
  
# Driver code 
pages = [7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2] 
n = len(pages) 
capacity = 4
print(pageFaults(pages, n, capacity)) 
  
# This code is contributed by ishankhandelwals.
 
  

C#

   // C# implementation of above algorithm 
using System; 
using System.Collections.Generic; 
  
class GFG 
{ 
    // Method to find page faults  
    // using indexes 
    static int pageFaults(int []pages,  
                   int n, int capacity) 
    { 
        // To represent set of current pages.  
        // We use an unordered_set so that  
        // we quickly check if a page is  
        // present in set or not 
        HashSet<int> s = new HashSet<int>(capacity); 
      
        // To store least recently used indexes 
        // of pages. 
        Dictionary<int,  
                   int> indexes = new Dictionary<int, 
                                                 int>(); 
      
        // Start from initial page 
        int page_faults = 0; 
        for (int i = 0; i < n; i++) 
        { 
            // Check if the set can hold more pages 
            if (s.Count < capacity) 
            { 
                // Insert it into set if not present 
                // already which represents page fault 
                if (!s.Contains(pages[i])) 
                { 
                    s.Add(pages[i]); 
      
                    // increment page fault 
                    page_faults++; 
                } 
      
                // Store the recently used index of 
                // each page 
                if(indexes.ContainsKey(pages[i])) 
                    indexes[pages[i]] = i; 
                else
                    indexes.Add(pages[i], i); 
            } 
      
            // If the set is full then need to  
            // perform lru i.e. remove the least  
            // recently used page and insert 
            // the current page 
            else
            { 
                // Check if current page is not  
                // already present in the set 
                if (!s.Contains(pages[i])) 
                { 
                    // Find the least recently used pages 
                    // that is present in the set 
                    int lru = int.MaxValue, val = int.MinValue; 
                                          
                    foreach (int itr in s)  
                    { 
                        int temp = itr; 
                        if (indexes[temp] < lru) 
                        { 
                            lru = indexes[temp]; 
                            val = temp; 
                        } 
                    } 
                  
                    // Remove the indexes page 
                    s.Remove(val); 
                      
                    //remove lru from hashmap 
                    indexes.Remove(val); 
                      
                    // insert the current page 
                    s.Add(pages[i]); 
      
                    // Increment page faults 
                    page_faults++; 
                } 
      
                // Update the current page index 
                if(indexes.ContainsKey(pages[i])) 
                    indexes[pages[i]] = i; 
                else
                    indexes.Add(pages[i], i); 
            } 
        } 
        return page_faults; 
    } 
      
    // Driver Code 
    public static void Main(String []args) 
    { 
        int []pages = {7, 0, 1, 2, 0, 3,  
                       0, 4, 2, 3, 0, 3, 2}; 
          
        int capacity = 4; 
          
        Console.WriteLine(pageFaults(pages,  
                          pages.Length, capacity)); 
    } 
} 
  
// This code is contributed by 29AjayKumar 
 
  

Javascript

   <script> 
  
// JavaScript implementation of above algorithm 
  
// Method to find page faults using indexes 
function pageFaults(pages,n,capacity) 
{ 
    // To represent set of current pages. We use 
        // an unordered_set so that we quickly check 
        // if a page is present in set or not 
        let s = new Set(); 
         
        // To store least recently used indexes 
        // of pages. 
        let indexes = new Map(); 
         
        // Start from initial page 
        let page_faults = 0; 
        for (let i=0; i<n; i++) 
        { 
            // Check if the set can hold more pages 
            if (s.size < capacity) 
            { 
                // Insert it into set if not present 
                // already which represents page fault 
                if (!s.has(pages[i])) 
                { 
                    s.add(pages[i]); 
         
                    // increment page fault 
                    page_faults++; 
                } 
         
                // Store the recently used index of 
                // each page 
                indexes.set(pages[i], i); 
            } 
         
            // If the set is full then need to perform lru 
            // i.e. remove the least recently used page 
            // and insert the current page 
            else
            { 
                // Check if current page is not already 
                // present in the set 
                if (!s.has(pages[i])) 
                { 
                    // Find the least recently used pages 
                    // that is present in the set 
                    let lru = Number.MAX_VALUE, val=Number.MIN_VALUE; 
                        
                      
                        
                    for(let itr of s.values()) { 
                        let temp = itr; 
                        if (indexes.get(temp) < lru) 
                        { 
                            lru = indexes.get(temp); 
                            val = temp; 
                        } 
                    } 
                    
                    // Remove the indexes page 
                    s.delete(val); 
                   //remove lru from hashmap 
                   indexes.delete(val); 
                    // insert the current page 
                    s.add(pages[i]); 
         
                    // Increment page faults 
                    page_faults++; 
                } 
         
                // Update the current page index 
                indexes.set(pages[i], i); 
            } 
        } 
         
        return page_faults; 
} 
  
 // Driver method 
let pages=[7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2]; 
let capacity = 4; 
document.write(pageFaults(pages, pages.length, capacity)); 
  
  
// This code is contributed by rag2127 
  
</script> 
 
  

Output:

Complexity Analysis :

Time Complexity : average time complexity of set and map operations is O(1) and the worst-case time complexity is O(n) but O(n) is the dominant term.
Space Complexity : O(capacity) which is a constant and depends on the size of the input array and the size of the memory buffer.

Another approach: (Without using HashMap)

Following are the steps to solve this problem :

Using a deque data structure, the program implements the page replacement algorithm.
A predetermined number of pages are kept in memory by the algorithm, and they are replaced as new pages are requested.
Using an integer array to stimulate page requests, the code keeps track the number of page faults that occur throughout the simulation.
The deque data structure, which is built using STL in C++, is used to maintain the pages in memory.
The total number of page faults that occurred throughout the simulation is given as output by the code.

Below is the implementation of the above approach :

C++

   // C++ program for page replacement algorithms 
#include <iostream> 
#include<bits/stdc++.h> 
using namespace std; 
  
int main() 
{ 
  int capacity = 4; 
  int arr[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; 
  
  deque<int> q(capacity); 
  int count=0; 
  int page_faults=0; 
  deque<int>::iterator itr; 
  q.clear(); 
  for(int i:arr) 
  { 
  
    // Insert it into set if not present 
    // already which represents page fault 
    itr = find(q.begin(),q.end(),i); 
    if(!(itr != q.end())) 
    { 
  
      ++page_faults; 
  
      // Check if the set can hold equal pages 
      if(q.size() == capacity) 
      { 
        q.erase(q.begin()); 
        q.push_back(i); 
      } 
      else{ 
        q.push_back(i); 
  
      } 
    } 
    else
    { 
      // Remove the indexes page 
      q.erase(itr); 
  
      // insert the current page 
      q.push_back(i);          
    } 
  
  } 
  cout<<page_faults; 
} 
  
// This code is contributed by Akshit Saxena 
 
  

Java

   // Java program for page replacement algorithms 
import java.util.ArrayList; 
  
public class LRU { 
      
    // Driver method 
    public static void main(String[] args) { 
        int capacity = 4; 
        int arr[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; 
          
        // To represent set of current pages.We use 
        // an Arraylist 
        ArrayList<Integer> s=new ArrayList<>(capacity); 
        int count=0; 
        int page_faults=0; 
        for(int i:arr) 
        { 
            // Insert it into set if not present 
            // already which represents page fault 
            if(!s.contains(i)) 
            { 
              
            // Check if the set can hold equal pages 
            if(s.size()==capacity) 
            { 
                s.remove(0); 
                s.add(capacity-1,i); 
            } 
            else
                s.add(count,i); 
                // Increment page faults 
                page_faults++; 
                ++count; 
          
            } 
            else
            { 
                // Remove the indexes page 
                s.remove((Object)i); 
                // insert the current page 
                s.add(s.size(),i);          
            } 
          
        } 
        System.out.println(page_faults); 
    } 
} 
 
  

Python3

   # Python3 program for page replacement algorithm 
  
# Driver code 
capacity = 4 
processList = [ 7, 0, 1, 2, 0, 3, 0, 
                4, 2, 3, 0, 3, 2] 
                  
# List of current pages in Main Memory 
s = []  
  
pageFaults = 0
# pageHits = 0 
  
for i in processList: 
  
    # If i is not present in currentPages list 
    if i not in s: 
  
        # Check if the list can hold equal pages 
        if(len(s) == capacity): 
            s.remove(s[0]) 
            s.append(i) 
  
        else: 
            s.append(i) 
  
        # Increment Page faults 
        pageFaults +=1
  
    # If page is already there in  
    # currentPages i.e in Main 
    else: 
          
        # Remove previous index of current page 
        s.remove(i) 
  
        # Now append it, at last index 
        s.append(i) 
      
print("{}".format(pageFaults)) 
  
# This code is contributed by mahi_07
 
  

C#

   // C# program for page replacement algorithms  
using System; 
using System.Collections.Generic; 
  
class LRU 
{  
      
    // Driver method  
    public static void Main(String[] args)  
    {  
        int capacity = 4;  
        int []arr = {7, 0, 1, 2, 0, 3, 0,  
                     4, 2, 3, 0, 3, 2};  
          
        // To represent set of current pages. 
        // We use an Arraylist  
        List<int> s = new List<int>(capacity);  
        int count = 0;  
        int page_faults = 0;  
        foreach(int i in arr)  
        {  
            // Insert it into set if not present  
            // already which represents page fault  
            if(!s.Contains(i))  
            {  
              
            // Check if the set can hold equal pages  
            if(s.Count == capacity)  
            {  
                s.RemoveAt(0);  
                s.Insert(capacity - 1, i);  
            }  
            else
                s.Insert(count, i);  
                  
                // Increment page faults  
                page_faults++;  
                ++count;  
            }  
            else
            {  
                // Remove the indexes page  
                s.Remove(i);  
                  
                // insert the current page  
                s.Insert(s.Count, i);          
            }  
        }  
        Console.WriteLine(page_faults);  
    }  
}  
  
// This code is contributed by Rajput-Ji 
 
  

Javascript

   let capacity = 4; 
let arr = [7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2]; 
  
let q = []; 
let count = 0; 
let page_faults = 0; 
let itr; 
q.length = 0; 
  
for (let i of arr)  
{ 
  
  // Insert it into set if not present 
  // already which represents page fault 
  itr = q.indexOf(i); 
  if (itr == -1) { 
    page_faults++; 
  
    // Check if the set can hold equal pages 
    if (q.length == capacity) { 
      q.shift(); 
      q.push(i); 
    } else { 
      q.push(i); 
    } 
  } else { 
    // Remove the indexes page 
    q.splice(itr, 1); 
  
    // insert the current page 
    q.push(i); 
  } 
} 
  
console.log(page_faults); 
  
// This code is contributed by ishankhandelwals.
 
  

Output:

Complexity Analysis :

Time Complexity : O(n), as it performs a constant amount of work for each page request.
Space Complexity : O(n+4), where n is the size of the input array and 4 is the size of the memory buffer.

Note : We can also find the number of page hits. Just have to maintain a separate count.
If the current page is already in the memory then that must be count as Page-hit.
We will discuss other Page-replacement Algorithms in further sets.

Techniques to handle Thrashing

S

Sahil Chhabra

Improve

Article Tags :

Practice Tags :

Greedy

Similar Reads

Operating System Tutorial

An Operating System(OS) is a software that manages and handles hardware and software resources of a computing device. Responsible for managing and controlling all the activities and sharing of computer resources among different running applications.A low-level Software that includes all the basic fu