Program to implement FIFO Page replacement algorithm

Page Replacement Algorithm
This is an algorithm with low overhead effort, requiring little accounting on the part of the operating system. In this algorithm, the operating system uses the R and M bits to distinguish pages and the "R" and "M" bits to distinguish page. Whenever a page needs to be replaced, the operating system selects the page with the lowest counter and exchanges it. This algorithm returns the total number of pages that are incorrect when saving or removing pages from the set. Instead of increasing the count of the page references to highlight them equally regardless of the time, we move the reference counter for each page by dividing it by 2 and adding the referenced bit to the left of the binary number. If a page needs to be changed, it selects the pages with a lower counter. ,
The quality of the page replacement algorithm is determined by the number of pages that are waiting for a page and the time that remains for each page in between. The number of page changes per second or the total number of pages in a sentence determines the "quality" of this page replacement algorithm. The quantity and quality of a page exchanged per second determine the "quality" of a page replacement algorithm? The total usage volume is a little blurred, because processes share physical memory through heuristics and replacement algorithms, rather than capturing and releasing it. For example, there are page errors that occur with a FIFO algorithm for page substitution. If the algorithm generates a page error, it is all the more effective and the greater the number of pages in the sentence, the higher the "quality" of the page change.
We could use a framework allocation policy for page switching: we know the number of pages per box, but we do not know exactly enough to decide whether or not a certain set of memory references must be included. When the algorithm runs on certain strings of memories or references, it is evaluated by calculating the number of page errors. We know that, so we need to know that, and that is what we decide whether or how many pages of the sentence we are going to replace. This process determines the quality of the page replacement algorithm: the less time we wait for a page, the better the algorithm. We can replace pages with the same algorithm as when switching pages, but with a different set of memory references. For example, if we use an algorithm that contains only a memory reference to the distant future in the sentence, we could replace all pages with a reference to it. However, if we use a process with multiple reminders and multiple references to a single future, we cannot replace each page, so we need to replace them individually.
We have to scroll through all memory pages to make room for the requested page, so we have to write to the hard disk and write back to the hard disk. The page change occurs if the requested page is not available in memory and no new pages are assigned. The Page Replacement Algorithm (FIFO) uses a number of free pages that are below the threshold, and if none of them exceeds that, the page will switch if no new page can be requested and the available space is not sufficient to allocate the requesting page. Page switching can also be done if a requested page is in memory (not the fault of the page) and a free page can be used to fulfill the assignment if it is below the low threshold or if there is none. The page will only be changed if the space required is limited or there are not enough pages available to assign a new page. Page switching can only take place if a request page was not in memory, cannot be used at the fault of the pages, or a free page cannot be used to fulfill the assignments, even if it is below a lower threshold.
The efficiency of the page replacement algorithm can be evaluated by running it against a certain number of memory references and calculating the number of page errors. A random page reference string is applied to the algorithm and the number of page errors it causes is recorded. The use of Optimal Page Switching is a benchmark set so that other replacement algorithms can analyze it.
To evaluate the page replacement algorithm, it must run against a certain set of memory references and determine the number of page errors that occur. A page exchange algorithm that has been used recently and is not used frequently can generate more page errors than its most recently used counterpart if a page table contains a null pointer value. This is a measure of the efficiency of the page replacement algorithm compared to the memory reference string. 
    
/*Objective: implement FIFO Page replacement algorithm
   Author:Rahul kumar */

   #include <stdio.h>

#define max 100
int main()
{
  int i,j,k,no_of_pages,ref_str[max],no_of_frames,frame[max],avail,count=0;
  printf("\nEnter the total no of pages: ");
  scanf("%d",&no_of_pages);
  printf("\nEnter the Page No. OR Ref String: ");
  for(i=0;i< no_of_pages;i++)
  {
    scanf("%d",&ref_str[i]);
  }
  printf("\n Enter the total no. of frames: ");
  scanf("%d",&no_of_frames);
  for(i=0;i< no_of_frames;i++)
  {
    frame[i]=-1;  //for empty frame
  }
  j=0;
  printf("\tRef String\tFrames\n");
  for(i=0;i< no_of_pages;i++)
  {
    printf("%d\t\t",ref_str[i]);
    avail=0;
    for(k=0;k< no_of_frames;k++)
    {
      if(frame[k]==ref_str[i])    //to check frame is not empty
      avail=1;
    }
    if(avail==0)
    {
      
      
      frame[j]=ref_str[i];
      j=(j+1)%no_of_frames; 
      count++;
      for(k=0;k< no_of_frames;k++)
      printf("%d\t",frame[k]);
    
    }
    printf("\n");
  }
  printf("Page Fault is %d",count);
  return 0;
}

Output:

Enter the total no of pages: 10

Enter the Page No. OR Ref String: 4
7
6
1
7
6
1
2
7
2

 Enter the total no. of frames: 3
        Ref String      Frames
4               4       -1      -1
7               4       7       -1
6               4       7       6
1               1       7       6
7
6
1
2               1       2       6
7               1       2       7
2
Page Fault is 6