动态分区分配存储管理系统

合集下载

动态分区存储管理方式的主存分配回收总结

动态分区存储管理方式的主存分配回收总结

动态分区存储管理方式的主存分配回收总结动态分区存储管理是一种常见的主存分配回收技术,它通过动态创建并分配大小不等的存储块来管理主存空间,以满足不同进程的需求。

这种管理方式在操作系统中起着至关重要的作用,因此本文将对动态分区存储管理的主存分配回收进行总结,从原理、特点、优缺点及其在实际应用中的情况进行阐述。

一、原理动态分区存储管理是基于分区的主存管理机制,它将主存空间划分为多个不等大小的分区,每个分区可以被分配给一个进程使用。

当系统收到一个新进程的请求时,它会根据需要的主存大小为进程分配一个合适大小的分区。

当进程执行完毕,系统会回收该进程所占用的分区,使得该空间可以再次被分配给其他进程使用。

在动态分区存储管理中,主要有两种分配方式:首次适应算法和最佳适应算法。

首次适应算法是从第一个满足大小要求的分区开始进行分配;而最佳适应算法是从所有满足大小要求的分区中选择最小的分区进行分配。

这两种分配方式都有自己的优点和局限性,但它们都是基于动态分区存储管理的基本原理。

二、特点1.灵活性动态分区存储管理可以根据进程的需求动态地分配和回收主存空间,提高了主存的利用率和效率。

进程可以根据需要申请和释放主存空间,而无需预先分配固定大小的空间。

2.节省空间动态分区存储管理可以尽可能地利用主存中的碎片空间,减少了外部碎片的浪费。

这种管理方式能够充分利用主存空间,提高了主存的利用率。

3.多样性动态分区存储管理可以适应不同大小的进程需求,能够根据进程的大小灵活地进行分区分配,满足了不同进程的需求。

三、优缺点1.优点(1)提高了主存的利用率和效率。

(2)灵活地分配和回收主存空间,满足不同进程的需求。

(3)节省了主存空间,减少了碎片的浪费。

2.缺点(1)会产生外部碎片,影响了分区空间的利用率。

(2)分配和回收过程中可能产生较大的开销,影响了系统的性能。

四、在实际应用中的情况动态分区存储管理在操作系统中得到了广泛的应用,特别是在多道程序设计和实时系统中。

存储管理动态分区分配及回收算法

存储管理动态分区分配及回收算法

存储管理动态分区分配及回收算法存储管理是计算机系统中的重要组成部分,它负责管理和分配计算机中的物理内存资源。

在计算机系统中,通过动态分区分配和回收算法来实现对这些资源的有效利用。

本文将介绍动态分区分配和回收算法的原理、主要算法以及优缺点。

动态分区分配是一种灵活、动态的内存分配方式,它根据进程的需求动态地分配内存空间。

动态分区分配算法有多种,其中最常用的有首次适应算法、最佳适应算法和最坏适应算法。

首次适应算法(First Fit)是最常用的分配算法之一、它从低地址开始寻找第一个满足要求的空闲分区来分配进程。

这种算法的优点是简单、高效,但是可能会产生大量的碎片空间,降低内存的利用率。

最佳适应算法(Best Fit)是在所有空闲分区中找到一个大小最适合进程的分区来分配。

它的主要思想是选择一个更接近进程大小的空闲分区,以减少碎片空间的产生。

然而,这种算法的缺点是需要遍历整个空闲分区链表,因此效率相对较低。

最坏适应算法(Worst Fit)与最佳适应算法相反,它选择一个大小最大的空闲分区来分配进程。

这种算法的好处是可以尽可能地保留大块的碎片空间,以便后续分配使用。

但是,它也会导致更多的碎片空间浪费。

动态分区的回收算法是用于回收被释放的内存空间并合并相邻的空闲分区,以尽量减少碎片空间的产生。

常见的回收算法有合并相邻空闲分区算法和快速回收算法。

合并相邻空闲分区算法会在每次有分区被回收时,检查是否有相邻的空闲分区可以合并。

如果有,就将它们合并为一个大的空闲分区。

这样可以最大程度地减少碎片空间,提高内存的利用效率。

快速回收算法是一种将被释放的分区插入到一个空闲分区链表的头部,而不是按照地址顺序进行插入的算法。

这样可以减少对整个空闲分区链表的遍历时间,提高回收的效率。

总结起来,动态分区分配和回收算法在存储管理中起着重要的作用。

