计算机操作系统报告.docx
《计算机操作系统报告.docx》由会员分享，可在线阅读，更多相关《计算机操作系统报告.docx（40页珍藏版）》请在冰点文库上搜索。
计算机操作系统报告
淮阴工学院
姓名:
学号：
班级:
学院:
计算机与软件工程学院
专业:
计算机科学与技术
指导教师：
2017
年
12
月
实验一：
存储器的分配与回收算法实现
一、实验内容
1.模拟操作系统的主存分配，运用可变分区的存储管理算法设计主存分配和回收程序，并不实际启动装入作业。
2.采用最先适应法、最佳适应法、最坏适应法分配主存空间。
3.当一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。
若找到的空闲区大于作业需要量，这是应把它分成二部分，一部分为占用区，加一部分又成为一个空闲区。
4.当一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
5.运行所设计的程序，输出有关数据结构表项的变化和内存的当前状态。
二、实验要求：
1．详细描述实验设计思想、程序结构及各模块设计思路；
2．详细描述程序所用数据结构及算法；
3．明确给出测试用例和实验结果；
4．为增加程序可读性，在程序中进行适当注释说明；
5．认真进行实验总结，包括：
设计中遇到的问题、解决方法与收获等；
6．实验报告撰写要求结构清晰、描述准确逻辑性强；
3、实验过程
1.设计思想：
运用可变分区的存储管理算法设计主存分配和回收。
一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。
一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
最先适应法
最佳适应法
最坏适应法
设计思路：
利用链表对已有作业进行排序，并根据地址判断该作业状态。
2.所用数据库结构：
循环链表
3.测试用例和结果：
初始内存状况:
（选择最坏适应法）
*******************************************
=开始地址==大小==结束地址==状态=
80601400
3040700
020200
第一次分配32,
第二次分配14,
第三次分配23
最终结果：
空闲内存如下:
********************************************************
4426700
13551400
已分配区如下:
**************************************************************
开始地址大小结束地址状态进程号
803211211
1122313511
30144412
4.注释已在代码中
5.实验总结：
存储器的分配与回收算法实现方法，采用最先适应法、最佳适应法、最坏适应法分配主存空间。
当一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。
当一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
本次实验对于队列数据结构有些陌生，发现自己对课程的掌握不太牢固，课后应进行仔细的复习，加深印象。
对某些算法的理解不太透彻，应该巩固完善。
在网络和同学的帮助下最终得以解决。
并使我更加深刻的了解了计算机操作系统中内存分配的执行过程，内存回收的执行过程的方式。
对以后的学习和应用奠定了良好的基础。
6.实验源代码：
#include
//链式结构
typedefstructrt
{
//起始地址
intstartaddress;
//内存区大小
intsize;
//内存区状态
intstate;
structrt*next;
structrt*last;
//已分配区的进程号
intthread;
}memory;
//空闲区链表
memory*head=NULL;
//已分配区链表
memory*top=NULL;
//全局进程号
intthreadnum;
//按首地址排序
voidsort（）
//循环指针变量
memory*p,*q;
intr;
intt;
//交换记录变量
ints;
p=head;
//冒泡排序
for（p=p->next;p!
=NULL;p=p->next）
for（q=p->next;q!
=NULL;q=q->next）
if（q->startaddressstartaddress）
t=p->startaddress;p->startaddress=q->startaddress;q->startaddress=t;
s=p->size;p->size=q->size;q->size=s;
t=r;s=r->next;r=r->last;
//改变指针操作，建立r和s之间的指针关系，“孤立”t
r->next=s;if（s!
=NULL）s->last=r;
//释放t
free（t）;
}
//开始端重叠，或者开始端在当前结点的左边，结束端在当前结点的左右端之间
elseif（start==left&&left{//内存被局部释放，进程遭破坏，标记状态为结束，进程号清零r->startaddress=end;r->size-=（end-left）;r->state=0;r->thread=0;}//结束端重叠，或者结束端在当前结点的右边，开始端在当前结点的左右端之间elseif（leftright）{//内存被局部释放，进程遭破坏，标记状态为结束，进程号清零r->startaddress=left;r->size=（start-left）;r->state=0;}//开始和结束端都被包含，则结点被拆成了两个elseif（start>left&&end{//内存被局部释放，进程遭破坏，标记状态为结束，进程号清零，前一部分为rr->startaddress=left;r->size=（start-left）;r->state=0;r->thread=0;//新建一个结点w=（memory*）malloc（sizeof（memory））;//后一部分为ww->state=1;w->startaddress=end;w->size=（right-end）;w->state=0;w->thread=0;//将w加入以已配表if（r->next!=NULL）r->next->last=w;w->next=r->next;r->next=w;w->last=r;}}//在空闲区里寻找与需要释放的内存区域有公共区域的结点for（r=head->next;r!=NULL;r=r->next）{//记录当前结点的左右端left=r->startaddress;right=r->startaddress+r->size;//s-el-r两段无重叠，在结点左边if（end{//增加一个空闲区的结点w=（memory*）malloc（sizeof（memory））;//结点状态为结束，起始地址为start，大小为sizew->state=0;w->startaddress=start;w->size=size;//改变指针操作cout<<"回收完内存后，已分配区状态如下:\n";if（which==1）sortn（）;//首次适应法if（which==2）sortn2（）;//最佳适应法if（which==3）sortn3（）;//最坏适应法printn（）;}cout<<"新一轮操作即将开始，请按任意键继续...";//下一组开始}//5秒过后，重新发问elseif（type=='n'）Sleep（5000）;//停止elseif（type==EOF）break;}return0;}7.实验截图：分配块数为3，最坏适应法：分配完成： 实验二死锁 一、实验题目设计一个n个并发进程共享m个系统资源的系统。进程可动态申请资源和释放资源，系统按各进程的申请动态的分配资源。要求采用银行家算法防止死锁。二、实验目的死锁会引起计算机工作僵死，造成整个系统瘫痪。因此，死锁现象是操作系统特别是大型系统中必须设法防止的。通过本次实验，使学生掌握死锁的概念和产生死锁的原因和必要条件，预防和避免死锁的方法，死锁的检测与解除。通过本次实验，使学生加深了对死锁概念的理解和掌握，深刻领会银行家算法的实质及实现过程。三、设计思想1．程序流程图安全（safe）函数框图如下：2．逻辑设计用结构体数组表示3个进程，其中包括使用数组形式的线性表表示某个进程申请资源的列表（队列），以及进程需要的总资源数、进程当前已经运行到的位置等信息。模拟分配的程序部分，采用循环队列对各进程进行调度。3、物理设计全局变量的结构定义如下：boolavoid;structinfo//进程信息{longtot,n;//最大占用资源,申请次数longlist[16];//申请资源列表longpre[16];//已占用资源数longp;//已分配状况的指针}pro[4];longLeftRes;程序的结构定义如下：intmain（）//主函数{init（）;allot（）;}voidinit（）//函数功能:输入和初始化voidallot（）//函数功能:模拟资源分配过程allot（）使用以下函数模拟分配过程：boolrequire（longx）//函数功能:尝试分配资源给进程xboolsafe（longx）//函数功能:检查分配是否安全可以处理3种资源的程序全局变量结构如下：//共有3种资源，3个进程boolavoid;structinfo//进程信息{longtot[4];//最大占用资源数longp[4];//已经占有的资源数}pro[5];longLeftRes[4];//剩余资源数longqu[4];四、测试结果对于一组会导致死锁的数据，分别选择采用和不采用避免算法，结果如下：Avoiddeadlock?（Y/N）YPleaseinputtheresourse-requirelistsofthese3processes,onelistsinaline:23423331=================================================================Process1:234（Sum=9）Process2:233（Sum=8）Process3:31（Sum=4）=================================================================Process1require2unit（s）resourse......Success!LeftResourse=8Process2require2unit（s）resourse......Success!LeftResourse=6Process3require3unit（s）resourse......Success!LeftResourse=3Process1require3unit（s）resourse......Denied!NotsafeProcess2require3unit（s）resourse......Denied!NotsafeProcess3require1unit（s）resourse......Success!LeftResourse=2Process3finish.LeftResourse=6Process1require3unit（s）resourse......Denied!NotsafeProcess2require3unit（s）resourse......Success!LeftResourse=3Process1require3unit（s）resourse......Denied!NotsafeProcess2require3unit（s）resourse......Success!LeftResourse=0Process2finish.LeftResourse=8Process1require3unit（s）resourse......Success!LeftResourse=5Process1require4unit（s）resourse......Success!LeftResourse=1Process1finish.LeftResourse=10Finish如果不避免死锁：Avoiddeadlock?（Y/N）NPleaseinputtheresourse-requirelistsofthese3processes,onelistsinaline:23423331=================================================================Process1:234（Sum=9）Process2:233（Sum=8）Process3:31（Sum=4）=================================================================Process1require2unit（s）resourse......Success!LeftResourse=8Process2require2unit（s）resourse......Success!LeftResourse=6Process3require3unit（s）resourse......Success!LeftResourse=3Process1require3unit（s）resourse......Success!LeftResourse=0Process2require3unit（s）resourse......Denied!NoenoughresourseProcess3require1unit（s）resourse......Denied!NoenoughresourseProcess1require4unit（s）resourse......Denied!NoenoughresourseAlreadyDeadlockFinish改进版本（可以使用3种资源的程序）测试结果如下：五、实验总结银行家算法是一个经典的避免死锁的算法，它可以有效的避免资源分配时产生死锁。但死锁的避免时相当复杂的，而且浪费时间。每次分配时都要进行分配检查看是否会产生死锁，通过实验加深对银行家算法的了解和认识，同时对避免死锁的机制也有所了解。实验不仅锻炼了我动手能力，也巩固了我课堂所学的知识。只有在实验过程中我们才能深刻的认识到课本知识的重要性。实验采用银行家算法避免在资源分配时产生死锁现象。六、附录：源代码（带注释）#include#include#include#include//共有3种资源，3个进程boolavoid;structinfo//进程信息{longtot[4];//最大占用资源数longp[4];//已经占有的资源数}pro[5];longLeftRes[4];//剩余资源数longqu[4];voidinit（）//函数功能:输入和初始化}if（avoid）{if（safe（x））{;}else{printf（"申请被拒绝!不符合安全规则。\n"）;return;}}else{printf（"申请成功!\n"）;}printf（"\n===============================================================\n"）;for（i=1;i<=3;i++）{printf（"\n%s%ld%-15s","进程",i,"（占用/最大）"）;for（j=1;j<=3;j++）{if（i==x&&!avoid）pro[i].p[j]+=qu[i];printf（"%4ld/%3ld",pro[i].p[j],pro[i].tot[j]）;}}printf（"\n===============================================================\n\n"）;}voidallot（）//函数功能:模拟资源分配过程{longi,j;printf（"请输入申请资源的进程ID，以及申请的各种资源数量:\n"）;scanf（"%ld",&i）;for（j=1;j<=3;j++）{scanf（"%ld",&qu[j]）;}require（i）;}intmain（）{init（）;allot（）;return0;}实验三主存空间的分配和回收一、实验目的熟悉主存的分配与回收。理解在不同的存储管理方式下，如何实现主存空间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。二、实验内容和要求主存的分配和回收的实现是与主存储器的管理方式有关的。所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。所谓回收，就是当作业运行完成时将作业或进程所占的主存空间归还给系统。可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求，并且分区个数是可以调整的。当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入，作业等待。随着作业的装入、完成，主存空间被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的。实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、循环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。三、实验主要仪器设备和材料硬件环境：IBM-PC或兼容机软件环境：VC++6.0四、实验原理及设计方案1、循环首次适应算法在该算法中，把主存中所有空闲区按其物理地址递增的次序排列。在为作业分配存储空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直到找到第一个能满足要求的空闲区，从中划出与请求的大小相等的存储空间分配给作业，余下的空闲区仍留在空闲区表或链中。1、实验步骤（1）初始化空闲分区；（2）反复对现有的空闲分区进行进程创建和撤消，即内存分配和回收；（3）退出。 3、流程图五、结果过程及截图初始化主存大小后的状态按1后分配一块内存：按1后分配一块内存：按2释放内存：六、实验总结总之，编写主存空间的分配和回收的过程有（如解决实际问题）。从解决实际问题的角度，我们可以这样来看：首先要了解这个问题的基本要求，即输入、输出、完成从输入到输出的要求是什么；其次，从问题的要害入手，从前到后的解决问
//内存被局部释放，进程遭破坏，标记状态为结束，进程号清零
r->startaddress=end;r->size-=（end-left）;r->state=0;r->thread=0;}
//结束端重叠，或者结束端在当前结点的右边，开始端在当前结点的左右端之间
elseif（leftright）
r->startaddress=left;r->size=（start-left）;r->state=0;
//开始和结束端都被包含，则结点被拆成了两个
elseif（start>left&&end{//内存被局部释放，进程遭破坏，标记状态为结束，进程号清零，前一部分为rr->startaddress=left;r->size=（start-left）;r->state=0;r->thread=0;//新建一个结点w=（memory*）malloc（sizeof（memory））;//后一部分为ww->state=1;w->startaddress=end;w->size=（right-end）;w->state=0;w->thread=0;//将w加入以已配表if（r->next!=NULL）r->next->last=w;w->next=r->next;r->next=w;w->last=r;}}//在空闲区里寻找与需要释放的内存区域有公共区域的结点for（r=head->next;r!=NULL;r=r->next）{//记录当前结点的左右端left=r->startaddress;right=r->startaddress+r->size;//s-el-r两段无重叠，在结点左边if（end{//增加一个空闲区的结点w=（memory*）malloc（sizeof（memory））;//结点状态为结束，起始地址为start，大小为sizew->state=0;w->startaddress=start;w->size=size;//改变指针操作cout<<"回收完内存后，已分配区状态如下:\n";if（which==1）sortn（）;//首次适应法if（which==2）sortn2（）;//最佳适应法if（which==3）sortn3（）;//最坏适应法printn（）;}cout<<"新一轮操作即将开始，请按任意键继续...";//下一组开始}//5秒过后，重新发问elseif（type=='n'）Sleep（5000）;//停止elseif（type==EOF）break;}return0;}7.实验截图：分配块数为3，最坏适应法：分配完成： 实验二死锁 一、实验题目设计一个n个并发进程共享m个系统资源的系统。进程可动态申请资源和释放资源，系统按各进程的申请动态的分配资源。要求采用银行家算法防止死锁。二、实验目的死锁会引起计算机工作僵死，造成整个系统瘫痪。因此，死锁现象是操作系统特别是大型系统中必须设法防止的。通过本次实验，使学生掌握死锁的概念和产生死锁的原因和必要条件，预防和避免死锁的方法，死锁的检测与解除。通过本次实验，使学生加深了对死锁概念的理解和掌握，深刻领会银行家算法的实质及实现过程。三、设计思想1．程序流程图安全（safe）函数框图如下：2．逻辑设计用结构体数组表示3个进程，其中包括使用数组形式的线性表表示某个进程申请资源的列表（队列），以及进程需要的总资源数、进程当前已经运行到的位置等信息。模拟分配的程序部分，采用循环队列对各进程进行调度。3、物理设计全局变量的结构定义如下：boolavoid;structinfo//进程信息{longtot,n;//最大占用资源,申请次数longlist[16];//申请资源列表longpre[16];//已占用资源数longp;//已分配状况的指针}pro[4];longLeftRes;程序的结构定义如下：intmain（）//主函数{init（）;allot（）;}voidinit（）//函数功能:输入和初始化voidallot（）//函数功能:模拟资源分配过程allot（）使用以下函数模拟分配过程：boolrequire（longx）//函数功能:尝试分配资源给进程xboolsafe（longx）//函数功能:检查分配是否安全可以处理3种资源的程序全局变量结构如下：//共有3种资源，3个进程boolavoid;structinfo//进程信息{longtot[4];//最大占用资源数longp[4];//已经占有的资源数}pro[5];longLeftRes[4];//剩余资源数longqu[4];四、测试结果对于一组会导致死锁的数据，分别选择采用和不采用避免算法，结果如下：Avoiddeadlock?（Y/N）YPleaseinputtheresourse-requirelistsofthese3processes,onelistsinaline:23423331=================================================================Process1:234（Sum=9）Process2:233（Sum=8）Process3:31（Sum=4）=================================================================Process1require2unit（s）resourse......Success!LeftResourse=8Process2require2unit（s）resourse......Success!LeftResourse=6Process3require3unit（s）resourse......Success!LeftResourse=3Process1require3unit（s）resourse......Denied!NotsafeProcess2require3unit（s）resourse......Denied!NotsafeProcess3require1unit（s）resourse......Success!LeftResourse=2Process3finish.LeftResourse=6Process1require3unit（s）resourse......Denied!NotsafeProcess2require3unit（s）resourse......Success!LeftResourse=3Process1require3unit（s）resourse......Denied!NotsafeProcess2require3unit（s）resourse......Success!LeftResourse=0Process2finish.LeftResourse=8Process1require3unit（s）resourse......Success!LeftResourse=5Process1require4unit（s）resourse......Success!LeftResourse=1Process1finish.LeftResourse=10Finish如果不避免死锁：Avoiddeadlock?（Y/N）NPleaseinputtheresourse-requirelistsofthese3processes,onelistsinaline:23423331=================================================================Process1:234（Sum=9）Process2:233（Sum=8）Process3:31（Sum=4）=================================================================Process1require2unit（s）resourse......Success!LeftResourse=8Process2require2unit（s）resourse......Success!LeftResourse=6Process3require3unit（s）resourse......Success!LeftResourse=3Process1require3unit（s）resourse......Success!LeftResourse=0Process2require3unit（s）resourse......Denied!NoenoughresourseProcess3require1unit（s）resourse......Denied!NoenoughresourseProcess1require4unit（s）resourse......Denied!NoenoughresourseAlreadyDeadlockFinish改进版本（可以使用3种资源的程序）测试结果如下：五、实验总结银行家算法是一个经典的避免死锁的算法，它可以有效的避免资源分配时产生死锁。但死锁的避免时相当复杂的，而且浪费时间。每次分配时都要进行分配检查看是否会产生死锁，通过实验加深对银行家算法的了解和认识，同时对避免死锁的机制也有所了解。实验不仅锻炼了我动手能力，也巩固了我课堂所学的知识。只有在实验过程中我们才能深刻的认识到课本知识的重要性。实验采用银行家算法避免在资源分配时产生死锁现象。六、附录：源代码（带注释）#include#include#include#include//共有3种资源，3个进程boolavoid;structinfo//进程信息{longtot[4];//最大占用资源数longp[4];//已经占有的资源数}pro[5];longLeftRes[4];//剩余资源数longqu[4];voidinit（）//函数功能:输入和初始化}if（avoid）{if（safe（x））{;}else{printf（"申请被拒绝!不符合安全规则。\n"）;return;}}else{printf（"申请成功!\n"）;}printf（"\n===============================================================\n"）;for（i=1;i<=3;i++）{printf（"\n%s%ld%-15s","进程",i,"（占用/最大）"）;for（j=1;j<=3;j++）{if（i==x&&!avoid）pro[i].p[j]+=qu[i];printf（"%4ld/%3ld",pro[i].p[j],pro[i].tot[j]）;}}printf（"\n===============================================================\n\n"）;}voidallot（）//函数功能:模拟资源分配过程{longi,j;printf（"请输入申请资源的进程ID，以及申请的各种资源数量:\n"）;scanf（"%ld",&i）;for（j=1;j<=3;j++）{scanf（"%ld",&qu[j]）;}require（i）;}intmain（）{init（）;allot（）;return0;}实验三主存空间的分配和回收一、实验目的熟悉主存的分配与回收。理解在不同的存储管理方式下，如何实现主存空间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。二、实验内容和要求主存的分配和回收的实现是与主存储器的管理方式有关的。所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。所谓回收，就是当作业运行完成时将作业或进程所占的主存空间归还给系统。可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求，并且分区个数是可以调整的。当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入，作业等待。随着作业的装入、完成，主存空间被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的。实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、循环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。三、实验主要仪器设备和材料硬件环境：IBM-PC或兼容机软件环境：VC++6.0四、实验原理及设计方案1、循环首次适应算法在该算法中，把主存中所有空闲区按其物理地址递增的次序排列。在为作业分配存储空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直到找到第一个能满足要求的空闲区，从中划出与请求的大小相等的存储空间分配给作业，余下的空闲区仍留在空闲区表或链中。1、实验步骤（1）初始化空闲分区；（2）反复对现有的空闲分区进行进程创建和撤消，即内存分配和回收；（3）退出。 3、流程图五、结果过程及截图初始化主存大小后的状态按1后分配一块内存：按1后分配一块内存：按2释放内存：六、实验总结总之，编写主存空间的分配和回收的过程有（如解决实际问题）。从解决实际问题的角度，我们可以这样来看：首先要了解这个问题的基本要求，即输入、输出、完成从输入到输出的要求是什么；其次，从问题的要害入手，从前到后的解决问
//内存被局部释放，进程遭破坏，标记状态为结束，进程号清零，前一部分为r
r->startaddress=left;r->size=（start-left）;r->state=0;r->thread=0;
//新建一个结点
w=（memory*）malloc（sizeof（memory））;
//后一部分为w
w->state=1;w->startaddress=end;w->size=（right-end）;w->state=0;w->thread=0;
//将w加入以已配表
if（r->next!
=NULL）r->next->last=w;w->next=r->next;r->next=w;w->last=r;
//在空闲区里寻找与需要释放的内存区域有公共区域的结点
for（r=head->next;r!
=NULL;r=r->next）
//记录当前结点的左右端
left=r->startaddress;right=r->startaddress+r->size;
//s-el-r两段无重叠，在结点左边
if（end{//增加一个空闲区的结点w=（memory*）malloc（sizeof（memory））;//结点状态为结束，起始地址为start，大小为sizew->state=0;w->startaddress=start;w->size=size;//改变指针操作cout<<"回收完内存后，已分配区状态如下:\n";if（which==1）sortn（）;//首次适应法if（which==2）sortn2（）;//最佳适应法if（which==3）sortn3（）;//最坏适应法printn（）;}cout<<"新一轮操作即将开始，请按任意键继续...";//下一组开始}//5秒过后，重新发问elseif（type=='n'）Sleep（5000）;//停止elseif（type==EOF）break;}return0;}7.实验截图：分配块数为3，最坏适应法：分配完成： 实验二死锁 一、实验题目设计一个n个并发进程共享m个系统资源的系统。进程可动态申请资源和释放资源，系统按各进程的申请动态的分配资源。要求采用银行家算法防止死锁。二、实验目的死锁会引起计算机工作僵死，造成整个系统瘫痪。因此，死锁现象是操作系统特别是大型系统中必须设法防止的。通过本次实验，使学生掌握死锁的概念和产生死锁的原因和必要条件，预防和避免死锁的方法，死锁的检测与解除。通过本次实验，使学生加深了对死锁概念的理解和掌握，深刻领会银行家算法的实质及实现过程。三、设计思想1．程序流程图安全（safe）函数框图如下：2．逻辑设计用结构体数组表示3个进程，其中包括使用数组形式的线性表表示某个进程申请资源的列表（队列），以及进程需要的总资源数、进程当前已经运行到的位置等信息。模拟分配的程序部分，采用循环队列对各进程进行调度。3、物理设计全局变量的结构定义如下：boolavoid;structinfo//进程信息{longtot,n;//最大占用资源,申请次数longlist[16];//申请资源列表longpre[16];//已占用资源数longp;//已分配状况的指针}pro[4];longLeftRes;程序的结构定义如下：intmain（）//主函数{init（）;allot（）;}voidinit（）//函数功能:输入和初始化voidallot（）//函数功能:模拟资源分配过程allot（）使用以下函数模拟分配过程：boolrequire（longx）//函数功能:尝试分配资源给进程xboolsafe（longx）//函数功能:检查分配是否安全可以处理3种资源的程序全局变量结构如下：//共有3种资源，3个进程boolavoid;structinfo//进程信息{longtot[4];//最大占用资源数longp[4];//已经占有的资源数}pro[5];longLeftRes[4];//剩余资源数longqu[4];四、测试结果对于一组会导致死锁的数据，分别选择采用和不采用避免算法，结果如下：Avoiddeadlock?（Y/N）YPleaseinputtheresourse-requirelistsofthese3processes,onelistsinaline:23423331=================================================================Process1:234（Sum=9）Process2:233（Sum=8）Process3:31（Sum=4）=================================================================Process1require2unit（s）resourse......Success!LeftResourse=8Process2require2unit（s）resourse......Success!LeftResourse=6Process3require3unit（s）resourse......Success!LeftResourse=3Process1require3unit（s）resourse......Denied!NotsafeProcess2require3unit（s）resourse......Denied!NotsafeProcess3require1unit（s）resourse......Success!LeftResourse=2Process3finish.LeftResourse=6Process1require3unit（s）resourse......Denied!NotsafeProcess2require3unit（s）resourse......Success!LeftResourse=3Process1require3unit（s）resourse......Denied!NotsafeProcess2require3unit（s）resourse......Success!LeftResourse=0Process2finish.LeftResourse=8Process1require3unit（s）resourse......Success!LeftResourse=5Process1require4unit（s）resourse......Success!LeftResourse=1Process1finish.LeftResourse=10Finish如果不避免死锁：Avoiddeadlock?（Y/N）NPleaseinputtheresourse-requirelistsofthese3processes,onelistsinaline:23423331=================================================================Process1:234（Sum=9）Process2:233（Sum=8）Process3:31（Sum=4）=================================================================Process1require2unit（s）resourse......Success!LeftResourse=8Process2require2unit（s）resourse......Success!LeftResourse=6Process3require3unit（s）resourse......Success!LeftResourse=3Process1require3unit（s）resourse......Success!LeftResourse=0Process2require3unit（s）resourse......Denied!NoenoughresourseProcess3require1unit（s）resourse......Denied!NoenoughresourseProcess1require4unit（s）resourse......Denied!NoenoughresourseAlreadyDeadlockFinish改进版本（可以使用3种资源的程序）测试结果如下：五、实验总结银行家算法是一个经典的避免死锁的算法，它可以有效的避免资源分配时产生死锁。但死锁的避免时相当复杂的，而且浪费时间。每次分配时都要进行分配检查看是否会产生死锁，通过实验加深对银行家算法的了解和认识，同时对避免死锁的机制也有所了解。实验不仅锻炼了我动手能力，也巩固了我课堂所学的知识。只有在实验过程中我们才能深刻的认识到课本知识的重要性。实验采用银行家算法避免在资源分配时产生死锁现象。六、附录：源代码（带注释）#include#include#include#include//共有3种资源，3个进程boolavoid;structinfo//进程信息{longtot[4];//最大占用资源数longp[4];//已经占有的资源数}pro[5];longLeftRes[4];//剩余资源数longqu[4];voidinit（）//函数功能:输入和初始化}if（avoid）{if（safe（x））{;}else{printf（"申请被拒绝!不符合安全规则。\n"）;return;}}else{printf（"申请成功!\n"）;}printf（"\n===============================================================\n"）;for（i=1;i<=3;i++）{printf（"\n%s%ld%-15s","进程",i,"（占用/最大）"）;for（j=1;j<=3;j++）{if（i==x&&!avoid）pro[i].p[j]+=qu[i];printf（"%4ld/%3ld",pro[i].p[j],pro[i].tot[j]）;}}printf（"\n===============================================================\n\n"）;}voidallot（）//函数功能:模拟资源分配过程{longi,j;printf（"请输入申请资源的进程ID，以及申请的各种资源数量:\n"）;scanf（"%ld",&i）;for（j=1;j<=3;j++）{scanf（"%ld",&qu[j]）;}require（i）;}intmain（）{init（）;allot（）;return0;}实验三主存空间的分配和回收一、实验目的熟悉主存的分配与回收。理解在不同的存储管理方式下，如何实现主存空间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。二、实验内容和要求主存的分配和回收的实现是与主存储器的管理方式有关的。所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。所谓回收，就是当作业运行完成时将作业或进程所占的主存空间归还给系统。可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求，并且分区个数是可以调整的。当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入，作业等待。随着作业的装入、完成，主存空间被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的。实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、循环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。三、实验主要仪器设备和材料硬件环境：IBM-PC或兼容机软件环境：VC++6.0四、实验原理及设计方案1、循环首次适应算法在该算法中，把主存中所有空闲区按其物理地址递增的次序排列。在为作业分配存储空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直到找到第一个能满足要求的空闲区，从中划出与请求的大小相等的存储空间分配给作业，余下的空闲区仍留在空闲区表或链中。1、实验步骤（1）初始化空闲分区；（2）反复对现有的空闲分区进行进程创建和撤消，即内存分配和回收；（3）退出。 3、流程图五、结果过程及截图初始化主存大小后的状态按1后分配一块内存：按1后分配一块内存：按2释放内存：六、实验总结总之，编写主存空间的分配和回收的过程有（如解决实际问题）。从解决实际问题的角度，我们可以这样来看：首先要了解这个问题的基本要求，即输入、输出、完成从输入到输出的要求是什么；其次，从问题的要害入手，从前到后的解决问
//增加一个空闲区的结点
//结点状态为结束，起始地址为start，大小为size
w->state=0;w->startaddress=start;w->size=size;
//改变指针操作
cout<<"回收完内存后，已分配区状态如下:
\n";
if（which==1）sortn（）;//首次适应法
if（which==2）sortn2（）;//最佳适应法
if（which==3）sortn3（）;//最坏适应法
printn（）;
cout<<"新一轮操作即将开始，请按任意键继续...";
//下一组开始
//5秒过后，重新发问
elseif（type=='n'）Sleep（5000）;
//停止
elseif（type==EOF）
break;
return0;
7.实验截图：
分配块数为3，最坏适应法：
分配完成：
实验二死锁
一、实验题目
设计一个n个并发进程共享m个系统资源的系统。
进程可动态申请资源和释放资源，系统按各进程的申请动态的分配资源。
要求采用银行家算法防止死锁。
二、实验目的
死锁会引起计算机工作僵死，造成整个系统瘫痪。
因此，死锁现象是操作系统特别是大型系统中必须设法防止的。
通过本次实验，使学生掌握死锁的概念和产生死锁的原因和必要条件，预防和避免死锁的方法，死锁的检测与解除。
通过本次实验，使学生加深了对死锁概念的理解和掌握，深刻领会银行家算法的实质及实现过程。
三、设计思想
1．程序流程图
安全（safe）函数框图如下：
2．逻辑设计
用结构体数组表示3个进程，其中包括使用数组形式的线性表表示某个进程申请资源的列表（队列），以及进程需要的总资源数、进程当前已经运行到的位置等信息。
模拟分配的程序部分，采用循环队列对各进程进行调度。
3、物理设计
全局变量的结构定义如下：
boolavoid;
structinfo//进程信息
longtot,n;//最大占用资源,申请次数
longlist[16];//申请资源列表
longpre[16];//已占用资源数
longp;//已分配状况的指针
}pro[4];
longLeftRes;
程序的结构定义如下：
intmain（）//主函数
init（）;
allot（）;
voidinit（）//函数功能:
输入和初始化
voidallot（）//函数功能:
模拟资源分配过程
allot（）使用以下函数模拟分配过程：
boolrequire（longx）//函数功能:
尝试分配资源给进程x
boolsafe（longx）//函数功能:
检查分配是否安全
可以处理3种资源的程序全局变量结构如下：
//共有3种资源，3个进程
longtot[4];//最大占用资源数
longp[4];//已经占有的资源数
}pro[5];
longLeftRes[4];//剩余资源数
longqu[4];
四、测试结果
对于一组会导致死锁的数据，分别选择采用和不采用避免算法，
结果如下：
Avoiddeadlock?
（Y/N）Y
Pleaseinputtheresourse-requirelistsofthese3processes,onelistsinaline:
234
233
31
=================================================================
Process1:
234（Sum=9）
Process2:
233（Sum=8）
Process3:
31（Sum=4）
Process1require2unit（s）resourse......Success!
LeftResourse=8
Process2require2unit（s）resourse......Success!
LeftResourse=6
Process3require3unit（s）resourse......Success!
LeftResourse=3
Process1require3unit（s）resourse......Denied!
Notsafe
Process2require3unit（s）resourse......Denied!
Process3require1unit（s）resourse......Success!
LeftResourse=2
Process3finish.LeftResourse=6
Process2require3unit（s）resourse......Success!
LeftResourse=0
Process2finish.LeftResourse=8
Process1require3unit（s）resourse......Success!
LeftResourse=5
Process1require4unit（s）resourse......Success!
LeftResourse=1
Process1finish.LeftResourse=10
Finish
如果不避免死锁：
（Y/N）N
Pleaseinputtheresourse-requirelistsofthese3processes,onelistsinalin
e:
Noenoughresourse
Process3require1unit（s）resourse......Denied!
Process1require4unit（s）resourse......Denied!
AlreadyDeadlock
改进版本（可以使用3种资源的程序）测试结果如下：
五、实验总结
银行家算法是一个经典的避免死锁的算法，它可以有效的避免资源分配时产生死锁。
但死锁的避免时相当复杂的，而且浪费时间。
每次分配时都要进行分配检查看是否会产生死锁，通过实验加深对银行家算法的了解和认识，同时对避免死锁的机制也有所了解。
实验不仅锻炼了我动手能力，也巩固了我课堂所学的知识。
只有在实验过程中我们才能深刻的认识到课
本知识的重要性。
实验采用银行家算法避免在资源分配时产生死锁现象。
六、附录：
源代码（带注释）
if（avoid）
if（safe（x））
;
else
printf（"申请被拒绝!
不符合安全规则。
\n"）;
return;
printf（"申请成功!
printf（"\n===========================================================
====\n"）;
for（i=1;i<=3;i++）
printf（"\n%s%ld%-15s","进程",i,"（占用/最大）"）;
for（j=1;j<=3;j++）
if（i==x&&!
avoid）
pro[i].p[j]+=qu[i];
printf（"%4ld/%3ld",pro[i].p[j],pro[i].tot[j]）;
====\n\n"）;
longi,j;
printf（"请输入申请资源的进程ID，以及申请的各种资源数量:
scanf（"%ld",&i）;
scanf（"%ld",&qu[j]）;
require（i）;
intmain（）
实验三主存空间的分配和回收
一、实验目的
熟悉主存的分配与回收。
理解在不同的存储管理方式下，如何实现主存空间的分配与回收。
掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。
二、实验内容和要求
主存的分配和回收的实现是与主存储器的管理方式有关的。
所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。
所谓回收，就是当作业运行完成时将作业或进程所占的主存空间归还给系统。
可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求，并且分区个数是可以调整的。
当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入，作业等待。
随着作业的装入、完成，主存空间被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的。
实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、循环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。
同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。
三、实验主要仪器设备和材料
硬件环境：
IBM-PC或兼容机
软件环境：
VC++6.0
四、实验原理及设计方案
1、循环首次适应算法
在该算法中，把主存中所有空闲区按其物理地址递增的次序排列。
在为作业分配存储空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直到找到第一个能满足要求的空闲区，从中划出与请求的大小相等的存储空间分配给作业，余下的空闲区仍留在空闲区表或链中。
1、实验步骤
（1）初始化空闲分区；
（2）反复对现有的空闲分区进行进程创建和撤消，即内存分配和回收；
（3）退出。
3、流程图
五、结果过程及截图
初始化主存大小后的状态
按1后分配一块内存：
按2释放内存：
六、实验总结
总之，编写主存空间的分配和回收的过程有（如解决实际问题）。
从解决实际问题的角度，我们可以这样来看：
首先要了解这个问题的基本要求，即输入、输出、完成从输入到输出的要求是什么；其次，从问题的要害入手，从前到后的解决问
copyright@ 2008-2023 冰点文库 网站版权所有
经营许可证编号:鄂ICP备19020893号-2
升级会员 