操作系统实验1【短作业优先调度算法（C++实现——FCFS\SJF\HRRN）】

操作系统实验2【动态高优先权优先调度算法 C++实现】

操作系统实验3【动态分区存储管理 Python实现】

操作系统实验4【基本分页存储管理 C++实现】

一、实验目的（目的与任务）

二、实验内容（内容、要求与安排方式）

三、实验代码

①创建表示分区的类，类包含：分区ID、起始地址、结束地址、分区长度、分区状态

②导入python模块，方便拷贝分区对象

③编写表示分区状态的函数

④编写冒泡排序函数

⑤编写首次适应算法（First Fit）函数

⑥编写最佳适应算法（Best Fit）函数

⑦回收内存（作业）函数

⑧编写主函数

完整实验代码

四、实验结果

五、实验总结

一、实验目的（目的与任务）

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

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

二、实验内容（内容、要求与安排方式）

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

分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。

分区的初始化——可以由用户输入初始分区的大小。（初始化后只有一个空闲分区，起始地址为0，大小是用户输入的大小）

分区的动态分配过程：由用户输入作业号和作业的大小，实现分区过程。

分区的回收：用户输入作业号，实现分区回收，同时，分区的合并要体现出来。（注意：不存在的作业号要给出错误提示！）

分区的显示：任何时刻，可以查看当前内存的情况（起始地址是什么，大小多大的分区时空闲的，或者占用的，能够显示出来）

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

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

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

三、实验代码

①创建表示分区的类，类包含：分区ID、起始地址、结束地址、分区长度、分区状态

class Memory(object):

def __init__(self, start, end, length, state=1, ID=0):

self.Id = ID ##ID为0是未分配，其余为任务编号

self.start = start

self.end = end

self.length = length

self.state = state # state为1：内存未分配

②导入python模块，方便拷贝分区对象

import copy # 导入python模块，copy仅拷贝对象本身

③编写表示分区状态的函数

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 bubble_sort(list):

count = len(list)

for i in range(0, count):

for j in range(i + 1, count):

if list[i].length < list[j].length:

list[i], list[j] = list[j], list[i]

return list

⑤编写首次适应算法（First Fit）函数

# 首次适应算法（First Fit）

def FF(work_id, work_length, list):

for i in list:

if i.Id == work_id:

print('作业已存在！')

return

for i in range(0, len(list)):

p = list[i]

if p.state == 1 and p.length > work_length:  # p是当前未分配内存的大小

node2 = Memory(p.start + work_length, p.end, p.length - work_length, 1, 0)  # 剩下的未分配的

a = Memory(p.start, p.start + work_length - 1, work_length, state=0, ID=work_id)  # a是已分配的

del list[i]

list.insert(i, node2)

list.insert(i, a)

show_memory(list)

return

if p.state == 1 and p.length == work_length:

p.state = 0

show_memory(list)

return

print("内存空间不足！")

⑥编写最佳适应算法（Best Fit）函数

##最佳适应算法（Best Fit）

def BF(work_id, work_length, li):

for i in li:

if i.Id == work_id:

print('作业已存在！')

return

q = copy.copy(li)

q = bubble_sort(q)  # 从小到大排序,给所有已分配和未分配的排序

s = -1

ss12 = -1

for i in range(0, len(q)):

p = q[i]

if p.state == 1 and p.length > work_length:  # p.state == 1 已分配的不参与分配

s = p.start  # s得到起始位置

elif p.state == 1 and p.length == work_length:

ss12 = p.start

if s == -1 and ss12 == -1:

print("内存空间不足！")

return

for i in range(0, len(li)):

p = li[i]

if p.start == s:

node2 = Memory(p.start + work_length, p.end, p.length - work_length, 1, 0)  # 未分配

a = Memory(p.start, p.start + work_length - 1, work_length, state=0, ID=work_id)

del li[i]

li.insert(i, node2)

li.insert(i, a)

show_memory(li)

return

elif p.start == ss12:

p.state = 0

show_memory(li)

return

⑦回收内存（作业）函数

##回收内存（作业）函数

def free1(work_id, li):

for i in range(0, len(li)):

p = li[i]

if p.Id == work_id:

p.state = 1

target = i

p.Id = 0

break

# 向前合并空闲块

if target - 1 > 0:

if li[target - 1].state == 1:

a = Memory(li[target - 1].start, li[target].end, li[target - 1].length + li[target].length, 1, 0)

del li[target - 1]

del li[target - 1]

li.insert(target - 1, a)

target = target - 1

# 向后合并空闲块

if target + 1 < len(li):

if li[target + 1].state == 1:

a = Memory(li[target].start, li[target + 1].end, li[target].length + li[target + 1].length, 1, 0)

del li[target]

del li[target]

li.insert(target, a)

show_memory(li)

⑧编写主函数

if __name__ == '__main__':

print("输入内存大小：")

size = int(input())

a = Memory(0, size - 1, size, state=1, ID=0)

b = []

b.append(a)

print('*******1：初始化******')

print('*******2：分配空间****')

print('*******3：回收********')

print('*******4：查看********')

