存储管理实验报告一分区存储管理模拟 二请求页式存储管理模拟

存储管理实验报告

一、分区存储管理模拟

（一）实验目的

通过模拟分区存储管理，深入理解分区存储管理的基本原理、分配策略以及内存的分配与回收过程，掌握如何有效地利用内存空间，避免内存碎片的产生。

（二）实验原理

分区存储管理是将内存划分为若干个连续的区域，每个区域称为一个分区，每个分区可以独立地装入一个作业，作业只能在其对应的分区内运行，常见的分区分配策略有首次适应算法（First Fit）、最佳适应算法（Best Fit）和最坏适应算法（Worst Fit）。

（三）实验环境与工具

编程语言：Python

开发工具：PyCharm

（四）实验步骤与代码实现

1、数据结构定义

定义内存分区类Partition，包含分区起始地址start_address、大小size、占用标志occupied等属性。

定义作业类Job，包含作业编号job_id、所需内存大小memory_requirement等属性。

class Partition:
    def __init__(self, start_address, size):
        self.start_address = start_address
        self.size = size
        self.occupied = False
class Job:
    def __init__(self, job_id, memory_requirement):
        self.job_id = job_id
        self.memory_requirement = memory_requirement

2、首次适应算法实现

遍历内存分区列表，找到第一个满足作业内存需求的未被占用的分区，将作业分配到该分区，并标记分区为已占用。

def first_fit(partitions, job):
    for partition in partitions:
        if not partition.occupied and partition.size >= job.memory_requirement:
            partition.occupied = True
            print(f"作业 {job.job_id} 分配到分区起始地址为 {partition.start_address}，大小为 {partition.size} 的分区")
            return
    print(f"无法为作业 {job.job_id} 分配内存")

3、最佳适应算法实现

遍历内存分区列表，找到所有满足作业内存需求的未被占用的分区中最小的分区，将作业分配到该分区，并标记分区为已占用。

def best_fit(partitions, job):
    suitable_partitions = [p for p in partitions if not p.occupied and p.size >= job.memory_requirement]
    if suitable_partitions:
        best_partition = min(suitable_partitions, key=lambda x: x.size)
        best_partition.occupied = True
        print(f"作业 {job.job_id} 分配到分区起始地址为 {best_partition.start_address}，大小为 {best_partition.size} 的分区")
    else:
        print(f"无法为作业 {job.job_id} 分配内存")

4、最坏适应算法实现

遍历内存分区列表，找到所有满足作业内存需求的未被占用的分区中最大的分区，将作业分配到该分区，并标记分区为已占用。

def worst_fit(partitions, job):
    suitable_partitions = [p for p in partitions if not p.occupied and p.size >= job.memory_requirement]
    if suitable_partitions:
        worst_partition = max(suitable_partitions, key=lambda x: x.size)
        worst_partition.occupied = True
        print(f"作业 {job.job_id} 分配到分区起始地址为 {worst_partition.start_address}，大小为 {worst_partition.size} 的分区")
    else:
        print(f"无法为作业 {job.job_id} 分配内存")

5、测试用例

创建内存分区列表和作业列表，分别使用三种分配算法进行内存分配，并输出分配结果。

partitions = [Partition(0, 100), Partition(100, 200), Partition(300, 150)]
jobs = [Job(1, 50), Job(2, 120), Job(3, 80)]
print("首次适应算法分配结果：")
for job in jobs:
    first_fit(partitions, job)
