操作系统课程设计

操作系统课程设计

（操作系统课程设计）

连续动态分区内存

管理模拟实现

学生姓名：韩慧

学生学号： 031140312

班级： 031140--3

0311401、02、03、04班制

二〇一三年十二月

目录

《操作系统》课程设计 (1)

引言 (3)

课程设计目的和内容 (3)

需求分析 (3)

概要设计 (3)

开发环境 (4)

系统分析设计.....................................................................

4

有关了解内存管理的相关理论 (4)

内存管理概念 (4)

内存管理的必要性 (4)

内存的物理组织 (4)

什么是虚拟内存 (5)

连续动态分区内存管理方式 (5)

单一连续分配（单个分区) (5)

固定分区存储管理 (5)

可变分区存储管理（动态分区） (5)

可重定位分区存储管理 (5)

问题描述和分析 (6)

程序流程图 (6)

数据结构体分析 (8)

主要程序代码分析 (9)

分析并实现四种内存分配算法 (11)

最先适应

算 (11)

下次适应分配算法 (13)

最优适应算法 (16)

最坏适应算法......................................................... (18)

回收内存算法 (20)

调试与操作说明 (22)

初始界

面 (22)

模拟内存分配 (23)

已分配分区说明表面 (24)

空闲区说明表界

面 (24)

回收内存界

面 (25)

重新申请内存界面..........................................................26.总结与体会. (28)

参考文献 (28)

引言

操作系统是最重要的系统软件，同时也是最活跃的学科之一。我们通过操作系统可以理解计算机系统的资源如何组织，操作系统如何有效地管理这些系统资源，用户如何通过操作系统与计算机系统打交道。

存储器是计算机系统的重要组成部分，近年来，存储器容量虽然一直在不断扩大，但仍不能满足现代软件发展的需要，因此，存储器仍然是一种宝贵而又紧俏的资源。如何对它加以有效的管理，不仅直接影响到存储器的利用率，而且还对系统性能有重大影响。而动态分区分配属于连续分配的一种方式，它至今仍在内存分配方式中占有一席之地。

课程设计目的和内容：

理解内存管理的相关理论，掌握连续动态分区内存管理的理论；通过对实际问题的编程实现，获得实际应用和编程能力。

编写程序实现连续动态分区内存管理方式，该程序管理一块虚拟内存，实现内存分配和回收功能。分析并实现四种内存分配算法，即最先适应算法，下次最先适应算法，最优适应算法，最坏适应算法。内存分配算法和回收算法的实现。

需求分析

动态分区分配是根据进程的实际需要，动态地为之分配内存空间。在实现动态分区分配时，将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配和回收操作这样三个问题。常用的数据结构有动态分区表和动态分区链。在对数据结构有一定掌握程度的情况下设计合理的数据结构来描述存储空间，实现分区存储管理的内存分配功能，应该选择最合适的适应算法（首次适应算法，最佳适应算法，最后适应算法，最坏适应算法），在动态分区存储管理方式

中主要实现内存分配和内存回收算法，在这些存储管理中间必然会有碎片的产生，当碎片产生时，进行碎片的拼接等相关的内容

概要设计

本程序采用机构化模块化的设计方法，共分为四大模块。

⑴最先适应算法实现

从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。为适应这种算法，空闲分区表（空闲区链）中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。

⑵下次适应分配算法实现

该算法是最先适应算法的变种。在分配内存空间时，不再每次从表头（链首）开始查找，而是从上次找到空闲区的下一个空闲开始查找，直到找到第一个能满足要求的的空闲区为止，并从中划出一块与请求大小相等的内存空间分配给作业。该算法能使内存中的空闲区分布得较均匀。

⑶最优适应算法实现

它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。

⑷最坏算法实现

最坏适应分配算法要扫描整个空闲分区或链表，总是挑选一个最大的空闲分区分割给作业使用。该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链，查找时只要看第一个分区能否满足作业要求。

开发环境：

win7 下 VC++6.0

系统分析设计：

相关算法原理，算法流程图，涉及的数据结构内容都相应包含在各章节中

有关了解内存管理的相关理论

内存管理概念：

内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。内存不是预先划分好的，而是在系统运行的过程中建立分区.当作业装入主存

