OS综合实验报告.docx
《OS综合实验报告.docx》由会员分享，可在线阅读，更多相关《OS综合实验报告.docx（35页珍藏版）》请在冰豆网上搜索。
OS综合实验报告
综合实验报告
名称：
操作系统原理综合实验
院系：
计算机系
班级：
计科0901
学号：
200909010116
学生姓名：
指导教师：
赵文清
成绩：
日期：
2011年11月9日
1、实验名称单处理器系统的进程调度
2、实验目的
在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
3、实验内容与要求
1、设计多个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
2、模拟调度程序选择优先数调度算法实现。
3、程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
四、实验原理及说明
1、假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。
进程控制块的格式为：
进程名
指针
要求运行时间
已运行时间
状态
其中，进程名——作为进程的标识，假设五个进程的进程名分别为Q1，Q2，Q3，Q4，Q5。
指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数，初始值为“0”。
状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。
当一个进程运行结束后，它的状态为“结束”，用“E”表示。
2、每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。
3、把五个进程按顺序排成循环队列，用指针指出队列连接情况。
另用一标志单元记录轮到运行的进程。
例如，当前轮到P2执行，则有：
标志单元
K2
K1
Q1
K2
Q2
K3
Q3
K4
Q4
K5
Q5
K2
K3
K4
K5
K1
2
3
1
2
4
1
0
0
0
0
R
R
R
R
R
PCB1
PCB2
PCB3
PCB4
PCB5
4、处理器调度总是选择标志单元指示的进程运行。
由于本实验是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：
已运行时间+1
来模拟进程的一次运行，表示进程已经运行过一个单位的时间。
在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。
在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。
5、进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。
同时，应判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。
若该进程的要求运行时间=已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”（E）且退出队列。
此时，应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。
6、若“就绪”状态的进程队列不为空，则重复上面的（4）和（5）的步骤，直到所有的进程都成为“结束”状态。
7、在所设计的程序中应有显示或打印语句，能显示或打印每次选中进程的进程名以及运行一次后进程队列的变化。
8、为五个进程任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中的进程名以及进程控制块的动态变化过程。
五、实验流程
六、实验结果
七、实验总结
本实验实现了在单处理器情况下的进程调度，我采用了按时间轮转法实现处理器调度，程序编写的比较简单，基本达到实验目的。
本实验的成功完成加深了我对进程调度算法的理解，这为后面的作业调度等实验的完成打下了坚实的基础，让我有信心去完成后面的实验设计。
程序如下：
#include
typedefstructpcb
{
charname[10];
intntime;
intrtime;
charestate;
structpcb*next;
}*pointer;
voidCreatlist（pointer&head,pointer&f,pointer&l,pointerq[]）
{
pointerp;
head=newpcb;
head->next=NULL;
f=head;
for（inti=1;i<=5;i++）
{
p=newpcb;
p->next=NULL;
cout<<"name:
"<cin>>p->name;
cout<<"needtime:
"<cin>>p->ntime;
p->rtime=0;
p->estate='R';
f->next=p;
f=f->next;
q[i]=p;
}
f=head->next;
l=p;
l->next=f;
}
voidCout（pointer&head,pointerq[]）
{
for（inti=1;i<=5;i++）
{
cout<<"标识符：
"<name<<""<<"要求运行时间：
"<ntime<<""<<"已运行时间：
"<rtime<<"状态：
"<estate;
cout<cout<}
}
voidsuanfa（pointer&head,pointer&f,pointer&l,pointerr[]）
{
pointerp,q;
q=l;
p=head->next;
while（（p->next!
=p）||（p->ntime!
=p->rtime））
{
p->rtime=p->rtime+1;
cout<name<<"已运行时间+1。
"<if（p->ntime==p->rtime）
{
p->estate='E';
cout<name<<"已结束。
"<q->next=p->next;
p=q->next;
}
else
{
p=p->next;
q=q->next;
}
Cout（head,r）;
}
}
voidmain（）
{
pointerh,f,l,q[5];
Creatlist（h,f,l,q）;
Cout（h,q）;
suanfa（h,f,l,q）;
}
1、实验名称批处理系统中作业调度
2、实验目的
通过本实验算法的设计加深对作业调度的认识，清楚作业调度的全过程。
3、实验内容与要求
此实验模拟批处理系统中的作业调度，并采用响应比高者优先算法作为作业调度算法。
4、实验原理及说明
1、从输入井中选择作业读入内存，使其获得处理器，得到运行的机会，即为作业调度。
输入井中的作业用“作业控制块”（JCB，如下所示）标识，为了进行作业调度，将作业控制块组成一个队列，这个队列称为后备队列。
2、模拟实验中没有实际作业，作业控制块中的信息内容只使用了模拟实验中需要的数据。
作业控制块中包括作业名、作业大小、所需打印机台数、所需磁带机数量、作业估计执行时间、作业等待时间、指向下一个作业控制块的指针等内容。
将作业控制块组成一个队列，实验中采用动态链表的方式模拟作业的后备队列。
作业控制块采用结构型数据模拟。
3、模拟实验中，主存采用可移动的可变分区管理方法，即只要主存空闲区总和比作业大就可以满足作业对主存的需求。
对打印机和磁带机这两种独占设备采用静态分配法，即作业执行前必须获得所需资源，并且执行完才归还。
4、实验中作业的调度采用响应比高者优先算法。
响应比为作业的等待时间和作业估计执行时间之比。
首先计算出输入井中满足条件的作业的响应比，从中选择响应比最高的一个作业装入主存储器，分配资源。
由于是模拟实验，可将作业控制块出队装入主存储器的工作用输出作业名模拟，同时修改系统的资源数量。
5、模拟实验时，可以首先假设系统的资源情况。
假设系统资源只有主存200MB、磁带机10台、打印机10台，然后手工输入某个时刻输入井中的各个作业情况，最后进行作业调度到就绪队列，按先来先服务进程调度进行进程调度，输出调用情况。
6、批处理系统中的作业调度模拟程序主要由创建作业队列的程序段、作业调度函数组成和进程调用函数组成。
五、实验流程
六、实验结果
七、实验总结
本实验是完成批处理系统作业调度，我采用的是高响应比优先调度算法，总体来说本实验还算成功，基本达到实验目的。
实验的基本原理比较简单，但是仍然遇到了一些问题，让我我明白了实际编程和理论知识间的差异，明白了在学习课本的基础上我们还需要很多的时间才能真正学好这门课程。
程序如下：
#include
typedefstructjcb
{
charname[4];
intlength;
intnprinter;
intntape;
doublentime;
doublewtime;
structjcb*next;
}*Pointer;
inttape=2,printer=4,memory=64;
voidCreatlist（Pointer&head）
{
Pointerp,q;
head=newjcb;
head->next=NULL;
q=head;
for（inti=1;i<=3;i++）
{
p=newjcb;
p->next=NULL;
cout<<"name:
";
cin>>p->name;
cout<<"length:
";
cin>>p->length;
cout<<"needprinter:
";
cin>>p->nprinter;
cout<<"needtape:
";
cin>>p->ntape;
cout<<"needtime";
cin>>p->ntime;
cout<<"waittime:
";
cin>>p->wtime;
q->next=p;
q=q->next;
}
}
PointerFindmax（Pointer&head）
{
doublex,temp=-1.0;
Pointerp,q;
p=head;
do
{
if（head->next!
=NULL）
{
p=p->next;
x=p->wtime/p->ntime;
if（x>temp）
{
temp=x;
q=p;
}
}
}while（p->next!
=NULL）;
returnq;
}
voidDeletejcb（Pointer&head,Pointer&q）
{
Pointerp;
p=head;
while（p->next!
=q）
{
p=p->next;
}
p->next=q->next;
}
voidsuanfa（Pointer&head）
{
Pointerp,q;
doubletemp;
for（inti=1;i<=3;i++）
{
p=head;
q=Findmax（head）;
cout<name<<"运行。
"<temp=q->wtime;
Deletejcb（head,q）;
while（p->next!
=NULL）
{
p=p->next;
p->wtime=temp+（p->wtime）;
}
}
}
voidmain（）
{
Pointerhead;
Creatlist（head）;
suanfa（head）;
}
一、实验名称银行家算法
二、实验目的和要求
银行家算法是避免死锁的一种重要方法，要求编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
三、实验内容
1．设计进程对各类资源最大申请表示及初值确定。
2．设定系统提供资源初始状况。
3．设定每次某个进程对各类资源的申请表示。
4．编制程序，依据银行家算法，决定其申请是否得到满足。
四、实验原理及说明
1．数据结构
假设有M个进程N类资源，则有如下数据结构：
MAX[M*N] M个进程对N类资源的最大需求量
AVAILABLE[N]系统可用资源数
ALLOCATION[M*N]M个进程已经得到N类资源的资源量
NEED[M*N] M个进程还需要N类资源的资源量
2．银行家算法
设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。
（1）如果Request[N]<=NEED[I，N]，则转
（2）；否则，出错。
（2）如果Request[N]<=AVAILABLE，则转（3）；否则，出错。
（3）系统试探分配资源，修改相关数据：
AVAILABLE=AVAILABLE-REQUEST
ALLOCATION=ALLOCATION+REQUEST
NEED=NEED-REQUEST
（4）系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
3．安全性检查
（1）设置两个工作向量WORK=AVAILABLE；FINISH[M]=FALSE
（2）从进程集合中找到一个满足下述条件的进程，
FINISH[i]=FALSE
NEED<=WORK
如找到，执行（3）；否则，执行（4）
（3）设进程获得资源，可顺利执行，直至完成，从而释放资源。
WORK=WORK+ALLOCATION
FINISH=TRUE
GO TO 2
（4）如所有的进程Finish[M]=true，则表示安全；否则系统不安全。
五、实验流程
六、实验结果
七、实验总结
本实验是采用银行家算法避免死锁，本次实验基本达到实验目的。
银行家算法是避免死锁的一种有效方法，上课的时候老师花费了很多精力让我们能够充分理解银行家算法的内涵，上课时虽然理论理解的还算透彻，但是编程实现还是需要一定的编程经验积累。
实验不允许有一点差错，需要认真去对待。
程序如下：
#include
#defineM5//总进程数
#defineN3//总资源数
#definefalse0
#definetrue1
intMax[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
intAvailable[N]={3,3,2};
intAllocation[M][N]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
intNeed[M][N]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};
intFind（intWork[N],boolFinish[M]）//m为false个数
{
inti=0,k,x=0;
for（intn=0;n{
if（Finish[i]==0）
{
k=0;
for（intj=0;j<3;j++）
{
if（Need[i][j]<=Work[j]）
k++;
else
break;
}
if（k==3）
{
x=1;
break;
}
else
i++;
}
else
i++;
}
if（x==0）
return111;//未找到
else
returni;
}
charsafety（）
{
inti,m=5;//false个数
intWork[N];
boolFinish[M]={0,0,0,0,0};
for（inti1=0;i1Work[i1]=Available[i1];
for（intj=0;j{
i=Find（Work,Finish）;
if（i!
=111）
{
for（inti2=0;i2Work[i2]=Work[i2]+Allocation[i][i2];
Finish[i]=1;
cout<m--;
}
else
break;
}
if（m==0）
return'y';
else
return'n';
}
voidbank（）
{
inti,m,n;
charx;
intRequesti[N];
cout<<"请输入请求向量的编号：
";
cin>>i;
cout<<"请输入请求资源：
";
for（intj=0;jcin>>Requesti[j];
m=0;
for（inti1=0;i1{
if（Requesti[i1]<=Need[i][i1]）
m++;
else
break;
}
if（m==3）
{
n=0;
for（inti2=0;i2{
if（Requesti[i2]<=Available[i2]）
n++;
else
break;
}
if（n==3）
{
for（inti3=0;i3{
Available[i3]=Available[i3]-Requesti[i3];
Allocation[i][i3]=Allocation[i][i3]+Requesti[i3];
Need[i][i3]=Need[i][i3]-Requesti[i3];
}
x=safety（）;
if（x=='y'）
cout<<"安全状态,资源已分配";
else
{
cout<<"不安全状态，资源不分配";
for（inti4=0;i4{
Available[i3]=Available[i4]+Requesti[i4];
Allocation[i][i4]=Allocation[i][i4]-Requesti[i4];
Need[i][i4]=Need[i][i4]+Requesti[i4];
}
}
}
else
cout<<"不分配。
";
}
else
cout<<"不分配.";
}
voidmain（）
{
bank（）;
}
一、实验名称主存储器空间的分配和回收
二、实验目的
一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
主存的分配和回收的实现虽与主存储器的管理方式有关的，通过本实验帮助学生理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
三、实验内容
本实验模拟在两种存储管理方式下的主存分配和回收。
四、实验原理及说明
可变分区方式是按作业需要的主存空间大小来分割分区的。
当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。
随着作业的装入、撤离，主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。
例如：
0
5k
10k
14k
26k
32k
128k
操作系统
作业1
作业3
空闲区
作业2
空闲区
为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如下：
起址
长度
状态
第一栏
14K
12K
未分配
第二栏
32K
96K
未分配
空表目
空表目
其中，起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区；另一种是“空表目”状态，表示表中对应的登记项目是空白（无效），可用来登记新的空闲区（例如，作业撤离后，它所占的区域就成了空闲区，应找一个“空表目”栏登记归还区的起址和长度且修改状态）。
由于分区的个数不定，所以空闲区说明表中应有适量的状态为“空表目”的登记栏目，否则造成表格“溢出”无法登记。
上述的这张说明表的登记情况是按提示
1、中的例所装入的三个作业占用的主存区域后填写的。
2、当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。
有时找到的空闲区可能大于作业需要量，这时应把原来的空闲区变成两部分：
一部分分给作业占用；另一部分又成为一个较小的空闲区。
为了尽量减少由于分割造成的空闲区，而尽量保存高地址部分有较大的连续空闲区域，以利于大型作业的装入。
为此，在空闲区说明表中，把每个空闲区按其地址顺序登记，即每个后继的空闲区其起始地址总是比前者大。
为了方便查找还可使表格“紧缩”，总是让“空表目”栏集中在表格的后部。
3、采用最先适应算法（顺序分配算法）分配主存空间。
按照作业的需要量，查空闲区说明表，顺序查看登记栏，找到第一个能满足要求的空闲区。
当空闲区大于需要量时，一部分用来装入作业，另一部分仍为空闲区登记在空闲区说明表中。
由于本实验是模拟主存的分配，所以把主存区分配给作业后并不实际启动装入程序装入作业，而用输出“分配情况”来代替。
最先适应分配算法如图4-1。
4、当一个作业执行结束撤离时，作业所占的区域应该归还，归还的区域如果与其它空闲区相邻，则应合成一个较大的空闲区，登记在空闲区说明表中。
例如，在提示
（1）中列举的情况下，如果作业2撤离，归还所占主存区域时，应与上、下相邻的空闲区一起合成一个大的空闲区登记在空闲区说明表中。
归还主存时的回收算法如图4-2。
5、请按最先适应算法
升级会员 