print("
最佳适应算法分配结果：")
for job in jobs:
    best_fit(partitions, job)
print("
最坏适应算法分配结果：")
for job in jobs:
    worst_fit(partitions, job)

（五）实验结果分析

通过上述实验，我们可以观察到不同分配算法在内存分配过程中的特点：

首次适应算法简单快速，但可能会导致内存碎片的产生，因为它总是选择第一个满足条件的分区，而不考虑分区的大小是否合适。

最佳适应算法能够选择最小的满足条件的分区，从而在一定程度上减少内存碎片，但算法复杂度相对较高，需要遍历所有分区来找到最佳分区。

最坏适应算法选择最大的满足条件的分区，虽然可以减少分区的使用数量，但可能会导致大作业无法得到及时分配，因为大的分区可能被小作业占用。

二、请求页式存储管理模拟

（一）实验目的

模拟请求页式存储管理系统的工作原理，包括页面的分配、置换以及缺页中断的处理，理解虚拟内存的概念和作用，掌握常见的页面置换算法（如先进先出算法FIFO、最近最久未使用算法LRU）。

（二）实验原理

请求页式存储管理将作业的逻辑地址空间划分为若干个页面，将物理内存也划分为相同大小的页面，当作业执行时，如果所需的页面不在物理内存中，就会发生缺页中断，系统会将所需的页面从磁盘调入内存，页面置换算法用于决定当物理内存已满时，应该将哪个页面换出内存。

（三）实验环境与工具

编程语言：Python

开发工具：PyCharm

（四）实验步骤与代码实现

1、数据结构定义

定义页面类Page，包含页面号page_number、修改标志modified等属性。

定义内存类Memory，包含页面列表pages、容量capacity等属性。

class Page:
    def __init__(self, page_number):
        self.page_number = page_number
        self.modified = False
class Memory:
    def __init__(self, capacity):
        self.capacity = capacity
        self.pages = []

2、先进先出算法（FIFO）实现

使用队列来实现页面的先进先出顺序，当发生缺页中断时，将新页面添加到队尾，如果内存已满，则将队首页面换出。

from collections import deque
def fifo(memory, page_number):
    if page_number in [page.page_number for page in memory.pages]:
        print(f"页面 {page_number} 已在内存中")
    else:
        if len(memory.pages) < memory.capacity:
            memory.pages.append(Page(page_number))
            print(f"页面 {page_number} 调入内存")
        else:
            replaced_page = memory.pages.popleft()
            print(f"页面 {replaced_page.page_number} 被换出内存")
            memory.pages.append(Page(page_number))
            print(f"页面 {page_number} 调入内存")

3、最近最久未使用算法（LRU）实现

记录每个页面的访问时间戳，当发生缺页中断时，选择时间戳最早且未修改的页面进行换出。

def lru(memory, page_number):
    if page_number in [page.page_number for page in memory.pages]:
        for page in memory.pages:
            if page.page_number == page_number:
                page.timestamp = time.time()
                print(f"页面 {page_number} 已在内存中，更新访问时间")
                break
    else:
        if len(memory.pages) < memory.capacity:
            memory.pages.append(Page(page_number))
            print(f"页面 {page_number} 调入内存")
        else:
            # 找到最近最久未使用的页面
            min_timestamp = min([page.timestamp for page in memory.pages])
            for page in memory.pages:
                if page.timestamp == min_timestamp and not page.modified:
                    replaced_page = page
                    break
            memory.pages.remove(replaced_page)
            print(f"页面 {replaced_page.page_number} 被换出内存")
            memory.pages.append(Page(page_number))
            print(f"页面 {page_number} 调入内存")

4、测试用例

创建内存对象，设置容量为3，模拟一组页面请求序列，分别使用FIFO和LRU算法进行处理，并输出页面的调入和换出情况。

memory = Memory(3)
page_requests = [1, 2, 3, 4, 2, 1, 5, 6]
print("FIFO算法页面调度情况：")
for page in page_requests:
    fifo(memory, page)
print("
LRU算法页面调度情况：")
for page in page_requests:
    lru(memory, page)

（五）实验结果分析

FIFO算法简单直观，但可能会产生异常情况，即某些经常被访问的页面可能会因为按照先进先出的顺序而被过早地换出内存，在一个程序中，如果对某个页面的访问呈现出周期性规律，那么在周期中间访问的其他页面可能会因为FIFO算法而被频繁地换进换出，影响系统性能。

LRU算法能够根据页面的访问历史来选择最合适的页面进行换出，较好地避免了异常情况的发生，LRU算法需要维护每个页面的访问时间戳，并且每次访问页面时都需要遍历所有页面来查找最近最久未使用的页面，因此算法实现相对复杂，时间开销较大。

相关问答FAQs

问题1：在分区存储管理中，如何判断一个作业是否可以装入某个分区？

答：判断一个作业是否可以装入某个分区，需要比较作业所需的内存大小与分区的大小，如果作业所需的内存大小小于或等于分区的大小，并且分区处于未被占用状态，那么该作业就可以装入这个分区，还需要考虑作业的地址空间是否与分区的起始地址对齐等因素。

问题2：在请求页式存储管理中，为什么需要页面置换算法？

答：在请求页式存储管理中，当多个作业并发执行时，系统的物理内存可能无法同时容纳所有作业所需的页面，当一个作业需要访问的页面不在物理内存中时，就会发生缺页中断，如果没有页面置换算法来选择将哪个页面换出内存，就无法腾出空间来调入新的页面，从而导致系统无法正常运行，页面置换算法的作用就是在内存已满的情况下，根据一定的策略选择一个合适的页面进行换出，以保证系统能够继续运行。

小编有话说

本次存储管理实验通过模拟分区存储管理和请求页式存储管理，让我们对操作系统中的存储管理机制有了更深入的理解和认识，在实验过程中，我们不仅掌握了不同存储管理方式的原理和实现方法，还体会到了各种算法的优缺点及其适用场景，希望同学们在今后的学习和实践中，能够进一步探索和优化这些算法，提高系统的存储管理效率。