基本分页存储管理

一、实验目的

目的：熟悉并掌握基本分页存储管理的思想及其实现方法，熟悉并掌握基本分页存储管理的分配和回收方式。

任务：模拟实现基本分页存储管理方式下内存空间的分配和回收。

二、实验内容

1、实验内容

内存空间的初始化——可以由用户输入初始内存空间各个物理块情况。（用二维矩阵的方式按物理块号，逐行给出每个物理块的状态，1——表示已分配，0——表示未分配，并能够将行标、列标转换为对应的物理块号，以查看或修改每一个块的状态，要求：初始时部分物理块已分配）

基本分页的分配过程：由用户输入作业号和作业的大小（这里的大小是逻辑页面数），实现分配过程：空间充足，分配，修改状态矩阵的相应位置的值（值由0转变为1），并用专门的数据结构记录下该作业占用的物理块的块号，以备删除作业时回收空间。

作业空间的回收：用户输入作业号，实现分区回收（通过相应的数据结构找到该作业占有的物理块号，将块号转变成对应的行标、列标，将对应位置的值由1转变成0就完成了回收）。

分区的显示：任何时刻，可以查看当前内存的情况（显示记录内存情况的矩阵的值）。

2、实验要求

（1）内存空间不足的情况，要有相应的显示；

（2）作业不能同名，但是删除后可以再用这个名字；

（3）作业空间回收是输入作业名，回收相应的空间，如果这个作业名不存在，也要有相应的提示。

三、实验代码

class Memory:
    def __init__(self, rows, cols, initial_state=None):
        self.rows = rows
        self.cols = cols
        if initial_state:  # 如果有初始状态，使用它
            self.memory = initial_state
        else:  # 否则初始化为全未分配
            self.memory = [[0] * cols for _ in range(rows)]
        self.job_records = {}  # 用于存储作业号与占用块的映射

    def allocate(self, job_id, job_size):
        if job_id in self.job_records:
            print(f"作业号 {job_id} 已存在！无法重复分配。")
            return

        available_blocks = []
        for i in range(self.rows):
            for j in range(self.cols):
                if self.memory[i][j] == 0:  # 查找未分配的块
                    available_blocks.append((i, j))
                    if len(available_blocks) == job_size:
                        break
            if len(available_blocks) == job_size:
                break
        
        if len(available_blocks) < job_size:
            print("空间不足，无法分配所需的作业大小。")
            return

        # 进行分配
        for (i, j) in available_blocks:
            self.memory[i][j] = 1  # 修改状态矩阵
            block_number = i * self.cols + j
            if job_id not in self.job_records:
                self.job_records[job_id] = []
            self.job_records[job_id].append(block_number)

        print(f"作业 {job_id} 成功分配，已占用的物理块: {self.job_records[job_id]}")

    def free(self, job_id):
        if job_id not in self.job_records:
            print(f"作业号 {job_id} 不存在，无法回收。")
            return
        
        for block_number in self.job_records[job_id]:
            i = block_number // self.cols
            j = block_number % self.cols
            self.memory[i][j] = 0  # 释放块
        print(f"作业 {job_id} 成功回收。")
        del self.job_records[job_id]  # 删除作业记录

    def displaying(self):
        print("内存状态（0-未分配, 1-已分配）：")
        for i in range(self.rows):
            for j in range(self.cols):
                print(f"{self.memory[i][j]}", end=" ")
            print()  # 换行


if __name__ == "__main__":
    N = 10  # 定义每行的列数
    
    # 初始化部分物理块已分配的状态，手动设置
    initial_memory_state = [
        [0, 1, 0, 0, 0, 1, 0, 0, 0, 0],
        [0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [1, 1, 0, 0, 0, 0, 0, 1, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 1, 0, 0, 1, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    ]

    memory = Memory(rows=N, cols=N, initial_state=initial_memory_state)  # 初始化内存，包括初始状态

    while True:
        print("\n1. 分配作业\n2. 回收作业\n3. 显示内存情况\n4. 退出")
        choice = input("请选择操作: ")

        if choice == "1":
            job_id = input("请输入作业号: ")
            job_size = int(input("请输入作业大小（逻辑页面数）: "))
            memory.allocate(job_id, job_size)
        
        elif choice == "2":
            job_id = input("请输入要回收的作业号: ")
            memory.free(job_id)
        
        elif choice == "3":
            memory.displaying()
        
        elif choice == "4":
            print("退出程序")
            break
        
        else:
            print("无效选择，请重新选择。")