print('*******5：退出********')

while (True):

select = input('请输入想要执行的功能：')

if select == '5':

break

elif select == '1':

print("输入内存大小：")

size = int(input())

a = Memory(0, size - 1, size, state=1, ID=0)

b = []

b.append(a)

elif select == '2':

print("1.首次适应算法：FF")

print("2.最佳适应算法：BF")

x = input("请输入分配执行的算法：")

x = float(x)

repit = 'Y'

while (repit == 'Y'):

if x == 1:

work_size = input('请输入作业id和大小：').split()

FF(work_size[0], int(work_size[1]), b)

repit = input('是否继续（Y/N）：')

elif x == 2:

work_size = input('请输入作业id和大小：').split()

BF(work_size[0], int(work_size[1]), b)

repit = input('是否继续（Y/N）：')

elif select == '3':

id_delete = input('请输入删除作业id：')

free1(id_delete, b)

else:

show_memory(b)

完整实验代码

import copy  # 导入python模块，copy仅拷贝对象本身# 创建表示分区的类，类包含：分区ID、起始地址、结束地址、分区长度、分区状态
class Memory(object):def __init__(self, start, end, length, state=1, ID=0):  # __init__()方法是一种特殊的方法，被称为类的初始化方法，当创建这个类的实例时就会调用该方法# self代表类的实例，self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数self.Id = ID  ##ID为0是未分配，其余为任务编号self.start = startself.end = endself.length = lengthself.state = state  # state为1：内存未分配# 编写表示分区状态的函数
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))# 首次适应算法（First Fit）
def FF(work_id, work_length, list):for i in list:if i.Id == work_id:print('作业已存在！')returnfor i in range(0, len(list)):p = list[i]if p.state == 1 and p.length > work_length:  # p是当前未分配内存的大小node2 = Memory(p.start + work_length, p.end, p.length - work_length, 1, 0)  # 剩下的未分配的a = Memory(p.start, p.start + work_length - 1, work_length, state=0, ID=work_id)  # a是已分配的del list[i]list.insert(i, node2)list.insert(i, a)show_memory(list)returnif p.state == 1 and p.length == work_length:p.state = 0show_memory(list)returnprint("内存空间不足！")# 回收内存（作业）函数
def free1(work_id, li):for i in range(0, len(li)):p = li[i]if p.Id == work_id:p.state = 1target = ip.Id = 0break# 向前合并空闲块if target - 1 > 0:if li[target - 1].state == 1:a = Memory(li[target - 1].start, li[target].end, li[target - 1].length + li[target].length, 1, 0)del li[target - 1]del li[target - 1]li.insert(target - 1, a)target = target - 1# 向后合并空闲块if target + 1 < len(li):if li[target + 1].state == 1:a = Memory(li[target].start, li[target + 1].end, li[target].length + li[target + 1].length, 1, 0)del li[target]del li[target]li.insert(target, a)show_memory(li)# 冒泡排序
def bubble_sort(list):count = len(list)for i in range(0, count):for j in range(i + 1, count):if list[i].length < list[j].length:list[i], list[j] = list[j], list[i]return list# 最佳适应算法（Best Fit）
def BF(work_id, work_length, li):for i in li:if i.Id == work_id:print('作业已存在！')returnq = copy.copy(li)q = bubble_sort(q)  # 从小到大排序,给所有已分配和未分配的排序s = -1ss12 = -1for i in range(0, len(q)):p = q[i]if p.state == 1 and p.length > work_length:  # p.state == 1，已分配的不参与分配s = p.start  # s得到起始位置elif p.state == 1 and p.length == work_length:ss12 = p.startif s == -1 and ss12 == -1:print("内存空间不足！")returnfor i in range(0, len(li)):p = li[i]if p.start == s:node2 = Memory(p.start + work_length, p.end, p.length - work_length, 1, 0)  # 未分配a = Memory(p.start, p.start + work_length - 1, work_length, state=0, ID=work_id)del li[i]li.insert(i, node2)li.insert(i, a)show_memory(li)returnelif p.start == ss12:p.state = 0show_memory(li)return# 主函数
if __name__ == '__main__':print("输入内存大小：")size = int(input())a = Memory(0, size - 1, size, state=1, ID=0)b = []b.append(a)print('*******1：初始化******')print('*******2：分配空间（FF\BF）****')print('*******3：回收********')print('*******4：查看********')print('*******5：退出********')while (True):select = input('请输入想要执行的功能：')if select == '5':breakelif select == '1':print("输入内存大小：")size = int(input())a = Memory(0, size - 1, size, state=1, ID=0)b = []b.append(a)elif select == '2':print("1.首次适应算法：FF")print("2.最佳适应算法：BF")x = input("请输入分配执行的算法：")x = float(x)repit = 'Y'while (repit == 'Y'):if x == 1:work_size = input('请输入作业id和大小：').split()FF(work_size[0], int(work_size[1]), b)repit = input('是否继续（Y/N）：')elif x == 2:work_size = input('请输入作业id和大小：').split()BF(work_size[0], int(work_size[1]), b)repit = input('是否继续（Y/N）：')elif select == '3':id_delete = input('请输入删除作业id：')free1(id_delete, b)else:show_memory(b)