时，根据作业所需要的主存容量查看是否有足够的主存空间，若有则按需要分割一个分区给该作业；否则令该作业等待.分区长度不固定分区个数不固定。这种存储管理的方法克服了固定分区严重浪费主存的问题，提高了主存资源的利用率。

内存管理的必要性：

内存管理对于编写出高效率的 Windows 程序是非常重要的，这是因为Windows 是多任务系统，它的内存管理和单任务的 DOS 相比有很大的差异。DOS 是单任务操作系统，应用程序分配到内存后，如果它不主动释放，系统是不会对它作任何改变的；但 Windows 却不然，它在同一时刻可能有多个应用程序共享内存，有时为了使某个任务更好地执行，Windows 系统可能会对其它任务分配的内存进行移动，甚至删除。因此，我们在 Windows 应用程序中使用内存时，要遵循Windows 内存管理的一些约定，以尽量提高 Windows 内存的利用率。1.3 内存的物理组织：

物理地址：

把内存分成若干个大小相等的存储单元，每个存储单元占 8 位，称作字节（byte）。每个单元给一个编号，这个编号称为物理地址（内存地址、绝对地址、实地址）。二、物理地址空间：物理地址的集合称为物理地址空间（主存地址空间），它是一个一维空间。

什么是虚拟内存：

虚拟内存是内存管理技术的一个极其实用的创新。它是一段程序（由操作系统调度），持续监控着所有物理内存中的代码段、数据段，并保证他们在运行中的效率以及可靠性，对于每个用户层（user-level）的进程分配一段虚拟内存空间。当进程建立时，不需要在物理内存件之间搬移数据，数据储存于磁盘内的虚拟内存空间，也不需要为该进程去配置主内存空间，只有当该进程被被调用的时候才会被加载到主内存。

连续动态分区内存管理方式的实现

在早期的操作系统中，主存分配广泛采用连续分配方式。连续分配方式，是指为一个用户程序分配一个连续的内存空间，该连续内存空间指的的是物理内存。下面介绍连续分配的四种方式。

单一连续分配（单个分区）

最简单的存储管理方式，用于多道程序设计技术之前。内存分为系统区和用户区，系统区由操作系统使用。用户区作为一个连续的分区分配给一个作业。分区存储管理是满足多道程序设计的最简单的一种存储管理方法，它允许多 4个用户程序同时存在系统内存中，即共享内存空间。按分区划分方式可分为固定分区和可变分区。

固定分区存储管理

把内存的用户区预先划分成多个分区，每个分区大小可以相同，也可以不同。（分区的划分由计算机的操作员或者由操作系统给出，并给出主存分配表）分区个数固定，分区的大小固定。一个分区中可装入一个作业，作业执行过程中不会改变存放区域。早期的 IBM 的 OS/MFT（具有固定任务数的多道程序系统）采用了这种固定分区的方法。

可变分区存储管理（动态分区）

内存不是预先划分好的，而是在系统运行的过程中建立分区.当作业装入主存时，根据作业所需要的主存容量查看是否有足够的主存空间，若有则按需要分割一个分区给该作业；否则令该作业等待。分区长度不固定分区个数不固定。这种存储管理的方法克服了固定分区严重浪费主存的问题，提高了主存资源的利用率。ＩＢＭ操作系统ＯＳ／ＭＶＴ采用可变分区存储管理。

可重定位分区存储管理

解决碎片问题的一种简单方法是采用可重定位分区分配.。其中心思想是，把不同程序，且在内存中地址不连续的想法让他们连续。

例：内存中现有 3 个空闲区，现有一作业到达，要求获得 30k 内存空间，没有分区满足容量要求，若想把作业装入，可将内存中所有作业进行移动，这样把原来分散的空闲区汇集成一个大的空闲区。将内存中的作业进行移动使它们连接在一起把原来分散的多个小分区拼接成一个大的空闲区.这个过程称为”紧凑”或”移动”。需解决的问题:每次”紧凑”后程序或数据装入的物理地址变化采用动态重定位。

问题描述和分析

系统应利用某种分配算法，从空闲分区链表中找到所需大小的分区，如果空闲分区大小大于请求分区大小，则从该分区中按改请求的大小划分出一块内存空间大小划分出一块内存空间分配出去，余下的部分仍留在空闲链表中。然后，将分配区的首址返回给调用者。