首次适应算法、最佳适应算法和最坏适应算法是常用的动态分区分配算法,它们各自有着不同的优缺点。

ppt某系统采用动态分区存储管理技术某时刻内存中有三个空.ppt

ppt某系统采用动态分区存储管理技术某时刻内存中有三个空.ppt
(1)因为页表放在内存,故取一条指令(或一个操作 数)须访问两次内存,所以需0.6us×2 = 1.2us的时间。 (2)这里假定访问快表的时间可以忽略不计,命中快 表时取数只要一次访存,故此时的平均存取周期为 0.6us×0.75+1.2us×(1-0.75)=0.75us 关键:要知道访问快表的时间可以忽略不计和平均存取 周期的概念。
(1)程序空间的大小为32KB,因此逻辑地址的有效位数 是15位。
(2)内存储空间的大小是16KB,因此物理地址至少需要 14位。
(3)当页面为1KB时,虚地址0A5C表示页号为00010, 页内地址是1001011100。该页在内存的第4块,即块号为 0100,因此0A5C的物理地址是01001001011100,即 125CH。
对于逻辑地址1011 P=int(1011/1024)=0 W=1011 mod 1024=1011 A=1101=(0,1101) 查页表第0页在第2块,所以物理地址为M=1024*2+1101= 3059。
对于逻辑地址为2148 P=2148/1024=2 W=2148 mod 1024=100 A=2148=(2,100) 查页表第2页在第1块,所以物理地址为M=1024*1+100=1124。
EAT=命中快表时的存取时间×快表命中率+命中内存时的 存取时间×内存命中率+页面失效时的存取时间×页面失 效率
将题中的已知条件代入可得
EAT=1us×80%+2us×10%+(5000us+2us)×10%
=0.8us+0.2us+500.2us
=501.2us
说明:解此题除了要了解“有效存取时间”的计算公式外, 还应了解在命中快表、命中内存和页面失效三种情况下存 取时间的计算方法。特别是,当页面失效时,除了页面传 送时间,还应加上2次访问内存的时间,因为页面失效的 前提是不命中快表。

shujuku第4章习题课

shujuku第4章习题课

第四章存储器管理1.选择题1.存储保护的工作通常由实现。

A.软件B.硬件C.文件D.硬件和软件配合2.段页式存储管理中,访问快表失败时,每访问一条指令或存取一个操作数都要次访问主存。

A.1 B.2 C.3 D.43.在虚拟存储系统中,若进程在内存中占3块(开始时为空)采用先进先出页面淘汰算法,当执行访问页号序列为1、2、3、4、1、2、5、1、2、3、4、5、6时,将产生次缺页中断。

A.7 B.8 C.9 D.104.采用段页式存储管理,在CPU中应设置寄存器。

A.段表和页表控制B.段表控制C.页表控制D.界地址5.采用段页式存储管理时,内存地址分成段号、段内页号和页内地址三部分,地址。

A.但仍是线性B.但仍是二维C.故是三维D.从而成为四维6.用户程序的逻辑地址可以不连续的存储管理方式是。

A.固定分区B.可变分区C.页式D.段页7.在可变分区分配方案中,为了实现主存的空间分配,采用进行管理。

A.页表B.段表C.段表+页表D.分区分配表+空闲区表8.动态重定位是在完成的。

A.作业执行前集中一次B.作业执行过程中集中一次C.作业执行过程中D.作业执行过程中由用户9.在以下的存储管理方案中,能扩充主存容量的是。

A.固定式分区分配B.可变式分区分配C.页式存储管理D.分页虚拟存储管理10.在可变分区分配方案中,在空闲区表中以空闲区长度按递减顺序排列适合于________算法。

A.最坏适应算法B.最先适应算法C.最优适应算法D.首次循环适应算法11.在页式虚拟存储管理中,为实现地址变换,应建立。

A.空闲区表B.分区分配表C.页表D.段表12.在下述存储管理方案中,管理方式要求作业的逻辑地址与占有主存的存储区域都是连续的。

A.段页式B.页式C.段式D.可变分区13.将主存空闲区按地址顺序从小到大登记在空闲区表中,每次分配时总是顺序查找空闲区表,此种分配算法称为分配算法。

A.最先适应B.最优适应C.最坏适应D.随机适应14.页式存储管理中,每次从主存中取指令或取操作数,当读快表失败时,要读次主存。

实验三 动态分区存储管理

实验三 动态分区存储管理

实验三存储管理动态分区存储管理
实验目的
•熟悉并掌握动态分区分配的各种算法。

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

