Program for Least Recently Used (LRU) Page Replacement algorithm - GeeksforGeeks

25 Nov, 2021
Prerequisite: Page Replacement AlgorithmsIn 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 their 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. 
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. 
 
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++
Java
C#
Javascript
//C++ implementation of above algorithm#include<bits/stdc++.h>using namespace std; // Function to find page faults using indexesint 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 codeint 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 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
// C# implementation of above algorithmusing 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
<script> // JavaScript implementation of above algorithm // Method to find page faults using indexesfunction 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[temp] < lru)                        {                            lru = indexes[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 methodlet 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:  
6
Another approach: (Without using HashMap)  
C++
Java
Python3
C#
// Online C++ compiler to run C++ program online#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 program for page replacement algorithmsimport 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 program for page replacement algorithm # Driver codecapacity = 4processList = [ 7, 0, 1, 2, 0, 3, 0,                4, 2, 3, 0, 3, 2]                 # List of current pages in Main Memorys = [] 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# program for page replacement algorithmsusing 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
Output:  
6
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.This article is contributed by Sahil Chhabra. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
RajatNigam1
AkashKhairnar
29AjayKumar
Rajput-Ji
mahi_07
rag2127
akshitsaxenaa09
GATE CS
Greedy
Operating Systems
Operating Systems
Greedy
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Semaphores in Process Synchronization
Differences between TCP and UDP
Data encryption standard (DES) | Set 1
Regular Expressions, Regular Grammar and Regular Languages
Caesar Cipher in Cryptography
Dijkstra's shortest path algorithm | Greedy Algo-7
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Program for array rotation
Huffman Coding | Greedy Algo-3