当进程运行完毕师范内存时，系统根据回收区的首址，从空闲区中找到相应的插入点，此时可能出现以下四种情况之一：

⑴该空闲区的上下两相邻分区都是空闲区：将三个空闲区合并为一个空闲区。新空闲区的起始地址为上空闲区的起始地址，大小为三个空闲区之和。空闲区合并后，取消可用表或自由链中下空闲区的表目项或链指针，修改上空闲区的对应项。

⑵该空闲区的上相邻区是空闲区：将释放区与上空闲区合并为一个空闲区，其起始地址为上空闲区的起始地址，大小为上空闲区与释放区之和。合并后，

修改上空闲区对应的可用表的表目项或自由链指针。

⑶该空闲区的下相邻区是空闲区：将释放区与下空闲区合并，并将释放区的起始地址作为合并区的起始地址。合并区的长度为释放区与下空闲区之和。同理，合并后修改可用表或自由链中相应的表目项或链指针。

⑷两相邻区都不是空闲区：释放区作为一个新空闲可用区插入可用表或自由

链。

程序流程图

内存分配流程图，如图

内存回收流程图，如图

数据结构体分析

⑴进程属性结构体

typedef struct readyque

{

char name[10];

int size;

}readyque,*readyqueue;

⑵空闲链表结构体

typedef struct idlyspace

{

int from;

int size;

idlyspace * next;

}idlyspace,*idly;

⑶已分配链表结构体

typedef struct busyspace

{

int from;

readyque r;

busyspace * next;

}busyspace,*busy

主要程序代码分析

⑴主函数//代码请添加适当的注释。

int main()

{

Is=(idly)malloc(sizeof(idlyspace));

Is->from=0;

Is->size=256;

Is->next=NULL;

Is2=Is;

Bs=(busy)malloc(sizeof(busyspace));

Bs->next=NULL;

int t,t1;

printf("\n.......................欢迎来到动态分区存储管理系统..................\n\n"); printf("...........................请选择要执行的算法:...........................\n");

printf("......................... 1.最先适应算法...............................\n");

printf("......................... 2.下次适应算法............................\n");

printf("..........................3.最优适应算法...............................\n");

printf("......................... 4.最坏适应算法................................\n");

printf("........................................................................\n");

printf("请输入您的选择:");

scanf("%d",&t);

int i;

while(i!=5)

{

printf("........................................................................\n");

printf(".........................操作菜单如下：（请选择）.......................n"); printf("..........................1.输入进程分配空间...........................n");

printf("......................... 2.进程撤销回收空间...........................\n");

printf("......................... 3.输出所有空闲分区..........................\n"); printf("..........................4.输出所有已分配分区..........................\n"); printf(".......................... 5.退出..........................\n");

printf("........................................................................\n");

scanf("%d",&i);

switch(i)

{

case 1:

switch(t)

{

case 1:

t1=FF();

break;

case 2:

t1=NF();

break;

case 3:

t1=BF();

break;

case 4:

t1=WF();

break;

default:

printf("选择算法错误\n");

return 1;

}

if(t1)

printf("分配空间成功\n");

else

printf("分配空间失败\n");

break;

case 2:

t1=recover();

if(t1)

printf("回收成功\n");

else

printf("回收失败\n");

break;

case 3:

Isprint();

break;

case 4:

Bsprint();

break;

}

}

return 0;

}

第三章：分析并实现四种内存分配算法

最先适应算法

空闲区按地址从小到大的次序排列。

分配：当进程申请大小为 SIZE 的内存时，系统顺序查找空闲区表（链），直到找到容量满足要求（≥SIZE）的空闲区为止。从该空闲区中划出大小为 SIZE 的分区分配给进程，余下的部分仍作为一个空闲区，但要修改其首址和大小。

优点：这种算法是尽可能地利用低地址部分的空闲区，而尽量地保证高地址6部分的大空闲区，有利于大作业的装入。

缺点:主存低地址和高地址分区利用不均衡。在低地址部分集中了许多非常小的空闲区碎片降低了主存的利用率。

最先适应算法

int FF()