实验内容及要求
•用高级语言模拟实现动态分区存储管理,要求:
–分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。

熟悉并掌握各种算法的空闲区组织方式。

–分区的初始化——可以由用户输入初始分区的大小。

(初始化后只有一个空闲分区,起始地址为0,大小是用户输入的大小)–分区的动态分配过程:由用户输入作业号和作业的大小,实现分区过程。

–分区的回收:用户输入作业号,实现分区回收,同时,分区的合并要体现出来。

(注意:不存在的作业号要给出错误提示!)–分区的显示:任何时刻,可以查看当前内存的情况(起始地址是什么,大小多大的分区时空闲的,或者占用的,能够显示出来)
实验报告要求
•实验报告应包含但不限于以下内容:–设计图(结构图/流程图)和源代码;
–使用的编程语言和系统环境;
–结果截图;
–对结果截图的解释性说明。

注意事项
•三个动态分区分配算法可以使用一套程序,差别只在空闲分区链(表)的排序策略。

•至少完成一个分配算法。

•需完成回收算法。

动态分区分配存储管理系统

动态分区分配存储管理系统

动态分区分配存储管理系统一、设计目的与内容用高级语言编写和调试一个动态分区内存分配程序,演示实现下列两种动态分区分配算法1)首次适应算法2)循环首次适应算法1.内存中有0-100M的空间为用户程序空间,最开始用户空间是空闲的。

2.作业数量、作业大小、进入内存时间、运行时间需要通过界面进行输入。

3.可读取样例数据(要求存放在外部文件中)进行作业数量、作业大小、进入内存时间、运行时间的初始化。

4.根据作业进入内存的时间,采用简单的先进先出原则进行从外存到内存的调度,作业具有等待(从外存进入内存执行)、装入(在内存可执行)、结束(运行结束,退出内存)三种状态。

5.能够自动进行内存分配与回收,可根据需要自动进行紧凑与拼接操作。

