先决条件：页面替换算法
在使用分页进行内存管理的操作系统中，需要使用页面替换算法来确定新页面进入时需要替换哪个页面。每当引用新页面且内存中不存在该新页面时，就会发生页面错误，并且操作系统会替换其中之一。现有页面以及新需要的页面。不同的页面替换算法建议了不同的方法来决定替换哪个页面。所有算法的目标是减少页面错误的数量。
先进先出(FIFO)页面替换算法–
这是最简单的页面替换算法。在这种算法中，操作系统会跟踪队列中内存中的所有页面，最早的页面位于队列的最前面。当需要替换页面时，选择要删除队列前面的页面。
示例-1。考虑页面参考字符串1、3、0、3、5、6和3页面插槽。
最初，所有插槽都是空的，因此当出现1、3、0时，会将它们分配给空插槽—> 3 Page Faults。
当3到来时，它已经在内存中，因此-> 0 Page Faults。
然后5来了，它在内存中不可用，因此它将替换最早的页面插槽，即1。—> 1 Page Fault。
最后是6，它在内存中也不可用，因此它将替换最早的页面插槽，即3 —> 1 Page Fault。
因此，总页面错误数= 5 。
示例-2。请考虑以下参考字符串：0、2、1、6、4、0、1、0、3、1、2、1。
使用FIFO页面替换算法– _0.jpg)
因此，页面错误总数= 9。
给定内存容量(它可以容纳的页面数)和代表要引用的页面的字符串，编写一个函数以查找页面错误数。
实现–将容量设为内存可以容纳的页面数。设set为内存中的当前页面集。
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
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 s;
// To store the pages in FIFO manner
queue indexes;
// Start from initial page
int page_faults = 0;
for (int i=0; i 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 s = new HashSet<>(capacity);
// To store the pages in FIFO manner
Queue indexes = new LinkedList<>() ;
// Start from initial page
int page_faults = 0;
for (int i=0; i Python3
# Python3 implementation of FIFO page
# replacement in Operating Systems.
from queue import Queue
# Function to find page faults using FIFO
def 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
s = set()
# To store the pages in FIFO manner
indexes = Queue()
# Start from initial page
page_faults = 0
for i in range(n):
# Check if the set can hold
# more pages
if (len(s) < capacity):
# Insert it into set if not present
# already which represents page fault
if (pages[i] not in s):
s.add(pages[i])
# increment page fault
page_faults += 1
# Push the current page into
# the queue
indexes.put(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 (pages[i] not in s):
# Pop the first page from the queue
val = indexes.queue[0]
indexes.get()
# Remove the indexes page
s.remove(val)
# insert the current page
s.add(pages[i])
# push the current page into
# the queue
indexes.put(pages[i])
# Increment page faults
page_faults += 1
return page_faults
# Driver code
if __name__ == '__main__':
pages = [7, 0, 1, 2, 0, 3, 0,
4, 2, 3, 0, 3, 2]
n = len(pages)
capacity = 4
print(pageFaults(pages, n, capacity))
# This code is contributed by PranchalKC#
// C# implementation of FIFO page replacement
// in Operating Systems.
using System;
using System.Collections;
using System.Collections.Generic;
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 s = new HashSet(capacity);
// To store the pages in FIFO manner
Queue indexes = new Queue() ;
// 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++;
// Push the current page into the queue
indexes.Enqueue(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 = (int)indexes.Peek();
indexes.Dequeue();
// Remove the indexes page
s.Remove(val);
// insert the current page
s.Add(pages[i]);
// push the current page into
// the queue
indexes.Enqueue(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;
Console.Write(pageFaults(pages, pages.Length, capacity));
}
}
// This code is contributed by Arnab Kundu 输出：
7
注意–我们还可以找到页面点击数。只需维护一个单独的计数即可。如果当前页面已在内存中，则必须将其计为Page-hit。
贝拉迪的异常-
Belady的异常现象证明，在使用先进先出(FIFO)页面替换算法时，增加页面帧数时，可能会出现更多的页面错误。例如，如果我们考虑参考字符串3、2、1、0、3、2、4、3、2、1、0、4和3个插槽，则总共会出现9个页面错误，但是如果将插槽增加到4个，我们得到10个页面错误。