四、实验结果

BF算法有一点小毛病儿：两个相同的分区，比如2个20，这个BF是从末尾地址开始分配的；不能这样写，应该从低地址开始分配。

五、实验总结

动态分区分配算法包括如下4种算法：首次适应算法（First Fit）、最佳适应算法（Best Fit）、最坏适应算法（Worst Fit）、临近适应算法（Next Fit）。

动态分区管理方式，在初始时不将主存划分区域，而是把占用区域外的空间看作一个大的空闲区。当作业要求装入主存时，根据作业的大小查询主存内各空闲区的状态，按照特定的算法选择一个合适的空闲区，按作业大小划分出一个分区并装入该作业，剩下的区域作为新的空闲区。

当作业执行完毕后，所占用的主存空间将被回收，成为一个空闲区；如果该空闲区的相邻分区也是空闲区，则需要将相邻空闲区合并成一个空闲区。

通过本次实验，我对动态分区分配算法有了更深的理解，将4种算法的特点整理如下：

算法

算法思想

分区排列顺序

优点

缺点

首次适应算法

从头到尾寻找合适的分区

空闲分区以地址递增次序排列

综合看，首次适应算法性能最好。算法开销小，回收分区后，一般不需要对空闲分区队列重新排序

略！

最佳适应算法

优先使用更小的分区，以保留更多的大分区

空闲分区以容量递增次序排列

会有更多的大分区被保留下来，更能满足大进程需求

会产生很多太小的、难以利用的碎片：算法开销大，回收分区后可能需要对空闲分区队列重新排序

最坏适应算法

优先使用更大的分区，以防止产生太小的不可用碎片

空闲分区以容量递减次序排列

可以减少难以利用的小碎片

大分区容易被用完，不利于大进程：算法开销大（原因同上）

临近适应算法

由首次适应算法演变而来，每次从上次查找结束的位置开始查找

空闲分区以地址递增次序排列（可排列成循环链表）

不用每次都从低地址的小分区开始检索。算法开销小（原因同首次适应算法）

会使高地址的大分区也被用完

操作系统实验3【动态分区存储管理】相关推荐

操作系统实验——模拟动态分区首次适应分配和回收算法
实验三实验题目:模拟动态分区首次适应分配和回收算法实验目的:通过本实验,可加深理解动态分区分配.回收程序的功能和具体实现,特别是对回收分区的合并的理解. 实验环境:硬件:pc 机.软件:Windo ...
操作系统分区分配java算法_合肥工业大学操作系统课程设计动态分区分配存储管理java版.doc...
合肥工业大学操作系统课程设计动态分区分配存储管理java版.doc 1课程设计动态分区分配存储管理设计题目学号专业班级学生姓名号指导教师22010年12月合肥工业大学课程设计任务书设计题目动态分区分 ...
操作系统Linux环境下动态分区存储管理的内存分别配回收
今天上机要求Linux下实现动态分区存储管理的内存分别配回收现在把源码贡献出来 #include<stdlib.h> #include <stdio.h> #include & ...
【计算机操作系统】测试题:动态分区内存分配;调页系统;分页存储管理;快表是什么?计算指令操作数地址;有效存储访问时间,缺页次数,缺页率;
目录填空题: 选择题: 简答题: 应用题: 填空题: 1. 在动态分区式内存分配算法中,倾向于优先使用低地址部分空闲区的算法是首次适应算法 :能使内存空间中空闲区分布较均匀的算法是循环 ...
《操作系统实验》模拟请求分页存储管理
模拟请求分页存储管理一.实验内容二.实验要求三.实验过程 1.设计思想 2.数据结构四.实验代码五.实验结果一.实验内容模拟请求分页存储管理方式. 二.实验要求 1.模拟请求分页存储管理 ...
操作系统—内存的动态分区分配算法
建议将思维导图保存下来观看,或点击这里在线观看
操作系统之动态分区分配与回收—C语言实现
前言这篇文章用来记录操作系统实验之动态分区分配与回收. 不想从网上copy代码,打算自己从头到尾写一下,没想到却花了我整整两个晚上的时间,好在终于写完了- 动态分区分配采用的算法是最佳适应(bes ...
java 动态分区链表_大二作业——操作系统实验——C语言用双向链表，模拟实现动态分区式存储管理...
实验:动态分区式存储管理实验内容: 编写程序模拟完成动态分区存储管理方式的内存分配和回收.实验具体包括:首先确定内存空闲分配表:然后采用最佳适应算法完成内存空间的分配和回收:最后编写主函数对所做工作 ...
内存管理-动态分区分配方式模拟
内存管理 - 动态分区分配方式模拟操作系统第二次课程作业 - 动态分区分配方式模拟项目需求假设初始态下,可用内存空间为640K,并有下列请求序列,请分别用首次适应算法和最佳适应算法进行内存块的分 ...

操作系统实验3【动态分区存储管理】

一、实验目的（目的与任务）

二、实验内容（内容、要求与安排方式）