Related Articles

# Page Faults in LRU | Implementation

• Difficulty Level : Medium
• Last Updated : 31 May, 2021

Overview :
In this, it is using the concept of paging for memory management, a page replacement algorithm is needed to decide which page needs to be replaced when the new page comes in. Whenever a new page is referred to and is not present in memory, the page fault occurs and the Operating System replaces one of the existing pages with a newly needed page. LRU is one such page replacement policy in which the least recently used pages are replaced.

Example :
Given a sequence of pages in an array of pages[] of length N and memory capacity C, find the number of page faults using the Least Recently Used (LRU) Algorithm.

Example-1 :

```Input : N = 7, C = 3
pages = {1, 2, 1, 4, 2, 3, 5}
Output : 5```

Explanation :

```Capacity is 3, thus, we can store maximum 3 pages at a time.
Page 1 is required, since it is not present,
it is a page fault: page fault = 1

Page 2 is required, since it is not present,
it is a page fault: page fault = 1 + 1 = 2

Page 1 is required, since it is present,
it is not a page fault: page fault = 2 + 0 = 2

Page 4 is required, since it is not present,
it is a page fault: page fault = 2 + 1 = 3

Page 2 is required, since it is present,
it is not a page fault: page fault = 3 + 0 = 3

Page 3 is required, since it is not present,
it replaces LRU page 2: page fault = 3 + 1 = 4

Page 5 is required, since it is not present,
it replaces LRU page 1: page fault = 4 + 1 = 5```

Example-2 :

```Input : N = 9, C = 4
Pages = {5, 0, 1, 3, 2, 4, 1, 0, 5}
Output : 8```

Explanation :

```Capacity is 4, thus, we can store maximum 4 pages at a time.
Page 5 is required, since it is not present,
it is a page fault: page fault = 1

Page 0 is required, since it is not present,
it is a page fault: page fault = 1 + 1 = 2

Page 1 is required, since it is not present,
it is a page fault: page fault = 2 + 1 = 3

Page 3 is required, since it is not present,
it is a page fault: page fault = 3 + 1 = 4

Page 2 is required, since it is not present,
it replaces LRU page 5: page fault = 4 + 1 = 5

Page 4 is required, since it is not present,
it replaces LRU page 0: page fault = 5 + 1 = 6

Page 1 is required, since it is present,
it is not a page fault: page fault = 6 + 0 = 6

Page 0 is required, since it is not present,
it replaces LRU page 3: page fault = 6 + 1 = 7

Page 5 is required, since it is not present,
it replaces LRU page 2: page fault = 7 + 1 = 8```

Algorithm :

```step-1 : Initialize count as 0.
step-2 : Create a vector / array of size equal to memory capacity.
step-3 : Traverse elements of pages[]
step-4 : In each traversal:
if(element is present in memory):
remove the element and push the element at the end
else:
if(memory is full) remove the first element
Increment count
push the element at the end       ```

Implementation of the algorithm :
Following is the implementation of the algorithm in C++ as follows.

## C++

 `// C++ program to illustrate``// page faults in LRU`` ` `#include ``using` `namespace` `std;`` ` `/* Counts no. of page faults */``int` `pageFaults(``int` `n, ``int` `c, ``int` `pages[])``{``    ``// Initialise count to 0``    ``int` `count = 0;`` ` `    ``// To store elements in memory of size c``    ``vector<``int``> v;``    ``int` `i;``    ``for` `(i = 0; i <= n - 1; i++) {`` ` `        ``// Find if element is present in memory or not``        ``auto` `it = find(v.begin(), v.end(), pages[i]);`` ` `        ``// If element is not present``        ``if` `(it == v.end()) {`` ` `            ``// If memory is full``            ``if` `(v.size() == c) {``               ` `                ``// Remove the first element``                ``// As it is least recently used``                ``v.erase(v.begin());``            ``}`` ` `            ``// Add the recent element into memory``            ``v.push_back(pages[i]);`` ` `            ``// Increment the count``            ``count++;``        ``}``        ``else` `{`` ` `            ``// If element is present``            ``// Remove the element``            ``// And add it at the end as it is``            ``// the most recent element``            ``v.erase(it);``            ``v.push_back(pages[i]);``        ``}``    ``}`` ` `    ``// Return total page faults``    ``return` `count;``}`` ` `/* Driver program to test pageFaults function*/``int` `main()``{`` ` `    ``int` `pages[] = { 1, 2, 1, 4, 2, 3, 5 };``    ``int` `n = 7, c = 3;`` ` `    ``cout << ``"Page Faults = "` `<< pageFaults(n, c, pages);``    ``return` `0;``}`` ` `// This code is contributed by rajsanghavi9.`

Output :

`Page Faults = 5`

Attention reader! Don’t stop learning now.  Practice GATE exam well before the actual exam with the subject-wise and overall quizzes available in GATE Test Series Course.

Learn all GATE CS concepts with Free Live Classes on our youtube channel.

My Personal Notes arrow_drop_up