Program for Page Replacement Algorithms | Set 2 (FIFO)

3

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.

First In First Out
This is the simplest page replacement algorithm. In this algorithm, operating system keeps track of all pages in the memory in a queue, oldest page is in the front of the queue. When a page needs to be replaced page in the front of the queue is selected for removal.

For example, consider page reference string 1, 3, 0, 3, 5, 6 and 3 page slots.

Initially all slots are empty, so when 1, 3, 0 came they are allocated to the empty slots —> 3 Page Faults.
when 3 comes, it is already in memory so —> 0 Page Faults.
Then 5 comes, it is not available in memory so it replaces the oldest page slot i.e 1. —>1 Page Fault.
Finally 6 comes, it is also not available in memory so it replaces the oldest page slot i.e 3 —>1 Page Fault.

So total page faults = 6.

FIFO

Image Source : http://pages.cs.wisc.edu/~mattmcc/cs537/notes/Replacement.pdf

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.

Implementation:
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 pages in the
      queue to perform FIFO.
   c) Increment page fault
 ii) Else 
   If current page is present in set, do nothing.
   Else 
     a) Remove the first page from the queue
        as it was the first to be entered in
        the memory
     b) Replace the first page in the queue with 
        the current page in the string.
     c) Store current page in the queue.
     d) Increment page faults.

2. Return page faults.

C++

// C++ implementation of FIFO page replacement
// in Operating Systems.
#include<bits/stdc++.h>
using namespace std;

// Function to find page faults using FIFO
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 the pages in FIFO manner
    queue<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++;

                // Push the current page into the queue
                indexes.push(pages[i]);
            }
        }

        // If the set is full then need to perform FIFO
        // i.e. remove the first page of the queue from
        // set and queue both and insert the current page
        else
        {
            // Check if current page is not already
            // present in the set
            if (s.find(pages[i]) == s.end())
            {
                //Pop the first page from the queue
                int val = indexes.front();

                indexes.pop();

                // Remove the indexes page
                s.erase(val);

                // insert the current page
                s.insert(pages[i]);

                // push the current page into
                // the queue
                indexes.push(pages[i]);

                // Increment page faults
                page_faults++;
            }
        }
    }

    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 FIFO page replacement
// in Operating Systems.

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;


class Test
{
	// Method to find page faults using FIFO
	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 the pages in FIFO manner
	    Queue<Integer> indexes = new LinkedList<>() ;
	 
	    // 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++;
	 
	                // Push the current page into the queue
	                indexes.add(pages[i]);
	            }
	        }
	 
	        // If the set is full then need to perform FIFO
	        // i.e. remove the first page of the queue from
	        // set and queue both and insert the current page
	        else
	        {
	            // Check if current page is not already
	            // present in the set
	            if (!s.contains(pages[i]))
	            {
	                //Pop the first page from the queue
	                int val = indexes.peek();
	 
	                indexes.poll();
	 
	                // Remove the indexes page
	                s.remove(val);
	 
	                // insert the current page
	                s.add(pages[i]);
	 
	                // push the current page into
	                // the queue
	                indexes.add(pages[i]);
	 
	                // Increment page faults
	                page_faults++;
	            }
	        }
	    }
	 
	    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


Output:

7

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.

Belady’s anomaly
Belady’s anomaly proves that it is possible to have more page faults when increasing the number of page frames while using the First in First Out (FIFO) page replacement algorithm. For example, if we consider reference string 3 2 1 0 3 2 4 3 2 1 0 4 and 3 slots, we get 9 total page faults, but if we increase slots to 4, we get 10 page faults.

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 contribute@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.

GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.

Recommended Posts:



3 Average Difficulty : 3/5.0
Based on 2 vote(s)










Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.