二、算法的基本思想1、定义基本结构:1作业结构:typedefstructJOB{intnum;//作业号intsize;//作业大小intctime;//作业进入时间intrtime;//作业运行时间intstate;//作业状态}Job;2)分区结构:typedefstructDuLNode{intID;//分区号intstart;//开始地址intsize;//大小intstate;//0=尚未使用1=使用2=释放structDuLNode*prior;〃前驱指针structDuLNode*next;//后即指针}DuLNode,*DuLinkList;2、基本操作:intFirstfit(int);//首次适应算法intNext_fit(int);//循环首次适应算法voidshowJob(int);//显示作业表voidshowPartiton(DuLinkList);//显示分区表DuLinkListInitpartitionList(DuLinkList&p);//初始化voidhuishou(DuLinkListpl3,DuLinkList&pl);//回收函数intPutin(int&口);//输入函数,输入作业相关信息3、首次适应算法空闲分区链以地址递增的次序链接,分配内存时,从链首开始顺序查找,直至找到一个大小能满足要求的空闲分区为止;然后再按照作业的大小,从该分区中划出一块内存空间分配给请求者,取消的空闲分区仍留在空闲链中。

操作系统-动态分区分配算法实验报告

操作系统-动态分区分配算法实验报告

实验题目:存储器内存分配设计思路:1.既然是要对内存进行操作,首先对和内存相关的内容进行设置我使用的是用自定义的数据结构struct来存放内存中一个内存块的内容包括:始地址、大小、状态(f:空闲u:使用e:结束)之后采用数组来存放自定义的数据类型,这样前期的准备工作就完成了2.有了要加工的数据,接下来定义并实现了存放自定义数据类型的数组的初始化函数和显示函数,需要显示的是每个内存块的块号、始地址、大小、状态3.接着依此定义三种动态分区分配算法首次适应算法、最佳适应算法和最差适应算法4.对定义的三种算法逐一进行实现①首次适应算法:通过遍历存放自定义数据类型的数组,找到遍历过程中第一个满足分配大小的内存块块号i,找到之后停止对数组的遍历,将i之后的块号逐个向后移动一个,然后将满足分配大小的内存块i分为两块,分别是第i块和第i+1块,将两块的始地址、大小、状态分别更新,这样便实现了首次适应算法②最佳适应算法:和首次适应算法一样,首先遍历存放自定义数据类型的数组,找到满足分配大小的内存块后,对内存块的大小进行缓存,因为最佳适应是要找到最接近要分配内存块大小的块,所以需要遍历整个数组,进而找到满足分配大小要求的而且碎片最小的块i,之后的操作和首次遍历算法相同③最差适应算法:和最佳适应算法一样,区别在于,最佳适应是找到最接近要分配内存块大小的块,而最差适应是要找到在数组中,内存最大的块i,找到之后的操作和最佳适应算法相同,因此不在这里赘述。

5.定义并实现释放内存的函数通过块号找到要释放的内存块,把要释放的内存块状态设置成为空闲,查看要释放的块的左右两侧块的状态是否为空闲,如果有空闲,则将空闲的块和要释放的块进行合并(通过改变块的始地址、大小、状态的方式)6.定义主函数,用switch来区分用户需要的操作,分别是:①首次适应②最佳适应③最差适应④释放内存⑤显示内存⑥退出系统实验源程序加注释:#include<bits/stdc++.h>#define MI_SIZE 100 //内存大小100typedef struct MemoryInfomation//一个内存块{int start; //始地址int Size; //大小char status; //状态 f:空闲 u:使用 e:结束} MI;MI MList[MI_SIZE];void InitMList() //初始化{int i;MI temp = { 0,0,'e' };for (i = 0; i < MI_SIZE; i++){MList[i] = temp;}MList[0].start = 0; //起始为0MList[0].Size = MI_SIZE;//大小起始最大MList[0].status = 'f'; //状态起始空闲}void Display() //显示{int i, used = 0;printf("\n---------------------------------------------------\n");printf("%5s%15s%15s%15s", "块号", "始地址", "大小", "状态");printf("\n---------------------------------------------------\n");for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].status == 'u'){used += MList[i].Size;}printf("%5d%15d%15d%15s\n", i, MList[i].start, MList[i].Size, MList[i].status == 'u' ? "使用" : "空闲");}printf("\n----------------------------------------------\n");}void FirstFit(){int i, j, flag = 0;int request;printf("最先适应算法:请问你要分配多大的内存\n");scanf("%d", &request);for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].Size >= request && MList[i].status == 'f') {if (MList[i].Size - request <= 0){MList[i].status = 'u';}else{for (j = MI_SIZE - 2; j > i; j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request; MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';flag = 1;}break;}}if (flag != 1 || i == MI_SIZE || MList[i].status == 'e'){printf("没有足够大小的空间分配\n");}Display();}void BadFit(){int i, j = 0, k = 0, flag = 0, request;printf("最坏适应算法:请问你要分配多大的内存\n");scanf("%d", &request);for (i = 0;i < MI_SIZE - 1 && MList[i].status != 'e';i++){if (MList[i].Size >= request && MList[i].status == 'f') {flag = 1;if (MList[i].Size > k){k = MList[i].Size;j = i;}}}i = j;if (flag == 0){printf("没有足够大小的空间分配\n");j = i;}else if (MList[i].Size - request <= 0){MList[i].status = 'u';}else{for (j = MI_SIZE - 2;j > i;j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request;MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';}Display();}void M_Release() //释放内存{int i, number;printf("\n请问你要释放哪一块内存:\n");scanf("%d", &number);if (MList[number].status == 'u'){MList[number].status = 'f';if (MList[number + 1].status == 'f')//右边空则合并{MList[number].Size += MList[number].Size;for (i = number + 1; i < MI_SIZE - 1 && MList[i].status != 'e'; i++) { //i后面的每一个结点整体后移if (i > 0){MList[i] = MList[i + 1];}}}if (number > 0 && MList[number - 1].status == 'f')//左边空则合并{MList[number - 1].Size += MList[number].Size;for (i = number; i < MI_SIZE - 1 && MList[i].status != 'e'; i++){MList[i] = MList[i + 1];}}}else{printf("该块内存无法正常释放\n");}Display();}void BestFit(){int i, j = 0, t, flag = 0, request;printf("最佳适应算法:请问你要分配多大的内存\n");scanf("%d", &request);t = MI_SIZE;for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].Size >= request && MList[i].status == 'f'){flag = 1;if (MList[i].Size < t){t = MList[i].Size;j = i;}}}i = j;if (flag == 0){printf("没有足够大小的空间分配\n");j = i;}else if (MList[i].Size - request <= 0){MList[i].status = 'u';}else {for (j = MI_SIZE - 2; j > i; j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request;MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';}Display();}int main(){int x;InitMList();while (1){printf(" \n"); printf(" 1.首次适应\n");printf(" 2.最佳适应\n");printf(" 3.最差适应\n"); printf(" 4.释放内存\n"); printf(" 5.显示内存\n"); printf(" 6.退出系统\n"); printf("请输入1-6:");scanf("%d", &x);switch (x){case 1:FirstFit();break;case 2:BestFit();break;case 3:BadFit();break;case 4:M_Release();break;case 5:Display();break;case 6:exit(0);}}return 0;}实验测试结果记录:1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:1最先适应算法:请问你要分配多大的内存10---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 90 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:1最先适应算法:请问你要分配多大的内存25---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 65 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:1最先适应算法:请问你要分配多大的内存15---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 15 使用3 50 50 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:1最先适应算法:请问你要分配多大的内存20---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 15 使用3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:4请问你要释放哪一块内存:---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 空闲1 10 25 使用2 35 15 使用3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:4请问你要释放哪一块内存:2---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 空闲1 10 25 使用2 35 15 空闲3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:2最佳适应算法:请问你要分配多大的内存5---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 5 使用1 5 5 空闲2 10 25 使用3 35 15 空闲4 50 20 使用5 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:3最坏适应算法:请问你要分配多大的内存25---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 5 使用1 5 5 空闲2 10 25 使用3 35 15 空闲4 50 20 使用5 70 25 使用6 95 5 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:总结与自评:总结:分区存储管理是操作系统进行内存管理的一种方式。

动态分区管理方式及动态分区算法

动态分区管理方式及动态分区算法

动态分区管理方式及动态分区算法一、动态分区概述在操作系统中,内存管理是一个非常重要的部分。

在实际的应用中,程序的内存需求是会发生变化的,因此需要一种灵活的内存管理方式来满足不同程序的内存需求。

动态分区管理方式应运而生,它可以根据程序的需求,灵活地分配和回收内存空间,是一种高效的内存管理方式。

二、动态分区管理方式动态分区管理方式是指将内存划分为多个大小不等的分区,每个分区都可以被分配给进程使用,当进程终止时,分区将被回收。

动态分区管理方式通常通过动态分区算法来实现,下面将介绍几种常见的动态分区算法。

三、首次适应算法首次适应算法是最简单和最直观的动态分区分配算法。

它的基本思想是在空闲分区链表中按照位置区域顺序查找第一个能够满足进程大小需求的空闲分区,并将其分配给进程。

首次适应算法的优点是实现简单,分区利用率较高,但缺点是会产生大量的不连续碎片。

四、最佳适应算法最佳适应算法是在空闲分区链表中查找满足进程大小需求的最小空闲分区,并将其分配给进程。

最佳适应算法的优点是可以减少外部碎片,缺点是查找适合的空闲分区会花费较长的时间。

五、最坏适应算法最坏适应算法是在空闲分区链表中查找满足进程大小需求的最大空闲分区,并将其分配给进程。

最坏适应算法的优点是能够产生较小的碎片,但缺点是会导致剩余分区较多,影响分区利用率。

六、动态分区管理方式的优缺点动态分区管理方式相比于静态分区管理方式有很多优点,比如可以灵活地满足不同程序的内存需求,可以动态地合并和分割分区,提高了内存的利用率等。

但是动态分区管理方式也有一些缺点,比如会产生碎片,分配和回收内存的开销较大等。

七、结语动态分区管理方式及其算法在实际应用中有着广泛的应用,通过合理选择动态分区算法,可以提高内存的利用率,改善系统性能。

也需要注意动态分区管理方式可能产生的碎片问题,可以通过内存紧缩等手段来解决。

希望本文对读者有所帮助。

动态分区管理方式及动态分区算法八、碎片问题与解决方法在动态分区管理方式中,经常会出现碎片问题,包括内部碎片和外部碎片。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

动态分区分配存储管理系统学院专业学号学生姓名指导教师姓名2014年3月19 日一、课题要求课程设计的目的:操作系统课程设计是计算机专业重要的教学环节,它为学生提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。

● 进一步巩固和复习操作系统的基础知识。

● 培养学生结构化程序、模块化程序设计的方法和能力。

● 提高学生调试程序的技巧和软件设计的能力。

● 提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。

设计内容:用高级语言编写和调试一个动态分区内存分配程序,演示实现下列两种动态分区分配算法1. 首次适应算法2. 循环首次适应算法设计要求:1. 内存中有0-100M 的空间为用户程序空间,最开始用户空间是空闲的2. 作业数量、作业大小、进入内存时间、运行时间需要通过界面进行输入3. 可读取样例数据(要求存放在外部文件中)进行作业数量、作业大小、进入内存时间、运行时间的初始化4. 根据作业进入内存的时间,采用简单的先进先出原则进行从外存到内存的调度,作业具有等待(从外存进入内存执行)、装入(在内存可执行)、结束(运行结束,退出内存)三种状态。

(为了简化,不考虑CPU 的调度与切换,运行时间为作业在内存中驻留的时间)5. 能够自动进行内存分配与回收,可根据需要自动进行紧凑与拼接操作,所有过程均有动态图形变化的显示6. 采用可视化界面,可随时暂停显示当前内存分配和使用情况图。

设计结束需提交下列资料:1、课程设计报告。

报告中至少应包括:相关操作系统的知识介绍,程序总的功能说明、程序各模块的功能说明、程序设计的流程图、源程序清单。

2、源程序和编译连接后的可执行程序文件。

时间安排:分析设计贮备阶段(1 天)编程调试阶段(7 天)写课程设计报告、考核(2 天)二、算法思想1、定义基本结构:1作业结构:typedef struct JOB{int num; //作业号int size; //作业大小int ctime; //作业进入时间int rtime; //作业运行时间int state; //作业状态}Job;2)分区结构:typedef struct DuLNode{int ID; //分区号int start; //开始地址int size; //大小int state; //0=尚未使用1=使用2=释放struct DuLNode *prior;//前向指针struct DuLNode *next; //后向指针}DuLNode, * DuLinkList;2、基本操作:int Firstfit(int);//首次适应算法int Next_fit(int); //循环首次适应算法void showJob(int); //显示作业表void showPartiton(DuLinkList);//显示分区表DuLinkList InitpartitionList(DuLinkList &p);//初始化void huishou(DuLinkList pl3,DuLinkList &pl);//回收函数int Putin(int &n);//输入函数,输入作业相关信息3、首次适应算法空闲分区链以地址递增的次序链接,分配内存时,从链首开始顺序查找,直至找到一个大小能满足要求的空闲分区为止;然后再按照作业的大小,从该分区中划出一块内存空间分配给请求者,取消的空闲分区仍留在空闲链中。

若从链首直至链尾都不能找到一个能满足要求的分区,则此次内存分配失败,返回。

4、循环首次适应算法在为进程分配内存空间时,不再是每次都从链首开始查找,而是从上次找到的空闲分区的下一个空闲分区开始查找,直至找到一个能满足要求的空闲分区,从中划出一块与请求大小相等的内存空间分配给作业。

三、主要功能模块流程图主函数:首次适应算法:循环首次适应算法四、系统测试1、输入界面2、首次适应算法:3、循坏首次适应算法:五、源程序#include <stdio.h>#include <stdlib.h>#include <iostream.h>#include <windows.h>#define Free 0#define Use 1#define MAX_length 100 //最大内存空间为100MB//--------------作业结构体数组----------------------------typedef struct JOB{int num; //作业号int size; //作业大小int ctime; //作业进入时间int rtime; //作业运行时间int state; //作业状态}Job;typedef struct DuLNode{int ID; //分区号int start; //开始地址int size; //大小int state; //0=尚未使用1=使用2=释放struct DuLNode *prior;//前向指针struct DuLNode *next; //后向指针}DuLNode, * DuLinkList;//-------------------------------------------------------------------------------int Firstfit(int);//首次适应算法int Next_fit(int); //循环首次适应算法void showJob(int); //显示作业表void showPartiton(DuLinkList);//显示分区表//-----------------------------------------------------------------------------//---------------------------全局变量------------------------------------------- int f;Job *A; //排序前Job *a; //排序后Job *temp;//--------------------------------------------------------------------------------//------------------------初始化--------------------------------------------------- DuLinkList InitpartitionList(DuLinkList &p){p=(DuLinkList)malloc(sizeof(DuLNode));//申请空间if(!p)exit(0);p->size=100; //初始化大小printf("输入分区首地址:");scanf("%d",&p->start);p->state=0; //状态置空闲p->ID=0; //分区号p->next=NULL;p->prior=NULL;return p;}//------------------------------------------------------------------------------//-----------------------------输入函数--------------------------------------------- int Putin(int &n){int i;Job temp;printf("输入作业个数:");scanf("%d",&n);a=(Job*)malloc(n*sizeof(Job));A=(Job*)malloc(n*sizeof(Job));for(i=0;i<n;i++){printf("\n");printf("作业号:");scanf("%d",&a[i].num);printf("作业大小:");scanf("%d",&a[i].size);printf("作业进入时间:");scanf("%d",&a[i].ctime);printf("作业运行时间:");scanf("%d",&a[i].rtime);a[i].state=0; //默认状态为FreeA[i] = a[i];}for(int j = 0;j < n;j++)for(i = j;i< n;i++)if(a[j].ctime > a[i].ctime){temp = a[j];a[j] = a[i];a[i] = temp;}//冒泡排序freopen("data.txt","w",stdout);for (i = 0;i < n;i++){printf("%d %d %d %d\n",a[i].num,a[i].size,a[i].ctime,a[i].rtime); }fclose(stdout);freopen("CON","w",stdout);printf("保存成功\n\n");return 1;}//---------------------------------------------------------------------------------------- //-----------------------------读文件----------------------------------------------------- int order(int &n){Job temp;printf("Input the number of the task:\n");scanf("%d",&n);a=(Job*)malloc(n*sizeof(Job));freopen("data.txt","r",stdin);for(int i=0;i<n;i++){scanf("%d",&a[i].num);scanf("%d",&a[i].size);scanf("%d",&a[i].ctime);scanf("%d",&a[i].rtime);}fclose(stdin);freopen("CON","r",stdin);for(int j = 0;j < n;j++)for(i = j;i< n;i++)if(a[j].ctime > a[i].ctime){temp = a[j];a[j] = a[i];a[i] = temp;}return 1;}//------------------------------------------------------------------------//-------------------------显示分区-------------------------------void showPartition(DuLinkList pl){printf("\n分区表\n");printf("---------------------------------------\n");printf("开始地址\t分区号\t大小状态\n");printf("---------------------------------------\n");while(pl){printf(" %d\t\t%d\t%d\t",pl->start,pl->ID,pl->size);if(pl->state == 0)printf("空闲\n");if(pl->state == 1)printf("已分配\n");pl=pl->next;}printf("---------------------------------------\n");}//-------------------------------------------------------------------------//---------------------------------回收函数---------------------------------void huishou(DuLinkList pl3,DuLinkList &pl){while(pl3){if(pl3->state==0){if(pl3->next&&pl3->prior&&pl3->prior->state==0&&pl3->next->state==1){pl3->size+=pl3->prior->size;pl3->start=pl3->prior->start;pl3->state=0;pl3->ID=0;if(pl3->prior->prior){pl3->prior->prior->next=pl3;pl3->prior=pl3->prior->prior;}else{pl3->prior=pl3->prior->prior;pl=pl3;pl3=pl;}}else if(pl3->prior&&pl3->next&&pl3->next->state==0&&pl3->prior->state==1) {pl3->size+=pl3->next->size;pl3->state=0;pl3->ID=0;if(pl3->next->next){pl3->next->next->prior=pl3;pl3->next=pl3->next->next;}else{pl3->next=pl3->next->next;}}else if(!pl3->prior){if(pl3->next->state==0){pl3->size+=pl3->next->size;pl3->state=0;pl3->ID=0;if(pl3->next->next)pl3->next->next->prior=pl3;pl3->next=pl3->next->next;}else{pl3->state=0;}}else if(!pl3->next){if(pl3->prior->state==0){pl3->size+=pl3->prior->size;pl3->state=0;pl3->ID=0;pl3->start=pl->start;if(pl3->prior->prior){pl3->prior->prior->next=pl3;pl3->prior=pl3->prior->prior;}else{ pl3->prior=NULL;pl=pl3;pl3=pl;}}else{pl3->state=0;}}else if(pl3->next&&pl3->prior&&pl3->next->state==0&&pl3->prior->state==0) {pl3->size=pl3->size+pl3->next->size+pl3->prior->size;pl3->state=0;pl3->ID=0;pl3->start=pl3->prior->start;if(pl3->next->next)pl3->next->next->prior=pl3;if(pl3->prior->prior){pl3->prior->prior->next=pl3;pl3->next=pl3->next->next;pl3->prior=pl3->prior->prior;}else{pl3->next=pl3->next->next;pl3->prior=pl3->prior->prior;pl=pl3;pl3=pl;}}}pl3=pl3->next;}}//--------------------------------------------------------------------------------------//----------------------------------首次适应算法--------------------------------------- void Firstfit(DuLinkList block_first,int n){int t=1;int num=n;while(t&&num){DuLinkList pl1=block_first,pl2,pl3=block_first;printf("时钟:%d\n",t);DuLNode *p=block_first;DuLNode *q=block_first;for(int m=0;m<n;m++){if(t==a[m].ctime+a[m].rtime){num-=1;a[m].state=2;while(q){if(q->ID==a[m].num){q->state=Free;}q=q->next;}showJob(n);showPartition(block_first);}}for( m=0;m<n;m++){if(a[m].ctime==t){a[m].state=1;printf("作业:%d开始运行,对其分配!",a[m].num);}}for( m=0;m<n;m++){if(t==a[m].ctime){while(pl1&&(pl1->state == 1||pl1->size<a[m].size)) pl1=pl1->next;if(pl1){pl2=(DuLinkList)malloc(sizeof(DuLNode));pl2->start=pl1->start+a[m].size;pl2->state=0;pl2->ID=0;pl2->size=pl1->size-a[m].size;if(pl2->size>5){pl1->size=a[m].size;pl1->state=1;pl1->ID=a[m].num;if(pl1->next)pl1->next->prior=pl2;pl2->next=pl1->next;pl2->prior=pl1;pl1->next=pl2;pl1=block_first;}else{pl1->state=1;pl1->ID=a[m].num;}showJob(n);showPartition(block_first); }else{cout<<"内存不足,等待释放"<<endl;for(int i=m;i<n;i++){a[i].ctime+=1;}p=block_first;huishou(p, block_first);}}}t+=1;}}//---------------------------------------------------------------//---------------------------显示作业----------------------------void showJob(int n){printf("\n作业表:\n");printf("--------------------------------------------------------------\n");printf(" 作业号\t大小\t进入时间\t运行时间\t状态\n");printf("--------------------------------------------------------------\n");for(int m=0;m<n;m++){printf(" %d\t %d\t%d\t %d\t",a[m].num,a[m].size,a[m].ctime,a[m].rtime);if(a[m].state == 0)printf(" 等待\n");if(a[m].state == 1)printf(" 装入\n");if(a[m].state == 2)printf(" 结束\n");}printf("--------------------------------------------------------------\n");}//---------------------------------------------------------------------//-------------------- 循环首次适应算法------------------------void Nextfit(DuLinkList block_first,int n){int t=1;int num=n;DuLinkList flag;flag=block_first;while(t&&num){DuLinkList pl1=block_first,pl2,pl3=block_first; printf("时钟:%d\n",t);DuLNode *p=block_first;DuLNode *q=block_first;for(int m=0;m<n;m++){if(t==a[m].ctime+a[m].rtime){num-=1;a[m].state=2;while(q){if(q->ID==a[m].num){q->state=Free;}q=q->next;}showJob(n);showPartition(block_first);}}for( m=0;m<n;m++){if(a[m].ctime==t){a[m].state=1;printf("作业:%d开始运行,对其分配!",a[m].num);}}for( m=0;m<n;m++){if(t==a[m].ctime){while(flag&&(flag->state == 1||flag->size<a[m].size)) flag=flag->next;pl1=flag;if(pl1){pl2=(DuLinkList)malloc(sizeof(DuLNode));pl2->start=pl1->start+a[m].size;pl2->state=0;pl2->ID=0;pl2->size=pl1->size-a[m].size;if(pl2->size>5){pl1->size=a[m].size;pl1->state=1;pl1->ID=a[m].num;if(pl1->next)pl1->next->prior=pl2;pl2->next=pl1->next;pl2->prior=pl1;pl1->next=pl2;pl1=block_first;}else{pl1->state=1;pl1->ID=a[m].num;}flag=pl2;showJob(n);showPartition(block_first); }else{cout<<"内存不足,等待释放"<<endl;for(int i=m;i<n;i++){a[i].ctime+=1;}p=block_first;huishou(p, block_first);flag=block_first;}}}t+=1;}}//------------------------------------------------------------------------------------- //----------------------------界面输入--------------------------------------------- void inputchoice(int &ch){cout<<" "<<endl;cout<<"1.首次适应算法"<<endl;cout<<"2.循环首次适应算法"<<endl;cout<<"3.退出"<<endl;cout<<" "<<endl;cout<<"请输入选择:"<<endl;scanf("%d",&ch);}//-------------------------------------------------------------------------------------- void main(){ DuLinkList p;int n,ch;ch = 0;f = 1;cout<<" "<<endl;cout<<" 动态分区分配存储管理系统"<<endl;cout<<" "<<endl;Putin(n);while(f){inputchoice(ch);switch(ch){case 1:InitpartitionList(p);Firstfit(p,n);ch = 0;break;case 2:InitpartitionList(p);Nextfit(p, n);ch = 0;break;case 3:f = 0;break;}}}。

相关文档
最新文档