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 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.
Another approach: (Without using HashMap)
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 contribute.geeksforgeeks.org or mail your article to firstname.lastname@example.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.
- Program for Page Replacement Algorithms | Set 2 (FIFO)
- Page Replacement Algorithms in Operating Systems
- Program for Optimal Page Replacement Algorithm
- Operating System | Second Chance (or Clock) Page Replacement Policy
- Minimize Cost with Replacement with other allowed
- Operating System | Page Fault Handling
- Operating System | Inverted Page Table
- Operating System | Page Table Entries
- Data Structures and Algorithms | Set 32
- Data Structures and Algorithms | Set 30
- Data Structures and Algorithms | Set 2
- Data Structures and Algorithms | Set 38
- Disk Scheduling Algorithms
- Data Structures and Algorithms | Set 20
- Data Structures and Algorithms | Set 7
Improved By : RajatNigam1