{

int t=0;

readyque D;

printf“"请输入进程名:\”");

scanf“"%”",https://www.360docs.net/doc/1e16761175.html,);

printf“"输入进程申请空间大小:\”");

scanf“"%”",&D.size);

idly l=Is;

int mt=256;

busy b=Bs;

idly min=NULL;

while(l)

//寻找空闲表中大小满足申请进程所需大小并且起址最小的空闲结点

{

if(D.size<=l->size)

{

if(l->from

{ mt=l->from; min=l; t=1;

}

}

l=l->next;

}

if(mt!=256) //如果找到则为进程分配空间

{

busy j;

j=(busy)malloc(sizeof(busyspace));

j->from=min->from;

for(int i=0;i<10;i++)

{

j->https://www.360docs.net/doc/1e16761175.html,[i]=https://www.360docs.net/doc/1e16761175.html,[i];

}

j->r.size=D.size;

while(b->next)

{ if(b->next->fromfrom)

b=b->next; else

break;

}

j->next=b->next;

b->next=j;

min->from=min->from+D.size;

min->size=min->size-D.size;

}

return t;

}

下次适应分配算法

最先适应算法的变种。

总是从空闲区上次扫描结束处顺序查找空闲区表（链），直到找到第一个满足容量要求的空闲区为止，分割一部分给作业，剩余部分仍作为空闲区。

下次适应分配算法

int NF()

{

int t=0;

readyque D;

printf“"请输入进程名:\”");

scanf“"%”",https://www.360docs.net/doc/1e16761175.html,);

printf“"输入进程申请空间大小:\”");

scanf“"%”",&D.size);

int mt=256;

idly l=Is2;

idly min=NULL;

busy b=Bs;

while(l)

//寻找空闲表中大小满足申请进程所需大小并且起址最小的空闲结点

{

if(D.size<=l->size)

{

if(l->from

{ mt=l->from; min=l; t=1;

}

}

l=l->next;

}

if(mt!=256) //如果找到则为进程分配空间{

busy j;

j=(busy)malloc(sizeof(busyspace));

j->from=min->from;

for(int i=0;i<10;i++)

{

j->https://www.360docs.net/doc/1e16761175.html,[i]=https://www.360docs.net/doc/1e16761175.html,[i];

}

j->r.size=D.size;

while(b->next)

{ if(b->next->fromfrom)

b=b->next; else

break;

}

//将申请空间进程插入到已分配链表中

j->next=b->next;

b->next=j;

//修改相应空闲节点的起址和大小

min->from=min->from+D.size;

min->size=min->size-D.size;

Is2=min->next; //ls2指向修改结点的下一个结点

t=1;

return t;

}

l=Is;//l指向空闲表的头

while(l!=Is2) //循环查找

{

if(D.size<=l->size)

{

if(l->from

{ mt=l->from; min=l; t=1;

}

}

l=l->next;

}

if(mt!=256)

{

busy j;

j=(busy)malloc(sizeof(busyspace));

j->from=min->from;

for(int i=0;i<10;i++)

{

j->https://www.360docs.net/doc/1e16761175.html,[i]=https://www.360docs.net/doc/1e16761175.html,[i];

}

j->r.size=D.size;

while(b->next)

{ if(b->next->fromfrom)

b=b->next; else

break;

}

j->next=b->next;

b->next=j;

min->from=min->from+D.size;

min->size=min->size-D.size;

Is2=min->next;

t=1;

return t;

}

return t;

}

最优适应算法

空闲区按容量递增的次序排列。

分配：当进程申请存储空间，系统顺序查找空闲区表（链），直到找到第一个满足容量要求的空闲区为止。采用最优适应算法选中的空闲区是满足容量要求的最小空闲区。

优点：选中的空闲区是满足容量要求的最小空闲区，而不致于毁掉较大的空闲区。

缺点：空闲区的大小一般与申请分区大小不相等，因此将其一分为二，留下来的空闲区一般情况下是很小的，以致无法使用。随着时间的推移，系统中的小空闲区会越来越多，从而造成存储空间的浪费。

最优适应算法

int BF()

{

int t=0;

readyque D;

printf“"请输入进程名:\”");

scanf“"%”",https://www.360docs.net/doc/1e16761175.html,);

