基于可重定位分区分配算法的内存管理的设计与实现
连续分配 分页管理动态重定位分区分配算法-Read
连续分配+分页管理
(2) 进程的换入。 系统应定时地查看所有进程的状态,从中找出“就绪” 状态但已换出的进程,将其中换出时间(换出到磁盘上)最久的 进程作为换入进程,将之换入,直至已无可换入的进程或无 可换出的进程为止。
连续分配+分页管理
4.3 基本分页存储管理方式
连续分配+分页管理
4.2.3 动态分区分配
连续分配+分页管理
连续分配+分页管理
1. 分区分配中的数据结构
(1) 空闲分区表。 (2) 空闲分区链。
前 向 指 针 N + 2 0
N个字节可用
后 向 指 针 N + 2 0
图 4-5 空闲链结构
连续分配+分页管理
2. 分区分配算法 (1) 首次适应算法FF。 (2) 循环首次适应算法,该算法是由首次适应算法演变而成的。 (3) 最佳适应算法。
之间的关系。
对于 64位的计算机,如果要求它能支持 2 64 (=1844744 TB)规模的物理存储空间,则即使是采用三级页表结构也是 难以办到的;而在当前的实际应用中也无此必要。
连续分配+分页管理
练习:
有一基本分页存储管理系统,假定页面大小为1024字节,页
表采用离散方式放在内存中。每个页表项占用4个字节。在 忽略页表及系统区等占用空间的条件下, 若采用一级页表,系统能支持的逻辑空间最多为多少? 若采用二级页表,系统能支持的逻辑空间最多为多少? 在二级页表中,现有逻辑地址为542783,求该地址对应的 外层页号,外层页内地址和页内地址?
求是连续的。 可以采用这样两个方法来解决这一问题:① 采
用离散分配方式来解决难以找到一块连续的大内存空间的问 题:② 只将当前需要的部分页表项调入内存, 其余的页表项 仍驻留在磁盘上,需要时再调入。
基于可重定位分区分配算法的内存管理的设计与实现
组号成绩计算机操作系统课程设计报告题目基于可重定位分区分配算法的内存管理的设计与实现专业:计算机科学与技术班级:学号+:指导教师:2016年12月23 日一.设计目的掌握内存的连续分配方式的各种分配算法二.设计内容基于可重定位分区分配算法的内存管理的设计与实现。
本系统模拟操作系统内存分配算法的实现,实现可重定位分区分配算法,采用PCB定义结构体来表示一个进程,定义了进程的名称和大小,进程内存起始地址和进程状态。
内存分区表采用空闲分区表的形式来模拟实现。
要求定义与算法相关的数据结构,如PCB、空闲分区;在使用可重定位分区分配算法时必须实现紧凑。
三.设计原理可重定位分区分配算法与动态分区分配算法基本上相同,差别仅在于:在这种分配算法中,增加了紧凑功能。
通常,该算法不能找到一个足够大的空闲分区以满足用户需求时,如果所有的小的空闲分区的容量总和大于用户的要求,这是便须对内存进行“紧凑”,将经过“紧凑”后所得到的大空闲分区分配给用户。
如果所有的小空闲分区的容量总和仍小于用户的要求,则返回分配失败信息四.详细设计及编码1.模块分析(1)分配模块这里采用首次适应(FF)算法。
设用户请求的分区大小为u.size,内存中空闲分区大小为m.size,规定的不再切割的剩余空间大小为size。
空闲分区按地址递增的顺序排列;在分配内存时,从空闲分区表第一个表目开始顺序查找,如果m.size≥u.size且m.size-u.size≤size,说明多余部分太小,不再分割,将整个分区分配给请求者;如果m.size≥u.size且m.size-u.size>size,就从该空闲分区中按请求的大小划分出一块内存空间分配给用户,剩余的部分仍留在空闲分区表中;如果m.size<u.size则查找下一个空闲分区表项,直到找到一个足够大的空闲分区;如果没有找到一个足够大的内存空闲分区,但所有的小的空闲分区的容量总和大于用户的要求,就进行紧凑,将紧凑后得到的大的空闲分区按上述的方式分配给用户;但如果所有的小的空闲分区的容量总和仍不能满足用户需要,则分配失败。
国家开放大学《操作系统》形考任务2答案
国家开放大学《操作系统》形考任务2答案一、单选题1.Linux系统中的进程调度采用(抢占式优先级)。
2.Linux系统中的shell是负责(解释并执行来自终端的命令)的模块。
3.作业一旦进入内存即为执行状态,与之相关的进程在作业进入内存时予以创建,该进程的初始状态为(就绪态)。
4.作业调度选择一个作业装入主存后,该作业能否占用处理器必须由(进程调度)来决定。
5.作业调度程序从处于(后备)状态的队列中选取适当的作业调入主存运行。
放在输入井中的作业处于(后备)状态。
6.作业生存期共经历四个状态,它们是提交、后备、(执行)和完成。
7.为了使系统中各部分资源得到均衡使用,就必须选择对资源需求不同的作业进行合理搭配,这项工作是由(作业调度)完成的。
8.为了使计算机在运行过程中能及时处理内部和外部发生的各种突发性事件,现代操作系统采用了(中断)机制。
9.为了对紧急进程或重要进程进行调度,调度算法应采用(优先级法)。
10.下列存储管理方式中,存储碎片尽可能少,使内存利用率较高的是(分页管理)。
11.下列存储器中,容量最大的是(硬盘)。
12.下列存储器中,速度最快的是(CPU内部寄存器)。
13.在存储管理中,为实现地址映射,硬件应提供两个寄存器,一个是基址寄存器。
另一个是(限长寄存器)。
14.下列存储管理方案中,不采用动态重定位的是(固定分区)。
15.下列存储管理方案中,不要求将进程全部调入并且也不要求连续存储空间的是(请求分页式存储管理)。
16.下列存储管理方式中,存储碎片尽可能少,使内存利用率较高的是(分页管理)。
17.下列中断中,可能要人工介入的中断是(硬件故障中断)在页式存储管理系统中,整个系统的页表个数是(和装入主存的进程个数相同)个。
18.下列中断类型中,属于自愿性中断事件的是(访管中断)。
19.在分页存储管理系统中,从页号到物理块号的地址映射是通过(页表)实现的。
20.在页式虚拟存储管理系统中,LRU算法是指(近期最长时间以来没被访问的页先淘汰)。
可变分区存储管理及可重定位分区存储管理实验报告
可变分区存储管理及可重定位分区存储管理实验报告一、实验目的与要求通过消化理解模拟管理程序,了解存储器的分配与回收过程,体会相关数据结构在实现管理算法中的重要性。
输入一到两组实验数据,观察分配与回收的处理结果,特别是回收时邻接空闲分区的合并处理,检测其算法的正确性。
二、算法思想1、可变分区存储管理(1)算法实现a.分配:查空闲分区链表b.回收:考虑邻接合并(2)实验过程:输入操作命令代码a.分配:输入作业号及作业长度(已建立作业不重复建立)b.回收:输入作业号(不存在作业不释放空间)c .可查看空闲链表情况(检测分配、回收正确性)d.可查看作业表情况(检测分配、回收正确性)2、可重定位分区存储管理在前述可变分区存储管理实验基础上修改实现,即遇大作业存在碎片不够分配时进行合并处理。
注:实现拼接(移动,合并):设立按作业地址排列的有序链表,即用静态链表实现(作业表增加静态链仿真指针),在此基础上按地址从小到大顺序依次向前移动(紧凑处理)。
三、算法实现(可重定位分区存储管理)1、修改相关数据结构(1)作业表增加链接仿真指针int next;分量(2)构造有序静态链表(初始化时next均赋值-1)(3)增加静态链首指针Linkp及空闲总容量计数变量size(注:初始化时Linkp=-1,size=n)2、修改分配函数判断新建立作业长度是否小于等于空闲总容量size值。
若无足够大分区,则先进行合并处理后再分配;若有足够大分区,则按可变分区分配算法处理;若作业长度超过总空闲容量,则产生溢出(无内存)。
3、增加插入排序操作函数(sort_tab())分配新作业空间,则按新作业分区首地址大小,将作业表表项插入静态链表。
回收时,还必须从中删除。
4、增加拼接(移动)操作函数(compact())主要是修改作业表表目内容及空闲分区链表,用模拟操作函数move()进行模拟搬家前移。
5、增加显示静态链表内容的较出操作函数(printsorttab())四、算法流程1、可变分区存储管理(1)主程序(main()函数)(2)分配程序(allocm()函数)(3)回收程序(freem()函数)(4)显示空闲分区链表及作业表程序(printlink()及printtab()函数)注:主程序(main()函数)分配程序(allocm()函数)回收程序(freem()函数)有四种情形(假定回收区首地址=> addr,长度=> length)(1)空闲分区链表空,或不与任何空闲区邻接=> 分配新结点空间,存入回收作业首地址及长度插入空闲分区链(链首,链中,链尾)(2)回收分区与后一空闲分区相邻接=> 进行后邻接合并(3)回首分区与前一空闲分区相邻接(4)回收分区与前同时又与后空闲分区相邻接=> 需进行三个分区合并,并删除一个空闲分区结点注:除了修改空闲分区链表,还要修改作业表(清除flag标志)2、可重定位分区存储管理(1)分配程序(修改allocm()函数)(2)回收程序(修改freem()函数)(3)有序静态链表插入操作程序(sort_tab()函数)(4)拼接(移动)操作程序(compact()函数)(5)输出有序静态链表操作程序(printsorttab()函数)注:分配程序(修改allocm()函数)n,l输出作业已建立提示串,返回内存容量不够,返回置新作业作业表作业地址(分配空间)提示操作者输入新建作业的作业号及长度作业n已建立?l≤size?NYNY分配作业表表项,填入作业长度,置标志为1,总空闲容量减去l查空闲分区链表查到表尾?调用拼接操作函数compact()进行拼接处理Y分区大小=lNYN分区大小>lY修改空闲分区链表(size= l,空闲链为空(一起分配),size> l ,分割分配)作业表表目插入有序静态链表返回切割分配分区空间,修改分区链表作业表表目插入有序静态链表分区整体分配,修改分区链(删除结点)作业表表目插入有序静态链表返回查下一分区N回收程序(修改freem()函数)有序静态链表插入操作程序(sort_tab())拼接(移动)操作程序(compact())五、实验步骤1、可变分区存储管理(1)消化实验算法程序(2)组织上机实验数据(3)第一组:指定(4)第二组:自定(要求能测试各种情形)(5)输入上机程序,编译,运行,记录各操作步骤的运行结果(通过显示空闲分区链表及作业表)2、可重定位分区存储管理(1)阅读相关算法程序(2)组织调试数据(必须包含需合并的操作)(3)上机运行、调试(测试),记录运行情况,分析运行结果六、实验运行情况分析1、可变分区存储管理(1)操作程序1a.分配作业1(80k),作业3(30k),作业8(50k),作业5(140k),作业9(50k),作业6(100k),作业4(50k)b.观察(记录)空闲表及作业表情况c.回收作业8,观察结果d.分配作业7(80k),观察结果e.回收作业6, 回收作业1, 观察结果f分配作业10(120k),观察运行情况g,回收作业7,作业3,作业5,观察各次结果(2)操作程序2a.分配作业1(100k)、作业2(50k)、作业3(50k)、作业4(80k)、作业5(120k),观察结果b.回收作业4c.分配作业6(90k)d.回收作业3 f.分配作业7(140k)2、可重定位分区存储管理(1)操作程序1a.分配作业1(80k),作业3(30k),作业8(50k),作业5(140k),作业9(50k),作业6(100k),作业4(50k)b.观察(记录)空闲表及作业表情况c.回收作业8,观察结果d.分配作业7(80k),观察结果e.回收作业6, 回收作业1, 观察结果f 分配作业10(120k ),观察运行情况g,回收作业7,作业3,作业5,观察各次结果(2)操作程序2a.分配作业1(100k)、作业2(50k)、作业3(50k)、作业4(80k)、作业5(120k),观察结果b.回收作业4c.分配作业6(90k)d.回收作业3 f.分配作业7(140k )七、实验总结通过这次实验,我掌握了可变分区存储管理及可重定位分区存储管理的具体方法,对书本上的理论知识有了更深刻的认识。
现代计算机系统中内存管理地址重定位
二 、地 址 重 定 位
地 址 重 定 位 是把 虚 拟地 址 转 换成 内存 中 的物 理地 址 。 这个 过 程 又 可 以叫 地址 映射 。 内存 中 ,每 一 个 存储 单 元都 有 一 个 内
存 地址 对 应 ,内 存 空间 是 以个 一 维线 性 空 间 。如 何把 虚 拟 存储 器 中 的一 维 或 多维 线 性 空 间转 变 成 内存 的 物理 线 性 空 间。 一个 存 储 器 是 计 算机 硬 件 系统 重 要 组 成 部 分 , 是 五 大 部 件 之 问题是 虚拟 空 间 的 划分 ,虚拟 空 间 的划 分 让 不 同的程 序 模块 链 因 此对 存 储 器 管理 直 接 影 响计 算 机 的 系统 性 能 。存 储 器 有 接到统一的虚拟空间中,它与计算机的系统空间有关。另一个 内存 和 外存 组 成 。 内存 由顺 序编 址 的 物理 单 元 组成 。任 何 程 序 问题 是 如何 把 虚 拟 空 间 中的 内容 调 进 内存 ,并将 虚 拟地 址 重定 都 必 须 先调 入 内存 才 能执 行 。 系统 中对 内 存 的管理 主要 是 对 内 位 成 内存地 址 的问 题 。 实现 地址 重 定位 有 两 种 方法 :静态 地 址 存 的分 配 、 内存 的保 护 、 地 址重 定 位 和 内存 的扩 展 。本 文 主 要 重 定位 和动 态地 址重 定位 。
《操作系统原理》课程标准
理、动态链接和共享的概念;掌握存储体系的概念、存储管理的任务、页式 存储管理和段式存储管理的实现原理和地址变换、虚拟存储技术、页面置换 算法; 7 8 9 10 了解设备分类、I/O 系统;理解缓冲技术和 Spooling 系统及磁盘调度算法; 掌握 I/O 控制方式、设备分配技术; 了解文件的概念、文件系统的主要操作、文件系统的安全性;理解文件系统 的功能;掌握文件及其分类、文件的逻辑结构和物理结构的概念,文件、目 录及目录结构; 理解外存的组织形式、文件存储空间的管理方法; 理解联机命令接口、命令解释程序;掌握 Shell 命令语言、系统调用;
(2)知识目标 序号 1 2 3 4 5 6 知 识 目 标
掌握操作系统基本概念、特征、类型、功能和组织结构; 理解程序的并发执行及其特征;掌握多道程序设计、并发、进程的概念、进 程的状态及其转换、进程控制原语; 理解临界资源、临界区概念、信号量机制、PV 操作及其应用、进程间的通 信;掌握进程的同步与互斥实现方法;了解进程通信、线程的概念; 掌握作业调度和进程调度算法、理解处理机调度的层次; 掌握死锁的概念与必要条件、死锁的预防与避免、资源分配图; 了解分区管理方案、段页式存储管理、覆盖技术;理解交换技术、局部性原
模 概论 用户接口 进程管理 处理机调度与死锁 进程同步 存储管理 设备管理 文件管理 磁盘存储器管理 综合 合计 3、能力训练项目设计
块
名
称
学 时 4 4 6 6 6 8 6 6 4 2 52
根据模块内容,可将多个单元的训练要求综合考虑,设计内含多个训练任务的、具有 平行、递进关系或包含关系的一级训练项目。训练的形式包扩示范讲解,课堂练习和课外作 业。
2、课程内容设计 (1)设计的整体思路:主要内容以操作系统的功能为单位组织教学模块,兼顾篇幅进 一步细分。各模块内容相对独立,以利学习进度的控制。针对本课程理论性强、概念繁多、 知识面广的特点,各单元的学习从提出实际问题开始,引出相应的概念,介绍解决问题的方 法和技术, 并在讲授中对理论概念辅以相应的练习以加深理解和融会贯通。 据此将课程划分 为下列模块。 (2)模块设计表:
电大计算机本科《操作系统》作业及答案
《操作系统》课程作业(四)姓名班级学号一、选择题(选择一个正确答案的代码填入括号中)1.通常,用户编写的程序中所使用的地址是()。
A.逻辑地址 B.物理地址2.3.4.5.6.调入其他所需数据,称为()。
A.覆盖技术B.对换技术C.虚拟技术D.物理扩充7.分区管理中进行分区的是主存的()。
A.系统区域 B.用户区域C.程序区域 D.整个区域8.分区管理要求对每一个作业都分配()的内存单元。
A.地址连续B.若干地址不连续C.若干连续的页面D.若干不连续的页面9.固定分区中各分区的大小是()。
A.相同的 B.相同或者不同,但预先固定10.11.12.A.绝对地址=界限寄存器值+逻辑地址B.绝对地址=下限寄存器值+逻辑地址C.绝对地址=基址寄存器值+逻辑地址D.绝对地址=块号 块长+页内地址13.最先适应分配算法把空闲区()A.按地址顺序从小到大登记在空闲区表中B.按地址顺序从大到小登记在空闲区表中C.按长度以递增顺序登记在空闲区表中D.按长度以递减顺序登记在空闲区表中14.最容易形成很多小碎片的可变分区算法是()。
A.最先适应算法 B.最佳适应算法C.位示图法 D.以上都不是15.16.17.18.19.虚拟存储器的容量是由计算机的地址结构决定的,若CPU有32位地址,则它的虚拟地址空间为()。
A.100K B.640K C.2G D.4G20.在请求分页虚拟存储管理中,若所需页面不在内存中,则会引起()。
A.输入输出中断 B.时钟中断C.越界中断 D.缺页中断21.下列存储管理方案中,不要求将进程全部调入并且也不要求连续存储空间的是()。
A.固定分区 B.可变分区C.页式存储管理 D.请求分页式存储管理22.存储管理中,页面抖动是指()。
23.1.2.3.固定分区存储管理的各分区的大小不可变化,这种管理方式不适合多道程序设计系统。
()4.可重定位分区存储管理可以对作业分配不连续的内存单元。
()5.采用动态重定位技术的系统,目标程序可以不经任何改动,而装入物理内存。
(实验6)基于动态分区分配的内存管理的模拟设计与实现
(实验6)基于动态分区分配的内存管理的模拟设计与实现实验6 内存的连续分配算法一.实验目的掌握内存的连续分配方式的各种分配算法二.实验内容本系统模拟操作系统内存分配算法的实现,实现固定分区和动态分区分配,算法,采用PCB定义结构体来表示一个进程,定义了进程的名称和大小,进程内存起始地址和进程状态。
内存分区表采用单链表来模拟实现。
三.实验题目基于动态分区分配的内存管理的模拟设计与实现四.实验要求1.定义与算法相关的数据结构,如PCB,空闲分区2.在使用动态分区分配算法时必须实现紧凑和对换功能3.武汉理工大学《操作系统》课程设计说明书14{ if(FFA(id,size)==OK) cout<<"分配成功!"<<<"分配失败!"< { if(BFA(id,size)==OK) cout<<"分配成功!"<<<"分配失败!"< { if(WFA(id,size)==OK) cout<<"分配成功!"<<<"分配失败!"<<="" }="">Show() { Node *cur=head->next; while(cur){ cout<<"***********************************"<<endl;< p=""> cout<<"区号:"; if(cur->data.ID==FREE) cout<<"无"<<data.ID<<<"起始地<="" p="">址:"<data.addr<<<"分区长<="" p="">度:"<data.size<<<"状态:";<="" p="">if(cur->data.state==BUSY) cout<<"已分配"<<<"未分配"<next; 武汉理工大学《操作系统》课程设计说明书 15 } } int main() { cout<<" 动态分区分配方式的模拟"<<endl;< p="">cout<<"********************************************"<<endl; < p="">cout<<"请输入内存大小(KB):"; cin>>area; while(area<=0){ cout<<"输入错误,请重新输入内存大小(KB)"; cin>>area; } while(1){ cout<<"********************************************"<<endl ;< p="">cout<<"** 1.FFA 2.BFA 3.WFA 0.EXIT **"<<endl;< p="">cout<<"********************************************"<<endl; < p="">cout<<"请选择:"; int ch; cin>>ch; if(ch==0) { break; } Init(area); int choice; while(1) { cout<<"********************************************"<<end< p="">l; cout<<"** 1.分配 2.回收 3.查看0.退出**"<<endl;< p="">cout<<"********************************************"<<endl; < p="">cout<<"请输入您的操作:"; cin>>choice; if(choice==1) { cout<<"请输入进程个数"; int num; cin>>num;for(;num>0;num--) { Assign(ch); // 分配内存} 武汉理工大学《操作系统》课程设计说明书 16 } elseif(choice==2) // 内存回收 { int ID; cout<<"请输入您要释放的分区号:"; cin>>ID; Free(ID); } elseif(choice==3) Show();//显示主存else if(choice==0) break;else //输入操作有误{ cout<<"输入有误,请重试!"<<endl;< p="">continue; } } } return 0; }4.</endl;<> </endl;<> </endl;<> </end<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<>。
4.10 可重定位分区分配
多重分区分配
6.分区的保护
为了防止一个作业有意或无意地破坏操作系统或其它作 业。一般说来,没有硬件支持,实现有效的存储保护是困难的。 通常采取: 界限寄存器方式
保护键方式
两种措施,或二者兼而有之。
保护过程----防止地址越界
一般由硬件提供一对寄存器: 基址寄存器:存放起始地址 限长寄存器:存放长度 (上界寄存器/下界寄存器)
CH4.10 可重定位分区分配
4.10 可重定位分区分配
1. 动态重定位的引入
图 4-3-1 紧凑的示意
2. 动态重定位的实现
图 4-3-2 动态重定位示意图
3. 动态重定位分区分配算法
图 4-3-3 动态分区分配算法流程图
4.可重定位分区的优缺点
优点:解决了可变分区分配所引入的“外零头” 问题。消
1)界限寄存器保护
如果60K > 访问地址 访问地址 > =124K则产生 访问地址界中断
2)基址、限长寄存器保护
如果相对地址 > 限长寄存器的值则产生访问 地址界中断
防止操作越权
对于允许多个进程共享的存储区域,每个进程都有
自己的访问权限。如果一个进程对共享区域的访问违反
了权限规定,则发生操作越权,即读写保护。
除内存碎片,提高内存利用率。
缺点:提高硬件成本,紧凑时花费CPU时间。
5.多重分区
以上讨论都是基于一个作业在主存中占据的是一个连续
分区的假定。
为了支持结构化程序设计,操作系统往往把一道作业分 成若干片段如子程序、主程序、数据组等)。这样,片段之 间就不需要连续了。 只要增加一些重定位寄存器,就可以有效地控制一道作 业片段之间的调用。 如下图作业A、B分别被分成两个片段放进互不相连的 区域中。由两个变址寄存器实现控制。
可重定向动态分区分配算法
组号成绩计算机操作系统课程设计报告题目内存的连续分配算法基于动态分区分配的内存管理的模拟设计与实现专业:班级:学号+姓名:指导教师:2016年12月 22 日一.设计目的掌握内存的连续分配方式的各种分配算法。
二.设计内容本系统模拟操作系统内存分配算法的实现,实现动态分区分配,算法,采用PCB定义结构体来表示一个进程,定义了进程的名称和大小,进程内存起始地址和进程状态。
内存分区表采用单链表来模拟实现。
定义与算法相关的数据结构,如PCB,空闲分区;在使用动态分区分配算法时必须实现紧凑功能。
三.设计原理1.首次适应算法分配内存:空闲分区链以地址递增的次序链接。
进行内存分配时,从链首开始顺序查找,直到找到一个大小能满足要求的空闲分区为止。
然后再按照作业的大小,从该分区中划出一块内存空间,分配给请求者,余下的空闲分区仍留在空闲链中。
若从链首直至链尾都不能找到一个能满足要求的分区,则表明系统中已没有足够大的内存分配给该进程,内存分配结束,返回。
2.回收内存:当进程运行完毕释放内存时,系统根据回收区的首址,从空闲区链中找到相应的插入点:(1)回收区与插入点的前一个空闲分区F1相邻接,此时应将回收区与插入点的前一分区合并,不必为回收分区分配新表项,而只需要修改前一分区F1的大小。
(2)回收区与插入点的后一个空闲分区F2相邻接,此时将两分区合并形成新的空闲分区,但用回收区的首址作为新空闲区的首址,大小为两者之和。
(3)回收区与插入点的前后两个空闲分区相邻接,此时将三个分区合并,使用F1的表项和F1的首址,取消F2的表项,大小为三者之和。
(4)回收区与插入点的前后两个空闲分区均不相邻接,此时应为回收区单独建立一个新表项,填写回收区的首址和大小,并根据其首址插入到空闲链中的适当位置。
3.紧凑:将内存中的所有作业移动,使他们全都相邻接。
可以把原来分散的多个空闲小分区拼接成一个大分区,可将一个作业装入该区。
这种技术称为“紧凑”。
国开电大 操作系统 形考作业1-3答案
形考作业一题目随机,请使用Ctrl+F组合键查找题目题目:按照所起的作用和需要的运行环境,操作系统属于()。
题目:UNIX操作系统核心层的实现结构设计采用的是()。
题目:UNIX命令的一般格式是()。
[选项] [参数]题目:操作系统的基本职能是()题目:操作系统对缓冲区的管理属于()的功能。
题目:操作系统内核与用户程序、应用程序之间的接口是()。
题目:工业过程控制系统中运行的操作系统最好是()。
题目:进程从运行状态变为阻塞状态的原因是()。
题目:进程控制块是描述进程状态和特性的数据结构,一个进程(题目:进程与程序之间有密切联系,但又是不同的概念。
题目:两个进程合作完成一个任务,在并发执行中,一个进程要等待其合作伙伴发来信息,或者建立某个条件后再向前执行,这种关系是进程间的()关系。
题目:两个进程争夺同一个资源()。
题目:某进程由于需要从磁盘上读入数据而处于阻塞状态。
题目:批处理系统的主要缺点是()。
题目:如果信号量S的值是0 , 此时进程A执行P(S)操作,那么,进程A会()。
CPU题目:若P、V操作的信号量S初值为2,当前值为-1,则表示有()个等待进程。
题目:实时操作系统追求的目标是()。
题目:死锁的四个必要条件中,无法破坏的是()。
题目:为了描述进程的动态变化过程,采用了一个与进程相联系的(),根据它而感知进程的存在。
题目:为了使系统中所有的用户都能得到及时的响应,该操作系统应该是()。
题目:为用户分配主存空间,保护主存中的程序和数据不被破坏,提高主存空间的利用率。
题目:系统出现死锁的原因是()。
题目:系统调用是由操作系统提供的内部调用,它()。
题目:下列关于进程和线程的叙述中,正确的是()。
题目:下列关于引入线程的好处的描述中,不正确的是()。
题目:下列进程状态的转换中,不正确的是()。
题目:下列系统中,属于实时系统的是()。
题目:下面不属于分时系统特征的是()。
题目:现代操作系统的基本特征是()、资源共享和操作的异步性。
基于可重定位分区分配算法的内存管理的设计与实现
组号成绩计算机操作系统课程设计报告题目基于可重定位分区分配算法的存管理的设计与实现专业:计算机科学与技术班级:学号+:指导教师:2016年12月23 日一.设计目的掌握存的连续分配方式的各种分配算法二.设计容基于可重定位分区分配算法的存管理的设计与实现。
本系统模拟操作系统存分配算法的实现,实现可重定位分区分配算法,采用PCB定义结构体来表示一个进程,定义了进程的名称和大小,进程存起始地址和进程状态。
存分区表采用空闲分区表的形式来模拟实现。
要求定义与算法相关的数据结构,如PCB、空闲分区;在使用可重定位分区分配算法时必须实现紧凑。
三.设计原理可重定位分区分配算法与动态分区分配算法基本上相同,差别仅在于:在这种分配算法中,增加了紧凑功能。
通常,该算法不能找到一个足够大的空闲分区以满足用户需求时,如果所有的小的空闲分区的容量总和大于用户的要求,这是便须对存进行“紧凑”,将经过“紧凑”后所得到的大空闲分区分配给用户。
如果所有的小空闲分区的容量总和仍小于用户的要求,则返回分配失败信息四.详细设计及编码1.模块分析(1)分配模块这里采用首次适应(FF)算法。
设用户请求的分区大小为u.size,存中空闲分区大小为m.size,规定的不再切割的剩余空间大小为size。
空闲分区按地址递增的顺序排列;在分配存时,从空闲分区表第一个表目开始顺序查找,如果m.size≥u.size且m.size-u.size≤size,说明多余部分太小,不再分割,将整个分区分配给请求者;如果m.size≥u.size且m.size-u.size>size,就从该空闲分区中按请求的大小划分出一块存空间分配给用户,剩余的部分仍留在空闲分区表中;如果m.size<u.size则查找下一个空闲分区表项,直到找到一个足够大的空闲分区;如果没有找到一个足够大的存空闲分区,但所有的小的空闲分区的容量总和大于用户的要求,就进行紧凑,将紧凑后得到的大的空闲分区按上述的方式分配给用户;但如果所有的小的空闲分区的容量总和仍不能满足用户需要,则分配失败。
存储管理分区分配算法
存储管理分区分配算法存储管理是操作系统中的重要组成部分,其任务是有效地管理计算机系统的存储空间。
在内存中,存储空间分为若干个分区,每个分区可以用来存放一个或多个进程。
存储管理分区分配算法是指操作系统如何将进程分配到可用的存储分区中。
本文将介绍常见的存储管理分区分配算法,包括固定分区分配、动态分区分配和可变分区分配。
固定分区分配算法是最简单的一种分区分配算法,它将内存划分为若干个固定大小的分区。
每个分区可以容纳一个进程,当一个进程需要被加载到内存中时,操作系统会找到一个合适大小的空闲分区,并将进程加载到该分区中。
固定分区分配算法不需要考虑内存碎片问题,但是由于分区大小固定,会导致一些内存空间不能被充分利用。
动态分区分配算法是一种比较灵活的分区分配算法,它将内存划分为若干个变化大小的分区。
当一个进程需要被加载到内存中时,操作系统会找到一个大小合适的空闲分区,并将进程加载到该分区中。
如果内存中没有合适大小的空闲分区,操作系统可以选择进行分区的合并或者分割,以满足进程的需求。
动态分区分配算法可以更好地利用内存空间,但是它需要考虑内存碎片问题。
可变分区分配算法是一种综合了固定分区分配算法和动态分区分配算法的算法。
它可以根据不同的情况选择最合适的分区分配方式。
当内存中有大块空闲分区时,可变分区分配算法可以使用固定分区分配算法,将该分区划分为多个固定大小的小分区,以利用内存空间;当内存中只有少量小块空闲分区时,可变分区分配算法可以使用动态分区分配算法,充分利用内存碎片。
可变分区分配算法可以在固定分区分配算法和动态分区分配算法之间取得一个平衡。
综上所述,存储管理分区分配算法有固定分区分配、动态分区分配和可变分区分配三种。
不同的算法适用于不同的场景,需要根据具体情况选择最合适的算法。
固定分区分配算法适用于空间布局比较确定的情况;动态分区分配算法适用于分区大小变化比较大的情况;可变分区分配算法适用于两种情况之间的平衡。
可变分区存储管理的内存分配算法模拟实现----最佳适应算法 -回复
可变分区存储管理的内存分配算法模拟实现----最佳适应算法-回复可变分区存储管理是一种内存管理技术,其通过将内存分割成不同大小的区域来存储进程。
每个进程被分配到与其大小最匹配的区域中。
内存分配算法的选择影响了系统的性能和资源利用率。
本文将介绍最佳适应算法,并模拟实现该算法。
一、什么是最佳适应算法?最佳适应算法是一种可变分区存储管理中的内存分配策略。
它的基本思想是在每次内存分配时选择最合适的空闲区域。
具体来说,它从可用的空闲区域中选择大小与需要分配给进程的内存最接近的区域。
二、算法实现思路最佳适应算法实现的关键是如何快速找到最合适的空闲区域。
下面给出一个模拟实现的思路:1. 初始化内存分区列表,首先将整个内存定义为一个大的空闲区域。
2. 当一个进程请求分配内存时,从列表中找到与所需内存最接近的空闲区域。
3. 将该空闲区域分割成两部分,一部分分配给进程,并将该部分标记为已分配,另一部分留作新的空闲区域。
4. 更新内存分区列表。
5. 当一个进程释放内存时,将其所占用的内存区域标记为空闲,然后尝试合并相邻的空闲区域。
三、算法模拟实现下面是一个简单的Python代码实现最佳适应算法:pythonclass MemoryPartition:def __init__(self, start_addr, end_addr, is_allocated=False): self.start_addr = start_addrself.end_addr = end_addrself.is_allocated = is_allocatedclass MemoryManager:def __init__(self, total_memory):self.total_memory = total_memoryself.partition_list = [MemoryPartition(0, total_memory)]def allocate_memory(self, process_size):best_fit_partition = Nonesmallest_size = float('inf')# 找到最佳适应的空闲区域for partition in self.partition_list:if not partition.is_allocated and partition.end_addr - partition.start_addr >= process_size:if partition.end_addr - partition.start_addr < smallest_size:best_fit_partition = partitionsmallest_size = partition.end_addr - partition.start_addrif best_fit_partition:# 将空闲区域分割,并标记为已分配new_partition =MemoryPartition(best_fit_partition.start_addr,best_fit_partition.start_addr + process_size, True)best_fit_partition.start_addr += process_sizeself.partition_list.append(new_partition)return new_partition.start_addr,new_partition.end_addrelse:return -1, -1def deallocate_memory(self, start_addr, end_addr):for partition in self.partition_list:if partition.start_addr == end_addr and not partition.is_allocated:# 标记空闲区域partition.is_allocated = False# 尝试合并相邻空闲区域for next_partition in self.partition_list:if not next_partition.is_allocated andnext_partition.start_addr == end_addr:end_addr = next_partition.end_addrself.partition_list.remove(next_partition)breakelse:breakdef print_partitions(self):for partition in self.partition_list:if partition.is_allocated:print(f"Allocated Partition: {partition.start_addr} - {partition.end_addr}")else:print(f"Free Partition: {partition.start_addr} - {partition.end_addr}")# 测试最佳适应算法if __name__ == "__main__":mm = MemoryManager(1024)start, end = mm.allocate_memory(256)print(f"Allocated memory: {start} - {end}")mm.print_partitions()mm.deallocate_memory(start, end)print("Memory deallocated:")mm.print_partitions()以上代码实现了一个简单的内存管理器类`MemoryManager`,它具有`allocate_memory`和`deallocate_memory`等方法。
操作系统选择填空练习题答案
期末练习题一、单项选择题注意:蓝色的选项为正确答案。
第一章1.在计算机系统中,控制和管理各种资源、有效地组织多道程序运行的系统软件称为( B )。
A.文件系统B.操作系统C.网络管理系统 D.数据库管理系统2.按照所起的作用和需要的运行环境,操作系统属于( D )。
A.用户软件 B.应用软件C.支撑软件 D.系统软件3.操作系统的基本职能是( D )。
A. 提供功能强大的网络管理工具B. 提供用户界面,方便用户使用C. 提供方便的可视化编辑程序D. 控制和管理系统内各种资源,有效地组织多道程序的运行4.操作系统负责管理计算机系统的( C )。
A.程序 B.作业 C.资源 D.进程5.在计算机系统中,操作系统是( A )。
A.处于裸机之上的第一层软件 B.处于硬件之下的低层软件C.处于应用软件之上的系统软件 D.处于系统软件之上的用户软件6.为用户分配主存空间,保护主存中的程序和数据不被破坏,提高主存空间的利用率。
这属于( B )。
A.处理器管理 B.存储管理C.文件管理 D.作业管理7.操作系统对缓冲区的管理属于( B )的功能。
A.处理器管理 B.设备管理C.文件管理 D.存储器管理8.以下不属于操作系统关心的主要问题的是( D )。
A.管理计算机裸机B.设计、提供用户程序与计算机硬件系统的界面C.管理计算机系统资源D.高级程序设计语言的编译器9.以下不属于操作系统具备的主要功能的是( C )。
A.内存管理 B.中断处理C.文档编辑 D.CPU调度10.在下列操作系统中,强调吞吐能力的是( B )。
A.分时系统 B.多道批处理系统C.实时系统 D.网络系统11.批处理系统的主要缺点是( B )。
A.CPU的利用率不高 B.失去了交互性C.不具备并行性 D.系统吞吐量小12.为了使系统中所有的用户都能得到及时的响应,该操作系统应该是( B )。
A.多道批处理系统 B.分时系统C.实时系统 D.网络系统13.下面不属于分时系统特征的是( D )。
内存管理与地址分配原理
内存管理与地址分配原理在计算机领域中,内存管理和地址分配原理是非常重要的概念。
它涉及到计算机系统中内存资源的有效利用和分配,对于系统的性能和稳定性至关重要。
本文将详细介绍内存管理和地址分配原理的基本概念、相关算法和常见问题。
一. 概述内存管理是操作系统中的一个关键功能,它负责管理和分配计算机系统的内存资源。
内存是计算机系统中用于存储和运行程序的重要组成部分,因此有效的内存管理对于系统的运行和性能至关重要。
内存管理的主要目标是实现内存资源的高效利用和合理分配。
通过内存管理,可以提高系统的性能、稳定性和可靠性,避免内存溢出和内存泄漏等问题,同时优化程序的加载和执行效率。
二. 内存管理原理1. 内存组织结构计算机系统中的内存通常被分为多个连续的地址空间。
内存组织结构主要包括物理地址空间、虚拟地址空间和逻辑地址空间。
物理地址空间是实际存在的内存地址范围,由硬件决定。
虚拟地址空间是由操作系统提供给应用程序的一种抽象地址空间,它可以具有比物理地址空间更大的范围。
逻辑地址空间是程序员代码中使用的地址,它通过地址转换机制映射到物理地址空间或虚拟地址空间。
2. 内存分配算法内存分配算法根据不同的需求和场景,采用不同的策略进行内存分配。
a. 顺序分配算法:按照地址的顺序进行分配,简单高效,但可能会造成内存碎片。
b. 链接分配算法:通过将内存按照不同大小进行划分,并形成一个链表结构,根据需求从链表中分配相应大小的内存块。
c. 位图分配算法:使用位图来管理内存,每个位表示一个内存块的状态(被占用或空闲)。
d. 页面分配算法:将内存划分为固定大小的页面,按需分配页面。
常见的页面大小为4KB或8KB。
3. 内存回收机制内存回收是指在程序运行过程中释放不再使用的内存资源,保证内存的有效利用和及时回收。
内存回收的机制主要有以下几种:a. 手动回收:由程序员手动释放不再使用的内存,是一种较为简单直接的方式,但容易出现遗漏或错误。
内存管理方法
内存管理方法1. 概述内存管理是操作系统中非常重要的一项任务,它负责管理计算机系统中的内存资源,确保各个程序能够正常运行并共享系统内存。
内存管理方法是为了有效地使用内存资源和提高系统性能而设计的一系列策略和算法。
2. 内存管理的目标内存管理的主要目标是实现以下几个方面的要求:2.1 内存分配内存管理需要能够根据程序的需求,将内存分配给不同的进程或线程。
分配内存时需要考虑内存的大小、位置和访问权限等因素。
2.2 内存回收当一个进程或线程不再需要某块内存时,内存管理需要能够将其回收并重新分配给其他进程或线程。
内存回收可以通过垃圾回收机制或手动释放内存来实现。
2.3 内存保护内存管理需要确保每个进程或线程只能访问其被分配的内存空间,防止程序之间相互干扰或非法访问内存的情况发生。
2.4 内存共享内存管理需要支持多个进程或线程之间的内存共享,以便它们能够进行有效的通信和数据交换。
2.5 内存扩展和收缩内存管理需要能够根据系统的需求,动态地扩展或收缩内存空间,以适应不同的工作负载和内存需求。
3. 内存管理方法为了实现上述目标,操作系统采用了多种内存管理方法和算法。
下面介绍几种常见的内存管理方法:3.1 固定分区分配固定分区分配是最简单的内存管理方法之一。
它将内存划分为若干固定大小的分区,每个分区只能分配给一个进程。
这种方法的优点是实现简单,但由于分区大小固定,可能会导致内存浪费或无法满足大内存需求的程序。
3.2 动态分区分配动态分区分配是一种更灵活的内存管理方法。
它将内存分为若干大小不等的分区,每个分区可以根据进程的需求进行动态分配和回收。
动态分区分配的算法有很多种,如首次适应算法、最佳适应算法和最坏适应算法等。
3.3 页式存储管理页式存储管理是一种基于分页的内存管理方法。
它将内存和进程的地址空间划分为固定大小的页,实现了虚拟内存的概念。
页式存储管理可以将进程的页存储在磁盘上,只将当前需要的页加载到内存中,从而节省了内存空间。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
组号成绩计算机操作系统课程设计报告题目基于可重定位分区分配算法得内存管理得设计与实现专业:计算机科学与技术班级:学号+姓名:指导教师:2016年12月 23日一.设计目得掌握内存得连续分配方式得各种分配算法二.设计内容基于可重定位分区分配算法得内存管理得设计与实现.本系统模拟操作系统内存分配算法得实现,实现可重定位分区分配算法,采用PCB定义结构体来表示一个进程,定义了进程得名称与大小,进程内存起始地址与进程状态.内存分区表采用空闲分区表得形式来模拟实现。
要求定义与算法相关得数据结构,如PCB、空闲分区;在使用可重定位分区分配算法时必须实现紧凑.三.设计原理可重定位分区分配算法与动态分区分配算法基本上相同,差别仅在于:在这种分配算法中,增加了紧凑功能。
通常,该算法不能找到一个足够大得空闲分区以满足用户需求时,如果所有得小得空闲分区得容量总与大于用户得要求,这就是便须对内存进行“紧凑”,将经过“紧凑”后所得到得大空闲分区分配给用户。
如果所有得小空闲分区得容量总与仍小于用户得要求,则返回分配失败信息四.详细设计及编码1.模块分析(1)分配模块这里采用首次适应(FF)算法.设用户请求得分区大小为u、size,内存中空闲分区大小为m、size,规定得不再切割得剩余空间大小为size。
空闲分区按地址递增得顺序排列;在分配内存时,从空闲分区表第一个表目开始顺序查找,如果m、size≥u、size且m、size—u、size≤size,说明多余部分太小,不再分割,将整个分区分配给请求者;如果m、size≥u、size且m、size-u、size>size,就从该空闲分区中按请求得大小划分出一块内存空间分配给用户,剩余得部分仍留在空闲分区表中;如果m、size<u、size则查找下一个空闲分区表项,直到找到一个足够大得空闲分区;如果没有找到一个足够大得内存空闲分区,但所有得小得空闲分区得容量总与大于用户得要求,就进行紧凑,将紧凑后得到得大得空闲分区按上述得方式分配给用户;但如果所有得小得空闲分区得容量总与仍不能满足用户需要,则分配失败.(2)内存回收模块进行内存回收操作时,先随机产生一个要回收得进程得进程号,把该进程从进程表中中删除,它所释放得空闲内存空间插入到空闲分区表;如果回收区与插入点得前一个空闲分区相邻,应将回收区与插入点得前一分区合并,修改前一个分区得大小;如果回收区与插入点得后一个空闲分区相邻,应将回收区与插入点得后一分区合并,回收区得首址作为新空闲分区得首址,大小为二者之与;如果回收区同时与插入点得前、后空闲分区相邻,应将三个分区合并,使用前一个分区得首址,取消后一个分区,大小为三者之与。
(3)紧凑模块将内存中所有作业进行移动,使她们全都相邻接,把原来分散得多个空闲小分区拼接成一个大分区。
2.流程图否否就是就是3.代码实现#include〈stdio、h〉#include<stdlib、h>#include〈time、h〉#include〈windows、h〉#define TURE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define SIZE 15////////////////////////////进程表//////////////int ppNo=1; //用于递增生成进程号int pLength=0;struct PCB{int pNo;//进程号(名)int pSize; //进程大小int pOccupy;// 实际占用得内存ﻩint pStartAddr; // 进程起始地址int pState; //进程状态};struct PCBpList[200];//////////////////空闲分区表部分///////////////typedef int Status;typedef struct emptyNode{//空闲分区结构体intareaSize; //空闲分区大小ﻩint aStartAddr;//空闲分区始址struct emptyNode *next;}emptyNode,*LinkList;intListDelete(struct PCB *pList,int i);//AAA/删除下标为i得进程void pSort(struct PCB *pList); //AAA/内存中得进程按始址递增排序voidpact(LinkList &L,struct PCB *pList);//AAA/紧凑 ,内存中进程移动,修改进程数据结构;空闲分区合并,修改空闲分区表数据结构void amalgamate(LinkList &L);//AAA/回收后进行合并空闲分区void recycle(LinkList &L,struct PCB *pList); //AAA/回收,从进程表中删除进程 ,把释放出得空间插入到空闲分区链表中StatusInitList(LinkList &L);//1AAA/构造一个新得有头节点得空链表LStatus ClearList(LinkList &L);//2AAA/将链表L重置为空表Status ListInsert(LinkList &L,LinkList s1);//AAA/*****根据始址进行插入void DeleteElem(LinkList &L,int aStartAddr);//*****删除线性表中始址值为aStartAddr得结点void PrintList(LinkList L); //AAA/*****输出各结点得值voidcreatP(struct PCB*p); //AAA/初始化进程int search(LinkList &L,intpSize);//AAA/检索分区表,返回合适分区得首址int add(LinkList &L);//AAA/返回空闲分区总与void pListPrint(struct PCB *pList); //AAA/输出内存中空间占用情况void distribute(LinkList &L,struct PCB *process);int ListDelete(struct PCB *pList,int i)//AAA/删除下标为i得进程{for(;i<pLength—1;i++){ﻩﻩpList[i]=pList[i+1];}pLength——;}//ListDeletevoid pSort(structPCB*pList){ //AAA/内存中得进程按始址递增排序ﻩint i,j;struct PCB temp;for(i=0;i〈pLength—1;i++){for(j=0;j〈pLength-i-1;j++){ﻩﻩif(pList[j]、pStartAddr>pList[j+1]、pStartAddr){ﻩﻩtemp=pList[j];ﻩﻩﻩpList[j]=pList[j+1];ﻩpList[j+1]=temp;ﻩﻩﻩ}}ﻩ}}//AAA/紧凑 ,内存中进程移动,修改进程数据结构;空闲分区合并,修改空闲分区表数据结构void pact(LinkList&L,struct PCB*pList){printf(”进行紧凑\n”);ﻩ//1、进程移动,修改进程数据结构ﻩint i;pList[0]、pStartAddr=0; //第一个进程移到最上面for(i=0;i<pLength—1;i++){ﻩﻩpList[i+1]、pStartAddr=pList[i]、pStartAddr+pList[i]、pOccu py;}//2、空闲分区合并,修改空闲分区表数据结构LinkListp=L->next,s;ﻩint sumEmpty=0;ﻩwhile(p!=NULL)//求空闲区总与{ﻩﻩsumEmpty+=p—>areaSize;ﻩp=p-〉next;ﻩClearList(L); //清空空闲分区表s=(LinkList)malloc(sizeof(emptyNode));s—>aStartAddr=pList[pLength-1]、pStartAddr+pList[pLengt h—1]、pOccupy;s-〉areaSize=sumEmpty;ﻩListInsert(L,s);ﻩprintf(”\n紧凑后得〉〉>〉\n");pListPrint(pList);ﻩPrintList(L);}void amalgamate(LinkList &L){//AAA/回收后进行合并空闲分区LinkList p=L-〉next,q=p->next;while(q!=NULL){ﻩif(p—>aStartAddr+p-〉areaSize==q->aStartAddr){ﻩp—〉areaSize+=q-〉areaSize;ﻩﻩDeleteElem(L,q—〉aStartAddr);//删除被合并得结点ﻩq=p-〉next;}else{p=q;ﻩﻩq=q->next;ﻩﻩ}}//AAA/回收,从进程表中删除进程 ,把释放出得空间插入到空闲分区链表中voidrecycle(LinkList&L,struct PCB *pList){int index,delPNo,delPSize,delPOccupy,delPStartAddr;LinkList s;srand(time(0));index=rand()%pLength;delPNo=pList[index]、pNo;delPSize=pList[index]、pSize;delPOccupy=pList[index]、pOccupy;delPStartAddr=pList[index]、pStartAddr;printf("________________________________________________________________________________");printf("回收内存进程 P%d: 始址:%d K 占用:%d KB\n”,delPNo,delPStartAddr,delPOccupy);printf("\n回收后〉〉〉>\n");ListDelete(pList,index);//pListPrint(pList);s=(LinkList)malloc(sizeof(emptyNode));ﻩs—>areaSize=delPOccupy;s—>aStartAddr=delPStartAddr;ListInsert(L,s);amalgamate(L);pListPrint(pList);//输出内存中空间占用情况PrintList(L);}///////////////////////////////////////////Status InitList(LinkList&L) //1AAA/构造一个新得有头节点得空链表L {ﻩLinkList s;L=(LinkList)malloc(sizeof(emptyNode));//生成新节点(头结点)if(!L) return ERROR; //申请内存失败s=(LinkList)malloc(sizeof(emptyNode));ﻩs->areaSize=900;ﻩs->aStartAddr=0;L-〉next=s;//头节点得指针域指向第一个结点s-〉next=NULL;return OK;}//InitListStatusClearList(LinkList &L) //2AAA/将链表L重置为空表{LinkList p,r;p=L-〉next; r=p—〉next;ﻩwhile(p!=NULL){free(p);ﻩif(r==NULL){ﻩﻩp=NULL;ﻩﻩ}else{ﻩﻩp=r;ﻩﻩ r=p—〉next;}}L->next=NULL;return OK;}//ClearList//AAA/*****根据始址进行插入Status ListInsert(LinkList &L,LinkList s1){ﻩLinkList r=L,p=L—>next,s;//指针s=(LinkList)malloc(sizeof(emptyNode));ﻩs—〉areaSize=s1->areaSize;s->aStartAddr=s1—>aStartAddr;ﻩif(p==NULL){ﻩﻩL—〉next=s;s—〉next=NULL;ﻩ}else{while(p!=NULL){ﻩﻩ if(s1—>aStartAddr <p->aStartAddr){ﻩﻩs->next=r->next;ﻩr-〉next=s;ﻩﻩbreak;}r=p;ﻩﻩp=p->next; //后移ﻩ}if(p==NULL){ﻩr-〉next=s;ﻩs->next=NULL;ﻩ}}return OK;}//ListInsert2voidDeleteElem(LinkList &L,int aStartAddr)//*****删除线性表中始址值为aStartAddr得结点{ﻩLinkListp=L,q;ﻩwhile(p—>next!=NULL){ﻩq=p->next;ﻩﻩif(q->aStartAddr==aStartAddr)ﻩ{ﻩp->next=q—>next;free(q);ﻩ}ﻩelseﻩp=p—>next;ﻩ}}//DeleteElem////////////////////////////////////////////////void PrintList(LinkList L)//AAA/*****输出各结点得值{printf(”\n空闲分区情况: 始址\t 大小\n”);LinkList p=L—〉next;ﻩwhile(p!=NULL)ﻩ{printf(" %d K\t%d KB\n",p-〉aStartAdd r,p—>areaSize);ﻩﻩp=p—>next;ﻩ}printf("\n");}//PrintListvoidcreatP(struct PCB *p){ //AAA/初始化进程int size;srand(time(NULL));size=rand()%7+1;size*=10;p->pNo=ppNo++;p->pSize=size;ﻩp->pOccupy=0;ﻩp—〉pStartAddr=0;ﻩp-〉pState=0;}int search(LinkList &L,int pSize){ //检索分区表,返回合适分区得首址LinkList p=L-〉next;while(p!=NULL){ﻩif(p—>areaSize>=pSize){ﻩﻩreturn p—>aStartAddr;}ﻩp=p-〉next;}return -1;//没有足够大得}int add(LinkList &L){ //返回空闲分区总与LinkList p=L—>next;int sum=0;ﻩwhile(p!=NULL){sum+=p->areaSize;p=p->next;ﻩ}ﻩreturn sum;}voidpListPrint(struct PCB *pList){//AAA/输出内存中空间占用情况printf("\n进程分配情况:进程\t 始址\t占用\n”);for(int i=0;i<pLength;i++){ﻩprintf(" P%d\t%d K\t%d KB\n",pList[i]、pNo,pList[i]、pStartAddr,pList[i]、pOccupy);ﻩ}}void distribute(LinkList&L,structPCB *process){ﻩLinkList p=L-〉next;ﻩwhile(p!=NULL)ﻩ{ﻩif(p—>areaSize>=process->pSize)ﻩbreak;ﻩﻩp=p—〉next;ﻩ}ﻩprintf(”%d KB <%d KB”,process—>pSize,p->areaSize);ﻩif(p—〉areaSize-process->pSize〈=SIZE){ﻩ//不用分割全部分配 (直接删除此空闲分区结点)process—〉pStartAddr=p->aStartAddr; //进程始址变化ﻩprocess->pState=1; //进程状态ﻩprocess->pOccupy=p—〉areaSize; //进程实际占用内存为改空闲分区得大小ﻩpList[pLength++]= *process; //把进程加入进程列表printf(" 且%d KB - %d KB = %d KB 〈%d KB则整区分配\n”,ﻩ p->areaSize,process—>pSize,p—>areaSize—process-〉p Size,SIZE);ﻩpSort(pList);printf("\n分配后>〉>〉\n”);ﻩﻩpListPrint(pList);//输出内存中空间占用情况ﻩﻩDeleteElem(L,p->aStartAddr);}else{//分割分配process—>pStartAddr=p->aStartAddr; //进程始址变化ﻩprocess->pState=1; //进程状态ﻩprocess-〉pOccupy=process->pSize;//进程实际占用内存为该进程得大小ﻩﻩpList[pLength++]= *process;//把进程加入进程列表ﻩprintf("且%d KB - %d KB = %d KB > %d KB 则划分分配\n”,ﻩﻩ p-〉areaSize,process-〉pSize,p->areaSize—process->pSiz e,SIZE);ﻩﻩpSort(pList);//进程排序ﻩprintf(”\n分配后>>>>\n”);ﻩpListPrint(pList);//输出内存中空间占用情况ﻩ//pact(L,pList);p—〉aStartAddr+=process—>pSize;//空闲分区始址变化p—〉areaSize—=process-〉pOccupy;//空闲分区大小变化}}intmain(){ﻩ//0、创建一个进程,参数随机数方式产生ﻩstruct PCB p;ﻩ inti,num,dele,k,stAddr,flag;ﻩ LinkList s,L;ﻩprintf(”********************************可重定位分区分配********************************");if(!InitList(L))//初始化空闲分区表ﻩprintf("创建表失败\n");while(1){ﻩsrand(time(0));ﻩflag=rand()%100+1;if(flag%2==0){creatP(&p);//初始化进程printf("________________________________________________________________________________");ﻩﻩprintf(”待装入作业:%dSize = %d KB\n",p、pNo,p、pSize);//1、请求分配 size//2、检索空闲分区表(首次适应FF)ﻩPrintList(L);stAddr=search(L,p、pSize);//得到足够大得分区得始址,没有则返回—1if(stAddr==-1){//没有足够大得分区ﻩif(add(L)>=p、pSize){//空闲区总与足够大ﻩﻩprintf("没有足够大得空闲分区但空闲总与足够大\n");ﻩﻩ//紧凑ﻩpact(L,pList);ﻩ //按动态分区方式分配ﻩdistribute(L,&p);ﻩ//pact(L,pList);//紧凑ﻩﻩ}else{ //空闲区总与不足ﻩprintf("分配失败\n\n");ﻩﻩ}}else{//有足够大得distribute(L,&p);ﻩﻩPrintList(L);ﻩﻩ//pact(L,pList);//紧凑ﻩ}ﻩ}else{//回收ﻩﻩﻩif(pLength〉0){ﻩrecycle(L,pList);//pact(L,pList);//紧凑}else{ﻩprintf("无可回收内存! ”);ﻩ}}system("pause”);}//whilereturn 0;}4.结果及其相关分析图4、1分析:作业1大小为20KB。