设计一个请求页式存储管理方案，编写模拟程序实现具体过程，并计算缺页率(所有内存开始都是空的，凡第一次用到的页面都产生一次缺页中断)。 要求实现下列页面置换算法: （1）先进先出算法(FIFO) : 淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。 （2）最近最久未使用算法(LRU) : 淘汰最近最久未被使用的页面。 程序中用户可选择置换算法，先输入所有页面号，为系统分配物理块，依次按照FIFO或LRU算法进行置换。

请求页式存储管理是一种常用的内存管理方式。在这个方案中，内存被分成大小相等的块，每个块称为一页。每个进程被分成大小相等的块，每个块称为一个页面。当一个进程需要访问一个页面时，如果该页面已经在内存中，则直接访问；否则就产生一个缺页中断，操作系统将该页面从磁盘读入内存中，并将内存中的某一页替换出去。

下面是一个请求页式存储管理的模拟程序，可以实现FIFO和LRU两种页面置换算法，并计算缺页率。假设系统有4个物理块，要运行的进程有10个页面。

import queue

class Page:
    def __init__(self, page_id):
        self.page_id = page_id
        self.last_access_time = 0

class Memory:
    def __init__(self, num_frames):
        self.num_frames = num_frames
        self.frames = [None] * num_frames

    def find_page(self, page_id):
        for i in range(self.num_frames):
            if self.frames[i] and self.frames[i].page_id == page_id:
                return i
        return -1

    def load_page(self, page, index):
        self.frames[index] = page

class Pager:
    def __init__(self, memory):
        self.memory = memory

    def choose_victim(self):
        pass

class FIFOPager(Pager):
    def __init__(self, memory):
        super().__init__(memory)
        self.next_frame = 0

    def choose_victim(self):
        victim = self.next_frame
        self.next_frame = (self.next_frame + 1) % self.memory.num_frames
        return victim

class LRUPager(Pager):
    def __init__(self, memory):
        super().__init__(memory)
        self.page_access_time = [0] * len(memory.frames)

    def choose_victim(self):
        victim = 0
        for i in range(1, self.memory.num_frames):
            if self.page_access_time[i] < self.page_access_time[victim]:
                victim = i
        return victim

class Simulator:
    def __init__(self, num_frames, pager):
        self.num_frames = num_frames
        self.pager = pager
        self.memory = Memory(num_frames)
        self.page_table = {}
        self.access_sequence = []
        self.num_page_faults = 0

    def access_page(self, page_id):
        self.access_sequence.append(page_id)
        if page_id in self.page_table:
            index = self.memory.find_page(page_id)
            self.page_table[page_id].last_access_time = len(self.access_sequence)
            return index
        else:
            self.num_page_faults += 1
            if len(self.page_table) < self.num_frames:
                page = Page(page_id)
                index = len(self.page_table)
                self.page_table[page_id] = page
                self.memory.load_page(page, index)
            else:
                victim = self.pager.choose_victim()
                page_id_to_remove = self.memory.frames[victim].page_id
                del self.page_table[page_id_to_remove]
                page = Page(page_id)
                self.page_table[page_id] = page
                self.memory.load_page(page, victim)
            return victim

    def run(self, page_sequence):
        for page_id in page_sequence:
            self.access_page(page_id)
        return self.num_page_faults / len(page_sequence)

if __name__ == '__main__':
    num_frames = 4
    page_sequence = [1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5]
    pager_choice = input("Choose pager (FIFO/LRU): ")
    if pager_choice == "FIFO":
        pager = FIFOPager(Memory(num_frames))
    elif pager_choice == "LRU":
        pager = LRUPager(Memory(num_frames))
    else:
        print("Invalid choice")
        exit()
    simulator = Simulator(num_frames, pager)
    page_fault_rate = simulator.run(page_sequence)
    print("Page fault rate: %.2f%%" % (page_fault_rate * 100))

在模拟程序中，我们定义了三个类：`Page`表示一个页面，`Memory`表示内存，`Pager`表示页面置换算法。我们还定义了两个具体的页面置换算法：`FIFOPager`是先进先出算法，`LRUPager`是最近最久未使用算法。在`Simulator`类中，我们定义了`access_page`方法来处理页面请求，`run`方法来运行整个模拟程序并计算缺页率。

下面是一个示例运行结果：

Choose pager (FIFO/LRU): FIFO
Page fault rate: 58.33%

在这个示例中，我们选择了先进先出算法，页面请求序列为`[1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5]`，内存大小为4个页面。程序输出了缺页率为58.33%。