printf“"输入进程申请空间大小:\”");

scanf“"%”",&D.size);

idly l=Is;

idly min=NULL;

int mt=256;

busy b=Bs;

while(l)

//在空闲链中寻找第一个大于所输入的进程大小的空闲块

{

if(D.size<=l->size)

{

if(l->size

{

mt=l->size; min=l; t=1;

}

}

l=l->next;

}

if(mt!=256) //找到第一个满足要求的空闲块{

busy j;

j=(busy)malloc(sizeof(busyspace)); //申请分配用于存放进程的内存空间

j->from=min->from;

//将第一个满足要求的空闲块（min）的首地址赋给j

for(int i=0;i<10;i++)

{

j->https://www.360docs.net/doc/1e16761175.html,[i]=https://www.360docs.net/doc/1e16761175.html,[i];

}

j->r.size=D.size;

while(b->next)

//按从小到大的顺序查找新进程在已分配区中的位置

{ if(b->next->fromfrom)

b=b->next; else

break;

}

j->next=b->next;

b->next=j; //将所输入的进程插入进程链

min->from=min->from+D.size; //改变该空闲块的起始地址

min->size=min->size-D.size; //改变该空闲块的剩余大小

}

return t;

}

最坏适应算法

为了克服最佳适应算法把空闲区切割得太小的缺点，人们提出了一种最坏适应算法，即每次分配时，总是将最大的空闲区切去一部分分配给请求者，剩余的部分仍是一个较大的空闲区。避免了空闲区越分越小的问题。

要求空闲区按容量递减的顺序排列。

分配：进程申请存储区时，检查空闲区表（链）的第一个空闲区的大小是否满足要求，若不满足则令进程等待；若满足则从该空闲区中分配一部分存储区给用户，剩下的部分仍作为空闲区。

最坏适应算法

int WF()

{

int t=0;

readyque D;

printf“"请输入进程名:\”");

scanf“"%”",https://www.360docs.net/doc/1e16761175.html,);

printf“"输入进程申请空间大小:\”");

scanf“"%”",&D.size); //输入进程申请的空间大小

idly l=Is;//l指向空闲链表ls头

idly min=NULL;

int mt=0;

busy b=Bs; //b指向已分配链表Bs头

//找到空闲分区中大小满足进程的请求且尺寸最大的结点

while(l)

{

if(D.size<=l->size)

//判断进程所申请的大小是否小于空闲区的各结点大小

{

if(l->size>mt)

{

mt=l->size;

min=l;//min指向空闲区中尺寸最大的结点

t=1;

}

}

l=l->next; //l指向空闲链表下一个结点

}

if(mt!=0) //判断是否找到了空闲区的满足结点

{

busy j;

j=(busy)malloc(sizeof(busyspace));

j->from=min->from;

for(int i=0;i<10;i++)

{

j->https://www.360docs.net/doc/1e16761175.html,[i]=https://www.360docs.net/doc/1e16761175.html,[i];

}

j->r.size=D.size;

while(b->next) //寻找插入到已分配链表中的位置

{ if(b->next->fromfrom)

b=b->next; else

break;

}

//把此进程结点j插入到已分配链表中

j->next=b->next;

b->next=j;

//修改空闲链表的相应结点的参数

min->from=min->from+D.size;

min->size=min->size-D.size;

}

return t;

}

可变分区的回收

当某个进程释放某存储区时，系统首先检查释放区是否与系统中的空闲区相邻若相邻则把释放区合并到相邻的空闲区去，否则把释放区作为一个空闲区插入到空闲表的适当位置。

释放区与空闲区相邻的四种情况。

（1）释放区与前空闲区相邻：把释放区与前空闲区合并到一个空闲区。其首址仍为前空闲区首址，大小为释放区大小与空闲区大小之和。

（2）释放区与后空闲区相邻：则把释放区合并到后空闲区，其首地址为释放区首地址，大小为二者之和。

（3）释放区与前后两空闲区相邻：这三个区合为一个空闲区，首地址为前空闲区首址，大小为这三个空闲区之和，并取消后空闲区表目。

（4）释放区不与任何空闲区相邻：将释放区作为一个空闲区，将其大小和首址插入到空闲区表的适当位置。