计算机操作系统报告Word文档下载推荐.docx
《计算机操作系统报告Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《计算机操作系统报告Word文档下载推荐.docx（39页珍藏版）》请在冰豆网上搜索。
循环链表
3.测试用例和结果：
初始内存状况:
（选择最坏适应法）
*******************************************
=开始地址==大小==结束地址==状态=
80601400
3040700
020200
第一次分配32,
第二次分配14,
第三次分配23
最终结果：
空闲内存如下:
********************************************************
4426700
020200
13551400
已分配区如下:
**************************************************************
开始地址大小结束地址状态进程号
803211211
1122313511
30144412
4.注释已在代码中
5.实验总结：
存储器的分配与回收算法实现方法，采用最先适应法、最佳适应法、最坏适应法分配主存空间。
当一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。
当一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
本次实验对于队列数据结构有些陌生，发现自己对课程的掌握不太牢固，课后应进行仔细的复习，加深印象。
对某些算法的理解不太透彻，应该巩固完善。
在网络和同学的帮助下最终得以解决。
并使我更加深刻的了解了计算机操作系统中内存分配的执行过程，内存回收的执行过程的方式。
对以后的学习和应用奠定了良好的基础。
6.实验源代码：
#include<
stdio.h>
stdlib.h>
string.h>
iostream.h>
windows.h>
//链式结构
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->
q!
q=q->
{
if（q->
startaddress<
p->
startaddress）
{
t=p->
startaddress;
startaddress=q->
q->
startaddress=t;
s=p->
size;
size=q->
size=s;
t=r;
s=r->
r=r->
last;
//改变指针操作，建立r和s之间的指针关系，“孤立”t
r->
next=s;
if（s!
=NULL）s->
last=r;
//释放t
free（t）;
}
//开始端重叠，或者开始端在当前结点的左边，结束端在当前结点的左右端之间
elseif（start==left&
&
left<
end&
end<
right||start<
left&
right）
//内存被局部释放，进程遭破坏，标记状态为结束，进程号清零
startaddress=end;
r->
size-=（end-left）;
state=0;
thread=0;
}
//结束端重叠，或者结束端在当前结点的右边，开始端在当前结点的左右端之间
elseif（left<
start&
start<
right&
end==right||left<
end>
startaddress=left;
size=（start-left）;
//开始和结束端都被包含，则结点被拆成了两个
elseif（start>
//内存被局部释放，进程遭破坏，标记状态为结束，进程号清零，前一部分为r
//新建一个结点
w=（memory*）malloc（sizeof（memory））;
//后一部分为w
w->
state=1;
w->
size=（right-end）;
//将w加入以已配表
if（r->
next!
=NULL）r->
next->
last=w;
next=r->
next=w;
}
//在空闲区里寻找与需要释放的内存区域有公共区域的结点
for（r=head->
r!
//记录当前结点的左右端
left=r->
right=r->
startaddress+r->
//s-el-r两段无重叠，在结点左边
if（end<
left）
//增加一个空闲区的结点
//结点状态为结束，起始地址为start，大小为size
startaddress=start;
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种资源的程序）测试结果如下：
五、实验总结
银行家算法是一个经典的避免死锁的算法，它可以有效的避免资源分配时产生死锁。
但死锁的避免时相当复杂的，而且浪费时间。
每次分配时都要进行分配检查看是否会产生死锁，通过实验加深对银行家算法的了解和认识，同时对避免死锁的机制也有所了解。
实验不仅锻炼了我动手能力，也巩固了我课堂所学的知识。
只有在实验过程中我们才能深刻的认识到课
本知识的重要性。
实验采用银行家算法避免在资源分配时产生死锁现象。
六、附录：
源代码（带注释）
#include<
cstdio>
cstring>
cstdlib>
ctime>
if（avoid）
if（safe（x））
else
printf（"
申请被拒绝!
不符合安全规则。
\n"
）;
return;
申请成功!
\n===========================================================
====\n"
for（i=1;
i<
=3;
i++）
\n%s%ld%-15s"
"
进程"
i,"
（占用/最大）"
for（j=1;
j<
j++）
if（i==x&
!
avoid）
pro[i].p[j]+=qu[i];
%4ld/%3ld"
pro[i].p[j],pro[i].tot[j]）;
====\n\n"
longi,j;
请输入申请资源的进程ID，以及申请的各种资源数量:
scanf（"
%ld"
&
i）;
qu[j]）;
require（i）;
intmain（）
return0;
实验三主存空间的分配和回收
一、实验目的
熟悉主存的分配与回收。
理解在不同的存储管理方式下，如何实现主存空间的分配与回收。
掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。
二、实验内容和要求
主存的分配和回收的实现是与主存储器的管理方式有关的。
所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。
所谓回收，就是当作业运行完成时将作业或进程所占的主存空间归还给系统。
可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求，并且分区个数是可以调整的。
当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；
若无，则作业不能装入，作业等待。
随着作业的装入、完成，主存空间被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的。
实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、循环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。
同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。
三、实验主要仪器设备和材料
硬件环境：
IBM-PC或兼容机
软件环境：
VC++6.0
四、实验原理及设计方案
1、循环首次适应算法
在该算法中，把主存中所有空闲区按其物理地址递增的次序排列。
在为作业分配存储空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直到找到第一个能满足要求的空闲区，从中划出与请求的大小相等的存储空间分配给作业，余下的空闲区仍留在空闲区表或链中。
1、实验步骤
（1）初始化空闲分区；
（2）反复对现有的空闲分区进行进程创建和撤消，即内存分配和回收；
（3）退出。
3、流程图
五、结果过程及截图
初始化主存大小后的状态
按1后分配一块内存：
按2释放内存：
六、实验总结
总之，编写主存空间的分配和回收的过程有（如解决实际问题）。
从解决实际问题的角度，我们可以这样来看：
首先要了解这个问题的基本要求，即输入、输出、完成从输入到输出的要求是什么；
其次，从问题的要害入手，从前到后的解决问题的每个方面，即从输入开始入手，着重考虑如何从输入导出输出。
在这个过程中，可确定所需的变量、
升级会员 