用Python模拟实现动态分区存储管理

最新推荐文章于 2023-01-04 19:59:15 发布

拾贰丶优

最新推荐文章于 2023-01-04 19:59:15 发布

阅读量3.7k

点赞数 3

文章标签： python 操作系统

本文链接：https://blog.csdn.net/DNandCYN/article/details/117599946

版权

实验目的：

1、熟悉并掌握动态分区分配的各种算法。

2、熟悉并掌握动态分区中分区回收的各种情况，并能够实现分区合并。

实验内容及要求：

用高级语言模拟实现动态分区存储管理

分区分配算法至少实现首次适应算法或最坏适应算法中的至少1种。熟悉并掌握各种算法的空闲区组织方式。
分区的初始化-可以由用户输入初始分区的大小。（初始化后只有一个空闲分区，起始地址为0，大小是用户输入的大小）
分区的动态分配过程：由用户输入作业号和作业的大小，实现分区过程。
分区的回收：用户输入作业号，实现分区回收，同时，分区的合并要体现出来。（注意：不存在的作业号要给出错误提示！）
分区的显示：任何时刻，可以查看当前内存的情况（起始地址是什么，大小多大的分区时空闲的，或者占用的，能够显示出来）。

代码（首次适应和最坏适应）：

import copy
import operator

class node(object):
    def __init__(self, start, end, length, state=1, ID=0):
        self.start = start
        self.end = end
        self.length = length
        self.state = state  #state为1：内存未分配
        self.Id = ID  #ID为0是未分配，其余为任务编号

#展示所有区块信息
def show_memory(list):
    print("分配状态    分区号    起始地址   终止地址  分区大小")
    for i in range(0,len(list)):
        p=list[i]
        if p.state==1:
            print("%s%s%s%11.d%11.d%10.d"%('空闲',"          ", p.Id,  p.start, p.end, p.length))
        else:
            print("%s%s%s%11.d%11.d%10.d"%('已分配',"        ", p.Id,  p.start, p.end, p.length))

#回收区块
def free_k(taskID, list_FREE):
    target=-1
    for i in range(0, len(list_FREE)):
        p = list_FREE[i]
        if p.Id == taskID:
            p.state = 1
            p.Id = 0
            target = i
            print("已回收:", taskID, '  start:', p.start, "  end:", p.end, "  length:", p.length)
            break
    if target == -1:
        print('不存在的作业号!请检查后重新输入。')
        return
    if target - 1 >= 0:
        if list_FREE[target - 1].state == 1:
            a = node(list_FREE[target - 1].start, list_FREE[target].end, list_FREE[target - 1].length + list_FREE[target].length, 1, 0)
            del list_FREE[target - 1]
            del list_FREE[target - 1]
            list_FREE.insert(target - 1, a)
            target = target - 1
    if target + 1 <= len(list_FREE):
        if list_FREE[target + 1].state == 1:
            a = node(list_FREE[target].start, list_FREE[target + 1].end, list_FREE[target].length + list_FREE[target + 1].length, 1, 0)
            del list_FREE[target]
            del list_FREE[target]
            list_FREE.insert(target, a)

#首次适应算法
def FF(taskID, Tasklength, list_FF):
    for i in range(0, len(list_FF)):
        p = list_FF[i]
        if p.state == 1 and p.length > Tasklength:
            node_bk = node(p.start + Tasklength, p.end, p.length - Tasklength, 1, 0)
            a = node(p.start, p.start + Tasklength - 1, Tasklength, state=0, ID=taskID)
            print("已分配:",a.Id, '  start:', a.start, "  end:", a.end, "  length:", a.length)
            del list_FF[i]
            list_FF.insert(i, node_bk)
            list_FF.insert(i, a)
            return
        if p.state == 1 and p.length == Tasklength:
            print("已分配:",taskID, '  start:', p.start, "  end:", p.end, "  length:", p.length)
            p.Id = taskID
            p.state = 0
            return
    print("内存空间不足")

#最坏适应算法
def BF(taskID, Tasklength, list_BF):
    q = copy.copy(list_BF)
    cmpfun = operator.attrgetter('length')
    q.sort(key=cmpfun,reverse=False)
    adr_1 = -1
    adr_2 = -1
    for i in range(0, len(q)):
        p = q[i]
        if p.state == 1 and p.length > Tasklength:
            adr_1 = p.start
        elif p.state == 1 and p.length == Tasklength:
            adr_2 = p.start
    if adr_1 == -1 and adr_2 == -1:
        print("内存空间不足")
        return
    for i in range(0, len(list_BF)):
        p = list_BF[i]
        if p.start == adr_1:
            node_bk = node(p.start + Tasklength, p.end, p.length - Tasklength, 1, 0)
            a = node(p.start, p.start + Tasklength - 1, Tasklength, state=0, ID=taskID)
            print("已分配:",a.Id, ' start:', a.start, " end:", a.end, " length:", a.length)
            del list_BF[i]
            list_BF.insert(i, node_bk)
            list_BF.insert(i, a)
            return
        elif p.start == adr_2:
            print("已分配:",taskID, ' start:', p.start, " end:", p.end, " length:", p.length)
            p.Id = taskID
            p.state = 0
            return

if __name__ == "__main__":
    while True:
        try:
            memory_size = int(input("请输入您想要的初始分区的大小 --> "))
            a = node(0, memory_size-1, memory_size, state=1, ID=0)
            b = []
            b.append(a)  #存放所有分区块的信息
            pd_num1 = int(input("请选择：0、首次适应算法 1、最坏适应算法 2、退出程序 --> "))
            if pd_num1 == 0:
                while True:
                    pd_num2 = int(input("请选择:1、分配内存 2、回收分区 3、展示分区表 4、退出 --> "))
                    if pd_num2 == 1:
                        task_id = int(input("请输入要分配任务的ID --> "))
                        task_size = int(input("请输入要该任务需要的内存大小 --> "))
                        FF(task_id, task_size, b)
                    elif pd_num2 == 2:
                        free_task_id = int(input("请输入要回收任务的ID --> "))
                        free_k(free_task_id, b)
                    elif pd_num2 == 3:
                        show_memory(b)
                    elif pd_num2 == 4:
                        break
                    else:
                        print("请重新输入 --> ")
            elif pd_num1 == 1:
                while True:
                    pd_num2 = int(input("请选择:1、分配内存 2、回收分区 3、展示分区表 4、退出 --> "))
                    if pd_num2 == 1:
                        task_id = int(input("请输入要分配任务的ID --> "))
                        task_size = int(input("请输入要该任务需要的内存大小 --> "))
                        BF(task_id, task_size, b)
                    elif pd_num2 == 2:
                        free_task_id = int(input("请输入要回收任务的ID --> "))
                        free_k(free_task_id, b)
                    elif pd_num2 == 3:
                        show_memory(b)
                    elif pd_num2 == 4:
                        break
                    else:
                        print("请重新输入 --> ")
            elif pd_num1 == 2:
                break
            else:
                print("请输入正确的选项！")
                continue
        except:
            print("请输入正确的选项！")